Merge pull request #24 from Fr1ngg/dev

Изменение логики расчета цен за доп. услуги (трафик, сервера, устройства). Теперь рассчитывается цена за месяц

.env.example

@@ -26,14 +26,25 @@ REMNAWAVE_API_KEY=
 # Для панелей установленных скриптом eGames прописывать ключ в формате XXXXXXX:DDDDDDDD - https://panel.example.com/auth/login?XXXXXXX=DDDDDDDD
 REMNAWAVE_SECRET_KEY=your_secret_key_here
 
+# ========= ПОДПИСКИ =========
 # ===== ТРИАЛ ПОДПИСКА =====
 TRIAL_DURATION_DAYS=3
 TRIAL_TRAFFIC_LIMIT_GB=10
 TRIAL_DEVICE_LIMIT=1
 TRIAL_SQUAD_UUID=
-DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+
+# ===== ПЛАТНАЯ ПОДПИСКА =====
+# Сколько устройств доступно по дефолту при покупке платной подписки
+DEFAULT_DEVICE_LIMIT=3
+
+# Максимум устройств достопных к покупке (0 = Нет лимита)
+MAX_DEVICES_LIMIT=15
+
+# Дефолт параметры для подписок выданных через админку
 DEFAULT_TRAFFIC_LIMIT_GB=100
-DEFAULT_DEVICE_LIMIT=1
+
+# ===== ГЛОБАЛЬНЫЙ ПАРАМЕТР ДЛЯ ВСЕХ ПОДПИСОК =====
+DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
 
 # ===== НАСТРОЙКИ ТРАФИКА =====
 # Режим выбора трафика:
@@ -62,16 +73,10 @@ PRICE_90_DAYS=36900
 PRICE_180_DAYS=69900
 PRICE_360_DAYS=109900
 
-# Цены за трафик
-PRICE_TRAFFIC_5GB=1000
-PRICE_TRAFFIC_10GB=2000
-PRICE_TRAFFIC_25GB=3000
-PRICE_TRAFFIC_50GB=4000
-PRICE_TRAFFIC_100GB=6000
-PRICE_TRAFFIC_250GB=10000
-PRICE_TRAFFIC_UNLIMITED=15000
+# Выводимые пакеты трафика и их цены в копейках
+TRAFFIC_PACKAGES_CONFIG="5:2000:false,10:3500:false,25:7000:false,50:11000:true,100:15000:true,250:17000:false,500:19000:false,1000:19500:true,0:20000:true"
 
-# Цена за дополнительное устройство
+# Цена за дополнительное устройство (DEFAULT_DEVICE_LIMIT идет бесплатно!)
 PRICE_PER_DEVICE=5000
 
 # ===== РЕФЕРАЛЬНАЯ СИСТЕМА =====
@@ -88,6 +93,7 @@ MIN_BALANCE_FOR_AUTOPAY_KOPEKS=10000
 
 # Telegram Stars (работает автоматически)
 TELEGRAM_STARS_ENABLED=true
+TELEGRAM_STARS_RATE_RUB=1.3
 
 # Tribute (https://tribute.app)
 TRIBUTE_ENABLED=false

.github/workflows/docker-registry.yml

@@ -4,12 +4,14 @@ on:
     branches:
       - main
       - master
+      - dev 
     tags:
       - 'v*'
   pull_request:
     branches:
       - main
       - master
+      - dev 
 env:
   REGISTRY: ghcr.io
   IMAGE_NAME: fr1ngg/remnawave-bedolaga-telegram-bot
@@ -42,6 +44,7 @@ jobs:
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
             type=raw,value=latest,enable={{is_default_branch}}
+            type=raw,value=dev,enable=${{ github.ref == 'refs/heads/dev' }}
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:

README.md

@@ -38,7 +38,7 @@
   
 ### 🎛️ **Гибкость конфигурации**
 - 🌍 **Выбор стран** - пользователи сами выбирают нужные локации
-- 📱 **Управление устройствами** - от 1 до 10 шт
+- 📱 **Управление устройствами** - от 1 до 10 шт (С настройкой кол-ва бесплатных у триальных и платных подписок)
 - 📊 **Гибкие тарифы** - от 5GB до безлимита, от 14 дней до года
 - 🎁 **Промо-система** - коды на деньги, дни подписки, триал-периоды
 - 3 режима показа ссылки подписки: 1) С гайдом по подключению прямо в боте(тянущий данные приложений и ссылок на скачку из app-config.json) 2) Обычное открытие ссылки подписки в миниапе 3) Интеграция сабпейджа maposia - кастомно прописать ссылку можно
@@ -119,14 +119,25 @@ REMNAWAVE_API_KEY=
 # Для панелей установленных скриптом eGames прописывать ключ в формате XXXXXXX:DDDDDDDD - https://panel.example.com/auth/login?XXXXXXX=DDDDDDDD
 REMNAWAVE_SECRET_KEY=your_secret_key_here
 
+# ========= ПОДПИСКИ =========
 # ===== ТРИАЛ ПОДПИСКА =====
 TRIAL_DURATION_DAYS=3
 TRIAL_TRAFFIC_LIMIT_GB=10
 TRIAL_DEVICE_LIMIT=1
 TRIAL_SQUAD_UUID=
-DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+
+# ===== ПЛАТНАЯ ПОДПИСКА =====
+# Сколько устройств доступно по дефолту при покупке платной подписки
+DEFAULT_DEVICE_LIMIT=3
+
+# Максимум устройств достопных к покупке (0 = Нет лимита)
+MAX_DEVICES_LIMIT=15
+
+# Дефолт параметры для подписок выданных через админку
 DEFAULT_TRAFFIC_LIMIT_GB=100
-DEFAULT_DEVICE_LIMIT=1
+
+# ===== ГЛОБАЛЬНЫЙ ПАРАМЕТР ДЛЯ ВСЕХ ПОДПИСОК =====
+DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
 
 # ===== НАСТРОЙКИ ТРАФИКА =====
 # Режим выбора трафика:
@@ -155,16 +166,10 @@ PRICE_90_DAYS=36900
 PRICE_180_DAYS=69900
 PRICE_360_DAYS=109900
 
-# Цены за трафик
-PRICE_TRAFFIC_5GB=1000
-PRICE_TRAFFIC_10GB=2000
-PRICE_TRAFFIC_25GB=3000
-PRICE_TRAFFIC_50GB=4000
-PRICE_TRAFFIC_100GB=6000
-PRICE_TRAFFIC_250GB=10000
-PRICE_TRAFFIC_UNLIMITED=15000
+# Выводимые пакеты трафика и их цены в копейках
+TRAFFIC_PACKAGES_CONFIG="5:2000:false,10:3500:false,25:7000:false,50:11000:true,100:15000:true,250:17000:false,500:19000:false,1000:19500:true,0:20000:true"
 
-# Цена за дополнительное устройство
+# Цена за дополнительное устройство (DEFAULT_DEVICE_LIMIT идет бесплатно!)
 PRICE_PER_DEVICE=5000
 
 # ===== РЕФЕРАЛЬНАЯ СИСТЕМА =====
@@ -181,6 +186,7 @@ MIN_BALANCE_FOR_AUTOPAY_KOPEKS=10000
 
 # Telegram Stars (работает автоматически)
 TELEGRAM_STARS_ENABLED=true
+TELEGRAM_STARS_RATE_RUB=1.3
 
 # Tribute (https://tribute.app)
 TRIBUTE_ENABLED=false

app/bot.py

@@ -25,6 +25,7 @@ from app.handlers.admin import (
     statistics as admin_statistics, servers as admin_servers,
     maintenance as admin_maintenance  
 )
+from app.handlers.stars_payments import register_stars_handlers
 
 logger = logging.getLogger(__name__)
 
@@ -70,6 +71,7 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     dp.callback_query.middleware(LoggingMiddleware())
     dp.message.middleware(AuthMiddleware())
     dp.callback_query.middleware(AuthMiddleware())
+    dp.pre_checkout_query.middleware(AuthMiddleware())
     dp.message.middleware(MaintenanceMiddleware())
     dp.callback_query.middleware(MaintenanceMiddleware())
     dp.message.middleware(ThrottlingMiddleware())
@@ -98,6 +100,9 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
 
     common.register_handlers(dp)
     
+    register_stars_handlers(dp)
+    logger.info("🌟 Зарегистрированы обработчики Telegram Stars платежей")
+    
     try:
         await maintenance_service.start_monitoring()
         logger.info("Мониторинг техработ запущен")

app/config.py

@@ -1,5 +1,5 @@
 import os
-from typing import List, Optional, Union
+from typing import List, Optional, Union, Dict
 from pydantic_settings import BaseSettings
 from pydantic import field_validator, Field
 from pathlib import Path
@@ -25,6 +25,7 @@ class Settings(BaseSettings):
     DEFAULT_DEVICE_LIMIT: int = 1
     TRIAL_SQUAD_UUID: str
     DEFAULT_TRAFFIC_RESET_STRATEGY: str = "MONTH"
+    MAX_DEVICES_LIMIT: int = 20
     
     TRIAL_WARNING_HOURS: int = 2 
     ENABLE_NOTIFICATIONS: bool = True 
@@ -44,13 +45,17 @@ class Settings(BaseSettings):
     PRICE_180_DAYS: int = 499000
     PRICE_360_DAYS: int = 899000
     
-    PRICE_TRAFFIC_5GB: int = 10000
-    PRICE_TRAFFIC_10GB: int = 19000
-    PRICE_TRAFFIC_25GB: int = 45000
-    PRICE_TRAFFIC_50GB: int = 85000
-    PRICE_TRAFFIC_100GB: int = 159000
-    PRICE_TRAFFIC_250GB: int = 369000
-    PRICE_TRAFFIC_UNLIMITED: int = 0
+    PRICE_TRAFFIC_5GB: int = 2000
+    PRICE_TRAFFIC_10GB: int = 3500
+    PRICE_TRAFFIC_25GB: int = 7000
+    PRICE_TRAFFIC_50GB: int = 11000
+    PRICE_TRAFFIC_100GB: int = 15000
+    PRICE_TRAFFIC_250GB: int = 17000
+    PRICE_TRAFFIC_500GB: int = 19000
+    PRICE_TRAFFIC_1000GB: int = 19500
+    PRICE_TRAFFIC_UNLIMITED: int = 20000
+    
+    TRAFFIC_PACKAGES_CONFIG: str = ""
     
     PRICE_PER_DEVICE: int = 5000
     
@@ -75,6 +80,7 @@ class Settings(BaseSettings):
     MAINTENANCE_MESSAGE: str = "🔧 Ведутся технические работы. Сервис временно недоступен. Попробуйте позже."
     
     TELEGRAM_STARS_ENABLED: bool = True
+    TELEGRAM_STARS_RATE_RUB: float = 1.3
     
     TRIBUTE_ENABLED: bool = False
     TRIBUTE_API_KEY: Optional[str] = None
@@ -281,6 +287,137 @@ class Settings(BaseSettings):
             service_name=self.PAYMENT_SERVICE_NAME,
             description=description
         )
