Update monitoring_service.py

README.md

@@ -1,4 +1,4 @@
-# 🚀 Remnawave Bedolaga Bot 2.0.0
+# 🚀 Remnawave Bedolaga Bot
 
 <div align="center">
 
@@ -42,7 +42,7 @@
 - 📱 **Управление устройствами** - от 1 до 10 шт
 - 📊 **Гибкие тарифы** - от 5GB до безлимита, от 14 дней до года
 - 🎁 **Промо-система** - коды на деньги, дни подписки, триал-периоды
-- 3 режима показа ссылки подписки: 1) С гайдом по подключению прямо в боте(тянущий данные приложений и ссылок на скачку из app-config.json) 2) Обычное открытие ссылки подписки в миниапе 3) Интеграция сабпейджа мипошки - кастомно прописать ссылку можно
+- 3 режима показа ссылки подписки: 1) С гайдом по подключению прямо в боте(тянущий данные приложений и ссылок на скачку из app-config.json) 2) Обычное открытие ссылки подписки в миниапе 3) Интеграция сабпейджа maposia - кастомно прописать ссылку можно
 - Возможность переключаться между пакетной продажей трафика и фиксированной(Пропуская шаг выбора пакета трафика при оформлении/настройки подписки юзера)
 
 ### 💪 **Enterprise готовность**

app/bot.py

@@ -8,6 +8,7 @@ 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.utils.cache import cache 
 
 from app.handlers import (
@@ -66,6 +67,9 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     dp.callback_query.middleware(AuthMiddleware())
     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)

app/database/crud/subscription.py

@@ -20,7 +20,12 @@ async def get_subscription_by_user_id(db: AsyncSession, user_id: int) -> Optiona
         .options(selectinload(Subscription.user))
         .where(Subscription.user_id == user_id)
     )
