Update README.md

.env.example

@@ -43,6 +43,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
 

app/config.py

@@ -69,6 +69,9 @@ class Settings(BaseSettings):
     TRIBUTE_DONATE_LINK: Optional[str] = None
     TRIBUTE_WEBHOOK_PATH: str = "/tribute-webhook"
     TRIBUTE_WEBHOOK_PORT: int = 8081
+
+    CONNECT_BUTTON_MODE: str = "guide" 
+    MINIAPP_CUSTOM_URL: str = "" 
     
     DEFAULT_LANGUAGE: str = "ru"
     AVAILABLE_LANGUAGES: str = "ru,en"

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
@@ -85,13 +87,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 +429,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'],
@@ -422,7 +526,6 @@ class RemnaWaveAPI:
         )
 
 
-
 def format_bytes(bytes_value: int) -> str:
     if bytes_value == 0:
         return "0 B"
@@ -467,55 +570,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/handlers/balance.py

@@ -96,7 +96,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 +113,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> - через 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 +158,15 @@ 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(
-    callback: types.CallbackQuery,
-    db_user: User,
-    state: FSMContext
-):
-    texts = get_texts(db_user.language)
-    
-    if not settings.TELEGRAM_STARS_ENABLED:
-        await callback.answer("❌ Оплата Stars временно недоступна", show_alert=True)
-        return
-    
-    amount_kopeks = int(callback.data.split('_')[-1])
-    
-    try:
-        payment_service = PaymentService(callback.bot)
-        invoice_link = await payment_service.create_stars_invoice(
-            amount_kopeks=amount_kopeks,
-            description=f"Пополнение баланса на {texts.format_price(amount_kopeks)}",
-            payload=f"balance_{db_user.id}_{amount_kopeks}"
-        )
-        
-        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
-            [types.InlineKeyboardButton(text="⭐ Оплатить", url=invoice_link)],
-            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
-        ])
-        
-        await callback.message.edit_text(
-            f"⭐ <b>Оплата через Telegram Stars</b>\n\n"
-            f"Сумма: {texts.format_price(amount_kopeks)}\n\n"
-            f"Нажмите кнопку ниже для оплаты:",
-            reply_markup=keyboard
-        )
-        
-    except Exception as e:
-        logger.error(f"Ошибка создания Stars invoice: {e}")
-        await callback.answer("❌ Ошибка создания платежа", show_alert=True)
-    
-    await callback.answer()
-
-
-@error_handler  
-async def process_tribute_quick_payment(
+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 +189,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 +230,11 @@ async def request_support_topup(
 • Способ оплаты
 
 ⏰ Время обработки: 1-24 часа
+
+<b>Доступные способы:</b>
+• Криптовалюта
+• Переводы между банками
+• Другие платежные системы
 """
     
     keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
@@ -288,16 +242,93 @@ 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)
+        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("❌ Ошибка создания платежа")
+
+
 def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(
@@ -316,26 +347,26 @@ 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_tribute_payment,
+        F.data == "topup_tribute"
     )
     
     dp.callback_query.register(
         request_support_topup,
-        F.data == "balance_support"
+        F.data == "topup_support"
     )
     
     dp.message.register(
         process_topup_amount,
         BalanceStates.waiting_for_amount
-    )
+    )

app/handlers/menu.py

@@ -108,15 +108,25 @@ 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')})"
+        days_left = user.subscription.days_left
+        if days_left > 1:
+            return f"🎁 Тестовая подписка\n📅 до {user.subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+        else:
+            return f"🎁 Тестовая подписка\n⚠️ истекает сегодня!"
+    
     elif user.subscription.is_active:
         days_left = user.subscription.days_left
-        return f"{texts.SUBSCRIPTION_ACTIVE} ({days_left} дн.)"
+        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} дн."
+        else:
+            return f"✅ Активна\n⚠️ истекает сегодня!"
     else:
-        return texts.SUBSCRIPTION_EXPIRED
+        return f"⏰ Истекла\n📅 {user.subscription.end_date.strftime('%d.%m.%Y')}"
 
 
 def register_handlers(dp: Dispatcher):
@@ -129,4 +139,4 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(
         show_service_rules,
         F.data == "menu_rules"
-    )
+    )

app/handlers/subscription.py

@@ -1946,20 +1946,83 @@ async def handle_connect_subscription(
         await callback.answer("❌ У вас нет активной подписки или ссылка еще генерируется", show_alert=True)
         return
     
-    device_text = f"""
+    connect_mode = settings.CONNECT_BUTTON_MODE
+    
+    if connect_mode == "miniapp_subscription":
+        keyboard = InlineKeyboardMarkup(inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="🔗 Открыть подписку", 
+                    web_app=types.WebAppInfo(url=subscription.subscription_url)
+                )
+            ],
+            [
+                InlineKeyboardButton(text="📋 Показать ссылку", callback_data="open_subscription_link")
+            ],
+            [
+                InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+            ]
+        ])
+        
+        await callback.message.edit_text(
+            f"""
+🔗 <b>Подключить подписку</b>
+
+📱 Нажмите кнопку ниже, чтобы открыть подписку в мини-приложении Telegram:
+            """,
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+        
+    elif connect_mode == "miniapp_custom":
+        if not settings.MINIAPP_CUSTOM_URL:
+            await callback.answer("❌ Кастомная ссылка для мини-приложения не настроена", show_alert=True)
+            return
+            
+        keyboard = InlineKeyboardMarkup(inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="🚀 Открыть приложение", 
+                    web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
+                )
+            ],
+            [
+                InlineKeyboardButton(text="📋 Показать ссылку подписки", callback_data="open_subscription_link")
+            ],
+            [
+                InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+            ]
+        ])
+        
+        await callback.message.edit_text(
+            f"""
+🚀 <b>Подключить подписку</b>
+
+📱 Нажмите кнопку ниже, чтобы открыть приложение:
+
+📋 <b>Ссылка подписки:</b>
+<code>{subscription.subscription_url}</code>
+            """,
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+        
+    else:
+        device_text = f"""
 📱 <b>Подключить подписку</b>
 
 🔗 <b>Ссылка подписки:</b>
 <code>{subscription.subscription_url}</code>
 
 💡 <b>Выберите ваше устройство</b> для получения подробной инструкции по настройке:
-"""
+        """
+        
+        await callback.message.edit_text(
+            device_text,
+            reply_markup=get_device_selection_keyboard(db_user.language),
+            parse_mode="HTML"
+        )
     
-    await callback.message.edit_text(
-        device_text,
-        reply_markup=get_device_selection_keyboard(db_user.language),
-        parse_mode="HTML"
-    )
     await callback.answer()
 
 

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/inline.py

@@ -97,13 +97,24 @@ 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:
@@ -292,45 +303,95 @@ 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)
 
 
 def get_payment_methods_keyboard(amount_kopeks: int, language: str = "ru") -> InlineKeyboardMarkup:
+    """Клавиатура выбора способа оплаты"""
     texts = get_texts(language)
     keyboard = []
     
     if settings.TELEGRAM_STARS_ENABLED:
         keyboard.append([
-            InlineKeyboardButton(text=texts.TOP_UP_STARS, callback_data=f"pay_stars_{amount_kopeks}")
+            InlineKeyboardButton(
+                text="⭐ Telegram Stars", 
+                callback_data="topup_stars"
+            )
         ])
     
+    if settings.TRIBUTE_ENABLED:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="💳 Банковская карта", 
+                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_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)
@@ -605,25 +666,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(

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>
 Переходите на полную подписку!

app/services/monitoring_service.py

@@ -32,7 +32,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 +60,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,7 +87,6 @@ class MonitoringService:
                 break 
     
     async def _check_expired_subscriptions(self, db: AsyncSession):
-        """Проверка истекших подписок"""
         try:
             expired_subscriptions = await get_expired_subscriptions(db)
             
@@ -99,7 +97,6 @@ class MonitoringService:
                 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)
                 
@@ -116,12 +113,10 @@ class MonitoringService:
             logger.error(f"Ошибка проверки истекших подписок: {e}")
     
     async def _check_expiring_subscriptions(self, db: AsyncSession):
-        """Проверка подписок, истекающих через 2-3 дня (только платные)"""
         try:
             warning_days = settings.get_autopay_warning_days()
             
             for days in warning_days:
-                # Получаем только платные подписки
                 expiring_subscriptions = await self._get_expiring_paid_subscriptions(db, days)
                 
                 for subscription in expiring_subscriptions:
@@ -131,7 +126,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 +145,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 +169,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,7 +188,6 @@ 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)
         
         result = await db.execute(
@@ -204,7 +196,7 @@ class MonitoringService:
             .where(
                 and_(
                     Subscription.status == SubscriptionStatus.ACTIVE.value,
-                    Subscription.is_trial == False,  # Только платные
+                    Subscription.is_trial == False, 
                     Subscription.end_date <= threshold_date,
                     Subscription.end_date > datetime.utcnow()
                 )
@@ -213,9 +205,7 @@ class MonitoringService:
         return result.scalars().all()
     
     async def _process_autopayments(self, db: AsyncSession):
-        """Обработка автоплатежей"""
         try:
-            # Исправленный запрос с использованием индивидуальных настроек
             current_time = datetime.utcnow()
             
             result = await db.execute(
@@ -225,13 +215,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 +237,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 +264,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 +278,98 @@ 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:
             texts = get_texts(user.language)
-            message = texts.SUBSCRIPTION_EXPIRING.format(days=days)
-            await self.bot.send_message(user.telegram_id, message, parse_mode="HTML")
+            
+            if subscription.autopay_enabled:
+                autopay_status = "✅ Включен - подписка продлится автоматически"
+                action_text = f"💰 Убедитесь, что на балансе достаточно средств: {texts.format_price(user.balance_kopeks)}"
+            else:
+                autopay_status = "❌ Отключен - не забудьте продлить вручную!"
+                action_text = "💡 Включите автоплатеж или продлите подписку вручную"
+            
+            message = f"""
+    ⚠️ <b>Подписка истекает через {days} дней!</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 +383,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 +394,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 +401,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 +418,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 +548,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 +642,4 @@ class MonitoringService:
             return 0
 
 
-monitoring_service = MonitoringService()
+monitoring_service = MonitoringService()