Merge pull request #24 from Fr1ngg/dev

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

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 - settings.DEFAULT_DEVICE_LIMIT) * 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/handlers/subscription.py

@@ -40,6 +40,12 @@ from app.localization.texts import get_texts
 from app.services.remnawave_service import RemnaWaveService
 from app.services.subscription_service import SubscriptionService
 from app.services.referral_service import process_referral_purchase
+from app.utils.pricing_utils import (
+    calculate_months_from_days,
+    get_remaining_months,
+    calculate_prorated_price,
+    validate_pricing_calculation
+)
 
 logger = logging.getLogger(__name__)
 
@@ -451,7 +457,7 @@ async def handle_add_countries(
     subscription = db_user.subscription
     
     if not subscription or subscription.is_trial:
-        await callback.answer("❌ Эта функция доступна только для платных подписок", show_alert=True)
+        await callback.answer("⚠ Эта функция доступна только для платных подписок", show_alert=True)
         return
     
     countries = await _get_available_countries()
@@ -484,7 +490,8 @@ async def handle_add_countries(
             countries, 
             current_countries.copy(), 
             current_countries, 
-            db_user.language
+            db_user.language,
+            subscription.end_date
         ),
         parse_mode="HTML"
     )
@@ -533,7 +540,7 @@ async def handle_manage_country(
     
     subscription = db_user.subscription
     if not subscription or subscription.is_trial:
-        await callback.answer("❌ Только для платных подписок", show_alert=True)
+        await callback.answer("⚠ Только для платных подписок", show_alert=True)
         return
     
     data = await state.get_data()
@@ -558,13 +565,14 @@ async def handle_manage_country(
                 countries, 
                 current_selected, 
                 subscription.connected_squads, 
-                db_user.language
+                db_user.language,
+                subscription.end_date 
             )
         )
         logger.info(f"✅ Клавиатура обновлена")
         
     except Exception as e:
-        logger.error(f"❌ Ошибка обновления клавиатуры: {e}")
+        logger.error(f"⚠ Ошибка обновления клавиатуры: {e}")
     
     await callback.answer()
 
@@ -574,6 +582,8 @@ async def apply_countries_changes(
     db: AsyncSession,
     state: FSMContext
 ):
+    from app.utils.pricing_utils import get_remaining_months, calculate_prorated_price
+    
     logger.info(f"🔍 Применение изменений стран")
     
     data = await state.get_data()