+
+    def get_stars_rate(self) -> float:
+        return self.TELEGRAM_STARS_RATE_RUB
+    
+    def stars_to_rubles(self, stars: int) -> float:
+        return stars * self.get_stars_rate()
+    
+    def rubles_to_stars(self, rubles: float) -> int:
+        return max(1, int(rubles / self.get_stars_rate()))
+    
+    def get_traffic_packages(self) -> List[Dict]:
+        import logging
+        logger = logging.getLogger(__name__)
+        
+        try:
+            packages = []
+            config_str = self.TRAFFIC_PACKAGES_CONFIG.strip()
+            
+            logger.info(f"CONFIG STRING: '{config_str}'")
+            
+            if not config_str:
+                logger.info("CONFIG EMPTY, USING FALLBACK")
+                return self._get_fallback_traffic_packages()
+            
+            logger.info("PARSING CONFIG...")
+            
+            for package_config in config_str.split(','):
+                package_config = package_config.strip()
+                if not package_config:
+                    continue
+                    
+                parts = package_config.split(':')
+                if len(parts) != 3:
+                    continue
+                    
+                try:
+                    gb = int(parts[0])
+                    price = int(parts[1])
+                    enabled = parts[2].lower() == 'true'
+                    
+                    packages.append({
+                        "gb": gb,
+                        "price": price,
+                        "enabled": enabled
+                    })
+                except ValueError:
+                    continue
+            
+            logger.info(f"PARSED {len(packages)} packages from config")
+            return packages if packages else self._get_fallback_traffic_packages()
+            
+        except Exception as e:
+            logger.info(f"ERROR PARSING CONFIG: {e}")
+            return self._get_fallback_traffic_packages()
+    
+    def _get_fallback_traffic_packages(self) -> List[Dict]:
+        try:
+            if self.TRAFFIC_PACKAGES_CONFIG.strip():
+                packages = []
+                for package_config in self.TRAFFIC_PACKAGES_CONFIG.split(','):
+                    package_config = package_config.strip()
+                    if not package_config:
+                        continue
+                        
+                    parts = package_config.split(':')
+                    if len(parts) != 3:
+                        continue
+                        
+                    try:
+                        gb = int(parts[0])
+                        price = int(parts[1])
+                        enabled = parts[2].lower() == 'true'
+                        
+                        packages.append({
+                            "gb": gb,
+                            "price": price,
+                            "enabled": enabled
+                        })
+                    except ValueError:
+                        continue
+                
+                if packages:
+                    return packages
+        except Exception as e:
+            pass
+        
+        return [
+            {"gb": 5, "price": self.PRICE_TRAFFIC_5GB, "enabled": True},
+            {"gb": 10, "price": self.PRICE_TRAFFIC_10GB, "enabled": True},
+            {"gb": 25, "price": self.PRICE_TRAFFIC_25GB, "enabled": True},
+            {"gb": 50, "price": self.PRICE_TRAFFIC_50GB, "enabled": True},
+            {"gb": 100, "price": self.PRICE_TRAFFIC_100GB, "enabled": True},
+            {"gb": 250, "price": self.PRICE_TRAFFIC_250GB, "enabled": True},
+            {"gb": 500, "price": self.PRICE_TRAFFIC_500GB, "enabled": True},
+            {"gb": 1000, "price": self.PRICE_TRAFFIC_1000GB, "enabled": True},
+            {"gb": 0, "price": self.PRICE_TRAFFIC_UNLIMITED, "enabled": True}, 
+        ]
+    
+    def get_traffic_price(self, gb: int) -> int:
+        packages = self.get_traffic_packages()
+        
+        for package in packages:
+            if package["gb"] == gb and package["enabled"]:
+                return package["price"]
+        
+        
+        enabled_packages = [pkg for pkg in packages if pkg["enabled"]]
+        if not enabled_packages:
+            return 0
+        
+        unlimited_package = next((pkg for pkg in enabled_packages if pkg["gb"] == 0), None)
+        
+        finite_packages = [pkg for pkg in enabled_packages if pkg["gb"] > 0]
+        if finite_packages:
+            max_package = max(finite_packages, key=lambda x: x["gb"])
+            
+            if gb > max_package["gb"]:
+                if unlimited_package:
+                    return unlimited_package["price"]
+                else:
+                    return max_package["price"]
+            
+            suitable_packages = [pkg for pkg in finite_packages if pkg["gb"] >= gb]
+            if suitable_packages:
+                nearest_package = min(suitable_packages, key=lambda x: x["gb"])
+                return nearest_package["price"]
+        
+        if unlimited_package:
+            return unlimited_package["price"]
+        
+        return 0
     
     model_config = {
         "env_file": ".env",
@@ -300,12 +437,14 @@ PERIOD_PRICES = {
     360: settings.PRICE_360_DAYS,
 }
 
-TRAFFIC_PRICES = {
-    5: settings.PRICE_TRAFFIC_5GB,
-    10: settings.PRICE_TRAFFIC_10GB,
-    25: settings.PRICE_TRAFFIC_25GB,
-    50: settings.PRICE_TRAFFIC_50GB,
-    100: settings.PRICE_TRAFFIC_100GB,
-    250: settings.PRICE_TRAFFIC_250GB,
-    0: settings.PRICE_TRAFFIC_UNLIMITED, 
-}
+def get_traffic_prices() -> Dict[int, int]:
+    packages = settings.get_traffic_packages()
+    return {package["gb"]: package["price"] for package in packages}
+
+TRAFFIC_PRICES = get_traffic_prices()
+
+def refresh_traffic_prices():
+    global TRAFFIC_PRICES
+    TRAFFIC_PRICES = get_traffic_prices()
+
+refresh_traffic_prices()

app/database/crud/subscription.py

@@ -9,6 +9,7 @@ from app.database.models import (
     Subscription, SubscriptionStatus, User, 
     SubscriptionServer
 )
+from app.utils.pricing_utils import calculate_months_from_days, get_remaining_months
 from app.config import settings
 
 logger = logging.getLogger(__name__)
@@ -407,9 +408,19 @@ async def add_subscription_servers(
     server_squad_ids: List[int],
     paid_prices: List[int] = None
 ) -> Subscription:
-    
     if paid_prices is None:
-        paid_prices = [0] * len(server_squad_ids)
+        months_remaining = get_remaining_months(subscription.end_date)
+        paid_prices = []
+        
+        from app.database.models import ServerSquad
+        for server_id in server_squad_ids:
+            result = await db.execute(
+                select(ServerSquad.price_kopeks)
+                .where(ServerSquad.id == server_id)
+            )
+            server_price_per_month = result.scalar() or 0
+            total_price_for_period = server_price_per_month * months_remaining
+            paid_prices.append(total_price_for_period)
     
     for i, server_id in enumerate(server_squad_ids):
         subscription_server = SubscriptionServer(
@@ -422,9 +433,79 @@ async def add_subscription_servers(
     await db.commit()
     await db.refresh(subscription)
     
-    logger.info(f"🌍 К подписке {subscription.id} добавлено {len(server_squad_ids)} серверов")
+    logger.info(f"🌍 К подписке {subscription.id} добавлено {len(server_squad_ids)} серверов с ценами: {paid_prices}")
     return subscription
 
+async def get_server_monthly_price(
+    db: AsyncSession,
+    server_squad_id: int
+) -> int:
+    from app.database.models import ServerSquad
+    
+    result = await db.execute(
+        select(ServerSquad.price_kopeks)
+        .where(ServerSquad.id == server_squad_id)
+    )
+    return result.scalar() or 0
+
+
+async def get_servers_monthly_prices(
+    db: AsyncSession,
+    server_squad_ids: List[int]
+) -> List[int]:
+    prices = []
+    for server_id in server_squad_ids:
+        price = await get_server_monthly_price(db, server_id)
+        prices.append(price)
+    return prices
+
+async def calculate_subscription_total_cost(
+    db: AsyncSession,
+    period_days: int,
+    traffic_gb: int,
+    server_squad_ids: List[int],
+    devices: int
+) -> Tuple[int, dict]:
+    from app.config import PERIOD_PRICES
+    
+    months_in_period = calculate_months_from_days(period_days)
+    
+    base_price = PERIOD_PRICES.get(period_days, 0)
+    
+    traffic_price_per_month = settings.get_traffic_price(traffic_gb)
+    total_traffic_price = traffic_price_per_month * months_in_period
+    
+    servers_prices = await get_servers_monthly_prices(db, server_squad_ids)
+    servers_price_per_month = sum(servers_prices)
+    total_servers_price = servers_price_per_month * months_in_period
+    
+    additional_devices = max(0, devices - settings.DEFAULT_DEVICE_LIMIT)
+    devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+    total_devices_price = devices_price_per_month * months_in_period
+    
+    total_cost = base_price + total_traffic_price + total_servers_price + total_devices_price
+    
+    details = {
+        'base_price': base_price,
+        'traffic_price_per_month': traffic_price_per_month,
+        'total_traffic_price': total_traffic_price,
+        'servers_price_per_month': servers_price_per_month,
+        'total_servers_price': total_servers_price,
+        'devices_price_per_month': devices_price_per_month,
+        'total_devices_price': total_devices_price,
+        'months_in_period': months_in_period,
+        'servers_individual_prices': [price * months_in_period for price in servers_prices]
+    }
+    
+    logger.info(f"📊 Расчет стоимости подписки на {period_days} дней ({months_in_period} мес):")
+    logger.info(f"   Базовый период: {base_price/100}₽")
+    logger.info(f"   Трафик: {traffic_price_per_month/100}₽/мес × {months_in_period} = {total_traffic_price/100}₽")
+    logger.info(f"   Серверы: {servers_price_per_month/100}₽/мес × {months_in_period} = {total_servers_price/100}₽")
+    logger.info(f"   Устройства: {devices_price_per_month/100}₽/мес × {months_in_period} = {total_devices_price/100}₽")
+    logger.info(f"   ИТОГО: {total_cost/100}₽")
+    
+    return total_cost, details
+    
 async def get_subscription_server_ids(
     db: AsyncSession,
     subscription_id: int
@@ -497,30 +578,43 @@ async def get_subscription_renewal_cost(
     period_days: int
 ) -> int:
     try:
-        from app.config import PERIOD_PRICES, TRAFFIC_PRICES, settings
+        from app.config import PERIOD_PRICES
+        
+        months_in_period = calculate_months_from_days(period_days)
         
         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)
+        servers_info = await get_subscription_servers(db, subscription_id)
+        servers_price_per_month = 0
+        for server_info in servers_info:
+            from app.database.models import ServerSquad
+            result = await db.execute(
+                select(ServerSquad.price_kopeks)
+                .where(ServerSquad.id == server_info['server_id'])
+            )
+            current_server_price = result.scalar() or 0
+            servers_price_per_month += current_server_price
         
-        devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+        total_servers_cost = servers_price_per_month * months_in_period
         
-        total_cost = base_price + servers_cost + traffic_cost + devices_cost
+        traffic_price_per_month = settings.get_traffic_price(subscription.traffic_limit_gb)
+        total_traffic_cost = traffic_price_per_month * months_in_period
         
-        logger.info(f"💰 Расчет продления подписки {subscription_id} на {period_days} дней:")
+        additional_devices = max(0, subscription.device_limit - settings.DEFAULT_DEVICE_LIMIT)
+        devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+        total_devices_cost = devices_price_per_month * months_in_period
+        
+        total_cost = base_price + total_servers_cost + total_traffic_cost + total_devices_cost
+        
+        logger.info(f"💰 Расчет продления подписки {subscription_id} на {period_days} дней ({months_in_period} мес):")
         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"   🌍 Серверы: {servers_price_per_month/100}₽/мес × {months_in_period} = {total_servers_cost/100}₽")
+        logger.info(f"   📊 Трафик: {traffic_price_per_month/100}₽/мес × {months_in_period} = {total_traffic_cost/100}₽")
+        logger.info(f"   📱 Устройства: {devices_price_per_month/100}₽/мес × {months_in_period} = {total_devices_cost/100}₽")
         logger.info(f"   💎 ИТОГО: {total_cost/100}₽")
         
         return total_cost
@@ -530,6 +624,49 @@ async def get_subscription_renewal_cost(
         from app.config import PERIOD_PRICES
         return PERIOD_PRICES.get(period_days, 0)
 
+async def calculate_addon_cost_for_remaining_period(
+    db: AsyncSession,
+    subscription: Subscription,
+    additional_traffic_gb: int = 0,
+    additional_devices: int = 0,
+    additional_server_ids: List[int] = None
+) -> int:
+    if additional_server_ids is None:
+        additional_server_ids = []
+    
+    months_to_pay = get_remaining_months(subscription.end_date)
+    
+    total_cost = 0
+    
+    if additional_traffic_gb > 0:
+        traffic_price_per_month = settings.get_traffic_price(additional_traffic_gb)
+        traffic_total_cost = traffic_price_per_month * months_to_pay
+        total_cost += traffic_total_cost
+        logger.info(f"Трафик +{additional_traffic_gb}ГБ: {traffic_price_per_month/100}₽/мес × {months_to_pay} = {traffic_total_cost/100}₽")
+    
+    if additional_devices > 0:
+        devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+        devices_total_cost = devices_price_per_month * months_to_pay
+        total_cost += devices_total_cost
+        logger.info(f"Устройства +{additional_devices}: {devices_price_per_month/100}₽/мес × {months_to_pay} = {devices_total_cost/100}₽")
+    
+    if additional_server_ids:
+        from app.database.models import ServerSquad
+        for server_id in additional_server_ids:
+            result = await db.execute(
+                select(ServerSquad.price_kopeks, ServerSquad.display_name)
+                .where(ServerSquad.id == server_id)
+            )
+            server_data = result.first()
+            if server_data:
+                server_price_per_month, server_name = server_data
+                server_total_cost = server_price_per_month * months_to_pay
+                total_cost += server_total_cost
+                logger.info(f"Сервер {server_name}: {server_price_per_month/100}₽/мес × {months_to_pay} = {server_total_cost/100}₽")
+    
+    logger.info(f"💰 Итого доплата за {months_to_pay} мес: {total_cost/100}₽")
+    return total_cost
+
 async def expire_subscription(
     db: AsyncSession,
     subscription: Subscription

app/external/telegram_stars.py

@@ -13,6 +13,14 @@ class TelegramStarsService:
     def __init__(self, bot: Bot):
         self.bot = bot
     
+    @staticmethod
+    def calculate_stars_from_rubles(rubles: float) -> int:
+        return settings.rubles_to_stars(rubles)
+    
+    @staticmethod
+    def calculate_rubles_from_stars(stars: int) -> float:
+        return settings.stars_to_rubles(stars)
+    
     async def create_invoice(
         self,
         chat_id: int,
@@ -23,7 +31,8 @@ class TelegramStarsService:
         start_parameter: Optional[str] = None
     ) -> Optional[str]:
         try:
-            stars_amount = max(1, amount_kopeks // 100)
+            amount_rubles = amount_kopeks / 100
+            stars_amount = self.calculate_stars_from_rubles(amount_rubles)
             
             invoice_link = await self.bot.create_invoice_link(
                 title=title,
@@ -35,7 +44,10 @@ class TelegramStarsService:
                 start_parameter=start_parameter
             )
             
-            logger.info(f"Создан Stars invoice на {stars_amount} звезд для {chat_id}")
+            logger.info(
+                f"Создан Stars invoice на {stars_amount} звезд (~{amount_rubles:.2f}₽) "
+                f"для {chat_id}, курс: {settings.get_stars_rate():.2f}₽/⭐"
+            )
             return invoice_link
             
         except Exception as e:
@@ -52,7 +64,8 @@ class TelegramStarsService:
         keyboard: Optional[InlineKeyboardMarkup] = None
     ) -> Optional[Dict[str, Any]]:
         try:
-            stars_amount = max(1, amount_kopeks // 100)
+            amount_rubles = amount_kopeks / 100
+            stars_amount = self.calculate_stars_from_rubles(amount_rubles)
             
             message = await self.bot.send_invoice(
                 chat_id=chat_id,
@@ -65,10 +78,14 @@ class TelegramStarsService:
                 reply_markup=keyboard
             )
             
-            logger.info(f"Отправлен Stars invoice {message.message_id} на {stars_amount} звезд")
+            logger.info(
+                f"Отправлен Stars invoice {message.message_id} на {stars_amount} звезд "
+                f"(~{amount_rubles:.2f}₽), курс: {settings.get_stars_rate():.2f}₽/⭐"
+            )
             return {
                 "message_id": message.message_id,
                 "stars_amount": stars_amount,
+                "rubles_amount": amount_rubles,
                 "payload": payload
             }
             
@@ -88,13 +105,8 @@ class TelegramStarsService:
                 ok=ok,
                 error_message=error_message
             )
+            logger.info(f"Ответ на pre_checkout_query: ok={ok}")
             return True
         except Exception as e:
             logger.error(f"Ошибка ответа на pre_checkout_query: {e}")
             return False
-    
-    def calculate_stars_amount(self, rubles: float) -> int:
-        return max(1, int(rubles))
-    
-    def calculate_rubles_from_stars(self, stars: int) -> float:
-        return float(stars)

app/handlers/admin/users.py

@@ -16,6 +16,8 @@ from app.localization.texts import get_texts
 from app.services.user_service import UserService
 from app.utils.decorators import admin_required, error_handler
 from app.utils.formatters import format_datetime, format_time_ago
+from app.services.remnawave_service import RemnaWaveService
+from app.database.crud.server_squad import get_all_server_squads, get_server_squad_by_uuid, get_server_squad_by_id
 
 logger = logging.getLogger(__name__)
 
@@ -1300,6 +1302,642 @@ async def process_subscription_grant_text(
     
     await state.clear()
 
+@admin_required
+@error_handler
+async def show_user_servers_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    profile = await user_service.get_user_profile(db, user_id)
+    
+    if not profile:
+        await callback.answer("❌ Пользователь не найден", show_alert=True)
+        return
+    
+    user = profile["user"]
+    subscription = profile["subscription"]
+    
+    text = f"🌍 <b>Управление серверами пользователя</b>\n\n"
+    text += f"👤 {user.full_name} (ID: <code>{user.telegram_id}</code>)\n\n"
+    
+    if subscription:
+        current_squads = subscription.connected_squads or []
+        
+        if current_squads:
+            text += f"<b>Текущие серверы ({len(current_squads)}):</b>\n"
+            
+            for squad_uuid in current_squads:
+                try:
+                    server = await get_server_squad_by_uuid(db, squad_uuid)
+                    if server:
+                        text += f"• {server.display_name}\n"
+                    else:
+                        text += f"• {squad_uuid[:8]}... (неизвестный)\n"
+                except Exception as e:
+                    logger.error(f"Ошибка получения сервера {squad_uuid}: {e}")
+                    text += f"• {squad_uuid[:8]}... (ошибка загрузки)\n"
+        else:
+            text += "<b>Серверы:</b> Не подключены\n"
+        
+        text += f"\n<b>Устройства:</b> {subscription.device_limit}\n"
+        traffic_display = f"{subscription.traffic_used_gb:.1f}/"
+        if subscription.traffic_limit_gb == 0:
+            traffic_display += "∞ ГБ"
+        else:
+            traffic_display += f"{subscription.traffic_limit_gb} ГБ"
+        text += f"<b>Трафик:</b> {traffic_display}\n"
+    else:
+        text += "❌ <b>Подписка отсутствует</b>"
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="🌍 Сменить сервер", callback_data=f"admin_user_change_server_{user_id}"),
+            types.InlineKeyboardButton(text="📱 Устройства", callback_data=f"admin_user_devices_{user_id}")
+        ],
+        [
+            types.InlineKeyboardButton(text="📊 Трафик", callback_data=f"admin_user_traffic_{user_id}"),
+            types.InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data=f"admin_user_reset_devices_{user_id}")
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_server_selection(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    await _show_servers_for_user(callback, user_id, db)
+    await callback.answer()
+
+async def _show_servers_for_user(
+    callback: types.CallbackQuery,
+    user_id: int,
+    db: AsyncSession
+):
+    try:
+        user = await get_user_by_id(db, user_id)
+        current_squads = []
+        if user and user.subscription:
+            current_squads = user.subscription.connected_squads or []
+        
+        all_servers, _ = await get_all_server_squads(db, available_only=False)
+        
+        servers_to_show = []
+        for server in all_servers:
+            if server.is_available or server.squad_uuid in current_squads:
+                servers_to_show.append(server)
+        
+        if not servers_to_show:
+            await callback.message.edit_text(
+                "❌ Доступные серверы не найдены",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_servers_{user_id}")]
+                ])
+            )
+            return
+        
+        text = f"🌍 <b>Управление серверами</b>\n\n"
+        text += f"Нажмите на сервер чтобы добавить/убрать:\n"
+        text += f"✅ - выбранный сервер\n"
+        text += f"⚪ - доступный сервер\n"
+        text += f"🔒 - неактивный (только для уже назначенных)\n\n"
+        
+        keyboard = []
+        selected_servers = [s for s in servers_to_show if s.squad_uuid in current_squads]
+        available_servers = [s for s in servers_to_show if s.squad_uuid not in current_squads and s.is_available]
+        inactive_servers = [s for s in servers_to_show if s.squad_uuid not in current_squads and not s.is_available]
+        
+        sorted_servers = selected_servers + available_servers + inactive_servers
+        
+        for server in sorted_servers[:20]: 
+            is_selected = server.squad_uuid in current_squads
+            
+            if is_selected:
+                emoji = "✅"
+            elif server.is_available:
+                emoji = "⚪"
+            else:
+                emoji = "🔒"
+            
+            display_name = server.display_name
+            if not server.is_available and not is_selected:
+                display_name += " (неактивный)"
+            
+            keyboard.append([
+                types.InlineKeyboardButton(
+                    text=f"{emoji} {display_name}",
+                    callback_data=f"admin_user_toggle_server_{user_id}_{server.id}"
+                )
+            ])
+        
+        if len(servers_to_show) > 20:
+            text += f"\n📝 Показано первых 20 из {len(servers_to_show)} серверов"
+        
+        keyboard.append([
+            types.InlineKeyboardButton(text="✅ Готово", callback_data=f"admin_user_servers_{user_id}"),
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_servers_{user_id}")
+        ])
+        
+        await callback.message.edit_text(
+            text,
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка показа серверов: {e}")
+
+@admin_required
+@error_handler
+async def toggle_user_server(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    user_id = int(parts[4]) 
+    server_id = int(parts[5])
+    
+    try:
+        user = await get_user_by_id(db, user_id)
+        if not user or not user.subscription:
+            await callback.answer("❌ Пользователь или подписка не найдены", show_alert=True)
+            return
+        
+        server = await get_server_squad_by_id(db, server_id)
+        if not server:
+            await callback.answer("❌ Сервер не найден", show_alert=True)
+            return
+        
+        subscription = user.subscription
+        current_squads = list(subscription.connected_squads or [])
+        
+        if server.squad_uuid in current_squads:
+            current_squads.remove(server.squad_uuid)
+            action_text = "удален"
+        else:
+            current_squads.append(server.squad_uuid)
+            action_text = "добавлен"
+        
+        subscription.connected_squads = current_squads
+        subscription.updated_at = datetime.utcnow()
+        await db.commit()
+        await db.refresh(subscription)
+        
+        if user.remnawave_uuid:
+            try:
+                remnawave_service = RemnaWaveService()
+                async with remnawave_service.api as api:
+                    await api.update_user(
+                        uuid=user.remnawave_uuid,
+                        active_internal_squads=current_squads
+                    )
+                logger.info(f"✅ Обновлены серверы в RemnaWave для пользователя {user.telegram_id}")
+            except Exception as rw_error:
+                logger.error(f"❌ Ошибка обновления RemnaWave: {rw_error}")
+        
+        logger.info(f"Админ {db_user.id}: сервер {server.display_name} {action_text} для пользователя {user_id}")
+        
+        await refresh_server_selection_screen(callback, user_id, db_user, db)
+        
+    except Exception as e:
+        logger.error(f"Ошибка переключения сервера: {e}")
+        await callback.answer("❌ Ошибка изменения сервера", show_alert=True)
+
+async def refresh_server_selection_screen(
+    callback: types.CallbackQuery,
+    user_id: int,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        user = await get_user_by_id(db, user_id)
+        current_squads = []
+        if user and user.subscription:
+            current_squads = user.subscription.connected_squads or []
+        
+        servers, _ = await get_all_server_squads(db, available_only=True)
+        
+        if not servers:
+            await callback.message.edit_text(
+                "❌ Доступные серверы не найдены",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_servers_{user_id}")]
+                ])
+            )
+            return
+        
+        text = f"🌍 <b>Управление серверами</b>\n\n"
+        text += f"Нажмите на сервер чтобы добавить/убрать:\n\n"
+        
+        keyboard = []
+        for server in servers[:15]:
+            is_selected = server.squad_uuid in current_squads
+            emoji = "✅" if is_selected else "⚪"
+            
+            keyboard.append([
+                types.InlineKeyboardButton(
+                    text=f"{emoji} {server.display_name}",
+                    callback_data=f"admin_user_toggle_server_{user_id}_{server.id}"
+                )
+            ])
+        
+        if len(servers) > 15:
+            text += f"\n📝 Показано первых 15 из {len(servers)} серверов"
+        
+        keyboard.append([
+            types.InlineKeyboardButton(text="✅ Готово", callback_data=f"admin_user_servers_{user_id}"),
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_servers_{user_id}")
+        ])
+        
+        await callback.message.edit_text(
+            text,
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка обновления экрана серверов: {e}")
+
+
+@admin_required
+@error_handler
+async def start_devices_edit(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await state.update_data(editing_devices_user_id=user_id)
+    
+    await callback.message.edit_text(
+        "📱 <b>Изменение количества устройств</b>\n\n"
+        "Введите новое количество устройств (от 1 до 10):\n"
+        "• Текущее значение будет заменено\n"
+        "• Примеры: 1, 2, 5, 10\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [
+                types.InlineKeyboardButton(text="1", callback_data=f"admin_user_devices_set_{user_id}_1"),
+                types.InlineKeyboardButton(text="2", callback_data=f"admin_user_devices_set_{user_id}_2"),
+                types.InlineKeyboardButton(text="3", callback_data=f"admin_user_devices_set_{user_id}_3")
+            ],
+            [
+                types.InlineKeyboardButton(text="5", callback_data=f"admin_user_devices_set_{user_id}_5"),
+                types.InlineKeyboardButton(text="10", callback_data=f"admin_user_devices_set_{user_id}_10")
+            ],
+            [
+                types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_servers_{user_id}")
+            ]
+        ])
+    )
+    
+    await state.set_state(AdminStates.editing_user_devices)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def set_user_devices_button(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    user_id = int(parts[-2])
+    devices = int(parts[-1])
+    
+    success = await _update_user_devices(db, user_id, devices, db_user.id)
+    
+    if success:
+        await callback.message.edit_text(
+            f"✅ Количество устройств изменено на: {devices}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка изменения количества устройств",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_devices_edit_text(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    user_id = data.get("editing_devices_user_id")
+    
+    if not user_id:
+        await message.answer("❌ Ошибка: пользователь не найден")
+        await state.clear()
+        return
+    
+    try:
+        devices = int(message.text.strip())
+        
+        if devices <= 0 or devices > 10:
+            await message.answer("❌ Количество устройств должно быть от 1 до 10")
+            return
+        
+        success = await _update_user_devices(db, user_id, devices, db_user.id)
+        
+        if success:
+            await message.answer(
+                f"✅ Количество устройств изменено на: {devices}",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+                ])
+            )
+        else:
+            await message.answer("❌ Ошибка изменения количества устройств")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число устройств")
+        return
+    
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def start_traffic_edit(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await state.update_data(editing_traffic_user_id=user_id)
+    
+    await callback.message.edit_text(
+        "📊 <b>Изменение лимита трафика</b>\n\n"
+        "Введите новый лимит трафика в ГБ:\n"
+        "• 0 - безлимитный трафик\n"
+        "• Примеры: 50, 100, 500, 1000\n"
+        "• Максимум: 10000 ГБ\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [
+                types.InlineKeyboardButton(text="50 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_50"),
+                types.InlineKeyboardButton(text="100 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_100")
+            ],
+            [
+                types.InlineKeyboardButton(text="500 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_500"),
+                types.InlineKeyboardButton(text="1000 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_1000")
+            ],
+            [
+                types.InlineKeyboardButton(text="♾️ Безлимит", callback_data=f"admin_user_traffic_set_{user_id}_0")
+            ],
+            [
+                types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_servers_{user_id}")
+            ]
+        ])
+    )
+    
+    await state.set_state(AdminStates.editing_user_traffic)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def set_user_traffic_button(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    user_id = int(parts[-2])
+    traffic_gb = int(parts[-1])
+    
+    success = await _update_user_traffic(db, user_id, traffic_gb, db_user.id)
+    
+    if success:
+        traffic_text = "♾️ безлимитный" if traffic_gb == 0 else f"{traffic_gb} ГБ"
+        await callback.message.edit_text(
+            f"✅ Лимит трафика изменен на: {traffic_text}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка изменения лимита трафика",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_traffic_edit_text(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    user_id = data.get("editing_traffic_user_id")
+    
+    if not user_id:
+        await message.answer("❌ Ошибка: пользователь не найден")
+        await state.clear()
+        return
+    
+    try:
+        traffic_gb = int(message.text.strip())
+        
+        if traffic_gb < 0 or traffic_gb > 10000:
+            await message.answer("❌ Лимит трафика должен быть от 0 до 10000 ГБ (0 = безлимит)")
+            return
+        
+        success = await _update_user_traffic(db, user_id, traffic_gb, db_user.id)
+        
+        if success:
+            traffic_text = "♾️ безлимитный" if traffic_gb == 0 else f"{traffic_gb} ГБ"
+            await message.answer(
+                f"✅ Лимит трафика изменен на: {traffic_text}",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+                ])
+            )
+        else:
+            await message.answer("❌ Ошибка изменения лимита трафика")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число ГБ")
+        return
+    
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def confirm_reset_devices(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await callback.message.edit_text(
+        "🔄 <b>Сброс устройств пользователя</b>\n\n"
+        "⚠️ <b>ВНИМАНИЕ!</b>\n"
+        "Вы уверены, что хотите сбросить все HWID устройства этого пользователя?\n\n"
+        "Это действие:\n"
+        "• Удалит все привязанные устройства\n"
+        "• Пользователь сможет заново подключить устройства\n"
+        "• Действие необратимо!\n\n"
+        "Продолжить?",
+        reply_markup=get_confirmation_keyboard(
+            f"admin_user_reset_devices_confirm_{user_id}",
+            f"admin_user_servers_{user_id}",
+            db_user.language
+        )
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def reset_user_devices(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    try:
+        user = await get_user_by_id(db, user_id)
+        if not user or not user.remnawave_uuid:
+            await callback.answer("❌ Пользователь не найден или не связан с RemnaWave", show_alert=True)
+            return
+        
+        remnawave_service = RemnaWaveService()
+        async with remnawave_service.api as api:
+            success = await api.reset_user_devices(user.remnawave_uuid)
+        
+        if success:
+            await callback.message.edit_text(
+                "✅ Устройства пользователя успешно сброшены",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+                ])
+            )
+            logger.info(f"Админ {db_user.id} сбросил устройства пользователя {user_id}")
+        else:
+            await callback.message.edit_text(
+                "❌ Ошибка сброса устройств",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🌍 Управление серверами", callback_data=f"admin_user_servers_{user_id}")]
+                ])
+            )
+        
+    except Exception as e:
+        logger.error(f"Ошибка сброса устройств: {e}")
+        await callback.answer("❌ Ошибка сброса устройств", show_alert=True)
+
+async def _update_user_devices(db: AsyncSession, user_id: int, devices: int, admin_id: int) -> bool:
+    try:
+        user = await get_user_by_id(db, user_id)
+        if not user or not user.subscription:
+            logger.error(f"Пользователь {user_id} или подписка не найдены")
+            return False
+        
+        subscription = user.subscription
+        old_devices = subscription.device_limit
+        subscription.device_limit = devices
+        subscription.updated_at = datetime.utcnow()
+        
+        await db.commit()
+        
+        if user.remnawave_uuid:
+            try:
+                remnawave_service = RemnaWaveService()
+                async with remnawave_service.api as api:
+                    await api.update_user(
+                        uuid=user.remnawave_uuid,
+                        hwid_device_limit=devices
+                    )
+                logger.info(f"✅ Обновлен лимит устройств в RemnaWave для пользователя {user.telegram_id}")
+            except Exception as rw_error:
+                logger.error(f"❌ Ошибка обновления лимита устройств в RemnaWave: {rw_error}")
+        
+        logger.info(f"Админ {admin_id} изменил лимит устройств пользователя {user_id}: {old_devices} -> {devices}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка обновления лимита устройств: {e}")
+        await db.rollback()
+        return False
+
+
+async def _update_user_traffic(db: AsyncSession, user_id: int, traffic_gb: int, admin_id: int) -> bool:
+    try:
+        user = await get_user_by_id(db, user_id)
+        if not user or not user.subscription:
+            logger.error(f"Пользователь {user_id} или подписка не найдены")
+            return False
+        
+        subscription = user.subscription
+        old_traffic = subscription.traffic_limit_gb
+        subscription.traffic_limit_gb = traffic_gb
+        subscription.updated_at = datetime.utcnow()
+        
+        await db.commit()
+        
+        if user.remnawave_uuid:
+            try:
+                from app.external.remnawave_api import TrafficLimitStrategy
+                
+                remnawave_service = RemnaWaveService()
+                async with remnawave_service.api as api:
+                    await api.update_user(
+                        uuid=user.remnawave_uuid,
+                        traffic_limit_bytes=traffic_gb * (1024**3) if traffic_gb > 0 else 0,
+                        traffic_limit_strategy=TrafficLimitStrategy.MONTH
+                    )
+                logger.info(f"✅ Обновлен лимит трафика в RemnaWave для пользователя {user.telegram_id}")
+            except Exception as rw_error:
+                logger.error(f"❌ Ошибка обновления лимита трафика в RemnaWave: {rw_error}")
+        
+        traffic_text_old = "безлимитный" if old_traffic == 0 else f"{old_traffic} ГБ"
+        traffic_text_new = "безлимитный" if traffic_gb == 0 else f"{traffic_gb} ГБ"
+        logger.info(f"Админ {admin_id} изменил лимит трафика пользователя {user_id}: {traffic_text_old} -> {traffic_text_new}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка обновления лимита трафика: {e}")
+        await db.rollback()
+        return False
+
 
 async def _extend_subscription_by_days(db: AsyncSession, user_id: int, days: int, admin_id: int) -> bool:
     try:
@@ -1648,3 +2286,58 @@ def register_handlers(dp: Dispatcher):
         process_subscription_grant_text,
         AdminStates.granting_subscription
     )