-    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(
@@ -510,6 +515,41 @@ async def get_subscription_renewal_cost(
         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,

app/database/crud/user.py

@@ -150,33 +150,36 @@ async def add_user_balance(
 
 
 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 +327,4 @@ async def get_users_statistics(db: AsyncSession) -> dict:
         "new_today": new_today,
         "new_week": new_week,
         "new_month": new_month
-    }
+    }

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"  
 
 
@@ -133,21 +133,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 +508,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/handlers/admin/remnawave.py

@@ -1315,11 +1315,11 @@ 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>
 
 Выберите тип синхронизации:
@@ -1342,24 +1342,41 @@ async def show_sync_options(
 • Обновление подключенных сквадов
 • ⏱️ Время выполнения: 1-3 минуты
 
+🔍 <b>Валидация подписок</b>
+• Проверка и исправление проблем в данных
+• Восстановление отсутствующих полей
+• Исправление некорректных статусов
+
+🧹 <b>Мягкая очистка</b>  
+• Деактивация подписок отсутствующих в панели
+• Сохранение транзакций и истории
+
+🗑️ <b>ПРИНУДИТЕЛЬНАЯ ОЧИСТКА</b>
+• ⚠️ ОПАСНО: Полное удаление данных пользователей
+• Удаление транзакций, балансов, рефералов  
+• Только при серьезных проблемах синхронизации
+
 ⚠️ <b>Важно:</b>
 • Во время синхронизации не выполняйте другие операции
 • При полной синхронизации подписки пользователей, отсутствующих в панели, будут деактивированы
 • Рекомендуется делать полную синхронизацию ежедневно
 """
-   
-   keyboard = [
-       [types.InlineKeyboardButton(text="🔄 Синхронизировать всех", callback_data="sync_all_users")],
-       [types.InlineKeyboardButton(text="🆕 Только новых", callback_data="sync_new_users")],
-       [types.InlineKeyboardButton(text="📈 Обновить данные", callback_data="sync_update_data")],
-       [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
-   ]
-   
-   await callback.message.edit_text(
-       text,
-       reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
-   )
-   await callback.answer()
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🔄 Синхронизировать всех", callback_data="sync_all_users")],
+        [types.InlineKeyboardButton(text="🆕 Только новых", callback_data="sync_new_users")],
+        [types.InlineKeyboardButton(text="📈 Обновить данные", callback_data="sync_update_data")],
+        [types.InlineKeyboardButton(text="🔍 Валидация подписок", callback_data="sync_validate")],
+        [types.InlineKeyboardButton(text="🧹 Мягкая очистка", callback_data="sync_cleanup")],
+        [types.InlineKeyboardButton(text="🗑️ ПРИНУДИТЕЛЬНАЯ ОЧИСТКА", callback_data="confirm_force_cleanup")],
+        [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
@@ -1442,7 +1459,6 @@ async def validate_subscriptions(
     remnawave_service = RemnaWaveService()
     stats = await remnawave_service.validate_and_fix_subscriptions(db)
     
-    # Формируем отчет
     if stats['errors'] == 0:
         status_emoji = "✅"
         status_text = "успешно завершена"
@@ -1498,7 +1514,6 @@ async def cleanup_subscriptions(
     remnawave_service = RemnaWaveService()
     stats = await remnawave_service.cleanup_orphaned_subscriptions(db)
     
-    # Формируем отчет
     if stats['errors'] == 0:
         status_emoji = "✅"
         status_text = "успешно завершена"
@@ -1537,6 +1552,114 @@ async def cleanup_subscriptions(
     )
     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
 @error_handler
@@ -1725,6 +1848,8 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(show_sync_recommendations, F.data == "sync_recommendations")
     dp.callback_query.register(validate_subscriptions, F.data == "sync_validate") 
     dp.callback_query.register(cleanup_subscriptions, F.data == "sync_cleanup")
+    dp.callback_query.register(confirm_force_cleanup, F.data == "confirm_force_cleanup")
+    dp.callback_query.register(force_cleanup_all_orphaned_users, F.data == "force_cleanup_orphaned")
     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_"))

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,25 +109,33 @@ async def handle_back_to_menu(
 
 def _get_subscription_status(user: User, texts) -> str:
     if not user.subscription:
-        return "❌ Отсутствует"
+        return "⌐ Отсутствует"
     
-    if user.subscription.is_trial:
-        days_left = user.subscription.days_left
+    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📅 до {user.subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+            return f"🎁 Тестовая подписка\n📅 до {subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+        elif days_left == 1:
+            return f"🎁 Тестовая подписка\n⚠️ истекает завтра!"
         else:
             return f"🎁 Тестовая подписка\n⚠️ истекает сегодня!"
     
-    elif user.subscription.is_active:
-        days_left = user.subscription.days_left
+    else: 
         if days_left > 7:
-            return f"✅ Активна\n📅 до {user.subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
-        elif days_left > 0:
-            return f"✅ Активна\n⚠️ истекает через {days_left} дн."
+            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⚠️ истекает сегодня!"
-    else:
-        return f"⏰ Истекла\n📅 {user.subscription.end_date.strftime('%d.%m.%Y')}"
+            return f"💎 Активна\n⚠️ истекает сегодня!"
 
 
 def register_handlers(dp: Dispatcher):

app/handlers/subscription.py

@@ -62,15 +62,88 @@ async def show_subscription_info(
         await callback.answer()
         return
     
+    from app.database.crud.subscription import check_and_update_subscription_status
+    subscription = await check_and_update_subscription_status(db, subscription)
+    
     subscription_service = SubscriptionService()
     await subscription_service.sync_subscription_usage(db, subscription)
     
     await db.refresh(subscription)
     
-    info_text = await get_subscription_info_text(subscription, texts, db_user, db)
+    current_time = datetime.utcnow()
+    
+    if subscription.status == "expired" or subscription.end_date <= current_time:
+        actual_status = "expired"
+        status_display = "Истекла"
+        status_emoji = "🔴"
+    elif subscription.status == "active" and subscription.end_date > current_time:
+        if subscription.is_trial:
+            actual_status = "trial_active"
+            status_display = "Тестовая"
+            status_emoji = "🎁"
+        else:
+            actual_status = "paid_active"
+            status_display = "Активна"
+            status_emoji = "💎"
+    else:
+        actual_status = "unknown"
+        status_display = "Неизвестно"
+        status_emoji = "❓"
+    
+    if subscription.end_date <= current_time:
+        days_left = 0
+        time_left_text = "истёк"
+        warning_text = "" 
+    else:
+        delta = subscription.end_date - current_time
+        days_left = delta.days
+        hours_left = delta.seconds // 3600
+        
+        if days_left > 1:
+            time_left_text = f"{days_left} дн."
+            warning_text = ""
+        elif days_left == 1:
+            time_left_text = f"{days_left} дн."
+            warning_text = "\n⚠️ истекает завтра!"
+        elif hours_left > 0:
+            time_left_text = f"{hours_left} ч."
+            warning_text = "\n⚠️ истекает сегодня!"
+        else:
+            minutes_left = (delta.seconds % 3600) // 60
+            time_left_text = f"{minutes_left} мин."
+            warning_text = "\n🔴 истекает через несколько минут!"
+    
+    subscription_type = "Триал" if subscription.is_trial else "Платная"
+    
+    if subscription.traffic_limit_gb == 0:
+        traffic_used_display = f"∞ (безлимит) / {subscription.traffic_used_gb:.1f} ГБ"
+    else:
+        traffic_used_display = f"{subscription.traffic_used_gb:.1f} / {subscription.traffic_limit_gb} ГБ"
+    
+    devices_used = await get_current_devices_count(db_user)
+    
+
+    message = f"""👤 {db_user.full_name}
+━━━━━━━━━━━━━━━━━
+💰 Баланс: {settings.format_price(db_user.balance_kopeks)}
+📱 Подписка: {status_emoji} {status_display}{warning_text}
+━━━━━━━━━━━━━━━━━
+
+📱 Информация о подписке
+🎭 Тип: {subscription_type}
+📅 Действует до: {subscription.end_date.strftime("%d.%m.%Y %H:%M")}
+⏰ Осталось: {time_left_text}
+📈 Трафик: {traffic_used_display}
+🌍 Серверы: {len(subscription.connected_squads)} стран
+📱 Устройства: {devices_used} / {subscription.device_limit}"""
+    
+    if hasattr(subscription, 'subscription_url') and subscription.subscription_url:
+        if actual_status in ['trial_active', 'paid_active']:
+            message += f"\n\n🔗 <b>Ссылка для подключения:</b>\n<code>{subscription.subscription_url}</code>"
+            message += f"\n\n📱 Скопируйте ссылку и добавьте в ваше VPN приложение"
     
     await callback.message.edit_text(
-        info_text,
+        message,
         reply_markup=get_subscription_keyboard(
             db_user.language,
             has_subscription=True,
@@ -113,35 +186,33 @@ async def get_subscription_cost(subscription, db: AsyncSession) -> int:
         
         subscription_service = SubscriptionService()
         
+        base_cost = PERIOD_PRICES.get(30, 0)
+        
         try:
             servers_cost, _ = await subscription_service.get_countries_price_by_uuids(
                 subscription.connected_squads, db
             )
         except AttributeError:
-            logger.warning("Используем fallback для расчета стоимости серверов")
             servers_cost, _ = await get_countries_price_by_uuids_fallback(
                 subscription.connected_squads, db
             )
         
         traffic_cost = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
-        
         devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
         
-        base_cost = min(PERIOD_PRICES.values()) if PERIOD_PRICES else 0
-        
         total_cost = base_cost + servers_cost + traffic_cost + devices_cost
         
-        logger.info(f"📊 Расчет стоимости подписки {subscription.id} (по текущим ценам):")
-        logger.info(f"   📦 Базовая стоимость: {base_cost/100}₽")
-        logger.info(f"   🌍 Серверы ({len(subscription.connected_squads)}) по текущим ценам: {servers_cost/100}₽")
-        logger.info(f"   📊 Трафик ({subscription.traffic_limit_gb} ГБ): {traffic_cost/100}₽")
-        logger.info(f"   📱 Устройства ({subscription.device_limit}): {devices_cost/100}₽")
-        logger.info(f"   💎 ОБЩАЯ СТОИМОСТЬ: {total_cost/100}₽")
+        logger.info(f"📊 Месячная стоимость конфигурации подписки {subscription.id}:")
+        logger.info(f"   📅 Базовый тариф (30 дней): {base_cost/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}")
+        logger.error(f"⚠ Ошибка расчета стоимости подписки: {e}")
         return 0
 
 
@@ -1083,7 +1154,7 @@ async def get_subscription_info_text(subscription, texts, db_user, db: AsyncSess
     )
     
     if subscription_cost > 0:
-        info_text += f"\n💰 <b>Стоимость подписки:</b> {texts.format_price(subscription_cost)}"
+        info_text += f"\n💰 <b>Стоимость подписки в месяц:</b> {texts.format_price(subscription_cost)}"
     
     if subscription_url and subscription_url != "Генерируется...":
         info_text += f"\n\n🔗 <b>Ссылка для подключения:</b>\n<code>{subscription_url}</code>"

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/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__)
 
 
@@ -91,7 +95,8 @@ class MonitoringService:
             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:
@@ -100,17 +105,65 @@ class MonitoringService:
                 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):
         try:
@@ -188,7 +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)
@@ -197,12 +251,20 @@ class MonitoringService:
                 and_(
                     Subscription.status == SubscriptionStatus.ACTIVE.value,
                     Subscription.is_trial == False, 
-                    Subscription.end_date <= threshold_date,
-                    Subscription.end_date > datetime.utcnow()
+                    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:

app/services/remnawave_service.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Dict, List, Any, Optional
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import delete
 
 from app.config import settings
 from app.external.remnawave_api import (
@@ -9,7 +10,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__)
 
@@ -459,12 +463,12 @@ class RemnaWaveService:
                         continue
                 
                 if sync_type == "all":
-                    logger.info("🗑️ Полная очистка подписок пользователей, отсутствующих в панели...")
+                    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} (нет в панели)")
+                                logger.info(f"🗑️ ПОЛНАЯ очистка данных подписки пользователя {telegram_id} (нет в панели)")
                                 
                                 subscription = db_user.subscription
                                 
@@ -478,6 +482,66 @@ class RemnaWaveService:
                                     except Exception as hwid_error:
                                         logger.error(f"❌ Ошибка сброса HWID устройств для {telegram_id}: {hwid_error}")
                                 
+                                try:
+                                    from app.database.crud.subscription import get_subscription_server_ids, remove_subscription_servers
+                                    from sqlalchemy import delete
+                                    from app.database.models import SubscriptionServer
+                                    
+                                    await db.execute(
+                                        delete(SubscriptionServer).where(
+                                            SubscriptionServer.subscription_id == subscription.id
+                                        )
+                                    )
+                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ записи SubscriptionServer для подписки {subscription.id}")
+                                    
+                                except Exception as servers_error:
+                                    logger.warning(f"⚠️ Не удалось удалить серверы подписки: {servers_error}")
+                                
+                                try:
+                                    from sqlalchemy import delete
+                                    from app.database.models import Transaction
+                                    
+                                    await db.execute(
+                                        delete(Transaction).where(Transaction.user_id == db_user.id)
+                                    )
+                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ транзакции пользователя {telegram_id}")
+                                    
+                                except Exception as transactions_error:
+                                    logger.warning(f"⚠️ Не удалось удалить транзакции: {transactions_error}")
+                                
+                                try:
+                                    from sqlalchemy import delete
+                                    from app.database.models import ReferralEarning
+                                    
+                                    await db.execute(
+                                        delete(ReferralEarning).where(ReferralEarning.user_id == db_user.id)
+                                    )
+                                    await db.execute(
+                                        delete(ReferralEarning).where(ReferralEarning.referral_id == db_user.id)
+                                    )
+                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ реферальные доходы пользователя {telegram_id}")
+                                    
+                                except Exception as referral_error:
+                                    logger.warning(f"⚠️ Не удалось удалить реферальные доходы: {referral_error}")
+                                
+                                try:
+                                    from sqlalchemy import delete
+                                    from app.database.models import PromoCodeUse
+                                    
+                                    await db.execute(
+                                        delete(PromoCodeUse).where(PromoCodeUse.user_id == db_user.id)
+                                    )
+                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ использования промокодов пользователя {telegram_id}")
+                                    
+                                except Exception as promo_error:
+                                    logger.warning(f"⚠️ Не удалось удалить использования промокодов: {promo_error}")
+                                
+                                try:
+                                    db_user.balance_kopeks = 0
+                                    logger.info(f"💰 Сброшен баланс пользователя {telegram_id}")
+                                except Exception as balance_error:
+                                    logger.warning(f"⚠️ Не удалось сбросить баланс: {balance_error}")
+                                
                                 from app.database.models import SubscriptionStatus
                                 from datetime import datetime
                                 
@@ -490,22 +554,12 @@ class RemnaWaveService:
                                 subscription.connected_squads = []
                                 subscription.autopay_enabled = False
                                 subscription.autopay_days_before = 3
-                                
                                 subscription.remnawave_short_uuid = None
                                 subscription.subscription_url = ""
                                 
                                 db_user.remnawave_uuid = None
-                                
-                                try:
-                                    from app.database.crud.subscription import get_subscription_server_ids, remove_subscription_servers
-                                    
-                                    server_ids = await get_subscription_server_ids(db, subscription.id)
-                                    if server_ids:
-                                        await remove_subscription_servers(db, subscription.id, server_ids)
-                                        logger.info(f"🗑️ Удалены серверы подписки ({len(server_ids)}): {server_ids}")
-                                except Exception as servers_error:
-                                    logger.warning(f"⚠️ Не удалось удалить серверы подписки: {servers_error}")
-                                
+                                db_user.has_had_paid_subscription = False 
+                                db_user.used_promocodes = 0 
                                 
                                 await db.commit()
                                 
@@ -524,6 +578,8 @@ class RemnaWaveService:
             logger.error(f"❌ Критическая ошибка синхронизации пользователей: {e}")
             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
@@ -983,11 +1039,101 @@ class RemnaWaveService:
             logger.error(f"Ошибка валидации данных пользователя: {e}")
             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:
+                from datetime import datetime
+                
+                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("🧹 Начинаем очистку неактуальных подписок...")
+            logger.info("🧹 Начинаем усиленную очистку неактуальных подписок...")
         
             async with self.api as api:
                 panel_users_data = await api._make_request('GET', '/api/users')
@@ -1022,12 +1168,14 @@ class RemnaWaveService:
                             continue
                     
                         if user.telegram_id not in panel_telegram_ids:
-                            logger.info(f"🗑️ Деактивируем подписку пользователя {user.telegram_id} (отсутствует в панели)")
-                        
-                            from app.database.crud.subscription import deactivate_subscription
-                            await deactivate_subscription(db, subscription)
-                        
-                            stats["deactivated"] += 1
+                            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}")
@@ -1037,11 +1185,11 @@ class RemnaWaveService:
                 if len(subscriptions) < limit:
                     break
         
-            logger.info(f"🧹 Очистка завершена: проверено {stats['checked']}, деактивировано {stats['deactivated']}, ошибок {stats['errors']}")
+            logger.info(f"🧹 Усиленная очистка завершена: проверено {stats['checked']}, деактивировано {stats['deactivated']}, ошибок {stats['errors']}")
             return stats
         
         except Exception as e:
-            logger.error(f"❌ Критическая ошибка очистки подписок: {e}")
+            logger.error(f"❌ Критическая ошибка усиленной очистки подписок: {e}")
             return {"deactivated": 0, "errors": 1, "checked": 0}
 
 

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
@@ -106,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, 
@@ -120,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}")