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

@@ -40,7 +40,13 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     except Exception as e:
         logger.warning(f"⚠️ Кеш не инициализирован: {e}")
     
-    bot = Bot(token=settings.BOT_TOKEN, parse_mode="HTML")
+    from aiogram.client.default import DefaultBotProperties
+    from aiogram.enums import ParseMode
+
+    bot = Bot(
+        token=settings.BOT_TOKEN, 
+        default=DefaultBotProperties(parse_mode=ParseMode.HTML)
+    )
     
     try:
         redis_client = redis.from_url(settings.REDIS_URL)
@@ -85,4 +91,4 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     
     logger.info("✅ Бот успешно настроен")
     
-    return bot, dp
+    return bot, dp

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/database/crud/subscription.py

@@ -444,6 +444,72 @@ async def get_subscription_servers(
     
     return servers_info
 
+async def remove_subscription_servers(
+    db: AsyncSession,
+    subscription_id: int,
+    server_squad_ids: List[int]
+) -> bool:
+    try:
+        from app.database.models import SubscriptionServer
+        from sqlalchemy import delete
+        
+        await db.execute(
+            delete(SubscriptionServer)
+            .where(
+                SubscriptionServer.subscription_id == subscription_id,
+                SubscriptionServer.server_squad_id.in_(server_squad_ids)
+            )
+        )
+        
+        await db.commit()
+        logger.info(f"🗑️ Удалены серверы {server_squad_ids} из подписки {subscription_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка удаления серверов из подписки: {e}")
+        await db.rollback()
+        return False
+
+
+async def get_subscription_renewal_cost(
+    db: AsyncSession,
+    subscription_id: int,
+    period_days: int
+) -> int:
+    try:
+        from app.config import PERIOD_PRICES, TRAFFIC_PRICES, settings
+        
+        base_price = PERIOD_PRICES.get(period_days, 0)
+        
+        servers_info = await get_subscription_servers(db, subscription_id)
+        servers_cost = sum(server_info['paid_price_kopeks'] for server_info in servers_info)
+        
+        subscription = await db.get(Subscription, subscription_id)
+        if not subscription:
+            return base_price
+        
+        traffic_cost = 0
+        if subscription.traffic_limit_gb > 0:
+            traffic_cost = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
+        
+        devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+        
+        total_cost = base_price + servers_cost + traffic_cost + devices_cost
+        
+        logger.info(f"💰 Расчет продления подписки {subscription_id} на {period_days} дней:")
+        logger.info(f"   📅 Период: {base_price/100}₽")
+        logger.info(f"   🌍 Серверы: {servers_cost/100}₽")
+        logger.info(f"   📊 Трафик: {traffic_cost/100}₽")
+        logger.info(f"   📱 Устройства: {devices_cost/100}₽")
+        logger.info(f"   💎 ИТОГО: {total_cost/100}₽")
+        
+        return total_cost
+        
+    except Exception as e:
+        logger.error(f"Ошибка расчета стоимости продления: {e}")
+        from app.config import PERIOD_PRICES
+        return PERIOD_PRICES.get(period_days, 0)
+
 async def create_subscription(
     db: AsyncSession,
     user_id: int,
@@ -482,4 +548,4 @@ async def create_subscription(
     await db.refresh(subscription)
     
     logger.info(f"✅ Создана подписка для пользователя {user_id}")
-    return subscription
+    return subscription

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/admin/users.py

@@ -274,7 +274,7 @@ async def show_user_subscription(
         text += f"<b>Окончание:</b> {format_datetime(subscription.end_date)}\n"
         text += f"<b>Трафик:</b> {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
         text += f"<b>Устройства:</b> {subscription.device_limit}\n"
-        text += f"<b>Подключенных устройств:</b> {len(subscription.connected_devices) if subscription.connected_devices else 0}\n"
+        text += f"<b>Подключенных устройств:</b> {subscription.device_limit}\n"
         
         if subscription.is_active:
             days_left = (subscription.end_date - datetime.utcnow()).days
@@ -521,7 +521,14 @@ async def show_user_management(
     user = profile["user"]
     subscription = profile["subscription"]
     
-    status_text = "✅ Активен" if user.status == UserStatus.ACTIVE.value else "❌ Заблокирован"
+    if user.status == UserStatus.ACTIVE.value:
+        status_text = "✅ Активен"
+    elif user.status == UserStatus.BLOCKED.value:
+        status_text = "🚫 Заблокирован"
+    elif user.status == UserStatus.DELETED.value:
+        status_text = "🗑️ Удален"
+    else:
+        status_text = "❓ Неизвестно"
     
     text = f"""
 👤 <b>Управление пользователем</b>
@@ -558,7 +565,7 @@ async def show_user_management(
     
     await callback.message.edit_text(
         text,
-        reply_markup=get_user_management_keyboard(user.id, db_user.language)
+        reply_markup=get_user_management_keyboard(user.id, user.status, db_user.language)
     )
     await callback.answer()
 
@@ -746,6 +753,112 @@ async def show_inactive_users(
     )
     await callback.answer()
 
+@admin_required
+@error_handler
+async def confirm_user_unblock(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    await callback.message.edit_text(
+        "✅ <b>Разблокировка пользователя</b>\n\n"
+        "Вы уверены, что хотите разблокировать этого пользователя?\n"
+        "Пользователь снова получит доступ к боту.",
+        reply_markup=get_confirmation_keyboard(
+            f"admin_user_unblock_confirm_{user_id}",
+            f"admin_user_manage_{user_id}",
+            db_user.language
+        )
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def unblock_user(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    success = await user_service.unblock_user(db, user_id, db_user.id)
+    
+    if success:
+        await callback.message.edit_text(
+            "✅ Пользователь разблокирован",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка разблокировки пользователя",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def show_user_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    profile = await user_service.get_user_profile(db, user_id)
+    
+    if not profile:
+        await callback.answer("❌ Пользователь не найден", show_alert=True)
+        return
+    
+    user = profile["user"]
+    subscription = profile["subscription"]
+    
+    text = f"📊 <b>Статистика пользователя</b>\n\n"
+    text += f"👤 {user.full_name} (ID: <code>{user.telegram_id}</code>)\n\n"
+    
+    text += f"<b>Основная информация:</b>\n"
+    text += f"• Дней с регистрации: {profile['registration_days']}\n"
+    text += f"• Баланс: {settings.format_price(user.balance_kopeks)}\n"
+    text += f"• Транзакций: {profile['transactions_count']}\n"
+    text += f"• Язык: {user.language}\n\n"
+    
+    text += f"<b>Подписка:</b>\n"
+    if subscription:
+        sub_status = "✅ Активна" if subscription.is_active else "❌ Неактивна"
+        sub_type = " (триал)" if subscription.is_trial else " (платная)"
+        text += f"• Статус: {sub_status}{sub_type}\n"
+        text += f"• Трафик: {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
+        text += f"• Устройства: {subscription.device_limit}\n"
+        text += f"• Стран: {len(subscription.connected_squads)}\n"
+    else:
+        text += f"• Отсутствует\n"
+    
+    text += f"\n<b>Реферальная программа:</b>\n"
+    if user.referred_by_id:
+        text += f"• Пришел по рефералке\n"
+    else:
+        text += f"• Прямая регистрация\n"
+    text += f"• Реферальный код: <code>{user.referral_code}</code>\n"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+        ])
+    )
+    await callback.answer()
 
 @admin_required
 @error_handler
@@ -787,23 +900,48 @@ def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(
         show_user_subscription,
-        F.data.startswith("admin_user_sub_")
+        F.data.startswith("admin_user_subscription_")
     )
-    
+
     dp.callback_query.register(
         show_user_transactions,
-        F.data.startswith("admin_user_trans_")
+        F.data.startswith("admin_user_transactions_")
     )
-    
+
     dp.callback_query.register(
-        confirm_user_delete,
-        F.data.startswith("admin_user_delete_")
+        show_user_statistics,
+        F.data.startswith("admin_user_statistics_")
     )
-    
+
+    dp.callback_query.register(
+        block_user,
+        F.data.startswith("admin_user_block_confirm_")
+    )
+
     dp.callback_query.register(
         delete_user_account,
         F.data.startswith("admin_user_delete_confirm_")
     )
+
+    dp.callback_query.register(
+        confirm_user_block,
+        F.data.startswith("admin_user_block_")
+    )
+
+    dp.callback_query.register(
+        unblock_user,
+        F.data.startswith("admin_user_unblock_confirm_")
+    )
+
+    dp.callback_query.register(
+        confirm_user_unblock,
+        F.data.startswith("admin_user_unblock_") & ~F.data.contains("confirm")
+    )
+
+    dp.callback_query.register(
+        confirm_user_delete,
+        F.data.startswith("admin_user_delete_")
+    )
     
     dp.callback_query.register(
         handle_users_list_pagination_fixed,
@@ -835,15 +973,6 @@ def register_handlers(dp: Dispatcher):
         AdminStates.editing_user_balance
     )
     
-    dp.callback_query.register(
-        confirm_user_block,
-        F.data.startswith("admin_user_block_")
-    )
-    
-    dp.callback_query.register(
-        block_user,
-        F.data.startswith("admin_user_block_confirm_")
-    )
     
     dp.callback_query.register(
         show_inactive_users,
@@ -853,4 +982,4 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(
         cleanup_inactive_users,
         F.data == "admin_cleanup_inactive"
-    )
+    )

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

@@ -9,6 +9,7 @@ from app.states import RegistrationStates
 from app.database.crud.user import (
     get_user_by_telegram_id, create_user, get_user_by_referral_code
 )
+from app.database.models import UserStatus
 from app.keyboards.inline import (
     get_rules_keyboard, get_main_menu_keyboard
 )
@@ -19,7 +20,7 @@ from app.utils.user_utils import generate_unique_referral_code
 logger = logging.getLogger(__name__)
 
 
-async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession):
+async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession, db_user=None):
     logger.info(f"🚀 START: Обработка /start от {message.from_user.id}")
     
     referral_code = None
@@ -31,10 +32,10 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession)
     if referral_code:
         await state.set_data({'referral_code': referral_code})
     
-    user = await get_user_by_telegram_id(db, message.from_user.id)
+    user = db_user if db_user else await get_user_by_telegram_id(db, message.from_user.id)
     
-    if user:
-        logger.info(f"✅ Пользователь найден: {user.telegram_id}")
+    if user and user.status != UserStatus.DELETED.value:
+        logger.info(f"✅ Активный пользователь найден: {user.telegram_id}")
         texts = get_texts(user.language)
         
         if referral_code and not user.referred_by_id:
@@ -60,26 +61,82 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession)
                 subscription_is_active=subscription_is_active
             )
         )
+        await state.clear()
+        return
+    
+    if user and user.status == UserStatus.DELETED.value:
+        logger.info(f"🔄 Удаленный пользователь {user.telegram_id} начинает повторную регистрацию")
+        
+        try:
+            from app.services.user_service import UserService
+            from app.database.models import (
+                Subscription, Transaction, PromoCodeUse, 
+                ReferralEarning, SubscriptionServer
+            )
+            from sqlalchemy import delete
+            
+            if user.subscription:
+                await db.execute(
+                    delete(SubscriptionServer).where(
+                        SubscriptionServer.subscription_id == user.subscription.id
+                    )
+                )
+                logger.info(f"🗑️ Удалены записи SubscriptionServer")
+            
+            if user.subscription:
+                await db.delete(user.subscription)
+                logger.info(f"🗑️ Удалена подписка пользователя")
+            
+            await db.execute(
+                delete(PromoCodeUse).where(PromoCodeUse.user_id == user.id)
+            )
+            
+            await db.execute(
+                delete(ReferralEarning).where(ReferralEarning.user_id == user.id)
+            )
+            await db.execute(
+                delete(ReferralEarning).where(ReferralEarning.referral_id == user.id)
+            )
+            
+            await db.execute(
+                delete(Transaction).where(Transaction.user_id == user.id)
+            )
+            
+            user.status = UserStatus.ACTIVE.value
+            user.balance_kopeks = 0
+            user.remnawave_uuid = None
+            user.has_had_paid_subscription = False
+            user.referred_by_id = None
+            from app.utils.user_utils import generate_unique_referral_code
+            user.referral_code = await generate_unique_referral_code(db, user.telegram_id)
+            
+            await db.commit()
+            
+            logger.info(f"✅ Пользователь {user.telegram_id} подготовлен к восстановлению")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка подготовки к восстановлению: {e}")
+            await db.rollback()
     else:
         logger.info(f"🆕 Новый пользователь, начинаем регистрацию")
-        
-        language = 'ru'
-        texts = get_texts(language)
-        
-        data = await state.get_data() or {}
-        data['language'] = language
-        await state.set_data(data)
-        logger.info(f"💾 Установлен русский язык по умолчанию")
-        
-        await message.answer(
-            texts.RULES_TEXT,
-            reply_markup=get_rules_keyboard(language)
-        )
-        logger.info(f"📋 Правила отправлены")
-        
-        await state.set_state(RegistrationStates.waiting_for_rules_accept)
-        current_state = await state.get_state()
-        logger.info(f"📊 Установлено состояние: {current_state}")
+    
+    language = 'ru'
+    texts = get_texts(language)
+    
+    data = await state.get_data() or {}
+    data['language'] = language
+    await state.set_data(data)
+    logger.info(f"💾 Установлен русский язык по умолчанию")
+    
+    await message.answer(
+        texts.RULES_TEXT,
+        reply_markup=get_rules_keyboard(language)
+    )
+    logger.info(f"📋 Правила отправлены")
+    
+    await state.set_state(RegistrationStates.waiting_for_rules_accept)
+    current_state = await state.get_state()
+    logger.info(f"📊 Установлено состояние: {current_state}")
 
 
 async def process_rules_accept(
@@ -125,7 +182,7 @@ async def process_rules_accept(
                 if referrer:
                     data['referrer_id'] = referrer.id
                     await state.set_data(data)
-                    logger.info(f"✅ Референс найден: {referrer.id}")
+                    logger.info(f"✅ Реферер найден: {referrer.id}")
                 
                 await complete_registration_from_callback(callback, state, db)
             else:
@@ -237,8 +294,9 @@ async def complete_registration_from_callback(
     logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {callback.from_user.id}")
     
     existing_user = await get_user_by_telegram_id(db, callback.from_user.id)
-    if existing_user:
-        logger.warning(f"⚠️ Пользователь {callback.from_user.id} уже существует! Показываем главное меню.")
+    
+    if existing_user and existing_user.status == UserStatus.ACTIVE.value:
+        logger.warning(f"⚠️ Пользователь {callback.from_user.id} уже активен! Показываем главное меню.")
         texts = get_texts(existing_user.language)
         
         has_active_subscription = existing_user.subscription is not None
@@ -282,18 +340,43 @@ async def complete_registration_from_callback(
         if referrer:
             referrer_id = referrer.id
     
-    referral_code = await generate_unique_referral_code(db, callback.from_user.id)
-    
-    user = await create_user(
-        db=db,
-        telegram_id=callback.from_user.id,
-        username=callback.from_user.username,
-        first_name=callback.from_user.first_name,
-        last_name=callback.from_user.last_name,
-        language=language,
-        referred_by_id=referrer_id,
-        referral_code=referral_code 
-    )
+    if existing_user and existing_user.status == UserStatus.DELETED.value:
+        logger.info(f"🔄 Восстанавливаем удаленного пользователя {callback.from_user.id}")
+        
+        existing_user.username = callback.from_user.username
+        existing_user.first_name = callback.from_user.first_name
+        existing_user.last_name = callback.from_user.last_name
+        existing_user.language = language
+        existing_user.referred_by_id = referrer_id
+        existing_user.status = UserStatus.ACTIVE.value
+        existing_user.balance_kopeks = 0
+        existing_user.has_had_paid_subscription = False
+        
+        from datetime import datetime
+        existing_user.updated_at = datetime.utcnow()
+        existing_user.last_activity = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(existing_user)
+        
+        user = existing_user
+        logger.info(f"✅ Пользователь {callback.from_user.id} восстановлен")
+        
+    else:
+        logger.info(f"🆕 Создаем нового пользователя {callback.from_user.id}")
+        
+        referral_code = await generate_unique_referral_code(db, callback.from_user.id)
+        
+        user = await create_user(
+            db=db,
+            telegram_id=callback.from_user.id,
+            username=callback.from_user.username,
+            first_name=callback.from_user.first_name,
+            last_name=callback.from_user.last_name,
+            language=language,
+            referred_by_id=referrer_id,
+            referral_code=referral_code 
+        )
     
     if referrer_id:
         try:
@@ -355,7 +438,7 @@ async def complete_registration_from_callback(
             except Exception as final_error:
                 logger.error(f"❌ Критическая ошибка при отправке простого сообщения: {final_error}")
     
-    logger.info(f"✅ Зарегистрирован новый пользователь: {user_telegram_id}")
+    logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
 
 
 async def complete_registration(
@@ -366,6 +449,8 @@ async def complete_registration(
     
     logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {message.from_user.id}")
     
+    existing_user = await get_user_by_telegram_id(db, message.from_user.id)
+    
     data = await state.get_data()
     language = data.get('language', 'ru')
     texts = get_texts(language)
@@ -376,18 +461,43 @@ async def complete_registration(
         if referrer:
             referrer_id = referrer.id
     
-    referral_code = await generate_unique_referral_code(db, message.from_user.id)
-    
-    user = await create_user(
-        db=db,
-        telegram_id=message.from_user.id,
-        username=message.from_user.username,
-        first_name=message.from_user.first_name,
-        last_name=message.from_user.last_name,
-        language=language,
-        referred_by_id=referrer_id,
-        referral_code=referral_code
-    )
+    if existing_user and existing_user.status == UserStatus.DELETED.value:
+        logger.info(f"🔄 Восстанавливаем удаленного пользователя {message.from_user.id}")
+        
+        existing_user.username = message.from_user.username
+        existing_user.first_name = message.from_user.first_name
+        existing_user.last_name = message.from_user.last_name
+        existing_user.language = language
+        existing_user.referred_by_id = referrer_id
+        existing_user.status = UserStatus.ACTIVE.value
+        existing_user.balance_kopeks = 0
+        existing_user.has_had_paid_subscription = False
+        
+        from datetime import datetime
+        existing_user.updated_at = datetime.utcnow()
+        existing_user.last_activity = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(existing_user)
+        
+        user = existing_user
+        logger.info(f"✅ Пользователь {message.from_user.id} восстановлен")
+        
+    else:
+        logger.info(f"🆕 Создаем нового пользователя {message.from_user.id}")
+        
+        referral_code = await generate_unique_referral_code(db, message.from_user.id)
+        
+        user = await create_user(
+            db=db,
+            telegram_id=message.from_user.id,
+            username=message.from_user.username,
+            first_name=message.from_user.first_name,
+            last_name=message.from_user.last_name,
+            language=language,
+            referred_by_id=referrer_id,
+            referral_code=referral_code
+        )
     
     if referrer_id:
         try:
@@ -449,7 +559,7 @@ async def complete_registration(
             except:
                 pass
     
-    logger.info(f"✅ Зарегистрирован новый пользователь: {user_telegram_id}")
+    logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
 
 
 def _get_subscription_status(user, texts):
@@ -504,4 +614,4 @@ def register_handlers(dp: Dispatcher):
     )
     logger.info("✅ Зарегистрирован process_referral_code_input")
     
-    logger.info("🔧 === КОНЕЦ регистрации обработчиков start.py ===")
+    logger.info("🔧 === КОНЕЦ регистрации обработчиков start.py ===")

app/handlers/subscription.py

@@ -6,7 +6,7 @@ from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
 import json
 import os
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Tuple
 
 from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
 from app.states import SubscriptionStates
@@ -33,7 +33,8 @@ from app.keyboards.inline import (
     get_add_devices_keyboard, get_reset_traffic_confirm_keyboard,
     get_manage_countries_keyboard,
     get_device_selection_keyboard, get_connection_guide_keyboard,
-    get_app_selection_keyboard, get_specific_app_keyboard
+    get_app_selection_keyboard, get_specific_app_keyboard,
+    get_subscription_settings_keyboard, get_extend_subscription_keyboard_with_prices
 )
 from app.localization.texts import get_texts
 from app.services.remnawave_service import RemnaWaveService
@@ -149,67 +150,37 @@ async def get_subscription_cost(subscription, db: AsyncSession) -> int:
         if subscription.is_trial:
             return 0
         
-        from app.database.crud.transaction import get_user_transactions
-        from app.database.models import TransactionType
+        from app.config import TRAFFIC_PRICES, PERIOD_PRICES, settings
+        from app.services.subscription_service import SubscriptionService
         
-        transactions = await get_user_transactions(db, subscription.user_id, limit=100)
+        subscription_service = SubscriptionService()
         
-        logger.info(f"🔍 Всего транзакций у пользователя {subscription.user_id}: {len(transactions)}")
+        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
+            )
         
-        total_subscription_cost = 0
-        base_subscription_cost = 0
-        additions_cost = 0
+        traffic_cost = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
         
-        for transaction in transactions:
-            if transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value:
-                description = transaction.description.lower()
-                amount = transaction.amount_kopeks
-                
-                logger.info(f"📝 Транзакция: {amount/100}₽ - '{transaction.description}'")
-                
-                if 'сброс' in description:
-                    logger.info(f"   ⏭️ Пропускаем сброс")
-                    continue
-                    
-                
-                is_base_subscription = (
-                    ('подписка' in description and 'дней' in description) or
-                    ('покупка' in description and 'подписка' in description) or
-                    ('subscription' in description and 'days' in description)
-                )
-                
-                if is_base_subscription:
-                    base_subscription_cost += amount
-                    logger.info(f"   💎 Основная подписка: +{amount/100}₽")
-                    continue
-                
-                is_addition = any(keyword in description for keyword in [
-                    'добавление', 'добавить', 'продление', 'продлить'
-                ])
-                
-                if is_addition:
-                    additions_cost += amount
-                    logger.info(f"   🔧 Дополнение: +{amount/100}₽")
-                    continue
-                
-                if amount >= 50000:
-                    base_subscription_cost += amount
-                    logger.info(f"   💰 Крупная транзакция подписки: +{amount/100}₽")
-                    continue
-                
-                logger.info(f"   ❓ Неопознанная транзакция, пропускаем")
+        devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
         
-        total_subscription_cost = base_subscription_cost + additions_cost
+        base_cost = min(PERIOD_PRICES.values()) if PERIOD_PRICES else 0
         
-        if total_subscription_cost > 0:
-            logger.info(f"💰 Итого стоимость подписки:")
-            logger.info(f"   📦 Базовая подписка: {base_subscription_cost/100}₽")
-            logger.info(f"   🔧 Дополнения: {additions_cost/100}₽")
-            logger.info(f"   💎 ОБЩАЯ СТОИМОСТЬ: {total_subscription_cost/100}₽")
-            return total_subscription_cost
-        else:
-            logger.warning(f"⚠️ Стоимость подписки не найдена для пользователя {subscription.user_id}")
-            return 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}₽")
+        
+        return total_cost
         
     except Exception as e:
         logger.error(f"❌ Ошибка расчета стоимости подписки: {e}")
@@ -390,6 +361,36 @@ async def handle_add_countries(
     
     await callback.answer()
 
+async def get_countries_price_by_uuids_fallback(country_uuids: List[str], db: AsyncSession) -> Tuple[int, List[int]]:
+    try:
+        from app.database.crud.server_squad import get_server_squad_by_uuid
+        
+        total_price = 0
+        prices_list = []
+        
+        for country_uuid in country_uuids:
+            try:
+                server = await get_server_squad_by_uuid(db, country_uuid)
+                if server and server.is_available and not server.is_full:
+                    price = server.price_kopeks
+                    total_price += price
+                    prices_list.append(price)
+                else:
+                    default_price = 1000
+                    total_price += default_price
+                    prices_list.append(default_price)
+            except Exception:
+                default_price = 1000
+                total_price += default_price
+                prices_list.append(default_price)
+        
+        return total_price, prices_list
+        
+    except Exception as e:
+        logger.error(f"Ошибка fallback функции: {e}")
+        default_prices = [1000] * len(country_uuids)
+        return sum(default_prices), default_prices
+
 async def handle_manage_country(
     callback: types.CallbackQuery,
     db_user: User,
@@ -446,13 +447,14 @@ async def apply_countries_changes(
     logger.info(f"🔍 Применение изменений стран")
     
     data = await state.get_data()
-    new_countries = data.get('countries', [])
-    
+    texts = get_texts(db_user.language)
     subscription = db_user.subscription
-    old_countries = subscription.connected_squads
     
-    added = [c for c in new_countries if c not in old_countries]
-    removed = [c for c in old_countries if c not in new_countries]
+    selected_countries = data.get('countries', [])
+    current_countries = subscription.connected_squads
+    
+    added = [c for c in selected_countries if c not in current_countries]
+    removed = [c for c in current_countries if c not in selected_countries]
     
     if not added and not removed:
         await callback.answer("⚠️ Изменения не обнаружены", show_alert=True)
@@ -465,15 +467,17 @@ async def apply_countries_changes(
     added_names = []
     removed_names = []
     
+    added_server_prices = []
+    added_server_ids = []
+    
     for country in countries:
         if country['uuid'] in added:
             cost += country['price_kopeks']
             added_names.append(country['name'])
+            added_server_prices.append(country['price_kopeks'])
         if country['uuid'] in removed:
             removed_names.append(country['name'])
     
-    texts = get_texts(db_user.language)
-    
     if cost > 0 and db_user.balance_kopeks < cost:
         await callback.answer(
             f"❌ Недостаточно средств!\nТребуется: {texts.format_price(cost)}\nУ вас: {texts.format_price(db_user.balance_kopeks)}", 
@@ -482,7 +486,7 @@ async def apply_countries_changes(
         return
     
     try:
-        if cost > 0:
+        if added and cost > 0:
             success = await subtract_user_balance(
                 db, db_user, cost, 
                 f"Добавление стран: {', '.join(added_names)}"
@@ -499,7 +503,19 @@ async def apply_countries_changes(
                 description=f"Добавление стран к подписке: {', '.join(added_names)}"
             )
         
-        subscription.connected_squads = new_countries
+        if added:
+            from app.database.crud.server_squad import get_server_ids_by_uuids, add_user_to_servers
+            from app.database.crud.subscription import add_subscription_servers
+            
+            added_server_ids = await get_server_ids_by_uuids(db, added)
+            
+            if added_server_ids:
+                await add_subscription_servers(db, subscription, added_server_ids, added_server_prices)
+                await add_user_to_servers(db, added_server_ids)
+                
+                logger.info(f"📊 Добавлены серверы с ценами: {list(zip(added_server_ids, added_server_prices))}")
+        
+        subscription.connected_squads = selected_countries
         subscription.updated_at = datetime.utcnow()
         await db.commit()
         
@@ -533,7 +549,7 @@ async def apply_countries_changes(
             success_text += "\n".join(f"• {name}" for name in removed_names)
             success_text += "\nℹ️ Повторное подключение будет платным\n"
         
-        success_text += f"\n🌍 <b>Активных стран:</b> {len(new_countries)}"
+        success_text += f"\n🌍 <b>Активных стран:</b> {len(selected_countries)}"
         
         await callback.message.edit_text(
             success_text,
@@ -625,11 +641,27 @@ async def handle_extend_subscription(
         await callback.answer("❌ Продление доступно за 3 дня до окончания подписки", show_alert=True)
         return
     
+    subscription_service = SubscriptionService()
+    
+    renewal_prices = {}
+    for days in [30, 90, 180]:
+        price = await subscription_service.calculate_renewal_price(subscription, days, db)
+        renewal_prices[days] = price
+    
     await callback.message.edit_text(
         f"⏰ <b>Продление подписки</b>\n\n"
-        f"Осталось дней: {subscription.days_left}\n"
-        f"Выберите период продления:",
-        reply_markup=get_extend_subscription_keyboard(db_user.language)
+        f"Осталось дней: {subscription.days_left}\n\n"
+        f"<b>Ваша текущая конфигурация:</b>\n"
+        f"🌍 Серверов: {len(subscription.connected_squads)}\n"
+        f"📊 Трафик: {texts.format_traffic(subscription.traffic_limit_gb)}\n"
+        f"📱 Устройств: {subscription.device_limit}\n\n"
+        f"<b>Выберите период продления:</b>\n"
+        f"📅 30 дней - {texts.format_price(renewal_prices[30])}\n"
+        f"📅 90 дней - {texts.format_price(renewal_prices[90])}\n"
+        f"📅 180 дней - {texts.format_price(renewal_prices[180])}\n\n"
+        f"💡 <i>Цена включает все ваши текущие серверы и настройки</i>",
+        reply_markup=get_extend_subscription_keyboard_with_prices(db_user.language, renewal_prices),
+        parse_mode="HTML"
     )
     
     await callback.answer()
@@ -831,7 +863,8 @@ async def confirm_extend_subscription(
     texts = get_texts(db_user.language)
     subscription = db_user.subscription
     
-    price = PERIOD_PRICES[days]
+    subscription_service = SubscriptionService()
+    price = await subscription_service.calculate_renewal_price(subscription, days, db)
     
     if db_user.balance_kopeks < price:
         await callback.answer("❌ Недостаточно средств на балансе", show_alert=True)
@@ -876,11 +909,12 @@ async def confirm_extend_subscription(
         await callback.message.edit_text(
             f"✅ Подписка успешно продлена!\n\n"
             f"⏰ Добавлено: {days} дней\n"
-            f"Действует до: {subscription.end_date.strftime('%d.%m.%Y %H:%M')}",
+            f"Действует до: {subscription.end_date.strftime('%d.%m.%Y %H:%M')}\n\n"
+            f"💰 Списано: {texts.format_price(price)}",
             reply_markup=get_back_keyboard(db_user.language)
         )
         
-        logger.info(f"✅ Пользователь {db_user.telegram_id} продлил подписку на {days} дней")
+        logger.info(f"✅ Пользователь {db_user.telegram_id} продлил подписку на {days} дней за {price/100}₽")
         
     except Exception as e:
         logger.error(f"Ошибка продления подписки: {e}")
@@ -892,6 +926,34 @@ async def confirm_extend_subscription(
     await callback.answer()
 
 
+def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text=f"📅 30 дней - {texts.format_price(prices[30])}", 
+                callback_data="extend_period_30"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=f"📅 90 дней - {texts.format_price(prices[90])}", 
+                callback_data="extend_period_90"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=f"📅 180 дней - {texts.format_price(prices[180])}", 
+                callback_data="extend_period_180"
+            )
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ])
+
+
 async def confirm_reset_traffic(
     callback: types.CallbackQuery,
     db_user: User,
@@ -1011,7 +1073,8 @@ async def select_traffic(
 async def select_country(
     callback: types.CallbackQuery,
     state: FSMContext,
-    db_user: User
+    db_user: User,
+    db: AsyncSession
 ):
     
     country_uuid = callback.data.split('_')[1]
@@ -1027,10 +1090,12 @@ async def select_country(
     
     base_price = PERIOD_PRICES[data['period_days']] + TRAFFIC_PRICES[data['traffic_gb']]
     
-    countries_price = 0
-    for country in countries:
-        if country['uuid'] in selected_countries:
-            countries_price += country['price_kopeks']
+    try:
+        subscription_service = SubscriptionService()
+        countries_price, _ = await subscription_service.get_countries_price_by_uuids(selected_countries, db)
+    except AttributeError:
+        logger.warning("Используем fallback функцию для расчета цен стран")
+        countries_price, _ = await get_countries_price_by_uuids_fallback(selected_countries, db)
     
     data['countries'] = selected_countries
     data['total_price'] = base_price + countries_price
@@ -1107,7 +1172,8 @@ async def select_devices(
 async def devices_continue(
     callback: types.CallbackQuery,
     state: FSMContext,
-    db_user: User
+    db_user: User,
+    db: AsyncSession
 ):
     
     if not callback.data == "devices_continue":
@@ -1118,17 +1184,32 @@ async def devices_continue(
     texts = get_texts(db_user.language)
     
     countries = await _get_available_countries()
-    selected_countries_names = [
-        c['name'] for c in countries 
-        if c['uuid'] in data['countries']
-    ]
+    selected_countries_names = []
+    
+    try:
+        subscription_service = SubscriptionService()
+        countries_price, _ = await subscription_service.get_countries_price_by_uuids(data['countries'], db)
+    except AttributeError:
+        logger.warning("Используем fallback функцию для расчета цен стран")
+        countries_price, _ = await get_countries_price_by_uuids_fallback(data['countries'], db)
+    
+    for country in countries:
+        if country['uuid'] in data['countries']:
+            selected_countries_names.append(country['name'])
+    
+    base_price = PERIOD_PRICES[data['period_days']] + TRAFFIC_PRICES[data['traffic_gb']]
+    devices_price = (data['devices'] - 1) * settings.PRICE_PER_DEVICE
+    total_price = base_price + countries_price + devices_price
+    
+    data['total_price'] = total_price
+    await state.set_data(data)
     
     summary_text = texts.SUBSCRIPTION_SUMMARY.format(
         period=data['period_days'],
         traffic=texts.format_traffic(data['traffic_gb']),
         countries=", ".join(selected_countries_names),
         devices=data['devices'],
-        total_price=texts.format_price(data['total_price'])
+        total_price=texts.format_price(total_price)
     )
     
     await callback.message.edit_text(
@@ -1154,9 +1235,11 @@ async def confirm_purchase(
     base_price = PERIOD_PRICES[data['period_days']] + TRAFFIC_PRICES[data['traffic_gb']]
     
     countries_price = 0
+    server_prices = []
     for country in countries:
         if country['uuid'] in data['countries']:
             countries_price += country['price_kopeks']
+            server_prices.append(country['price_kopeks'])
     
     devices_price = (data['devices'] - 1) * settings.PRICE_PER_DEVICE
     final_price = base_price + countries_price + devices_price
@@ -1224,20 +1307,10 @@ async def confirm_purchase(
         server_ids = await get_server_ids_by_uuids(db, data['countries'])
         
         if server_ids:
-            countries = await _get_available_countries()
-            server_prices = []
-            for country_uuid in data['countries']:
-                for country in countries:
-                    if country['uuid'] == country_uuid:
-                        server_prices.append(country['price_kopeks'])
-                        break
-                else:
-                    server_prices.append(0)
-            
             await add_subscription_servers(db, subscription, server_ids, server_prices)
-            
             await add_user_to_servers(db, server_ids)
             
+            logger.info(f"📊 Сохранены цены серверов: {server_prices}")
             logger.info(f"📊 Обновлены счетчики пользователей для серверов: {server_ids}")
         
         await db.refresh(db_user)
@@ -1311,6 +1384,38 @@ async def confirm_purchase(
     await state.clear()
     await callback.answer()
 
+async def handle_subscription_settings(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    subscription = db_user.subscription
+    
+    if not subscription or subscription.is_trial:
+        await callback.answer("⚠️ Настройки доступны только для платных подписок", show_alert=True)
+        return
+    
+    devices_used = await get_current_devices_count(db_user)
+    
+    settings_text = f"""
+⚙️ <b>Настройки подписки</b>
+
+📊 <b>Текущие параметры:</b>
+🌍 Стран: {len(subscription.connected_squads)}
+📈 Трафик: {texts.format_traffic(subscription.traffic_used_gb)} / {texts.format_traffic(subscription.traffic_limit_gb)}
+📱 Устройства: {devices_used} / {subscription.device_limit}
+
+Выберите что хотите изменить:
+"""
+    
+    await callback.message.edit_text(
+        settings_text,
+        reply_markup=get_subscription_settings_keyboard(db_user.language),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
 
 async def handle_autopay_menu(
     callback: types.CallbackQuery,
@@ -1841,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()
 
 
@@ -2292,3 +2460,8 @@ def register_handlers(dp: Dispatcher):
         handle_open_subscription_link,
         F.data == "open_subscription_link"
     )
+
+    dp.callback_query.register(
+        handle_subscription_settings,
+        F.data == "subscription_settings"
+    )

app/handlers/subscription_notifications.py

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

app/keyboards/admin.py

@@ -172,24 +172,38 @@ def get_admin_statistics_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     ])
 
 
-def get_user_management_keyboard(user_id: int, language: str = "ru") -> InlineKeyboardMarkup:
-    return InlineKeyboardMarkup(inline_keyboard=[
+def get_user_management_keyboard(user_id: int, user_status: str, language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = [
         [
             InlineKeyboardButton(text="💰 Баланс", callback_data=f"admin_user_balance_{user_id}"),
-            InlineKeyboardButton(text="📱 Подписка", callback_data=f"admin_user_sub_{user_id}")
-        ],
-        [
-            InlineKeyboardButton(text="📊 Статистика", callback_data=f"admin_user_stats_{user_id}"),
-            InlineKeyboardButton(text="📋 Транзакции", callback_data=f"admin_user_trans_{user_id}")
+            InlineKeyboardButton(text="📱 Подписка", callback_data=f"admin_user_subscription_{user_id}")
         ],
         [
+            InlineKeyboardButton(text="📊 Статистика", callback_data=f"admin_user_statistics_{user_id}"),
+            InlineKeyboardButton(text="📋 Транзакции", callback_data=f"admin_user_transactions_{user_id}")
+        ]
+    ]
+    
+    if user_status == "active":
+        keyboard.append([
             InlineKeyboardButton(text="🚫 Заблокировать", callback_data=f"admin_user_block_{user_id}"),
             InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_user_delete_{user_id}")
-        ],
-        [
-            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users_list")
-        ]
+        ])
+    elif user_status == "blocked":
+        keyboard.append([
+            InlineKeyboardButton(text="✅ Разблокировать", callback_data=f"admin_user_unblock_{user_id}"),
+            InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_user_delete_{user_id}")
+        ])
+    elif user_status == "deleted":
+        keyboard.append([
+            InlineKeyboardButton(text="❌ Пользователь удален", callback_data="noop")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users_list")
     ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
 def get_confirmation_keyboard(
@@ -293,8 +307,8 @@ def get_custom_criteria_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
             InlineKeyboardButton(text="⚡ Активные сегодня", callback_data="criteria_active_today")
         ],
         [
-            InlineKeyboardButton(text="💤 Неактивные 7+ дней", callback_data="criteria_inactive_week"),
-            InlineKeyboardButton(text="💤 Неактивные 30+ дней", callback_data="criteria_inactive_month")
+            InlineKeyboardButton(text="👤 Неактивные 7+ дней", callback_data="criteria_inactive_week"),
+            InlineKeyboardButton(text="👤 Неактивные 30+ дней", callback_data="criteria_inactive_month")
         ],
         [
             InlineKeyboardButton(text="🤝 Через рефералов", callback_data="criteria_referrals"),

app/keyboards/inline.py

@@ -97,13 +97,34 @@ def get_subscription_keyboard(
     is_trial: bool = False,
     subscription=None
 ) -> InlineKeyboardMarkup:
+    from app.config import settings 
+    
     texts = get_texts(language)
     keyboard = []
     
     if has_subscription:
         if subscription and subscription.subscription_url:
+            connect_mode = settings.CONNECT_BUTTON_MODE
+            
+            if connect_mode == "miniapp_subscription":
+                button_text = "🚀 Подключить подписку"
+            elif connect_mode == "miniapp_custom":
+                button_text = "🚀 Подключить подписку"
+            else:
+                button_text = "🔗 Подключиться"
+                
             keyboard.append([
-                InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
+                InlineKeyboardButton(text=button_text, callback_data="subscription_connect")
+            ])
+        
+        if not is_trial and subscription and subscription.days_left <= 3:
+            keyboard.append([
+                InlineKeyboardButton(text="⏰ Продлить", callback_data="subscription_extend")
+            ])
+        
+        if not is_trial:
+            keyboard.append([
+                InlineKeyboardButton(text="💳 Автоплатеж", callback_data="subscription_autopay")
             ])
         
         if is_trial:
@@ -111,35 +132,9 @@ def get_subscription_keyboard(
                 InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="subscription_upgrade")
             ])
         else:
-            row1 = []
-            row2 = []
-            row3 = []
-            row4 = [] 
-            
-            row1.append(InlineKeyboardButton(text="🌐 Добавить страны", callback_data="subscription_add_countries"))
-            
-            if subscription and subscription.traffic_limit_gb > 0:
-                row1.append(InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic"))
-            
-            row2.append(InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices"))
-            
-            if subscription and subscription.days_left <= 3:
-                row2.append(InlineKeyboardButton(text="⏰ Продлить", callback_data="subscription_extend"))
-            
-            row3.append(InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic"))
-            
-            row3.append(InlineKeyboardButton(text="💳 Автоплатеж", callback_data="subscription_autopay"))
-            
-            row4.append(InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices"))
-            
-            if row1:
-                keyboard.append(row1)
-            if row2:
-                keyboard.append(row2)
-            if row3:
-                keyboard.append(row3)
-            if row4:
-                keyboard.append(row4)
+            keyboard.append([
+                InlineKeyboardButton(text="⚙️ Настройки подписки", callback_data="subscription_settings")
+            ])
     
     keyboard.append([
         InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
@@ -147,6 +142,31 @@ def get_subscription_keyboard(
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
+def get_subscription_settings_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = [
+        [
+            InlineKeyboardButton(text="🌍 Добавить страны", callback_data="subscription_add_countries")
+        ],
+        [
+            InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic")
+        ],
+        [
+            InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
 
 def get_trial_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
@@ -283,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)
@@ -596,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(
@@ -735,3 +812,31 @@ def get_specific_app_keyboard(
     ])
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
+    from app.localization.texts import get_texts
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text=f"📅 30 дней - {texts.format_price(prices[30])}", 
+                callback_data="extend_period_30"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=f"📅 90 дней - {texts.format_price(prices[90])}", 
+                callback_data="extend_period_90"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=f"📅 180 дней - {texts.format_price(prices[180])}", 
+                callback_data="extend_period_180"
+            )
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ])

app/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>
 Переходите на полную подписку!
@@ -354,7 +354,7 @@ class RussianTexts(Texts):
     ADMIN_MONITORING = "🔍 Мониторинг"
     ADMIN_REFERRALS = "🤝 Рефералы"
     ADMIN_RULES = "📋 Правила"
-    ADMIN_REMNAWAVE = "🖥️ RemnaWave"
+    ADMIN_REMNAWAVE = "🖥️ Remnawave"
     ADMIN_STATISTICS = "📊 Статистика"
     
     ACCESS_DENIED = "❌ Доступ запрещен"
@@ -485,4 +485,4 @@ async def refresh_rules_cache(language: str = "ru"):
 def clear_rules_cache():
     global _cached_rules
     _cached_rules.clear()
-    print("✅ Кеш правил очищен")
+    print("✅ Кеш правил очищен")

app/middlewares/auth.py

@@ -56,7 +56,7 @@ class AuthMiddleware(BaseMiddleware):
                     )
                     
                     if is_registration_process:
-                        logger.info(f"🔓 Пропускаем пользователя {user.id} в процессе регистрации")
+                        logger.info(f"📝 Пропускаем пользователя {user.id} в процессе регистрации")
                         data['db'] = db
                         data['db_user'] = None
                         data['is_admin'] = False
@@ -64,24 +64,74 @@ class AuthMiddleware(BaseMiddleware):
                     else:
                         if isinstance(event, Message):
                             await event.answer(
-                                "◀️ Для начала работы необходимо выполнить команду /start"
+                                "▶️ Для начала работы необходимо выполнить команду /start"
                             )
                         elif isinstance(event, CallbackQuery):
                             await event.answer(
-                                "◀️ Необходимо начать с команды /start",
+                                "▶️ Необходимо начать с команды /start",
                                 show_alert=True
                             )
                         logger.info(f"🚫 Заблокирован незарегистрированный пользователь {user.id}")
                         return
                 else:
+                    from app.database.models import UserStatus
+                    
+                    if db_user.status == UserStatus.BLOCKED.value:
+                        if isinstance(event, Message):
+                            await event.answer("🚫 Ваш аккаунт заблокирован администратором.")
+                        elif isinstance(event, CallbackQuery):
+                            await event.answer("🚫 Ваш аккаунт заблокирован администратором.", show_alert=True)
+                        logger.info(f"🚫 Заблокированный пользователь {user.id} попытался использовать бота")
+                        return
+                    
+                    if db_user.status == UserStatus.DELETED.value:
+                        state: FSMContext = data.get('state')
+                        current_state = None
+                        
+                        if state:
+                            current_state = await state.get_state()
+                        
+                        registration_states = [
+                            RegistrationStates.waiting_for_rules_accept,
+                            RegistrationStates.waiting_for_referral_code
+                        ]
+                        
+                        is_start_or_registration = (
+                            (isinstance(event, Message) and event.text and event.text.startswith('/start'))
+                            or (isinstance(event, CallbackQuery) and current_state and 
+                                any(str(state) in str(current_state) for state in registration_states))
+                            or (isinstance(event, CallbackQuery) and event.data and 
+                                (event.data in ['rules_accept', 'rules_decline', 'referral_skip']))
+                        )
+                        
+                        if is_start_or_registration:
+                            logger.info(f"🔄 Удаленный пользователь {user.id} начинает повторную регистрацию")
+                            data['db'] = db
+                            data['db_user'] = None 
+                            data['is_admin'] = False
+                            return await handler(event, data)
+                        else:
+                            if isinstance(event, Message):
+                                await event.answer(
+                                    "❌ Ваш аккаунт был удален.\n"
+                                    "🔄 Для повторной регистрации выполните команду /start"
+                                )
+                            elif isinstance(event, CallbackQuery):
+                                await event.answer(
+                                    "❌ Ваш аккаунт был удален. Для повторной регистрации выполните /start",
+                                    show_alert=True
+                                )
+                            logger.info(f"❌ Удаленный пользователь {user.id} попытался использовать бота без /start")
+                            return
+                    
                     from datetime import datetime
                     db_user.last_activity = datetime.utcnow()
                     await db.commit()
-                
+
                 data['db'] = db
                 data['db_user'] = db_user
                 data['is_admin'] = settings.is_admin(user.id)
-                
+
                 return await handler(event, data)
                 
             except Exception as e:
@@ -90,4 +140,4 @@ class AuthMiddleware(BaseMiddleware):
                 if hasattr(event, 'data'):
                     logger.error(f"Callback data: {event.data}")
                 await db.rollback()
-                raise
+                raise

app/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()

app/services/subscription_service.py

@@ -200,34 +200,113 @@ class SubscriptionService:
         devices: int,
         db: AsyncSession 
     ) -> Tuple[int, List[int]]:
-    
+
         from app.config import PERIOD_PRICES, TRAFFIC_PRICES
         from app.database.crud.server_squad import get_server_squad_by_id
-    
+
         base_price = PERIOD_PRICES.get(period_days, 0)
         traffic_price = TRAFFIC_PRICES.get(traffic_gb, 0)
-    
+
         server_prices = []
         total_servers_price = 0
-    
+
         for server_id in server_squad_ids:
             server = await get_server_squad_by_id(db, server_id)
             if server and server.is_available and not server.is_full:
                 server_prices.append(server.price_kopeks)
                 total_servers_price += server.price_kopeks
+                logger.debug(f"🏷️ Сервер {server.display_name}: {server.price_kopeks/100}₽")
             else:
                 server_prices.append(0)
-    
+                logger.warning(f"⚠️ Сервер ID {server_id} недоступен")
+
         devices_price = max(0, devices - 1) * settings.PRICE_PER_DEVICE
         
         total_price = base_price + traffic_price + total_servers_price + devices_price
+        
+        logger.info(f"💰 Расчет стоимости новой подписки:")
+        logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+        logger.info(f"   📊 Трафик {traffic_gb} ГБ: {traffic_price/100}₽")
+        logger.info(f"   🌍 Серверы ({len(server_squad_ids)}): {total_servers_price/100}₽")
+        logger.info(f"   📱 Устройства ({devices}): {devices_price/100}₽")
+        logger.info(f"   💎 ИТОГО: {total_price/100}₽")
+        
         return total_price, server_prices
     
-    async def _get_countries_price(self, country_uuids: List[str]) -> int:
-        # TODO: Реализовать получение цен из базы данных сквадов
-        # Пока возвращаем базовую логику
-        price_per_country = 1000 
-        return len(country_uuids) * price_per_country
+    async def calculate_renewal_price(
+        self,
+        subscription: Subscription,
+        period_days: int,
+        db: AsyncSession
+    ) -> int:
+        try:
+            from app.config import PERIOD_PRICES, TRAFFIC_PRICES
+            
+            base_price = PERIOD_PRICES.get(period_days, 0)
+            
+            servers_price, _ = await self.get_countries_price_by_uuids(
+                subscription.connected_squads, db
+            )
+            
+            devices_price = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+            
+            traffic_price = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
+            
+            total_price = base_price + servers_price + devices_price + traffic_price
+            
+            logger.info(f"💰 Расчет стоимости продления для подписки {subscription.id} (по текущим ценам):")
+            logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+            logger.info(f"   🌍 Серверы ({len(subscription.connected_squads)}) по текущим ценам: {servers_price/100}₽")
+            logger.info(f"   📱 Устройства ({subscription.device_limit}): {devices_price/100}₽")
+            logger.info(f"   📊 Трафик ({subscription.traffic_limit_gb} ГБ): {traffic_price/100}₽")
+            logger.info(f"   💎 ИТОГО: {total_price/100}₽")
+            
+            return total_price
+            
+        except Exception as e:
+            logger.error(f"Ошибка расчета стоимости продления: {e}")
+            from app.config import PERIOD_PRICES
+            return PERIOD_PRICES.get(period_days, 0)
+    
+    async def get_countries_price_by_uuids(
+        self, 
+        country_uuids: List[str], 
+        db: AsyncSession
+    ) -> Tuple[int, List[int]]:
+        try:
+            from app.database.crud.server_squad import get_server_squad_by_uuid
+            
+            total_price = 0
+            prices_list = []
+            
+            for country_uuid in country_uuids:
+                server = await get_server_squad_by_uuid(db, country_uuid)
+                if server and server.is_available and not server.is_full:
+                    price = server.price_kopeks
+                    total_price += price
+                    prices_list.append(price)
+                    logger.debug(f"🏷️ Страна {server.display_name}: {price/100}₽")
+                else:
+                    default_price = 1000  
+                    total_price += default_price
+                    prices_list.append(default_price)
+                    logger.warning(f"⚠️ Сервер {country_uuid} недоступен, используем базовую цену: {default_price/100}₽")
+            
+            logger.info(f"💰 Общая стоимость стран: {total_price/100}₽")
+            return total_price, prices_list
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения цен стран: {e}")
+            default_prices = [1000] * len(country_uuids)
+            return sum(default_prices), default_prices
+    
+    async def _get_countries_price(self, country_uuids: List[str], db: AsyncSession) -> int:
+        try:
+            total_price, _ = await self.get_countries_price_by_uuids(country_uuids, db)
+            return total_price
+        except Exception as e:
+            logger.error(f"Ошибка получения цен стран: {e}")
+            return len(country_uuids) * 1000
     
     def _gb_to_bytes(self, gb: int) -> int:
         if gb == 0: 
@@ -237,4 +316,4 @@ class SubscriptionService:
     def _bytes_to_gb(self, bytes_value: int) -> float:
         if bytes_value == 0:
             return 0.0
-        return bytes_value / (1024 * 1024 * 1024)
+        return bytes_value / (1024 * 1024 * 1024)

app/services/user_service.py

@@ -2,6 +2,7 @@ import logging
 from datetime import datetime, timedelta
 from typing import Optional, List, Dict, Any
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import delete
 
 from app.database.crud.user import (
     get_user_by_id, get_user_by_telegram_id, get_users_list,
@@ -10,7 +11,10 @@ from app.database.crud.user import (
 )
 from app.database.crud.transaction import get_user_transactions_count
 from app.database.crud.subscription import get_subscription_by_user_id
-from app.database.models import User, UserStatus
+from app.database.models import (
+    User, UserStatus, Subscription, Transaction, PromoCodeUse, 
+    ReferralEarning, SubscriptionServer
+)
 from app.config import settings
 
 logger = logging.getLogger(__name__)
@@ -157,6 +161,19 @@ class UserService:
             if not user:
                 return False
             
+            if user.remnawave_uuid:
+                try:
+                    from app.services.subscription_service import SubscriptionService
+                    subscription_service = SubscriptionService()
+                    await subscription_service.disable_remnawave_user(user.remnawave_uuid)
+                    logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован при блокировке")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка деактивации RemnaWave пользователя при блокировке: {e}")
+            
+            if user.subscription:
+                from app.database.crud.subscription import deactivate_subscription
+                await deactivate_subscription(db, user.subscription)
+            
             await update_user(db, user, status=UserStatus.BLOCKED.value)
             
             logger.info(f"Админ {admin_id} заблокировал пользователя {user_id}: {reason}")
@@ -179,6 +196,27 @@ class UserService:
             
             await update_user(db, user, status=UserStatus.ACTIVE.value)
             
+            if user.subscription:
+                from datetime import datetime
+                from app.database.models import SubscriptionStatus
+                
+                if user.subscription.end_date > datetime.utcnow():
+                    user.subscription.status = SubscriptionStatus.ACTIVE.value
+                    await db.commit()
+                    await db.refresh(user.subscription)
+                    logger.info(f"🔄 Подписка пользователя {user_id} восстановлена")
+                    
+                    if user.remnawave_uuid:
+                        try:
+                            from app.services.subscription_service import SubscriptionService
+                            subscription_service = SubscriptionService()
+                            await subscription_service.update_remnawave_user(db, user.subscription)
+                            logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} восстановлен при разблокировке")
+                        except Exception as e:
+                            logger.error(f"❌ Ошибка восстановления RemnaWave пользователя при разблокировке: {e}")
+                else:
+                    logger.info(f"⏰ Подписка пользователя {user_id} истекла, восстановление невозможно")
+            
             logger.info(f"Админ {admin_id} разблокировал пользователя {user_id}")
             return True
             
@@ -195,17 +233,100 @@ class UserService:
         try:
             user = await get_user_by_id(db, user_id)
             if not user:
+                logger.warning(f"Пользователь {user_id} не найден для удаления")
                 return False
             
-            success = await delete_user(db, user)
+            logger.info(f"🗑️ Начинаем полное удаление пользователя {user_id} (Telegram ID: {user.telegram_id})")
             
-            if success:
-                logger.info(f"Админ {admin_id} удалил пользователя {user_id}")
+            if user.remnawave_uuid:
+                try:
+                    from app.services.subscription_service import SubscriptionService
+                    subscription_service = SubscriptionService()
+                    await subscription_service.disable_remnawave_user(user.remnawave_uuid)
+                    logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка деактивации RemnaWave пользователя: {e}")
             
-            return success
+            if user.subscription:
+                try:
+                    await db.execute(
+                        delete(SubscriptionServer).where(
+                            SubscriptionServer.subscription_id == user.subscription.id
+                        )
+                    )
+                    logger.info(f"🗑️ Удалены записи SubscriptionServer для подписки {user.subscription.id}")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка удаления SubscriptionServer: {e}")
+            
+            if user.subscription:
+                try:
+                    await db.delete(user.subscription)
+                    logger.info(f"🗑️ Удалена подписка пользователя {user_id}")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка удаления подписки: {e}")
+            
+            try:
+                await db.execute(
+                    delete(PromoCodeUse).where(PromoCodeUse.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены использования промокодов пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления использований промокодов: {e}")
+            
+            try:
+                await db.execute(
+                    delete(ReferralEarning).where(ReferralEarning.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены реферальные доходы пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления реферальных доходов: {e}")
+            
+            try:
+                await db.execute(
+                    delete(ReferralEarning).where(ReferralEarning.referral_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены реферальные записи о пользователе {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления реферальных записей: {e}")
+            
+            try:
+                from sqlalchemy import update
+                await db.execute(
+                    update(User)
+                    .where(User.referred_by_id == user.id)
+                    .values(referred_by_id=None)
+                )
+                logger.info(f"🗑️ Очищены реферальные ссылки у рефералов пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка очистки реферальных ссылок: {e}")
+            
+            try:
+                await db.execute(
+                    delete(Transaction).where(Transaction.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены транзакции пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления транзакций: {e}")
+            
+            try:
+                user.status = UserStatus.DELETED.value
+                user.balance_kopeks = 0
+                user.remnawave_uuid = None
+                user.updated_at = datetime.utcnow()
+                
+                await db.commit()
+                logger.info(f"✅ Пользователь {user_id} помечен как удаленный и обнулен")
+            except Exception as e:
+                logger.error(f"❌ Ошибка обновления статуса пользователя: {e}")
+                await db.rollback()
+                return False
+            
+            logger.info(f"✅ Пользователь {user_id} (Telegram ID: {user.telegram_id}) полностью удален админом {admin_id}")
+            return True
             
         except Exception as e:
-            logger.error(f"Ошибка удаления пользователя: {e}")
+            logger.error(f"❌ Критическая ошибка удаления пользователя {user_id}: {e}")
+            await db.rollback()
             return False
     
     async def get_user_statistics(self, db: AsyncSession) -> Dict[str, Any]:
@@ -237,7 +358,7 @@ class UserService:
             deleted_count = 0
             
             for user in inactive_users:
-                success = await delete_user(db, user)
+                success = await self.delete_user_account(db, user.id, 0) 
                 if success:
                     deleted_count += 1
             
@@ -281,7 +402,7 @@ class UserService:
                 "subscription_active": subscription.is_active if subscription else False,
                 "subscription_trial": subscription.is_trial if subscription else False,
                 "transactions_count": transactions_count,
-                "referrer_id": user.referrer_id,
+                "referrer_id": user.referred_by_id,
                 "referral_code": user.referral_code
             }
             
@@ -330,4 +451,4 @@ class UserService:
             
         except Exception as e:
             logger.error(f"Ошибка получения пользователей по критериям: {e}")
-            return []
+            return []

requirements.txt

@@ -1,12 +1,12 @@
 # Основные зависимости
-aiogram==3.4.1
+aiogram==3.7.0
 aiohttp==3.9.1
 asyncpg==0.29.0
 SQLAlchemy==2.0.25
 alembic==1.13.1
 aiosqlite==0.19.0
 
-# Дополнительные зависимости
+# Дополнительные зависимости  
 pydantic==2.5.3
 pydantic-settings==2.1.0
 python-dotenv==1.0.0