+
+    dp.callback_query.register(
+        show_user_servers_management,
+        F.data.startswith("admin_user_servers_")
+    )
+    
+    dp.callback_query.register(
+        show_server_selection,
+        F.data.startswith("admin_user_change_server_")
+    )
+    
+    dp.callback_query.register(
+        toggle_user_server,
+        F.data.startswith("admin_user_toggle_server_") & ~F.data.endswith("_add") & ~F.data.endswith("_remove")
+    )
+    
+    dp.callback_query.register(
+        start_devices_edit,
+        F.data.startswith("admin_user_devices_") & ~F.data.contains("set")
+    )
+    
+    dp.callback_query.register(
+        set_user_devices_button,
+        F.data.startswith("admin_user_devices_set_")
+    )
+    
+    dp.message.register(
+        process_devices_edit_text,
+        AdminStates.editing_user_devices
+    )
+    
+    dp.callback_query.register(
+        start_traffic_edit,
+        F.data.startswith("admin_user_traffic_") & ~F.data.contains("set")
+    )
+    
+    dp.callback_query.register(
+        set_user_traffic_button,
+        F.data.startswith("admin_user_traffic_set_")
+    )
+    
+    dp.message.register(
+        process_traffic_edit_text,
+        AdminStates.editing_user_traffic
+    )
+    
+    dp.callback_query.register(
+        confirm_reset_devices,
+        F.data.startswith("admin_user_reset_devices_") & ~F.data.contains("confirm")
+    )
+    
+    dp.callback_query.register(
+        reset_user_devices,
+        F.data.startswith("admin_user_reset_devices_confirm_")
+    )