@@ -593,44 +603,58 @@ async def apply_countries_changes(
     logger.info(f"🔍 Добавлено: {added}, Удалено: {removed}")
     
     countries = await _get_available_countries()
-    cost = 0
+    
+    # Рассчитываем оставшиеся месяцы подписки для новых серверов
+    months_to_pay = get_remaining_months(subscription.end_date)
+    
+    cost_per_month = 0
     added_names = []
     removed_names = []
     
     added_server_prices = []
-    added_server_ids = []
     
     for country in countries:
         if country['uuid'] in added:
-            cost += country['price_kopeks']
+            server_price_per_month = country['price_kopeks']
+            cost_per_month += server_price_per_month
             added_names.append(country['name'])
-            added_server_prices.append(country['price_kopeks'])
         if country['uuid'] in removed:
             removed_names.append(country['name'])
     
-    if cost > 0 and db_user.balance_kopeks < cost:
+    total_cost, charged_months = calculate_prorated_price(cost_per_month, subscription.end_date)
+    
+    # Рассчитываем цены для каждого сервера за весь период
+    for country in countries:
+        if country['uuid'] in added:
+            server_price_per_month = country['price_kopeks']
+            server_total_price = server_price_per_month * charged_months
+            added_server_prices.append(server_total_price)
+    
+    logger.info(f"Стоимость новых серверов: {cost_per_month/100}₽/мес × {charged_months} мес = {total_cost/100}₽")
+    
+    if total_cost > 0 and db_user.balance_kopeks < total_cost:
         await callback.answer(
-            f"❌ Недостаточно средств!\nТребуется: {texts.format_price(cost)}\nУ вас: {texts.format_price(db_user.balance_kopeks)}", 
+            f"⚠ Недостаточно средств!\nТребуется: {texts.format_price(total_cost)} (за {charged_months} мес)\nУ вас: {texts.format_price(db_user.balance_kopeks)}", 
             show_alert=True
         )
         return
     
     try:
-        if added and cost > 0:
+        if added and total_cost > 0:
             success = await subtract_user_balance(
-                db, db_user, cost, 
-                f"Добавление стран: {', '.join(added_names)}"
+                db, db_user, total_cost, 
+                f"Добавление стран: {', '.join(added_names)} на {charged_months} мес"
             )
             if not success:
-                await callback.answer("❌ Ошибка списания средств", show_alert=True)
+                await callback.answer("⚠ Ошибка списания средств", show_alert=True)
                 return
             
             await create_transaction(
                 db=db,
                 user_id=db_user.id,
                 type=TransactionType.SUBSCRIPTION_PAYMENT,
-                amount_kopeks=cost,
-                description=f"Добавление стран к подписке: {', '.join(added_names)}"
+                amount_kopeks=total_cost,
+                description=f"Добавление стран к подписке: {', '.join(added_names)} на {charged_months} мес"
             )
         
         if added:
@@ -643,7 +667,7 @@ async def apply_countries_changes(
                 await add_subscription_servers(db, subscription, added_server_ids, added_server_prices)
                 await add_user_to_servers(db, added_server_ids)
                 
-                logger.info(f"📊 Добавлены серверы с ценами: {list(zip(added_server_ids, added_server_prices))}")
+                logger.info(f"📊 Добавлены серверы с ценами за {charged_months} мес: {list(zip(added_server_ids, added_server_prices))}")
         
         subscription.connected_squads = selected_countries
         subscription.updated_at = datetime.utcnow()
@@ -652,12 +676,12 @@ async def apply_countries_changes(
         subscription_service = SubscriptionService()
         await subscription_service.update_remnawave_user(db, subscription)
         
-        if cost > 0:
+        if total_cost > 0:
             try:
                 await process_referral_purchase(
                     db=db,
                     user_id=db_user.id,
-                    purchase_amount_kopeks=cost,
+                    purchase_amount_kopeks=total_cost,
                     transaction_id=None
                 )
             except Exception as e:
@@ -670,8 +694,8 @@ async def apply_countries_changes(
         if added_names:
             success_text += f"➕ <b>Добавлены страны:</b>\n"
             success_text += "\n".join(f"• {name}" for name in added_names)
-            if cost > 0:
-                success_text += f"\n💰 Списано: {texts.format_price(cost)}"
+            if total_cost > 0:
+                success_text += f"\n💰 Списано: {texts.format_price(total_cost)} (за {charged_months} мес)"
             success_text += "\n"
         
         if removed_names:
@@ -688,10 +712,10 @@ async def apply_countries_changes(
         )
         
         await state.clear()
-        logger.info(f"✅ Пользователь {db_user.telegram_id} обновил страны. Добавлено: {len(added)}, удалено: {len(removed)}")
+        logger.info(f"✅ Пользователь {db_user.telegram_id} обновил страны. Добавлено: {len(added)}, удалено: {len(removed)}, заплатил: {total_cost/100}₽")
         
     except Exception as e:
-        logger.error(f"❌ Ошибка применения изменений: {e}")
+        logger.error(f"⚠ Ошибка применения изменений: {e}")
         await callback.message.edit_text(
             texts.ERROR,
             reply_markup=get_back_keyboard(db_user.language)
@@ -715,11 +739,11 @@ async def handle_add_traffic(
     subscription = db_user.subscription
     
     if not subscription or subscription.is_trial:
-        await callback.answer("⌛ Эта функция доступна только для платных подписок", show_alert=True)
+        await callback.answer("⚠ Эта функция доступна только для платных подписок", show_alert=True)
         return
     
     if subscription.traffic_limit_gb == 0:
-        await callback.answer("⌛ У вас уже безлимитный трафик", show_alert=True)
+        await callback.answer("⚠ У вас уже безлимитный трафик", show_alert=True)
         return
     
     current_traffic = subscription.traffic_limit_gb
@@ -728,23 +752,23 @@ async def handle_add_traffic(
         f"📈 <b>Добавить трафик к подписке</b>\n\n"
         f"Текущий лимит: {texts.format_traffic(current_traffic)}\n"
         f"Выберите дополнительный трафик:",
-        reply_markup=get_add_traffic_keyboard(db_user.language)
+        reply_markup=get_add_traffic_keyboard(db_user.language, subscription.end_date),
+        parse_mode="HTML"
     )
     
     await callback.answer()
-
+    
 
 async def handle_add_devices(
     callback: types.CallbackQuery,
     db_user: User,
     db: AsyncSession
 ):
-    
     texts = get_texts(db_user.language)
     subscription = db_user.subscription
     
     if not subscription or subscription.is_trial:
-        await callback.answer("❌ Эта функция доступна только для платных подписок", show_alert=True)
+        await callback.answer("⚠ Эта функция доступна только для платных подписок", show_alert=True)
         return
     
     current_devices = subscription.device_limit
@@ -753,7 +777,8 @@ async def handle_add_devices(
         f"📱 <b>Добавить устройства к подписке</b>\n\n"
         f"Текущий лимит: {current_devices} устройств\n"
         f"Выберите количество дополнительных устройств:",
-        reply_markup=get_add_devices_keyboard(current_devices, db_user.language)
+        reply_markup=get_add_devices_keyboard(current_devices, db_user.language, subscription.end_date),
+        parse_mode="HTML"
     )
     
     await callback.answer()
@@ -764,15 +789,17 @@ async def handle_extend_subscription(
     db_user: User,
     db: AsyncSession
 ):
+    from app.utils.pricing_utils import calculate_months_from_days, format_period_description
+    
     texts = get_texts(db_user.language)
     subscription = db_user.subscription
     
     if not subscription or subscription.is_trial:
-        await callback.answer("⌛ Продление доступно только для платных подписок", show_alert=True)
+        await callback.answer("⚠ Продление доступно только для платных подписок", show_alert=True)
         return
     
     if subscription.days_left > 3:
-        await callback.answer("⌛ Продление доступно за 3 дня до окончания подписки", show_alert=True)
+        await callback.answer("⚠ Продление доступно за 3 дня до окончания подписки", show_alert=True)
         return
     
     subscription_service = SubscriptionService()
@@ -782,29 +809,40 @@ async def handle_extend_subscription(
     
     for days in available_periods:
         try:
-            price = await subscription_service.calculate_renewal_price(subscription, days, db)
+            months_in_period = calculate_months_from_days(days)
+            
+            from app.config import PERIOD_PRICES
+            base_price = PERIOD_PRICES.get(days, 0)
+            
+            servers_price_per_month, _ = await subscription_service.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
+            
+            price = base_price + total_servers_price + total_devices_price + total_traffic_price
             renewal_prices[days] = price
+            
         except Exception as e:
             logger.error(f"Ошибка расчета цены для периода {days}: {e}")
             continue
     
     if not renewal_prices:
-        await callback.answer("⌛ Нет доступных периодов для продления", show_alert=True)
+        await callback.answer("⚠ Нет доступных периодов для продления", show_alert=True)
         return
     
     prices_text = ""
-    period_display = {
-        14: "14 дней",
-        30: "30 дней", 
-        60: "60 дней",
-        90: "90 дней",
-        180: "180 дней",
-        360: "360 дней"
-    }
     
     for days in available_periods:
-        if days in renewal_prices and days in period_display:
-            prices_text += f"📅 {period_display[days]} - {texts.format_price(renewal_prices[days])}\n"
+        if days in renewal_prices:
+            period_display = format_period_description(days, db_user.language)
+            prices_text += f"📅 {period_display} - {texts.format_price(renewal_prices[days])}\n"
     
     await callback.message.edit_text(
         f"⏰ Продление подписки\n\n"
@@ -869,17 +907,18 @@ async def confirm_add_traffic(
     db_user: User,
     db: AsyncSession
 ):
-    from app.config import settings
-    
-    if settings.is_traffic_fixed():
-        await callback.answer("⚠️ В текущем режиме трафик фиксированный", show_alert=True)
-        return
+    from app.utils.pricing_utils import get_remaining_months, calculate_prorated_price
     
     traffic_gb = int(callback.data.split('_')[2])
     texts = get_texts(db_user.language)
     subscription = db_user.subscription
     
-    price = settings.get_traffic_price(traffic_gb)
+    months_to_pay = get_remaining_months(subscription.end_date)
+    
+    traffic_price_per_month = settings.get_traffic_price(traffic_gb)
+    price, charged_months = calculate_prorated_price(traffic_price_per_month, subscription.end_date)
+    
+    logger.info(f"Добавление трафика {traffic_gb}ГБ: {traffic_price_per_month/100}₽/мес × {charged_months} мес = {price/100}₽")
     
     if price == 0 and traffic_gb != 0:
         await callback.answer("⚠️ Цена для этого пакета не настроена", show_alert=True)
@@ -892,7 +931,7 @@ async def confirm_add_traffic(
     try:
         success = await subtract_user_balance(
             db, db_user, price,
-            f"Добавление {traffic_gb} ГБ трафика"
+            f"Добавление {traffic_gb} ГБ трафика на {charged_months} мес"
         )
         
         if not success:
@@ -912,7 +951,7 @@ async def confirm_add_traffic(
             user_id=db_user.id,
             type=TransactionType.SUBSCRIPTION_PAYMENT,
             amount_kopeks=price,
-            description=f"Добавление {traffic_gb} ГБ трафика"
+            description=f"Добавление {traffic_gb} ГБ трафика на {charged_months} мес"
         )
         
         try:
@@ -935,12 +974,14 @@ async def confirm_add_traffic(
             success_text += f"📈 Добавлено: {traffic_gb} ГБ\n"
             success_text += f"Новый лимит: {texts.format_traffic(subscription.traffic_limit_gb)}"
         
+        success_text += f"\n💰 Списано: {texts.format_price(price)} (за {charged_months} мес)"
+        
         await callback.message.edit_text(
             success_text,
             reply_markup=get_back_keyboard(db_user.language)
         )
         
-        logger.info(f"✅ Пользователь {db_user.telegram_id} добавил {traffic_gb} ГБ трафика")
+        logger.info(f"✅ Пользователь {db_user.telegram_id} добавил {traffic_gb} ГБ трафика за {price/100}₽")
         
     except Exception as e:
         logger.error(f"Ошибка добавления трафика: {e}")
@@ -962,6 +1003,7 @@ async def confirm_add_devices(
     db_user: User,
     db: AsyncSession
 ):
+    from app.utils.pricing_utils import get_remaining_months, calculate_prorated_price
     
     devices_count = int(callback.data.split('_')[2])
     texts = get_texts(db_user.language)
@@ -977,7 +1019,10 @@ async def confirm_add_devices(
         )
         return
     
-    price = devices_count * settings.PRICE_PER_DEVICE
+    devices_price_per_month = devices_count * settings.PRICE_PER_DEVICE
+    price, charged_months = calculate_prorated_price(devices_price_per_month, subscription.end_date)
+    
+    logger.info(f"Добавление {devices_count} устройств: {devices_price_per_month/100}₽/мес × {charged_months} мес = {price/100}₽")
     
     if db_user.balance_kopeks < price:
         await callback.answer("⚠️ Недостаточно средств на балансе", show_alert=True)
@@ -986,7 +1031,7 @@ async def confirm_add_devices(
     try:
         success = await subtract_user_balance(
             db, db_user, price,
-            f"Добавление {devices_count} устройств"
+            f"Добавление {devices_count} устройств на {charged_months} мес"
         )
         
         if not success:
@@ -1003,7 +1048,7 @@ async def confirm_add_devices(
             user_id=db_user.id,
             type=TransactionType.SUBSCRIPTION_PAYMENT,
             amount_kopeks=price,
-            description=f"Добавление {devices_count} устройств"
+            description=f"Добавление {devices_count} устройств на {charged_months} мес"
         )
         
         try:
@@ -1022,11 +1067,12 @@ async def confirm_add_devices(
         await callback.message.edit_text(
             f"✅ Устройства успешно добавлены!\n\n"
             f"📱 Добавлено: {devices_count} устройств\n"
-            f"Новый лимит: {subscription.device_limit} устройств",
+            f"Новый лимит: {subscription.device_limit} устройств\n"
+            f"💰 Списано: {texts.format_price(price)} (за {charged_months} мес)",
             reply_markup=get_back_keyboard(db_user.language)
         )
         
-        logger.info(f"✅ Пользователь {db_user.telegram_id} добавил {devices_count} устройств")
+        logger.info(f"✅ Пользователь {db_user.telegram_id} добавил {devices_count} устройств за {price/100}₽")
         
     except Exception as e:
         logger.error(f"Ошибка добавления устройств: {e}")
@@ -1043,37 +1089,70 @@ async def confirm_extend_subscription(
     db_user: User,
     db: AsyncSession
 ):
+    from app.utils.pricing_utils import calculate_months_from_days, validate_pricing_calculation
+    
     days = int(callback.data.split('_')[2])
     texts = get_texts(db_user.language)
     subscription = db_user.subscription
     
     if not subscription:
-        await callback.answer("❌ У вас нет активной подписки", show_alert=True)
+        await callback.answer("⚠ У вас нет активной подписки", show_alert=True)
         return
     
-    subscription_service = SubscriptionService()
+    months_in_period = calculate_months_from_days(days)
     
     try:
-        price = await subscription_service.calculate_renewal_price(subscription, days, db)
+        from app.config import PERIOD_PRICES
+        
+        base_price = PERIOD_PRICES.get(days, 0)
+        
+        subscription_service = SubscriptionService()
+        servers_price_per_month, _ = await subscription_service.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
+        
+        price = base_price + total_servers_price + total_devices_price + total_traffic_price
+        
+        monthly_additions = servers_price_per_month + devices_price_per_month + traffic_price_per_month
+        is_valid = validate_pricing_calculation(base_price, monthly_additions, months_in_period, price)
+        
+        if not is_valid:
+            logger.error(f"Ошибка в расчете цены продления для пользователя {db_user.telegram_id}")
+            await callback.answer("Ошибка расчета цены. Обратитесь в поддержку.", show_alert=True)
+            return
+        
+        logger.info(f"💰 Расчет продления подписки {subscription.id} на {days} дней ({months_in_period} мес):")
+        logger.info(f"   📅 Период {days} дней: {base_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"   📊 Трафик: {traffic_price_per_month/100}₽/мес × {months_in_period} = {total_traffic_price/100}₽")
+        logger.info(f"   💎 ИТОГО: {price/100}₽")
+        
     except Exception as e:
-        logger.error(f"❌ ОШИБКА РАСЧЕТА ЦЕНЫ: {e}")
-        await callback.answer("❌ Ошибка расчета стоимости", show_alert=True)
+        logger.error(f"⚠ ОШИБКА РАСЧЕТА ЦЕНЫ: {e}")
+        await callback.answer("⚠ Ошибка расчета стоимости", show_alert=True)
         return
     
     if db_user.balance_kopeks < price:
-        await callback.answer("❌ Недостаточно средств на балансе", show_alert=True)
+        await callback.answer("⚠ Недостаточно средств на балансе", show_alert=True)
         return
     
     try:
-        logger.info(f"🔄 Начинаем продление подписки {subscription.id} на {days} дней за {price/100}₽")
-        
         success = await subtract_user_balance(
             db, db_user, price,
             f"Продление подписки на {days} дней"
         )
         
         if not success:
-            await callback.answer("❌ Ошибка списания средств", show_alert=True)
+            await callback.answer("⚠ Ошибка списания средств", show_alert=True)
             return
         
         current_time = datetime.utcnow()
@@ -1090,26 +1169,30 @@ async def confirm_extend_subscription(
         await db.refresh(subscription)
         await db.refresh(db_user)
         
+        from app.database.crud.server_squad import get_server_ids_by_uuids
+        from app.database.crud.subscription import add_subscription_servers
+        
+        server_ids = await get_server_ids_by_uuids(db, subscription.connected_squads)
+        if server_ids:
+            server_prices_for_period = [total_servers_price // len(server_ids)] * len(server_ids)
+            await add_subscription_servers(db, subscription, server_ids, server_prices_for_period)
+        
         try:
             remnawave_result = await subscription_service.update_remnawave_user(db, subscription)
             if remnawave_result:
                 logger.info(f"✅ RemnaWave обновлен успешно")
             else:
-                logger.error(f"❌ ОШИБКА ОБНОВЛЕНИЯ REMNAWAVE")
+                logger.error(f"⚠ ОШИБКА ОБНОВЛЕНИЯ REMNAWAVE")
         except Exception as e:
-            logger.error(f"❌ ИСКЛЮЧЕНИЕ ПРИ ОБНОВЛЕНИИ REMNAWAVE: {e}")
+            logger.error(f"⚠ ИСКЛЮЧЕНИЕ ПРИ ОБНОВЛЕНИИ REMNAWAVE: {e}")
         
-        try:
-            transaction = await create_transaction(
-                db=db,
-                user_id=db_user.id,
-                type=TransactionType.SUBSCRIPTION_PAYMENT,
-                amount_kopeks=price,
-                description=f"Продление подписки на {days} дней"
-            )
-            logger.info(f"✅ Транзакция создана: ID {transaction.id}")
-        except Exception as e:
-            logger.error(f"❌ ОШИБКА СОЗДАНИЯ ТРАНЗАКЦИИ: {e}")
+        await create_transaction(
+            db=db,
+            user_id=db_user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=price,
+            description=f"Продление подписки на {days} дней ({months_in_period} мес)"
+        )
         
         try:
             await process_referral_purchase(
@@ -1118,9 +1201,8 @@ async def confirm_extend_subscription(
                 purchase_amount_kopeks=price,
                 transaction_id=None
             )
-            logger.info(f"✅ Рефералы обработаны")
         except Exception as e:
-            logger.error(f"❌ ОШИБКА ОБРАБОТКИ РЕФЕРАЛОВ: {e}")
+            logger.error(f"⚠ ОШИБКА ОБРАБОТКИ РЕФЕРАЛОВ: {e}")
         
         await callback.message.edit_text(
             f"✅ Подписка успешно продлена!\n\n"
@@ -1133,12 +1215,12 @@ async def confirm_extend_subscription(
         logger.info(f"✅ Пользователь {db_user.telegram_id} продлил подписку на {days} дней за {price/100}₽")
         
     except Exception as e:
-        logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА ПРОДЛЕНИЯ: {e}")
+        logger.error(f"⚠ КРИТИЧЕСКАЯ ОШИБКА ПРОДЛЕНИЯ: {e}")
         import traceback
         logger.error(f"TRACEBACK: {traceback.format_exc()}")
         
         await callback.message.edit_text(
-            "❌ Произошла ошибка при продлении подписки. Обратитесь в поддержку.",
+            "⚠ Произошла ошибка при продлении подписки. Обратитесь в поддержку.",
             reply_markup=get_back_keyboard(db_user.language)
         )
     
@@ -1558,6 +1640,8 @@ async def devices_continue(
     db_user: User,
     db: AsyncSession
 ):
+    from app.utils.pricing_utils import calculate_months_from_days, format_period_description, validate_pricing_calculation
+    
     if not callback.data == "devices_continue":
         await callback.answer("⚠️ Некорректный запрос", show_alert=True)
         return
@@ -1568,30 +1652,48 @@ async def devices_continue(
     countries = await _get_available_countries()
     selected_countries_names = []
     
-    try:
-        subscription_service = SubscriptionService()
-        countries_price, _ = await subscription_service.get_countries_price_by_uuids(data['countries'], db)
-    except AttributeError:
-        logger.warning("Используем fallback функцию для расчета цен стран")
-        countries_price, _ = await get_countries_price_by_uuids_fallback(data['countries'], db)
-    
-    for country in countries:
-        if country['uuid'] in data['countries']:
-            selected_countries_names.append(country['name'])
+    months_in_period = calculate_months_from_days(data['period_days'])
+    period_display = format_period_description(data['period_days'], db_user.language)
     
     base_price = PERIOD_PRICES[data['period_days']]
     
     if settings.is_traffic_fixed():
-        traffic_price = settings.get_traffic_price(settings.get_fixed_traffic_limit())
+        traffic_price_per_month = settings.get_traffic_price(settings.get_fixed_traffic_limit())
         final_traffic_gb = settings.get_fixed_traffic_limit()
     else:
-        traffic_price = settings.get_traffic_price(data['traffic_gb'])
+        traffic_price_per_month = settings.get_traffic_price(data['traffic_gb'])
         final_traffic_gb = data['traffic_gb']
     
-    devices_price = max(0, data['devices'] - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
-    total_price = base_price + traffic_price + countries_price + devices_price
+    total_traffic_price = traffic_price_per_month * months_in_period
+    
+    countries_price_per_month = 0
+    selected_server_prices = []
+    
+    for country in countries:
+        if country['uuid'] in data['countries']:
+            server_price_per_month = country['price_kopeks']
+            countries_price_per_month += server_price_per_month
+            selected_countries_names.append(country['name'])
+            selected_server_prices.append(server_price_per_month * months_in_period)
+    
+    total_countries_price = countries_price_per_month * months_in_period
+    
+    additional_devices = max(0, data['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_countries_price + total_devices_price
+    
+    monthly_additions = countries_price_per_month + devices_price_per_month + traffic_price_per_month
+    is_valid = validate_pricing_calculation(base_price, monthly_additions, months_in_period, total_price)
+    
+    if not is_valid:
+        logger.error(f"Ошибка в расчете цены подписки для пользователя {db_user.telegram_id}")
+        await callback.answer("Ошибка расчета цены. Обратитесь в поддержку.", show_alert=True)
+        return
     
     data['total_price'] = total_price
+    data['server_prices_for_period'] = selected_server_prices
     await state.set_data(data)
     
     if settings.is_traffic_fixed():
@@ -1608,12 +1710,18 @@ async def devices_continue(
     summary_text = f"""
 📋 <b>Сводка заказа</b>
 
-📅 <b>Период:</b> {data['period_days']} дней
+📅 <b>Период:</b> {period_display}
 📊 <b>Трафик:</b> {traffic_display}
 🌍 <b>Страны:</b> {", ".join(selected_countries_names)}
 📱 <b>Устройства:</b> {data['devices']}
 
-💰 <b>Общая стоимость:</b> {texts.format_price(total_price)}
+💰 <b>Детализация стоимости:</b>
+- Базовый период: {texts.format_price(base_price)}
+- Трафик: {texts.format_price(traffic_price_per_month)}/мес × {months_in_period} = {texts.format_price(total_traffic_price)}
+- Серверы: {texts.format_price(countries_price_per_month)}/мес × {months_in_period} = {texts.format_price(total_countries_price)}
+- Доп. устройства: {texts.format_price(devices_price_per_month)}/мес × {months_in_period} = {texts.format_price(total_devices_price)}
+
+💎 <b>Общая стоимость:</b> {texts.format_price(total_price)}
 
 Подтверждаете покупку?
 """
@@ -1634,30 +1742,57 @@ async def confirm_purchase(
     db_user: User,
     db: AsyncSession
 ):
+    from app.utils.pricing_utils import calculate_months_from_days, validate_pricing_calculation
+    
     data = await state.get_data()
     texts = get_texts(db_user.language)
     
     countries = await _get_available_countries()
     
+    months_in_period = calculate_months_from_days(data['period_days'])
+    
     base_price = PERIOD_PRICES[data['period_days']]
     
-    countries_price = 0
+    countries_price_per_month = 0
     server_prices = []
     for country in countries:
         if country['uuid'] in data['countries']:
-            countries_price += country['price_kopeks']
-            server_prices.append(country['price_kopeks'])
+            server_price_per_month = country['price_kopeks']
+            server_price_total = server_price_per_month * months_in_period
+            countries_price_per_month += server_price_per_month
+            server_prices.append(server_price_total)
     
-    devices_price = max(0, data['devices'] - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
+    total_countries_price = countries_price_per_month * months_in_period
+    
+    additional_devices = max(0, data['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
     
     if settings.is_traffic_fixed():
-        traffic_price = settings.get_traffic_price(settings.get_fixed_traffic_limit())
+        traffic_price_per_month = settings.get_traffic_price(settings.get_fixed_traffic_limit())
         final_traffic_gb = settings.get_fixed_traffic_limit()
     else:
-        traffic_price = settings.get_traffic_price(data['traffic_gb'])
+        traffic_price_per_month = settings.get_traffic_price(data['traffic_gb'])
         final_traffic_gb = data['traffic_gb']
     
-    final_price = base_price + traffic_price + countries_price + devices_price
+    total_traffic_price = traffic_price_per_month * months_in_period
+    
+    final_price = base_price + total_traffic_price + total_countries_price + total_devices_price
+    
+    monthly_additions = countries_price_per_month + devices_price_per_month + traffic_price_per_month
+    is_valid = validate_pricing_calculation(base_price, monthly_additions, months_in_period, final_price)
+    
+    if not is_valid:
+        logger.error(f"Ошибка в расчете цены подписки для пользователя {db_user.telegram_id}")
+        await callback.answer("Ошибка расчета цены. Обратитесь в поддержку.", show_alert=True)
+        return
+    
+    logger.info(f"Расчет покупки подписки на {data['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"   Серверы: {countries_price_per_month/100}₽/мес × {months_in_period} = {total_countries_price/100}₽")
+    logger.info(f"   Устройства: {devices_price_per_month/100}₽/мес × {months_in_period} = {total_devices_price/100}₽")
+    logger.info(f"   ИТОГО: {final_price/100}₽")
     
     if db_user.balance_kopeks < final_price:
         await callback.message.edit_text(
@@ -1684,7 +1819,7 @@ async def confirm_purchase(
         existing_subscription = db_user.subscription
         
         if existing_subscription:
-            logger.info(f"🔄 Обновляем существующую подписку пользователя {db_user.telegram_id}")
+            logger.info(f"Обновляем существующую подписку пользователя {db_user.telegram_id}")
             
             existing_subscription.is_trial = False
             existing_subscription.status = SubscriptionStatus.ACTIVE.value
@@ -1702,10 +1837,8 @@ async def confirm_purchase(
             await db.refresh(existing_subscription)
             subscription = existing_subscription
             
-            logger.info(f"✅ Подписка обновлена. Новая дата окончания: {subscription.end_date}")
-            
         else:
-            logger.info(f"🆕 Создаем новую подписку для пользователя {db_user.telegram_id}")
+            logger.info(f"Создаем новую подписку для пользователя {db_user.telegram_id}")
             subscription = await create_paid_subscription_with_traffic_mode(
                 db=db,
                 user_id=db_user.id,
@@ -1727,23 +1860,19 @@ async def confirm_purchase(
             await add_subscription_servers(db, subscription, server_ids, server_prices)
             await add_user_to_servers(db, server_ids)
             
-            logger.info(f"📊 Сохранены цены серверов: {server_prices}")
-            logger.info(f"📊 Обновлены счетчики пользователей для серверов: {server_ids}")
+            logger.info(f"Сохранены цены серверов за весь период: {server_prices}")
         
         await db.refresh(db_user)
         
         subscription_service = SubscriptionService()
         
         if db_user.remnawave_uuid:
-            logger.info(f"🔄 Обновляем существующего RemnaWave пользователя {db_user.remnawave_uuid}")
             remnawave_user = await subscription_service.update_remnawave_user(db, subscription)
         else:
-            logger.info(f"🆕 Создаем нового RemnaWave пользователя для {db_user.telegram_id}")
             remnawave_user = await subscription_service.create_remnawave_user(db, subscription)
             
         if not remnawave_user:
-            logger.error(f"⚠️ Не удалось создать/обновить RemnaWave пользователя для {db_user.telegram_id}")
-            logger.info(f"🔄 Fallback: принудительное создание нового RemnaWave пользователя")
+            logger.error(f"Не удалось создать/обновить RemnaWave пользователя для {db_user.telegram_id}")
             remnawave_user = await subscription_service.create_remnawave_user(db, subscription)
         
         await create_transaction(
@@ -1751,7 +1880,7 @@ async def confirm_purchase(
             user_id=db_user.id,
             type=TransactionType.SUBSCRIPTION_PAYMENT,
             amount_kopeks=final_price,
-            description=f"Подписка на {data['period_days']} дней"
+            description=f"Подписка на {data['period_days']} дней ({months_in_period} мес)"
         )
         
         try:
@@ -1769,7 +1898,7 @@ async def confirm_purchase(
         
         if remnawave_user and hasattr(subscription, 'subscription_url') and subscription.subscription_url:
             success_text = f"{texts.SUBSCRIPTION_PURCHASED}\n\n"
-            success_text += f"🔗 <b>Ваша ссылка для подключения:</b>\n"
+            success_text += f"📗 <b>Ваша ссылка для подключения:</b>\n"
             success_text += f"<code>{subscription.subscription_url}</code>\n\n"
             success_text += f"📱 Нажмите кнопку ниже, чтобы получить инструкцию по настройке VPN на вашем устройстве"
     
@@ -1796,7 +1925,7 @@ async def confirm_purchase(
                 reply_markup=get_back_keyboard(db_user.language)
             )
         
-        logger.info(f"✅ Пользователь {db_user.telegram_id} купил подписку на {data['period_days']} дней")
+        logger.info(f"✅ Пользователь {db_user.telegram_id} купил подписку на {data['period_days']} дней за {final_price/100}₽")
         
     except Exception as e:
         logger.error(f"Ошибка покупки подписки: {e}")

app/keyboards/inline.py

@@ -1,10 +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)
@@ -656,82 +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']]
     
-    traffic_packages = settings.get_traffic_packages()
+    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 package in traffic_packages:
-        gb = package["gb"]
-        price = package["price"]
-        enabled = package["enabled"]
-        
-        if not enabled:
-            continue
+    buttons = []
+    
+    for package in enabled_packages:
+        gb = package['gb']
+        price_per_month = package['price']
+        total_price = price_per_month * months_multiplier
         
         if gb == 0:
-            text = f"📊 Безлимит - {settings.format_price(package['price'])}"
+            if language == "ru":
+                text = f"♾️ Безлимитный трафик - {total_price/100:.2f} ₽{period_text}"
+            else:
+                text = f"♾️ Unlimited traffic - {total_price/100:.2f} ₽{period_text}"
         else:
-            text = f"📊 +{gb} ГБ - {settings.format_price(package['price'])}"
+            if language == "ru":
+                text = f"📊 +{gb} ГБ трафика - {total_price/100:.2f} ₽{period_text}"
+            else:
+                text = f"📊 +{gb} GB traffic - {total_price/100:.2f} ₽{period_text}"
         
-        keyboard.append([
+        buttons.append([
             InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
         ])
     
-    if not keyboard:
-        keyboard.append([
-            InlineKeyboardButton(
-                text="⚠️ Пакеты трафика не настроены", 
-                callback_data="no_traffic_packages"
-            )
-        ])
-    
-    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 = settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else 100
+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
     
-    max_add = min(5, max_devices - current_devices) 
+    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} мес)"
     
-    for add_count in range(1, max_add + 1): 
-        price = add_count * settings.PRICE_PER_DEVICE
-        total_devices = current_devices + add_count
+    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}")
         ])
     
-    if max_add == 0:
-        keyboard.append([
-            InlineKeyboardButton(
-                text="⚠️ Достигнут максимум устройств", 
-                callback_data="max_devices_reached"
-            )
-        ])
-    
-    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:
@@ -757,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/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__)
 
@@ -388,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/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)