app/handlers/balance.py

@@ -356,10 +356,15 @@ async def process_stars_payment_amount(
     texts = get_texts(db_user.language)
     
     if not settings.TELEGRAM_STARS_ENABLED:
-        await message.answer("❌ Оплата Stars временно недоступна")
+        await message.answer("⚠ Оплата Stars временно недоступна")
         return
     
     try:
+        from app.external.telegram_stars import TelegramStarsService
+        
+        amount_rubles = amount_kopeks / 100
+        stars_amount = TelegramStarsService.calculate_stars_from_rubles(amount_rubles)
+        
         payment_service = PaymentService(message.bot)
         invoice_link = await payment_service.create_stars_invoice(
             amount_kopeks=amount_kopeks,
@@ -374,7 +379,9 @@ async def process_stars_payment_amount(
         
         await message.answer(
             f"⭐ <b>Оплата через Telegram Stars</b>\n\n"
-            f"Сумма: {texts.format_price(amount_kopeks)}\n\n"
+            f"💰 Сумма: {texts.format_price(amount_kopeks)}\n"
+            f"⭐ К оплате: {stars_amount} звезд\n"
+            f"📊 Курс: {settings.get_stars_rate():.2f}₽ за звезду\n\n"
             f"Нажмите кнопку ниже для оплаты:",
             reply_markup=keyboard,
             parse_mode="HTML"
@@ -384,7 +391,7 @@ async def process_stars_payment_amount(
         
     except Exception as e:
         logger.error(f"Ошибка создания Stars invoice: {e}")
-        await message.answer("❌ Ошибка создания платежа")
+        await message.answer("⚠ Ошибка создания платежа")
 
 
 @error_handler

app/handlers/menu.py

@@ -19,7 +19,6 @@ async def show_main_menu(
     db_user: User, 
     db: AsyncSession
 ):
-    
     texts = get_texts(db_user.language)
     
     from datetime import datetime
@@ -34,7 +33,6 @@ async def show_main_menu(
     
     menu_text = texts.MAIN_MENU.format(
         user_name=db_user.full_name,
-        balance=texts.format_price(db_user.balance_kopeks),
         subscription_status=_get_subscription_status(db_user, texts)
     )
     
@@ -45,7 +43,8 @@ async def show_main_menu(
             is_admin=settings.is_admin(db_user.telegram_id),
             has_had_paid_subscription=db_user.has_had_paid_subscription,
             has_active_subscription=has_active_subscription,
-            subscription_is_active=subscription_is_active  
+            subscription_is_active=subscription_is_active,
+            balance_kopeks=db_user.balance_kopeks 
         )
     )
     await callback.answer()
@@ -109,7 +108,7 @@ async def handle_back_to_menu(
 
 def _get_subscription_status(user: User, texts) -> str:
     if not user.subscription:
-        return "⌐ Отсутствует"
+        return "❌ Отсутствует"
     
     subscription = user.subscription
     current_time = datetime.utcnow()

app/handlers/stars_payments.py

@@ -0,0 +1,132 @@
+import logging
+from aiogram import Dispatcher, types, F
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.services.payment_service import PaymentService
+from app.external.telegram_stars import TelegramStarsService
+from app.database.crud.user import get_user_by_telegram_id
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_pre_checkout_query(query: types.PreCheckoutQuery):
+    try:
+        logger.info(f"📋 Pre-checkout query от {query.from_user.id}: {query.total_amount} XTR, payload: {query.invoice_payload}")
+        
+        if not query.invoice_payload or not query.invoice_payload.startswith("balance_"):
+            logger.warning(f"Невалидный payload: {query.invoice_payload}")
+            await query.answer(
+                ok=False,
+                error_message="Ошибка валидации платежа. Попробуйте еще раз."
+            )
+            return
+        
+        try:
+            from app.database.database import get_db
+            async for db in get_db():
+                user = await get_user_by_telegram_id(db, query.from_user.id)
+                if not user:
+                    logger.warning(f"Пользователь {query.from_user.id} не найден в БД")
+                    await query.answer(
+                        ok=False,
+                        error_message="Пользователь не найден. Обратитесь в поддержку."
+                    )
+                    return
+                break 
+        except Exception as db_error:
+            logger.error(f"Ошибка подключения к БД в pre_checkout_query: {db_error}")
+            await query.answer(
+                ok=False,
+                error_message="Техническая ошибка. Попробуйте позже."
+            )
+            return
+        
+        await query.answer(ok=True)
+        logger.info(f"✅ Pre-checkout одобрен для пользователя {query.from_user.id}")
+        
+    except Exception as e:
+        logger.error(f"Ошибка в pre_checkout_query: {e}", exc_info=True)
+        await query.answer(
+            ok=False,
+            error_message="Техническая ошибка. Попробуйте позже."
+        )
+
+
+async def handle_successful_payment(
+    message: types.Message,
+    db: AsyncSession,
+    **kwargs
+):
+    try:
+        payment = message.successful_payment
+        user_id = message.from_user.id
+        
+        logger.info(
+            f"💳 Успешный Stars платеж от {user_id}: "
+            f"{payment.total_amount} XTR, "
+            f"payload: {payment.invoice_payload}, "
+            f"charge_id: {payment.telegram_payment_charge_id}"
+        )
+        
+        user = await get_user_by_telegram_id(db, user_id)
+        if not user:
+            logger.error(f"Пользователь {user_id} не найден при обработке Stars платежа")
+            await message.answer(
+                "❌ Ошибка: пользователь не найден. Обратитесь в поддержку."
+            )
+            return
+        
+        payment_service = PaymentService(message.bot)
+        success = await payment_service.process_stars_payment(
+            db=db,
+            user_id=user.id,
+            stars_amount=payment.total_amount,
+            payload=payment.invoice_payload,
+            telegram_payment_charge_id=payment.telegram_payment_charge_id
+        )
+        
+        if success:
+            rubles_amount = TelegramStarsService.calculate_rubles_from_stars(payment.total_amount)
+            
+            await message.answer(
+                f"🎉 <b>Платеж успешно обработан!</b>\n\n"
+                f"⭐ Потрачено звезд: {payment.total_amount}\n"
+                f"💰 Зачислено на баланс: {rubles_amount:.2f} ₽\n"
+                f"🆔 ID транзакции: {payment.telegram_payment_charge_id[:8]}...\n\n"
+                f"Спасибо за пополнение! 🚀",
+                parse_mode="HTML"
+            )
+            
+            logger.info(
+                f"✅ Stars платеж успешно обработан: "
+                f"пользователь {user.id}, {payment.total_amount} звезд → {rubles_amount:.2f}₽"
+            )
+        else:
+            logger.error(f"Ошибка обработки Stars платежа для пользователя {user.id}")
+            await message.answer(
+                "❌ Произошла ошибка при зачислении средств. "
+                "Обратитесь в поддержку, платеж будет проверен вручную."
+            )
+        
+    except Exception as e:
+        logger.error(f"Ошибка в successful_payment: {e}", exc_info=True)
+        await message.answer(
+            "❌ Техническая ошибка при обработке платежа. "
+            "Обратитесь в поддержку для решения проблемы."
+        )
+
+
+def register_stars_handlers(dp: Dispatcher):
+    
+    dp.pre_checkout_query.register(
+        handle_pre_checkout_query,
+        F.currency == "XTR" 
+    )
+    
+    dp.message.register(
+        handle_successful_payment,
+        F.successful_payment
+    )
+    
+    logger.info("🌟 Зарегистрированы обработчики Telegram Stars платежей")

app/handlers/start.py

@@ -138,7 +138,6 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
         await message.answer(
             texts.MAIN_MENU.format(
                 user_name=user.full_name,
-                balance=texts.format_price(user.balance_kopeks),
                 subscription_status=_get_subscription_status(user, texts)
             ),
             reply_markup=get_main_menu_keyboard(
@@ -146,7 +145,8 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
                 is_admin=settings.is_admin(user.telegram_id),
                 has_had_paid_subscription=user.has_had_paid_subscription,
                 has_active_subscription=has_active_subscription,
-                subscription_is_active=subscription_is_active
+                subscription_is_active=subscription_is_active,
+                balance_kopeks=user.balance_kopeks 
             )
         )
         await state.clear()
@@ -380,6 +380,7 @@ async def process_referral_code_skip(
     await complete_registration_from_callback(callback, state, db)
 
 
+
 async def complete_registration_from_callback(
     callback: types.CallbackQuery,
     state: FSMContext, 
@@ -405,21 +406,24 @@ async def complete_registration_from_callback(
             subscription_is_active = existing_user.subscription.is_active
         
         user_name = existing_user.full_name
+        user_telegram_id = existing_user.telegram_id
+        user_language = existing_user.language
+        has_had_paid_subscription = existing_user.has_had_paid_subscription
         balance_kopeks = existing_user.balance_kopeks
         
         try:
             await callback.message.answer(
                 texts.MAIN_MENU.format(
                     user_name=user_name,
-                    balance=texts.format_price(balance_kopeks),
                     subscription_status=_get_subscription_status(existing_user, texts)
                 ),
                 reply_markup=get_main_menu_keyboard(
-                    language=existing_user.language,
-                    is_admin=settings.is_admin(existing_user.telegram_id),
-                    has_had_paid_subscription=existing_user.has_had_paid_subscription,
+                    language=user_language,
+                    is_admin=settings.is_admin(user_telegram_id),
+                    has_had_paid_subscription=has_had_paid_subscription,
                     has_active_subscription=has_active_subscription,
-                    subscription_is_active=subscription_is_active
+                    subscription_is_active=subscription_is_active,
+                    balance_kopeks=balance_kopeks
                 )
             )
         except Exception as e:
@@ -503,7 +507,6 @@ async def complete_registration_from_callback(
     
     has_active_subscription = False 
     subscription_is_active = False
-    
     user_name = user.full_name
     balance_kopeks = user.balance_kopeks
     user_telegram_id = user.telegram_id
@@ -514,7 +517,6 @@ async def complete_registration_from_callback(
         await callback.message.answer(
             texts.MAIN_MENU.format(
                 user_name=user_name,
-                balance=texts.format_price(balance_kopeks),
                 subscription_status=_get_subscription_status_simple(texts)
             ),
             reply_markup=get_main_menu_keyboard(
@@ -522,7 +524,8 @@ async def complete_registration_from_callback(
                 is_admin=settings.is_admin(user_telegram_id),
                 has_had_paid_subscription=has_had_paid_subscription,
                 has_active_subscription=has_active_subscription,
-                subscription_is_active=subscription_is_active
+                subscription_is_active=subscription_is_active,
+                balance_kopeks=balance_kopeks
             )
         )
         logger.info(f"✅ Главное меню отправлено для пользователя {user_telegram_id}")
@@ -532,24 +535,25 @@ async def complete_registration_from_callback(
             balance_rubles = balance_kopeks / 100
             await callback.message.answer(
                 f"Добро пожаловать, {user_name}!\n"
-                f"Баланс: {balance_rubles} ₽\n"
+                f"Баланс: {balance_rubles:.2f} ₽\n"
                 f"Подписка: Нет активной подписки",
                 reply_markup=get_main_menu_keyboard(
                     language=user_language,
                     is_admin=settings.is_admin(user_telegram_id),
                     has_had_paid_subscription=has_had_paid_subscription,
                     has_active_subscription=has_active_subscription,
-                    subscription_is_active=subscription_is_active
+                    subscription_is_active=subscription_is_active,
+                    balance_kopeks=balance_kopeks
                 )
             )
             logger.info(f"✅ Fallback главное меню отправлено для пользователя {user_telegram_id}")
         except Exception as fallback_error:
-            logger.error(f"❌ Критическая ошибка при отправке fallback меню: {fallback_error}")
+            logger.error(f"⛔ Критическая ошибка при отправке fallback меню: {fallback_error}")
             try:
                 await callback.message.answer(f"Добро пожаловать, {user_name}! Регистрация завершена.")
                 logger.info(f"✅ Простое приветствие отправлено для пользователя {user_telegram_id}")
             except Exception as final_error:
-                logger.error(f"❌ Критическая ошибка при отправке простого сообщения: {final_error}")
+                logger.error(f"⛔ Критическая ошибка при отправке простого сообщения: {final_error}")
     
     logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
 
@@ -578,24 +582,30 @@ async def complete_registration(
         if existing_user.subscription:
             subscription_is_active = existing_user.subscription.is_active
         
+        user_name = existing_user.full_name
+        user_telegram_id = existing_user.telegram_id
+        user_language = existing_user.language
+        has_had_paid_subscription = existing_user.has_had_paid_subscription
+        balance_kopeks = existing_user.balance_kopeks
+        
         try:
             await message.answer(
                 texts.MAIN_MENU.format(
-                    user_name=existing_user.full_name,
-                    balance=texts.format_price(existing_user.balance_kopeks),
+                    user_name=user_name,
                     subscription_status=_get_subscription_status(existing_user, texts)
                 ),
                 reply_markup=get_main_menu_keyboard(
-                    language=existing_user.language,
-                    is_admin=settings.is_admin(existing_user.telegram_id),
-                    has_had_paid_subscription=existing_user.has_had_paid_subscription,
+                    language=user_language,
+                    is_admin=settings.is_admin(user_telegram_id),
+                    has_had_paid_subscription=has_had_paid_subscription,
                     has_active_subscription=has_active_subscription,
-                    subscription_is_active=subscription_is_active
+                    subscription_is_active=subscription_is_active,
+                    balance_kopeks=balance_kopeks
                 )
             )
         except Exception as e:
             logger.error(f"Ошибка при показе главного меню существующему пользователю: {e}")
-            await message.answer(f"Добро пожаловать, {existing_user.full_name}!")
+            await message.answer(f"Добро пожаловать, {user_name}!")
         
         await state.clear()
         return
@@ -674,7 +684,6 @@ async def complete_registration(
     
     has_active_subscription = False
     subscription_is_active = False
-    
     user_name = user.full_name
     balance_kopeks = user.balance_kopeks
     user_telegram_id = user.telegram_id
@@ -685,7 +694,6 @@ async def complete_registration(
         await message.answer(
             texts.MAIN_MENU.format(
                 user_name=user_name,
-                balance=texts.format_price(balance_kopeks),
                 subscription_status=_get_subscription_status_simple(texts)
             ),
             reply_markup=get_main_menu_keyboard(
@@ -693,7 +701,8 @@ async def complete_registration(
                 is_admin=settings.is_admin(user_telegram_id),
                 has_had_paid_subscription=has_had_paid_subscription,
                 has_active_subscription=has_active_subscription,
-                subscription_is_active=subscription_is_active
+                subscription_is_active=subscription_is_active,
+                balance_kopeks=balance_kopeks
             )
         )
         logger.info(f"✅ Главное меню отправлено для пользователя {user_telegram_id}")
@@ -703,19 +712,20 @@ async def complete_registration(
             balance_rubles = balance_kopeks / 100
             await message.answer(
                 f"Добро пожаловать, {user_name}!\n"
-                f"Баланс: {balance_rubles} ₽\n"
+                f"Баланс: {balance_rubles:.2f} ₽\n"
                 f"Подписка: Нет активной подписки",
                 reply_markup=get_main_menu_keyboard(
                     language=user_language,
                     is_admin=settings.is_admin(user_telegram_id),
                     has_had_paid_subscription=has_had_paid_subscription,
                     has_active_subscription=has_active_subscription,
-                    subscription_is_active=subscription_is_active
+                    subscription_is_active=subscription_is_active,
+                    balance_kopeks=balance_kopeks
                 )
             )
             logger.info(f"✅ Fallback главное меню отправлено для пользователя {user_telegram_id}")
         except Exception as fallback_error:
-            logger.error(f"❌ Критическая ошибка при отправке fallback меню: {fallback_error}")
+            logger.error(f"⛔ Критическая ошибка при отправке fallback меню: {fallback_error}")
             try:
                 await message.answer(f"Добро пожаловать, {user_name}! Регистрация завершена.")
                 logger.info(f"✅ Простое приветствие отправлено для пользователя {user_telegram_id}")
@@ -726,9 +736,44 @@ async def complete_registration(
 
 
 def _get_subscription_status(user, texts):
-    if user.subscription and user.subscription.is_active:
-        return getattr(texts, 'SUBSCRIPTION_ACTIVE', 'Активна')
-    return getattr(texts, 'SUBSCRIPTION_NONE', 'Нет активной подписки')
+    if not user or not hasattr(user, 'subscription'):
+        return getattr(texts, 'SUBSCRIPTION_NONE', 'Нет активной подписки')
+    
+    if not user.subscription:
+        return getattr(texts, 'SUBSCRIPTION_NONE', 'Нет активной подписки')
+    
+    subscription = user.subscription
+    
+    from datetime import datetime
+    current_time = datetime.utcnow()
+    
+    if hasattr(subscription, 'end_date') and subscription.end_date <= current_time:
+        return f"🔴 Истекла\n📅 {subscription.end_date.strftime('%d.%m.%Y')}"
+    
+    if hasattr(subscription, 'end_date'):
+        days_left = (subscription.end_date - current_time).days
+    else:
+        days_left = 0
+    
+    is_trial = getattr(subscription, 'is_trial', False)
+    
+    if is_trial:
+        if days_left > 1:
+            return f"🎁 Тестовая подписка\n📅 до {subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+        elif days_left == 1:
+            return "🎁 Тестовая подписка\n⚠️ истекает завтра!"
+        else:
+            return "🎁 Тестовая подписка\n⚠️ истекает сегодня!"
+    else: 
+        if days_left > 7:
+            return f"💎 Активна\n📅 до {subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+        elif days_left > 1:
+            return f"💎 Активна\n⚠️ истекает через {days_left} дн."
+        elif days_left == 1:
+            return "💎 Активна\n⚠️ истекает завтра!"
+        else:
+            return "💎 Активна\n⚠️ истекает сегодня!"
+
 
 
 def _get_subscription_status_simple(texts):

app/handlers/subscription_notifications.py

@@ -1,171 +0,0 @@
-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

@@ -180,7 +180,10 @@ def get_user_management_keyboard(user_id: int, user_status: str, language: str =
             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_servers_{user_id}"), 
+            InlineKeyboardButton(text="📊 Статистика", callback_data=f"admin_user_statistics_{user_id}")
+        ],
+        [
             InlineKeyboardButton(text="📋 Транзакции", callback_data=f"admin_user_transactions_{user_id}")
         ]
     ]
@@ -578,7 +581,6 @@ def get_admin_pagination_keyboard(
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 def get_maintenance_keyboard(language: str = "ru", is_active: bool = False, monitoring_active: bool = False) -> InlineKeyboardMarkup:
-    """Клавиатура для управления техработами"""
     
     if language == "en":
         toggle_text = "🔴 Disable maintenance" if is_active else "🔧 Enable maintenance"

app/keyboards/inline.py

@@ -1,9 +1,13 @@
 from typing import List, Optional
+from aiogram import types
 from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from datetime import datetime
 
 from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
 from app.localization.texts import get_texts
+import logging
 
+logger = logging.getLogger(__name__)
 
 def get_rules_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
@@ -20,20 +24,29 @@ def get_main_menu_keyboard(
     is_admin: bool = False,
     has_had_paid_subscription: bool = False,
     has_active_subscription: bool = False,
-    subscription_is_active: bool = False 
+    subscription_is_active: bool = False,
+    balance_kopeks: int = 0
 ) -> InlineKeyboardMarkup:
     texts = get_texts(language)
     
     if settings.DEBUG:
-        print(f"DEBUG KEYBOARD: language={language}, is_admin={is_admin}, has_had_paid={has_had_paid_subscription}, has_active={has_active_subscription}, sub_active={subscription_is_active}")
+        print(f"DEBUG KEYBOARD: language={language}, is_admin={is_admin}, has_had_paid={has_had_paid_subscription}, has_active={has_active_subscription}, sub_active={subscription_is_active}, balance={balance_kopeks}")
+    
+    if hasattr(texts, 'BALANCE_BUTTON') and balance_kopeks > 0:
+        balance_button_text = texts.BALANCE_BUTTON.format(balance=texts.format_price(balance_kopeks))
+    else:
+        balance_button_text = f"💰 Баланс: {texts.format_price(balance_kopeks)}"
     
     keyboard = [
         [
-            InlineKeyboardButton(text=texts.MENU_BALANCE, callback_data="menu_balance"),
-            InlineKeyboardButton(text=texts.MENU_SUBSCRIPTION, callback_data="menu_subscription")
+            InlineKeyboardButton(text=balance_button_text, callback_data="menu_balance")
         ]
     ]
     
+    if has_active_subscription and subscription_is_active:
+        keyboard.append([
+            InlineKeyboardButton(text=texts.MENU_SUBSCRIPTION, callback_data="menu_subscription")
+        ])
     
     show_trial = not has_had_paid_subscription and not has_active_subscription
     
@@ -107,15 +120,28 @@ def get_subscription_keyboard(
             connect_mode = settings.CONNECT_BUTTON_MODE
             
             if connect_mode == "miniapp_subscription":
-                button_text = "🚀 Открыть в мини-приложении"
+                keyboard.append([
+                    InlineKeyboardButton(
+                        text="🚀 Открыть в мини-приложении",
+                        web_app=types.WebAppInfo(url=subscription.subscription_url)
+                    )
+                ])
             elif connect_mode == "miniapp_custom":
-                button_text = "🚀 Открыть приложение"
+                if settings.MINIAPP_CUSTOM_URL:
+                    keyboard.append([
+                        InlineKeyboardButton(
+                            text="🚀 Открыть приложение",
+                            web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
+                        )
+                    ])
+                else:
+                    keyboard.append([
+                        InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
+                    ])
             else:
-                button_text = "🔗 Подключиться"
-                
-            keyboard.append([
-                InlineKeyboardButton(text=button_text, callback_data="subscription_connect")
-            ])
+                keyboard.append([
+                    InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
+                ])
         
         if not is_trial and subscription and subscription.days_left <= 3:
             keyboard.append([
@@ -219,28 +245,57 @@ def get_subscription_period_keyboard(language: str = "ru") -> InlineKeyboardMark
 
 
 def get_traffic_packages_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    import logging
+    logger = logging.getLogger(__name__)
+    
     from app.config import settings
     
     if settings.is_traffic_fixed():
         return get_back_keyboard(language)
     
+    logger.info(f"🔍 RAW CONFIG: '{settings.TRAFFIC_PACKAGES_CONFIG}'")
+    
+    all_packages = settings.get_traffic_packages()
+    logger.info(f"🔍 ALL PACKAGES: {all_packages}")
+    
+    enabled_packages = [pkg for pkg in all_packages if pkg['enabled']]
+    disabled_packages = [pkg for pkg in all_packages if not pkg['enabled']]
+    
+    logger.info(f"🔍 ENABLED: {len(enabled_packages)} packages")
+    logger.info(f"🔍 DISABLED: {len(disabled_packages)} packages")
+    
+    for pkg in disabled_packages:
+        logger.info(f"🔍 DISABLED PACKAGE: {pkg['gb']}GB = {pkg['price']} kopeks, enabled={pkg['enabled']}")
+    
     texts = get_texts(language)
     keyboard = []
     
-    packages = [
-        (5, texts.TRAFFIC_5GB),
-        (10, texts.TRAFFIC_10GB),
-        (25, texts.TRAFFIC_25GB),
-        (50, texts.TRAFFIC_50GB),
-        (100, texts.TRAFFIC_100GB),
-        (250, texts.TRAFFIC_250GB),
-        (0, texts.TRAFFIC_UNLIMITED) 
-    ]
+    traffic_packages = settings.get_traffic_packages()
     
-    for gb, text in packages:
+    for package in traffic_packages:
+        gb = package["gb"]
+        price = package["price"]  
+        enabled = package["enabled"]
+        
+        if not enabled:
+            continue
+        
+        if gb == 0:
+            text = f"♾️ Безлимит - {settings.format_price(package['price'])}"
+        else:
+            text = f"📊 {gb} ГБ - {settings.format_price(package['price'])}"
+        
         keyboard.append([
             InlineKeyboardButton(text=text, callback_data=f"traffic_{gb}")
         ])
+
+    if not keyboard:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="⚠️ Пакеты трафика не настроены", 
+                callback_data="no_traffic_packages"
+            )
+        ])
     
     keyboard.append([
         InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")
@@ -248,7 +303,6 @@ def get_traffic_packages_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
-
 def get_countries_keyboard(countries: List[dict], selected: List[str], language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
     keyboard = []
@@ -291,19 +345,31 @@ def get_devices_keyboard(current: int, language: str = "ru") -> InlineKeyboardMa
     texts = get_texts(language)
     keyboard = []
     
-    for devices in range(1, 6): 
-        price = (devices - 1) * settings.PRICE_PER_DEVICE
-        price_text = f" (+{texts.format_price(price)})" if price > 0 else ""
+    start_devices = settings.DEFAULT_DEVICE_LIMIT
+    max_devices = settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else 50
+    end_devices = min(max_devices + 1, start_devices + 10)
+    
+    buttons = []
+    
+    for devices in range(start_devices, end_devices): 
+        price = max(0, devices - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
+        price_text = f" (+{texts.format_price(price)})" if price > 0 else " (вкл.)"
         emoji = "✅" if devices == current else "⚪"
         
-        device_word = _get_device_declension(devices)
+        button_text = f"{emoji} {devices}{price_text}"
         
-        keyboard.append([
+        buttons.append(
             InlineKeyboardButton(
-                text=f"{emoji} {devices} {device_word}{price_text}",
+                text=button_text,
                 callback_data=f"devices_{devices}"
             )
-        ])
+        )
+    
+    for i in range(0, len(buttons), 2):
+        if i + 1 < len(buttons):
+            keyboard.append([buttons[i], buttons[i + 1]])
+        else:
+            keyboard.append([buttons[i]])
     
     keyboard.extend([
         [InlineKeyboardButton(text="✅ Продолжить", callback_data="devices_continue")],
@@ -593,60 +659,103 @@ def get_extend_subscription_keyboard(language: str = "ru") -> InlineKeyboardMark
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
-def get_add_traffic_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+def get_add_traffic_keyboard(language: str = "ru", subscription_end_date: datetime = None) -> InlineKeyboardMarkup:
+    from app.utils.pricing_utils import get_remaining_months
     from app.config import settings
     
-    if settings.is_traffic_fixed():
-        return get_back_keyboard(language)
+    months_multiplier = 1
+    period_text = ""
+    if subscription_end_date:
+        months_multiplier = get_remaining_months(subscription_end_date)
+        if months_multiplier > 1:
+            period_text = f" (за {months_multiplier} мес)"
     
-    texts = get_texts(language)
-    keyboard = []
+    packages = settings.get_traffic_packages()
+    enabled_packages = [pkg for pkg in packages if pkg['enabled']]
     
-    packages = [
-        (5, f"📊 +5 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_5GB)}"),
-        (10, f"📊 +10 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_10GB)}"),
-        (25, f"📊 +25 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_25GB)}"),
-        (50, f"📊 +50 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_50GB)}"),
-        (100, f"📊 +100 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_100GB)}"),
-        (0, f"📊 Безлимит - {settings.format_price(settings.PRICE_TRAFFIC_UNLIMITED)}")
-    ]
+    if not enabled_packages:
+        return InlineKeyboardMarkup(inline_keyboard=[
+            [InlineKeyboardButton(
+                text="❌ Нет доступных пакетов" if language == "ru" else "❌ No packages available",
+                callback_data="no_traffic_packages"
+            )],
+            [InlineKeyboardButton(
+                text="⬅️ Назад" if language == "ru" else "⬅️ Back",
+                callback_data="menu_subscription"
+            )]
+        ])
     
-    for gb, text in packages:
-        keyboard.append([
+    buttons = []
+    
+    for package in enabled_packages:
+        gb = package['gb']
+        price_per_month = package['price']
+        total_price = price_per_month * months_multiplier
+        
+        if gb == 0:
+            if language == "ru":
+                text = f"♾️ Безлимитный трафик - {total_price/100:.2f} ₽{period_text}"
+            else:
+                text = f"♾️ Unlimited traffic - {total_price/100:.2f} ₽{period_text}"
+        else:
+            if language == "ru":
+                text = f"📊 +{gb} ГБ трафика - {total_price/100:.2f} ₽{period_text}"
+            else:
+                text = f"📊 +{gb} GB traffic - {total_price/100:.2f} ₽{period_text}"
+        
+        buttons.append([
             InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
         ])
     
-    keyboard.append([
-        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
+    buttons.append([
+        InlineKeyboardButton(
+            text="⬅️ Назад" if language == "ru" else "⬅️ Back",
+            callback_data="menu_subscription"
+        )
     ])
     
-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
-
-
-def get_add_devices_keyboard(current_devices: int, language: str = "ru") -> InlineKeyboardMarkup:
-    texts = get_texts(language)
-    keyboard = []
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
     
-    max_devices = 10 
+def get_add_devices_keyboard(current_devices: int, language: str = "ru", subscription_end_date: datetime = None) -> InlineKeyboardMarkup:
+    from app.utils.pricing_utils import get_remaining_months
+    from app.config import settings
     
-    for add_count in range(1, min(6, max_devices - current_devices + 1)): 
-        price = add_count * settings.PRICE_PER_DEVICE
-        total_devices = current_devices + add_count
+    months_multiplier = 1
+    period_text = ""
+    if subscription_end_date:
+        months_multiplier = get_remaining_months(subscription_end_date)
+        if months_multiplier > 1:
+            period_text = f" (за {months_multiplier} мес)"
+    
+    device_price_per_month = settings.PRICE_PER_DEVICE
+    
+    buttons = []
+    
+    for count in [1, 2, 3, 4, 5]:
+        new_total = current_devices + count
+        if settings.MAX_DEVICES_LIMIT > 0 and new_total > settings.MAX_DEVICES_LIMIT:
+            continue
         
-        add_device_word = _get_device_declension(add_count)
+        price_per_month = count * device_price_per_month
+        total_price = price_per_month * months_multiplier
         
-        keyboard.append([
-            InlineKeyboardButton(
-                text=f"📱 +{add_count} {add_device_word} (итого: {total_devices}) - {settings.format_price(price)}",
-                callback_data=f"add_devices_{add_count}"
-            )
+        if language == "ru":
+            text = f"📱 +{count} устройство(а) (итого: {new_total}) - {total_price/100:.2f} ₽{period_text}"
+        else:
+            text = f"📱 +{count} device(s) (total: {new_total}) - {total_price/100:.2f} ₽{period_text}"
+        
+        buttons.append([
+            InlineKeyboardButton(text=text, callback_data=f"add_devices_{count}")
         ])
     
-    keyboard.append([
-        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
+    buttons.append([
+        InlineKeyboardButton(
+            text="⬅️ Назад" if language == "ru" else "⬅️ Back", 
+            callback_data="menu_subscription"
+        )
     ])
     
-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
 
 
 def get_reset_traffic_confirm_keyboard(price_kopeks: int, language: str = "ru") -> InlineKeyboardMarkup:
@@ -672,64 +781,72 @@ def get_manage_countries_keyboard(
     countries: List[dict], 
     selected: List[str], 
     current_subscription_countries: List[str],
-    language: str = "ru"
+    language: str = "ru",
+    subscription_end_date: datetime = None
 ) -> InlineKeyboardMarkup:
-    texts = get_texts(language)
-    keyboard = []
+    from app.utils.pricing_utils import get_remaining_months
+    
+    months_multiplier = 1
+    if subscription_end_date:
+        months_multiplier = get_remaining_months(subscription_end_date)
+        logger.info(f"🔍 Расчет для управления странами: осталось {months_multiplier} месяцев до {subscription_end_date}")
+    
+    buttons = []
+    total_cost = 0
     
     for country in countries:
-        if not country.get('is_available', True):
-            continue
+        uuid = country['uuid']
+        name = country['name']
+        price_per_month = country['price_kopeks']
         
-        is_currently_connected = country['uuid'] in current_subscription_countries
-        is_selected = country['uuid'] in selected
-        
-        if is_currently_connected:
-            if is_selected:
-                emoji = "✅"  
-                status = ""
+        if uuid in current_subscription_countries:
+            if uuid in selected:
+                icon = "✅"
             else:
-                emoji = "➖"  
-                status = " (отключить БЕСПЛАТНО)"
+                icon = "➖"
         else:
-            if is_selected:
-                emoji = "➕"  
-                price_text = f" (+{texts.format_price(country['price_kopeks'])})" if country['price_kopeks'] > 0 else " (Бесплатно)"
-                status = price_text
+            if uuid in selected:
+                icon = "➕"
+                total_cost += price_per_month * months_multiplier
             else:
-                emoji = "⚪"  
-                price_text = f" (+{texts.format_price(country['price_kopeks'])})" if country['price_kopeks'] > 0 else " (Бесплатно)"
-                status = price_text
+                icon = "⚪"
         
-        keyboard.append([
+        if uuid not in current_subscription_countries and uuid in selected:
+            total_price = price_per_month * months_multiplier
+            if months_multiplier > 1:
+                price_text = f" ({price_per_month/100:.2f}₽/мес × {months_multiplier} = {total_price/100:.2f}₽)"
+                logger.info(f"🔍 Сервер {name}: {price_per_month/100}₽/мес × {months_multiplier} мес = {total_price/100}₽")
+            else:
+                price_text = f" ({total_price/100:.2f}₽)"
+            display_name = f"{icon} {name}{price_text}"
+        else:
+            display_name = f"{icon} {name}"
+        
+        buttons.append([
             InlineKeyboardButton(
-                text=f"{emoji} {country['name']}{status}",
-                callback_data=f"country_manage_{country['uuid']}"
+                text=display_name,
+                callback_data=f"country_manage_{uuid}"
             )
         ])
     
-    if not keyboard:
-        keyboard.append([
-            InlineKeyboardButton(
-                text="❌ Нет доступных серверов",
-                callback_data="no_servers"
-            )
-        ])
+    if total_cost > 0:
+        apply_text = f"✅ Применить изменения ({total_cost/100:.2f} ₽)"
+        logger.info(f"🔍 Общая стоимость новых серверов: {total_cost/100}₽")
+    else:
+        apply_text = "✅ Применить изменения"
     
-    added = [c for c in selected if c not in current_subscription_countries]
-    removed = [c for c in current_subscription_countries if c not in selected]
-    
-    apply_text = "✅ Применить изменения"
-    if added or removed:
-        changes_count = len(added) + len(removed)
-        apply_text += f" ({changes_count})"
-    
-    keyboard.extend([
-        [InlineKeyboardButton(text=apply_text, callback_data="countries_apply")],
-        [InlineKeyboardButton(text="❌ Отмена", callback_data="menu_subscription")]
+    buttons.append([
+        InlineKeyboardButton(text=apply_text, callback_data="countries_apply")
     ])
     
-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+    buttons.append([
+        InlineKeyboardButton(
+            text="⬅️ Назад" if language == "ru" else "⬅️ Back",
+            callback_data="menu_subscription"
+        )
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
 
 def get_device_selection_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     from app.config import settings

app/localization/texts.py

@@ -105,19 +105,17 @@ class RussianTexts(Texts):
     REFERRAL_CODE_APPLIED = "🎁 Реферальный код применен! Вы получите бонус после первой покупки."
     REFERRAL_CODE_INVALID = "❌ Неверный реферальный код"
     REFERRAL_CODE_SKIP = "⏭️ Пропустить"
-    
+       
     MAIN_MENU = """👤 <b>{user_name}</b>
-━━━━━━━━━━━━━━━━━
-💰 <b>Баланс:</b> {balance}
+    
 📱 <b>Подписка:</b> {subscription_status}
-━━━━━━━━━━━━━━━━━
 
 Выберите действие:
 """
     
     MENU_BALANCE = "💰 Баланс"
     MENU_SUBSCRIPTION = "📱 Подписка"
-    MENU_TRIAL = "🎁 Тестовая подписка"
+    MENU_TRIAL = "🧪 Тестовая подписка"
     MENU_BUY_SUBSCRIPTION = "💎 Купить подписку"
     MENU_EXTEND_SUBSCRIPTION = "⏰ Продлить подписку"
     MENU_PROMOCODE = "🎫 Промокод"
@@ -126,9 +124,11 @@ class RussianTexts(Texts):
     MENU_RULES = "📋 Правила сервиса"
     MENU_LANGUAGE = "🌐 Язык"
     MENU_ADMIN = "⚙️ Админ-панель"
+    BALANCE_BUTTON = "💰 Баланс: {balance}"
+    BALANCE_BUTTON_ZERO = "💰 Баланс: 0.00 ₽"
     
     SUBSCRIPTION_NONE = "❌ Нет активной подписки"
-    SUBSCRIPTION_TRIAL = "🎁 Тестовая подписка"
+    SUBSCRIPTION_TRIAL = "🧪 Тестовая подписка"
     SUBSCRIPTION_ACTIVE = "✅ Активна"
     SUBSCRIPTION_EXPIRED = "⏰ Истекла"
     

app/services/monitoring_service.py

@@ -37,6 +37,7 @@ class MonitoringService:
         self.payment_service = PaymentService()
         self.bot = bot
         self._notified_users: Set[str] = set() 
+        self._last_cleanup = datetime.utcnow()
     
     async def start_monitoring(self):
         if self.is_running:
@@ -62,6 +63,8 @@ class MonitoringService:
     async def _monitoring_cycle(self):
         async for db in get_db():
             try:
+                await self._cleanup_notification_cache()
+                
                 await self._check_expired_subscriptions(db)
                 await self._check_expiring_subscriptions(db)
                 await self._check_trial_expiring_soon(db)  
@@ -69,10 +72,6 @@ class MonitoringService:
                 await self._cleanup_inactive_users(db)
                 await self._sync_with_remnawave(db)
                 
-                current_hour = datetime.utcnow().hour
-                if current_hour == 0:
-                    self._notified_users.clear()
-                
                 await self._log_monitoring_event(
                     db, "monitoring_cycle_completed", 
                     "Цикл мониторинга успешно завершен", 
@@ -90,6 +89,15 @@ class MonitoringService:
             finally:
                 break 
     
+    async def _cleanup_notification_cache(self):
+        current_time = datetime.utcnow()
+        
+        if (current_time - self._last_cleanup).total_seconds() >= 3600:
+            old_count = len(self._notified_users)
+            self._notified_users.clear()
+            self._last_cleanup = current_time
+            logger.info(f"🧹 Очищен кеш уведомлений ({old_count} записей)")
+    
     async def _check_expired_subscriptions(self, db: AsyncSession):
         try:
             expired_subscriptions = await get_expired_subscriptions(db)
@@ -168,30 +176,52 @@ class MonitoringService:
     async def _check_expiring_subscriptions(self, db: AsyncSession):
         try:
             warning_days = settings.get_autopay_warning_days()
+            all_processed_users = set() 
             
             for days in warning_days:
                 expiring_subscriptions = await self._get_expiring_paid_subscriptions(db, days)
+                sent_count = 0
                 
                 for subscription in expiring_subscriptions:
                     user = await get_user_by_id(db, subscription.user_id)
                     if not user:
                         continue
                     
-                    notification_key = f"expiring_{user.telegram_id}_{days}d"
-                    if notification_key in self._notified_users:
-                        continue 
+                    notification_key = f"expiring_{user.telegram_id}_{days}d_{subscription.id}"
+                    user_key = f"user_{user.telegram_id}_today"
+                    
+                    if (notification_key in self._notified_users or 
+                        user_key in all_processed_users):
+                        logger.debug(f"🔄 Пропускаем дублирование для пользователя {user.telegram_id} на {days} дней")
+                        continue
+                    
+                    should_send = True
+                    for other_days in warning_days:
+                        if other_days < days: 
+                            other_subs = await self._get_expiring_paid_subscriptions(db, other_days)
+                            if any(s.user_id == user.id for s in other_subs):
+                                should_send = False
+                                logger.debug(f"🎯 Пропускаем уведомление на {days} дней для пользователя {user.telegram_id}, есть более срочное на {other_days} дней")
+                                break
+                    
+                    if not should_send:
+                        continue
                     
                     if self.bot:
-                        await self._send_subscription_expiring_notification(user, subscription, days)
-                        self._notified_users.add(notification_key)
-                    
-                    logger.info(f"⚠️ Пользователю {user.telegram_id} отправлено уведомление об истечении подписки через {days} дней")
+                        success = await self._send_subscription_expiring_notification(user, subscription, days)
+                        if success:
+                            self._notified_users.add(notification_key)
+                            all_processed_users.add(user_key)
+                            sent_count += 1
+                            logger.info(f"✅ Пользователю {user.telegram_id} отправлено уведомление об истечении подписки через {days} дней")
+                        else:
+                            logger.warning(f"❌ Не удалось отправить уведомление пользователю {user.telegram_id}")
                 
-                if expiring_subscriptions:
+                if sent_count > 0:
                     await self._log_monitoring_event(
                         db, "expiring_notifications_sent",
-                        f"Отправлено {len(expiring_subscriptions)} уведомлений об истечении через {days} дней",
-                        {"days": days, "count": len(expiring_subscriptions)}
+                        f"Отправлено {sent_count} уведомлений об истечении через {days} дней",
+                        {"days": days, "count": sent_count}
                     )
                     
         except Exception as e:
@@ -220,15 +250,15 @@ class MonitoringService:
                 if not user:
                     continue
                 
-                notification_key = f"trial_2h_{user.telegram_id}"
+                notification_key = f"trial_2h_{user.telegram_id}_{subscription.id}"
                 if notification_key in self._notified_users:
                     continue  
                 
                 if self.bot:
-                    await self._send_trial_ending_notification(user, subscription)
-                    self._notified_users.add(notification_key)
-                
-                logger.info(f"🎁 Пользователю {user.telegram_id} отправлено уведомление об окончании тестовой подписки через 2 часа")
+                    success = await self._send_trial_ending_notification(user, subscription)
+                    if success:
+                        self._notified_users.add(notification_key)
+                        logger.info(f"🎁 Пользователю {user.telegram_id} отправлено уведомление об окончании тестовой подписки через 2 часа")
             
             if trial_expiring:
                 await self._log_monitoring_event(
@@ -257,9 +287,9 @@ class MonitoringService:
             )
         )
         
-        logger.info(f"🔍 Поиск платных подписок, истекающих в ближайшие {days_before} дней")
-        logger.info(f"📅 Текущее время: {current_time}")
-        logger.info(f"📅 Пороговая дата: {threshold_date}")
+        logger.debug(f"🔍 Поиск платных подписок, истекающих в ближайшие {days_before} дней")
+        logger.debug(f"📅 Текущее время: {current_time}")
+        logger.debug(f"📅 Пороговая дата: {threshold_date}")
         
         subscriptions = result.scalars().all()
         logger.info(f"📊 Найдено {len(subscriptions)} платных подписок для уведомлений")
@@ -340,15 +370,15 @@ class MonitoringService:
         except Exception as e:
             logger.error(f"Ошибка обработки автоплатежей: {e}")
     
-    async def _send_subscription_expired_notification(self, user: User):
+    async def _send_subscription_expired_notification(self, user: User) -> bool:
         try:
             message = """
-    ❌ <b>Подписка истекла</b>
+⛔ <b>Подписка истекла</b>
 
-    Ваша подписка истекла. Для восстановления доступа продлите подписку.
+Ваша подписка истекла. Для восстановления доступа продлите подписку.
 
-    🔧 Доступ к серверам заблокирован до продления.
-    """
+🔧 Доступ к серверам заблокирован до продления.
+"""
             
             from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
             
@@ -363,11 +393,13 @@ class MonitoringService:
                 parse_mode="HTML",
                 reply_markup=keyboard
             )
+            return True
             
         except Exception as e:
             logger.error(f"Ошибка отправки уведомления об истечении подписки пользователю {user.telegram_id}: {e}")
+            return False
     
-    async def _send_subscription_expiring_notification(self, user: User, subscription: Subscription, days: int):
+    async def _send_subscription_expiring_notification(self, user: User, subscription: Subscription, days: int) -> bool:
         try:
             from app.utils.formatters import format_days_declension
             
@@ -382,14 +414,14 @@ class MonitoringService:
                 action_text = "💡 Включите автоплатеж или продлите подписку вручную"
             
             message = f"""
-    ⚠️ <b>Подписка истекает через {days_text}!</b>
+⚠️ <b>Подписка истекает через {days_text}!</b>
 
-    Ваша платная подписка истекает {subscription.end_date.strftime("%d.%m.%Y %H:%M")}.
+Ваша платная подписка истекает {subscription.end_date.strftime("%d.%m.%Y %H:%M")}.
 
-    💳 <b>Автоплатеж:</b> {autopay_status}
+💳 <b>Автоплатеж:</b> {autopay_status}
 
-    {action_text}
-    """
+{action_text}
+"""
             
             from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
             
@@ -405,30 +437,32 @@ class MonitoringService:
                 parse_mode="HTML",
                 reply_markup=keyboard
             )
+            return True
             
         except Exception as e:
             logger.error(f"Ошибка отправки уведомления об истечении подписки пользователю {user.telegram_id}: {e}")
+            return False
     
-    async def _send_trial_ending_notification(self, user: User, subscription: Subscription):
+    async def _send_trial_ending_notification(self, user: User, subscription: Subscription) -> bool:
         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 устройств
 
-    ⚡️ Успейте оформить до окончания тестового периода!
-    """
+⚡️ Успейте оформить до окончания тестового периода!
+"""
             
             from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
             
@@ -443,9 +477,11 @@ class MonitoringService:
                 parse_mode="HTML",
                 reply_markup=keyboard
             )
+            return True
             
         except Exception as e:
             logger.error(f"Ошибка отправки уведомления об окончании тестовой подписки пользователю {user.telegram_id}: {e}")
+            return False
     
     async def _send_autopay_success_notification(self, user: User, amount: int, days: int):
         try:
@@ -554,7 +590,7 @@ class MonitoringService:
             
         except Exception as e:
             logger.error(f"Ошибка логирования события мониторинга: {e}")
-    
+
     async def get_monitoring_status(self, db: AsyncSession) -> Dict[str, Any]:
         try:
             from sqlalchemy import select, desc

app/services/payment_service.py

@@ -9,6 +9,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings
 from app.services.yookassa_service import YooKassaService
+from app.external.telegram_stars import TelegramStarsService
 from app.database.crud.yookassa import create_yookassa_payment, link_yookassa_payment_to_transaction
 from app.database.crud.transaction import create_transaction
 from app.database.crud.user import add_user_balance, get_user_by_id
@@ -22,6 +23,7 @@ class PaymentService:
     def __init__(self, bot: Optional[Bot] = None):
         self.bot = bot
         self.yookassa_service = YooKassaService() if settings.is_yookassa_enabled() else None
+        self.stars_service = TelegramStarsService(bot) if bot else None
     
     async def create_stars_invoice(
         self,
@@ -30,28 +32,90 @@ class PaymentService:
         payload: Optional[str] = None
     ) -> str:
         
-        if not self.bot:
+        if not self.bot or not self.stars_service:
             raise ValueError("Bot instance required for Stars payments")
         
         try:
-            stars_amount = max(1, amount_kopeks // 100)
+            amount_rubles = amount_kopeks / 100
+            stars_amount = TelegramStarsService.calculate_stars_from_rubles(amount_rubles)
             
             invoice_link = await self.bot.create_invoice_link(
                 title="Пополнение баланса VPN",
-                description=description,
+                description=f"{description} (≈{stars_amount} ⭐)",
                 payload=payload or f"balance_topup_{amount_kopeks}",
                 provider_token="", 
                 currency="XTR", 
                 prices=[LabeledPrice(label="Пополнение", amount=stars_amount)]
             )
             
-            logger.info(f"Создан Stars invoice на {stars_amount} звезд")
+            logger.info(f"Создан Stars invoice на {stars_amount} звезд (~{amount_rubles:.2f}₽)")
             return invoice_link
             
         except Exception as e:
             logger.error(f"Ошибка создания Stars invoice: {e}")
             raise
     
+    async def process_stars_payment(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        stars_amount: int,
+        payload: str,
+        telegram_payment_charge_id: str
+    ) -> bool:
+        try:
+            rubles_amount = TelegramStarsService.calculate_rubles_from_stars(stars_amount)
+            amount_kopeks = int(rubles_amount * 100)
+            
+            transaction = await create_transaction(
+                db=db,
+                user_id=user_id,
+                type=TransactionType.DEPOSIT,
+                amount_kopeks=amount_kopeks,
+                description=f"Пополнение через Telegram Stars ({stars_amount} ⭐)",
+                payment_method=PaymentMethod.TELEGRAM_STARS,
+                external_id=telegram_payment_charge_id,
+                is_completed=True
+            )
+            
+            user = await get_user_by_id(db, user_id)
+            if user:
+                await add_user_balance(
+                    db, 
+                    user, 
+                    amount_kopeks, 
+                    f"Пополнение Stars: {rubles_amount:.2f}₽ ({stars_amount} ⭐)"
+                )
+                
+                if self.bot:
+                    try:
+                        await self.bot.send_message(
+                            user.telegram_id,
+                            f"✅ <b>Пополнение успешно!</b>\n\n"
+                            f"⭐ Звезд: {stars_amount}\n"
+                            f"💰 Сумма: {settings.format_price(amount_kopeks)}\n"
+                            f"🏦 Способ: Telegram Stars\n"
+                            f"🆔 Транзакция: {telegram_payment_charge_id[:8]}...\n\n"
+                            f"Баланс пополнен автоматически!",
+                            parse_mode="HTML"
+                        )
+                        logger.info(f"✅ Отправлено уведомление пользователю {user.telegram_id} о пополнении на {rubles_amount:.2f}₽")
+                    except Exception as e:
+                        logger.error(f"Ошибка отправки уведомления о пополнении Stars: {e}")
+                
+                logger.info(
+                    f"✅ Обработан Stars платеж: пользователь {user_id}, "
+                    f"{stars_amount} звезд → {rubles_amount:.2f}₽"
+                )
+                return True
+            else:
+                logger.error(f"Пользователь с ID {user_id} не найден при обработке Stars платежа")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Ошибка обработки Stars платежа: {e}", exc_info=True)
+            return False
+    
     async def create_yookassa_payment(
         self,
         db: AsyncSession,
@@ -196,7 +260,7 @@ class PaymentService:
                                 user.telegram_id,
                                 f"✅ <b>Пополнение успешно!</b>\n\n"
                                 f"💰 Сумма: {settings.format_price(updated_payment.amount_kopeks)}\n"
-                                f"🏦 Способ: Банковская карта\n"
+                                f"🦐 Способ: Банковская карта\n"
                                 f"🆔 Транзакция: {yookassa_payment_id[:8]}...\n\n"
                                 f"Баланс пополнен автоматически!",
                                 parse_mode="HTML"

app/services/subscription_service.py

@@ -10,6 +10,12 @@ from app.external.remnawave_api import (
     TrafficLimitStrategy, RemnaWaveAPIError
 )
 from app.database.crud.user import get_user_by_id
+from app.utils.pricing_utils import (
+    calculate_months_from_days,
+    get_remaining_months,
+    calculate_prorated_price,
+    validate_pricing_calculation
+)
 
 logger = logging.getLogger(__name__)
 
@@ -229,36 +235,40 @@ class SubscriptionService:
         devices: int,
         db: AsyncSession 
     ) -> Tuple[int, List[int]]:
-
-        from app.config import PERIOD_PRICES, TRAFFIC_PRICES
+    
+        from app.config import PERIOD_PRICES
         from app.database.crud.server_squad import get_server_squad_by_id
-
+    
+        if settings.MAX_DEVICES_LIMIT > 0 and devices > settings.MAX_DEVICES_LIMIT:
+            raise ValueError(f"Превышен максимальный лимит устройств: {settings.MAX_DEVICES_LIMIT}")
+    
         base_price = PERIOD_PRICES.get(period_days, 0)
-        traffic_price = TRAFFIC_PRICES.get(traffic_gb, 0)
-
+        
+        traffic_price = settings.get_traffic_price(traffic_gb)
+    
         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}₽")
+                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
+                logger.warning(f"Сервер ID {server_id} недоступен")
+    
+        devices_price = max(0, devices - settings.DEFAULT_DEVICE_LIMIT) * 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}₽")
+        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
     
@@ -269,7 +279,7 @@ class SubscriptionService:
         db: AsyncSession
     ) -> int:
         try:
-            from app.config import PERIOD_PRICES, TRAFFIC_PRICES
+            from app.config import PERIOD_PRICES
             
             base_price = PERIOD_PRICES.get(period_days, 0)
             
@@ -277,9 +287,9 @@ class SubscriptionService:
                 subscription.connected_squads, db
             )
             
-            devices_price = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+            devices_price = max(0, subscription.device_limit - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
             
-            traffic_price = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
+            traffic_price = settings.get_traffic_price(subscription.traffic_limit_gb)
             
             total_price = base_price + servers_price + devices_price + traffic_price
             
@@ -384,6 +394,139 @@ class SubscriptionService:
         except Exception as e:
             logger.error(f"Ошибка получения цен стран: {e}")
             return len(country_uuids) * 1000
+
+    async def calculate_subscription_price_with_months(
+        self,
+        period_days: int,
+        traffic_gb: int,
+        server_squad_ids: List[int], 
+        devices: int,
+        db: AsyncSession 
+    ) -> Tuple[int, List[int]]:
+    
+        from app.config import PERIOD_PRICES
+        from app.database.crud.server_squad import get_server_squad_by_id
+        
+        if settings.MAX_DEVICES_LIMIT > 0 and devices > settings.MAX_DEVICES_LIMIT:
+            raise ValueError(f"Превышен максимальный лимит устройств: {settings.MAX_DEVICES_LIMIT}")
+        
+        months_in_period = calculate_months_from_days(period_days)
+        
+        base_price = PERIOD_PRICES.get(period_days, 0)
+        
+        traffic_price_per_month = settings.get_traffic_price(traffic_gb)
+        total_traffic_price = traffic_price_per_month * months_in_period
+        
+        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_price_per_month = server.price_kopeks
+                server_price_total = server_price_per_month * months_in_period
+                server_prices.append(server_price_total)
+                total_servers_price += server_price_total
+                logger.debug(f"Сервер {server.display_name}: {server_price_per_month/100}₽/мес x {months_in_period} мес = {server_price_total/100}₽")
+            else:
+                server_prices.append(0)
+                logger.warning(f"Сервер ID {server_id} недоступен")
+        
+        additional_devices = max(0, devices - settings.DEFAULT_DEVICE_LIMIT)
+        devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+        total_devices_price = devices_price_per_month * months_in_period
+        
+        total_price = base_price + total_traffic_price + total_servers_price + total_devices_price
+        
+        logger.info(f"Расчет стоимости новой подписки на {period_days} дней ({months_in_period} мес):")
+        logger.info(f"   Период {period_days} дней: {base_price/100}₽")
+        logger.info(f"   Трафик {traffic_gb} ГБ: {traffic_price_per_month/100}₽/мес x {months_in_period} = {total_traffic_price/100}₽")
+        logger.info(f"   Серверы ({len(server_squad_ids)}): {total_servers_price/100}₽")
+        logger.info(f"   Устройства ({additional_devices}): {devices_price_per_month/100}₽/мес x {months_in_period} = {total_devices_price/100}₽")
+        logger.info(f"   ИТОГО: {total_price/100}₽")
+        
+        return total_price, server_prices
+    
+    async def calculate_renewal_price_with_months(
+        self,
+        subscription: Subscription,
+        period_days: int,
+        db: AsyncSession
+    ) -> int:
+        try:
+            from app.config import PERIOD_PRICES
+            
+            months_in_period = calculate_months_from_days(period_days)
+            
+            base_price = PERIOD_PRICES.get(period_days, 0)
+            
+            servers_price_per_month, _ = await self.get_countries_price_by_uuids(
+                subscription.connected_squads, db
+            )
+            total_servers_price = servers_price_per_month * months_in_period
+            
+            additional_devices = max(0, subscription.device_limit - settings.DEFAULT_DEVICE_LIMIT)
+            devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+            total_devices_price = devices_price_per_month * months_in_period
+            
+            traffic_price_per_month = settings.get_traffic_price(subscription.traffic_limit_gb)
+            total_traffic_price = traffic_price_per_month * months_in_period
+            
+            total_price = base_price + total_servers_price + total_devices_price + total_traffic_price
+            
+            logger.info(f"💰 Расчет стоимости продления подписки {subscription.id} на {period_days} дней ({months_in_period} мес):")
+            logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+            logger.info(f"   🌍 Серверы: {servers_price_per_month/100}₽/мес x {months_in_period} = {total_servers_price/100}₽")
+            logger.info(f"   📱 Устройства: {devices_price_per_month/100}₽/мес x {months_in_period} = {total_devices_price/100}₽")
+            logger.info(f"   📊 Трафик: {traffic_price_per_month/100}₽/мес x {months_in_period} = {total_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 calculate_addon_price_with_remaining_period(
+        self,
+        subscription: Subscription,
+        additional_traffic_gb: int = 0,
+        additional_devices: int = 0,
+        additional_server_ids: List[int] = None,
+        db: AsyncSession = None
+    ) -> int:
+        
+        if additional_server_ids is None:
+            additional_server_ids = []
+        
+        current_time = datetime.utcnow()
+        months_to_pay = get_remaining_months(subscription.end_date)
+        
+        total_price = 0
+        
+        if additional_traffic_gb > 0:
+            traffic_price_per_month = settings.get_traffic_price(additional_traffic_gb)
+            total_price += traffic_price_per_month * months_to_pay
+            logger.info(f"Трафик +{additional_traffic_gb}ГБ: {traffic_price_per_month/100}₽/мес x {months_to_pay} = {traffic_price_per_month * months_to_pay/100}₽")
+        
+        if additional_devices > 0:
+            devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+            total_price += devices_price_per_month * months_to_pay
+            logger.info(f"Устройства +{additional_devices}: {devices_price_per_month/100}₽/мес x {months_to_pay} = {devices_price_per_month * months_to_pay/100}₽")
+        
+        if additional_server_ids and db:
+            for server_id in additional_server_ids:
+                from app.database.crud.server_squad import get_server_squad_by_id
+                server = await get_server_squad_by_id(db, server_id)
+                if server and server.is_available:
+                    server_price_per_month = server.price_kopeks
+                    server_total_price = server_price_per_month * months_to_pay
+                    total_price += server_total_price
+                    logger.info(f"Сервер {server.display_name}: {server_price_per_month/100}₽/мес x {months_to_pay} = {server_total_price/100}₽")
+        
+        logger.info(f"Итого доплата за {months_to_pay} мес: {total_price/100}₽")
+        return total_price
     
     def _gb_to_bytes(self, gb: int) -> int:
         if gb == 0: 

app/services/user_service.py

@@ -2,7 +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 sqlalchemy import delete, select, update
 
 from app.database.crud.user import (
     get_user_by_id, get_user_by_telegram_id, get_users_list,
@@ -13,7 +13,7 @@ from app.database.crud.transaction import get_user_transactions_count
 from app.database.crud.subscription import get_subscription_by_user_id
 from app.database.models import (
     User, UserStatus, Subscription, Transaction, PromoCodeUse, 
-    ReferralEarning, SubscriptionServer
+    ReferralEarning, SubscriptionServer, YooKassaPayment, BroadcastHistory
 )
 from app.config import settings
 
@@ -242,9 +242,81 @@ class UserService:
                     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} деактивирован")
+                    logger.info(f"   ✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован")
                 except Exception as e:
-                    logger.error(f"❌ Ошибка деактивации RemnaWave пользователя: {e}")
+                    logger.warning(f"   ⚠️ Ошибка деактивации RemnaWave: {e}")
+            
+            try:
+                from app.database.models import YooKassaPayment
+                from sqlalchemy import select
+                
+                yookassa_result = await db.execute(
+                    select(YooKassaPayment).where(YooKassaPayment.user_id == user_id)
+                )
+                yookassa_payments = yookassa_result.scalars().all()
+                
+                if yookassa_payments:
+                    logger.info(f"   🔄 Удаляем {len(yookassa_payments)} YooKassa платежей")
+                    await db.execute(
+                        delete(YooKassaPayment).where(YooKassaPayment.user_id == user_id)
+                    )
+                    await db.flush()
+                    logger.info(f"   ✅ YooKassa платежи удалены")
+            except Exception as e:
+                logger.error(f"   ❌ Ошибка удаления YooKassa платежей: {e}")
+            
+            try:
+                transactions_result = await db.execute(
+                    select(Transaction).where(Transaction.user_id == user_id)
+                )
+                transactions = transactions_result.scalars().all()
+                
+                if transactions:
+                    logger.info(f"   🔄 Удаляем {len(transactions)} транзакций")
+                    await db.execute(
+                        delete(Transaction).where(Transaction.user_id == user_id)
+                    )
+                    await db.flush()
+                    logger.info(f"   ✅ Транзакции удалены")
+            except Exception as e:
+                logger.error(f"   ❌ Ошибка удаления транзакций: {e}")
+            
+            try:
+                await db.execute(
+                    delete(PromoCodeUse).where(PromoCodeUse.user_id == user_id)
+                )
+                await db.flush()
+                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)
+                )
+                await db.flush()
+                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)
+                )
+                await db.flush()
+                logger.info(f"   🗑️ Удалены реферальные записи о пользователе {user_id}")
+            except Exception as e:
+                logger.error(f"   ❌ Ошибка удаления реферальных записей: {e}")
+            
+            try:
+                from app.database.models import BroadcastHistory
+                await db.execute(
+                    delete(BroadcastHistory).where(BroadcastHistory.admin_id == user_id)
+                )
+                await db.flush()
+                logger.info(f"   🗑️ Удалена история рассылок админа {user_id}")
+            except Exception as e:
+                logger.error(f"   ❌ Ошибка удаления истории рассылок: {e}")
             
             if user.subscription:
                 try:
@@ -253,74 +325,47 @@ class UserService:
                             SubscriptionServer.subscription_id == user.subscription.id
                         )
                     )
-                    logger.info(f"🗑️ Удалены записи SubscriptionServer для подписки {user.subscription.id}")
+                    await db.flush()
+                    logger.info(f"   🗑️ Удалены записи SubscriptionServer для подписки {user.subscription.id}")
                 except Exception as e:
-                    logger.error(f"❌ Ошибка удаления SubscriptionServer: {e}")
+                    logger.error(f"   ❌ Ошибка удаления SubscriptionServer: {e}")
             
             if user.subscription:
                 try:
-                    await db.delete(user.subscription)
-                    logger.info(f"🗑️ Удалена подписка пользователя {user_id}")
+                    from app.database.models import Subscription
+                    await db.execute(
+                        delete(Subscription).where(Subscription.user_id == user_id)
+                    )
+                    await db.flush()
+                    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}")
+                    logger.error(f"   ❌ Ошибка удаления подписки: {e}")
             
             try:
                 from sqlalchemy import update
-                await db.execute(
+                referrals_result = await db.execute(
                     update(User)
-                    .where(User.referred_by_id == user.id)
+                    .where(User.referred_by_id == user_id)
                     .values(referred_by_id=None)
                 )
-                logger.info(f"🗑️ Очищены реферальные ссылки у рефералов пользователя {user_id}")
+                if referrals_result.rowcount > 0:
+                    logger.info(f"   🔗 Очищены реферальные ссылки у {referrals_result.rowcount} рефералов")
+                await db.flush()
             except Exception as e:
-                logger.error(f"❌ Ошибка очистки реферальных ссылок: {e}")
+                logger.error(f"   ❌ Ошибка очистки реферальных ссылок: {e}")
             
             try:
                 await db.execute(
-                    delete(Transaction).where(Transaction.user_id == user.id)
+                    delete(User).where(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} помечен как удаленный и обнулен")
+                logger.info(f"   ✅ Пользователь {user_id} окончательно удален из базы")
             except Exception as e:
-                logger.error(f"❌ Ошибка обновления статуса пользователя: {e}")
+                logger.error(f"   ❌ Ошибка финального удаления пользователя: {e}")
                 await db.rollback()
                 return False
             
-            logger.info(f"✅ Пользователь {user_id} (Telegram ID: {user.telegram_id}) полностью удален админом {admin_id}")
+            logger.info(f"✅ Пользователь {user.telegram_id} (ID: {user_id}) полностью удален администратором {admin_id}")
             return True
             
         except Exception as e:

app/states.py

@@ -52,6 +52,8 @@ class AdminStates(StatesGroup):
     editing_squad_price = State()
     editing_traffic_price = State()
     editing_device_price = State()
+    editing_user_devices = State()
+    editing_user_traffic = State()
     
     editing_rules_page = State()
     

app/utils/__init__.py

@@ -1,3 +1,13 @@
-"""
-Утилиты
-"""
+from .pricing_utils import (
+    calculate_months_from_days,
+    get_remaining_months,
+    calculate_prorated_price,
+    format_period_description
+)
+
+__all__ = [
+    'calculate_months_from_days',
+    'get_remaining_months', 
+    'calculate_prorated_price',
+    'format_period_description'
+]

app/utils/pricing_utils.py

@@ -0,0 +1,94 @@
+from datetime import datetime, timedelta
+from typing import Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_months_from_days(days: int) -> int:
+    return max(1, round(days / 30))
+
+
+def get_remaining_months(end_date: datetime) -> int:
+    current_time = datetime.utcnow()
+    if end_date <= current_time:
+        return 1 
+    
+    remaining_days = (end_date - current_time).days
+    return max(1, round(remaining_days / 30))
+
+
+def calculate_period_multiplier(period_days: int) -> Tuple[int, float]:
+    exact_months = period_days / 30
+    months_count = max(1, round(exact_months))
+    
+    logger.debug(f"Период {period_days} дней = {exact_months:.2f} точных месяцев ≈ {months_count} месяцев для расчета")
+    
+    return months_count, exact_months
+
+
+def calculate_prorated_price(
+    monthly_price: int, 
+    end_date: datetime, 
+    min_charge_months: int = 1
+) -> Tuple[int, int]:
+    months_remaining = get_remaining_months(end_date)
+    months_to_charge = max(min_charge_months, months_remaining)
+    
+    total_price = monthly_price * months_to_charge
+    
+    logger.debug(f"Расчет пропорциональной цены: {monthly_price/100}₽/мес × {months_to_charge} мес = {total_price/100}₽")
+    
+    return total_price, months_to_charge
+
+
+def format_period_description(days: int, language: str = "ru") -> str:
+    months = calculate_months_from_days(days)
+    
+    if language == "ru":
+        if days == 30:
+            return "1 месяц"
+        elif days == 60:
+            return "2 месяца"
+        elif days == 90:
+            return "3 месяца"
+        elif days == 180:
+            return "6 месяцев"
+        elif days == 360:
+            return "12 месяцев"
+        else:
+            month_word = "месяц" if months == 1 else ("месяца" if 2 <= months <= 4 else "месяцев")
+            return f"{days} дней ({months} {month_word})"
+    else: 
+        month_word = "month" if months == 1 else "months"
+        return f"{days} days ({months} {month_word})"
+
+
+def validate_pricing_calculation(
+    base_price: int,
+    monthly_additions: int,
+    months: int,
+    total_calculated: int
+) -> bool:
+    expected_total = base_price + (monthly_additions * months)
+    is_valid = expected_total == total_calculated
+    
+    if not is_valid:
+        logger.warning(f"Несоответствие в расчете цены: ожидалось {expected_total/100}₽, получено {total_calculated/100}₽")
+        logger.warning(f"Детали: базовая цена {base_price/100}₽ + месячные дополнения {monthly_additions/100}₽ × {months} мес")
+    
+    return is_valid
+
+
+STANDARD_PERIODS = {
+    14: {"months": 0.5, "display_ru": "2 недели", "display_en": "2 weeks"},
+    30: {"months": 1, "display_ru": "1 месяц", "display_en": "1 month"},
+    60: {"months": 2, "display_ru": "2 месяца", "display_en": "2 months"},
+    90: {"months": 3, "display_ru": "3 месяца", "display_en": "3 months"},
+    180: {"months": 6, "display_ru": "6 месяцев", "display_en": "6 months"},
+    360: {"months": 12, "display_ru": "1 год", "display_en": "1 year"},
+}
+
+
+def get_period_info(days: int) -> dict:
+    return STANDARD_PERIODS.get(days)