Update subscription.py

.env.example

@@ -1,107 +1,114 @@
-# TELEGRAM BOT CONFIGURATION
+# ===============================================
+# 🤖 REMNAWAVE BEDOLAGA BOT CONFIGURATION
+# ===============================================
+
+# ===== TELEGRAM BOT =====
 BOT_TOKEN=
 ADMIN_IDS=
-SUPPORT_USERNAME=
+SUPPORT_USERNAME=@support
 
-# DATABASE CONFIGURATION
-DATABASE_URL=sqlite+aiosqlite:///./bot.db
-REDIS_URL=redis://localhost:6379/0
+# ===== DATABASE =====
+# Для Docker используйте PostgreSQL:
+DATABASE_URL=postgresql+asyncpg://remnawave_user:secure_password_123@postgres:5432/remnawave_bot
+# Для локального запуска без Docker используйте SQLite: sqlite+aiosqlite:///./bot.db 
+# DATABASE_URL=postgresql+asyncpg://remnawave_user:secure_password_123@postgres:5432/remnawave_bot
 
-# REMNAWAVE API CONFIGURATION
-REMNAWAVE_API_URL=
+REDIS_URL=redis://redis:6379/0
+
+# Пароли для Docker (PostgreSQL/Redis)
+POSTGRES_DB=remnawave_bot
+POSTGRES_USER=remnawave_user
+POSTGRES_PASSWORD=secure_password_123
+
+# ===== REMNAWAVE API =====
+REMNAWAVE_API_URL=https://panel.example.com
 REMNAWAVE_API_KEY=
+# Для панелей установленных скриптом eGames прописывать ключ в формате XXXXXXX:DDDDDDDD - https://panel.example.com/auth/login?XXXXXXX=DDDDDDDD
+REMNAWAVE_SECRET_KEY=your_secret_key_here
 
-# === NEW: Traffic Selection Mode Settings ===
+# ===== ТРИАЛ ПОДПИСКА =====
+TRIAL_DURATION_DAYS=3
+TRIAL_TRAFFIC_LIMIT_GB=10
+TRIAL_DEVICE_LIMIT=1
+TRIAL_SQUAD_UUID=
+DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+DEFAULT_TRAFFIC_LIMIT_GB=100
+DEFAULT_DEVICE_LIMIT=1
+
+# ===== НАСТРОЙКИ ТРАФИКА =====
 # Режим выбора трафика:
 # "selectable" - пользователи выбирают пакеты трафика (по умолчанию)
-# "fixed" - фиксированный лимит трафика для всех подписок, доступно 5/10/25/50/100/250/0 (0 безлимит) гб 
+# "fixed" - фиксированный лимит трафика для всех подписок
 TRAFFIC_SELECTION_MODE=selectable
 
 # Фиксированный лимит трафика в ГБ (используется только в режиме "fixed")
 # 0 = безлимит
-# для "fixed" обязательно должы быть проставлены цены на пакеты 5/10/25/50/100/250/0 можно постать 0 руб - будет беслпатно
-FIXED_TRAFFIC_LIMIT_GB=0
+FIXED_TRAFFIC_LIMIT_GB=100
 
-# TRIAL SUBSCRIPTION SETTINGS
-TRIAL_DURATION_DAYS=3
-TRIAL_TRAFFIC_LIMIT_GB=10
-TRIAL_DEVICE_LIMIT=2
-TRIAL_SQUAD_UUID=
-DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+# ===== ПЕРИОДЫ ПОДПИСКИ =====
+# Доступные периоды подписки (через запятую)
+# Возможные значения: 14,30,60,90,180,360
+AVAILABLE_SUBSCRIPTION_PERIODS=30,90,180
+AVAILABLE_RENEWAL_PERIODS=30,90,180
 
-# SUBSCRIPTION PRICING (в копейках для точности)
-BASE_SUBSCRIPTION_PRICE=50000
+# ===== ЦЕНЫ (в копейках) =====
+BASE_SUBSCRIPTION_PRICE=0
 
-PRICE_14_DAYS=5000
-PRICE_30_DAYS=9900  
-PRICE_60_DAYS=18900
-PRICE_90_DAYS=26900
-PRICE_180_DAYS=49900
-PRICE_360_DAYS=89900
+# Цены за периоды
+PRICE_14_DAYS=7000
+PRICE_30_DAYS=9900
+PRICE_60_DAYS=25900
+PRICE_90_DAYS=36900
+PRICE_180_DAYS=69900
+PRICE_360_DAYS=109900
 
-PRICE_TRAFFIC_5GB=2000
-PRICE_TRAFFIC_10GB=4000
-PRICE_TRAFFIC_25GB=6000
-PRICE_TRAFFIC_50GB=10000
-PRICE_TRAFFIC_100GB=15000
-PRICE_TRAFFIC_250GB=20000
-PRICE_TRAFFIC_UNLIMITED=25000
+# Цены за трафик
+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
 
+# Цена за дополнительное устройство
 PRICE_PER_DEVICE=5000
 
-# REFERRAL SYSTEM SETTINGS
-REFERRAL_REGISTRATION_REWARD=5000
+# ===== РЕФЕРАЛЬНАЯ СИСТЕМА =====
+REFERRAL_REGISTRATION_REWARD=10000
 REFERRED_USER_REWARD=10000
 REFERRAL_COMMISSION_PERCENT=25
 
-# Режим работы кнопки "Подключиться"
-# guide - открывает гайд подключения (режим 1)
-# miniapp_subscription - открывает ссылку подписки в мини-приложении (режим 2)
-# miniapp_custom - открывает заданную ссылку в мини-приложении (режим 3)
-CONNECT_BUTTON_MODE=miniapp_subscription
-# URL для режима miniapp_custom (обязателен при CONNECT_BUTTON_MODE=miniapp_custom)
-# MINIAPP_CUSTOM_URL=
-
-# AUTO-PAYMENT SETTINGS
+# ===== АВТОПРОДЛЕНИЕ =====
 AUTOPAY_WARNING_DAYS=3,1
+DEFAULT_AUTOPAY_DAYS_BEFORE=3
+MIN_BALANCE_FOR_AUTOPAY_KOPEKS=10000
 
-# MONITORING SETTINGS
-MONITORING_INTERVAL=60
-INACTIVE_USER_DELETE_MONTHS=3
+# ===== ПЛАТЕЖНЫЕ СИСТЕМЫ =====
 
-TRIAL_WARNING_HOURS=2
-ENABLE_NOTIFICATIONS=true
-NOTIFICATION_RETRY_ATTEMPTS=3
-MONITORING_LOGS_RETENTION_DAYS=30
-
-# PAYMENT SYSTEMS
+# Telegram Stars (работает автоматически)
 TELEGRAM_STARS_ENABLED=true
+
+# Tribute (https://tribute.app)
 TRIBUTE_ENABLED=false
 TRIBUTE_API_KEY=
 TRIBUTE_WEBHOOK_SECRET=your_webhook_secret
-TRIBUTE_DONATE_LINK=https://t.me/tribute/app?startapp=XXXX
+TRIBUTE_DONATE_LINK=
 TRIBUTE_WEBHOOK_PATH=/tribute-webhook
 TRIBUTE_WEBHOOK_PORT=8081
 
-# === НОВЫЕ НАСТРОЙКИ YOOKASSA ===
-# Включение/выключение YooKassa
+# YooKassa (https://yookassa.ru)
 YOOKASSA_ENABLED=false
-
-# Основные настройки YooKassa (получить в личном кабинете)
-YOOKASSA_SHOP_ID=your_shop_id_here
-YOOKASSA_SECRET_KEY=your_secret_key_here
-
-# URL для возврата после оплаты (необязательно, по умолчанию t.me/your_bot)
-YOOKASSA_RETURN_URL=https://yourdomain.com/payment-success
-
-# Email по умолчанию для чеков (если пользователь не указал свой)
+YOOKASSA_SHOP_ID=
+YOOKASSA_SECRET_KEY=
+YOOKASSA_RETURN_URL=
 YOOKASSA_DEFAULT_RECEIPT_EMAIL=receipts@yourdomain.com
 
 # Настройки чеков для налоговой
 YOOKASSA_VAT_CODE=1
 # Коды НДС:
 # 1 - НДС не облагается
-# 2 - НДС 0%  
+# 2 - НДС 0%
 # 3 - НДС 10%
 # 4 - НДС 20%
 # 5 - НДС 10/110
@@ -110,7 +117,7 @@ YOOKASSA_VAT_CODE=1
 YOOKASSA_PAYMENT_MODE=full_payment
 # Способы расчета:
 # full_payment - полная оплата
-# partial_payment - частичная оплата  
+# partial_payment - частичная оплата
 # advance - аванс
 # full_prepayment - полная предоплата
 # partial_prepayment - частичная предоплата
@@ -120,7 +127,7 @@ YOOKASSA_PAYMENT_MODE=full_payment
 YOOKASSA_PAYMENT_SUBJECT=service
 # Предметы расчета:
 # commodity - товар
-# excise - подакцизный товар  
+# excise - подакцизный товар
 # job - работа
 # service - услуга
 # gambling_bet - ставка в азартной игре
@@ -133,21 +140,63 @@ YOOKASSA_PAYMENT_SUBJECT=service
 # composite - составной предмет расчета
 # another - другое
 
-# Webhook для получения уведомлений от YooKassa
+# Webhook настройки
 YOOKASSA_WEBHOOK_PATH=/yookassa-webhook
 YOOKASSA_WEBHOOK_PORT=8082
-YOOKASSA_WEBHOOK_SECRET=ваш_секретный_ключ_для_webhook
+YOOKASSA_WEBHOOK_SECRET=your_webhook_secret
 
-WEBHOOK_URL=https://example.com
+# ===== НАСТРОЙКИ ОПИСАНИЙ ПЛАТЕЖЕЙ =====
+# Эти настройки позволяют изменить описания платежей, 
+# чтобы избежать блокировок платежных систем
+PAYMENT_SERVICE_NAME=Интернет-сервис
+PAYMENT_BALANCE_DESCRIPTION=Пополнение баланса
+PAYMENT_SUBSCRIPTION_DESCRIPTION=Оплата подписки
+PAYMENT_BALANCE_TEMPLATE={service_name} - {description}
+PAYMENT_SUBSCRIPTION_TEMPLATE={service_name} - {description}
+
+# ===== ИНТЕРФЕЙС И UX =====
+
+# Режим работы кнопки "Подключиться"
+# guide - открывает гайд подключения (режим 1)
+# miniapp_subscription - открывает ссылку подписки в мини-приложении (режим 2)
+# miniapp_custom - открывает заданную ссылку в мини-приложении (режим 3)
+CONNECT_BUTTON_MODE=guide
+
+# URL для режима miniapp_custom (обязателен при CONNECT_BUTTON_MODE=miniapp_custom)
+MINIAPP_CUSTOM_URL=
+
+# ===== МОНИТОРИНГ И УВЕДОМЛЕНИЯ =====
+MONITORING_INTERVAL=60
+INACTIVE_USER_DELETE_MONTHS=3
+
+# Уведомления
+TRIAL_WARNING_HOURS=2
+ENABLE_NOTIFICATIONS=true
+NOTIFICATION_RETRY_ATTEMPTS=3
+MONITORING_LOGS_RETENTION_DAYS=30
+NOTIFICATION_CACHE_HOURS=24
+
+# ===== РЕЖИМ ТЕХНИЧЕСКИХ РАБОТ =====
+MAINTENANCE_MODE=false
+MAINTENANCE_CHECK_INTERVAL=30
+MAINTENANCE_AUTO_ENABLE=true
+MAINTENANCE_MESSAGE=Ведутся технические работы. Сервис временно недоступен. Попробуйте позже.
+
+# ===== ЛОКАЛИЗАЦИЯ =====
+DEFAULT_LANGUAGE=ru
+AVAILABLE_LANGUAGES=ru,en
+
+# ===== ЛОГИРОВАНИЕ =====
+LOG_LEVEL=INFO
+LOG_FILE=logs/bot.log
+
+# ===== РАЗРАБОТКА =====
+DEBUG=false
+WEBHOOK_URL=
 WEBHOOK_PATH=/webhook
 
-# LOCALIZATION
-DEFAULT_LANGUAGE=ru
-AVAILABLE_LANGUAGES=ru
-
-# LOGGING
-LOG_LEVEL=INFO
-LOG_FILE=/tmp/bot.log
-
-# DEVELOPMENT
-DEBUG=false
+# ===== ДОПОЛНИТЕЛЬНЫЕ НАСТРОЙКИ =====
+# Конфигурация приложений для гайда подключения
+APP_CONFIG_PATH=app-config.json
+ENABLE_DEEP_LINKS=true
+APP_CONFIG_CACHE_TTL=3600

.gitignore

@@ -1,2 +1,30 @@
-/screens
-/assets
+# Игнорируем все файлы и папки по умолчанию
+*
+
+# Исключения: разрешаем только нужные файлы
+!.env.example
+!Dockerfile
+!app-config.json
+!main.py
+!requirements.txt
+
+# Разрешаем папку app/ и все её содержимое рекурсивно
+!app/
+!app/**
+
+# Дополнительно разрешаем README и лицензию (опционально)
+!README.md
+!LICENSE
+
+# Разрешаем .gitignore чтобы он попал в репозиторий
+!.gitignore
+
+# Внутри разрешенных папок игнорируем служебные файлы
+app/__pycache__/
+app/**/__pycache__/
+app/**/*.pyc
+app/**/*.pyo
+app/**/*.pyd
+*.pyc
+*.pyo
+*.pyd

Dockerfile

@@ -1,33 +1,43 @@
 FROM python:3.11-slim
-
 WORKDIR /app
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
     gcc \
+    wget \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first for better caching
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Create non-root user with specific UID/GID for consistency
+RUN groupadd -g 1000 app && \
+    useradd -u 1000 -g 1000 -m -s /bin/bash app
+
 # Copy application code
 COPY . .
 
-# Create logs directory
-RUN mkdir -p logs
+# Create necessary directories and set permissions
+RUN mkdir -p logs data && \
+    chown -R app:app /app && \
+    chmod -R 755 /app && \
+    chmod -R 777 logs
+
+# Switch to non-root user
+USER app
 
 # Set environment variables
 ENV PYTHONPATH=/app
 ENV PYTHONUNBUFFERED=1
 
-# Create non-root user
-RUN useradd --create-home --shell /bin/bash app
-RUN chown -R app:app /app
-USER app
+# Expose webhook ports
+EXPOSE 8081
+EXPOSE 8082
 
-# Expose port (if needed for webhooks)
-EXPOSE 8000
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:8081/health || exit 1
 
 # Run the application
 CMD ["python", "main.py"]

app/bot.py

@@ -52,6 +52,9 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
         default=DefaultBotProperties(parse_mode=ParseMode.HTML)
     )
     
+    maintenance_service.set_bot(bot)
+    logger.info("Бот установлен в maintenance_service")
+    
     try:
         redis_client = redis.from_url(settings.REDIS_URL)
         await redis_client.ping()
@@ -107,7 +110,6 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
 
 
 async def shutdown_bot():
-    """Корректное завершение работы бота"""
     try:
         await maintenance_service.stop_monitoring()
         logger.info("Мониторинг техработ остановлен")

app/config.py

@@ -16,6 +16,7 @@ class Settings(BaseSettings):
     
     REMNAWAVE_API_URL: str
     REMNAWAVE_API_KEY: str
+    REMNAWAVE_SECRET_KEY: Optional[str] = None
     
     TRIAL_DURATION_DAYS: int = 3
     TRIAL_TRAFFIC_LIMIT_GB: int = 10
@@ -33,7 +34,9 @@ class Settings(BaseSettings):
     NOTIFICATION_CACHE_HOURS: int = 24  
     
     BASE_SUBSCRIPTION_PRICE: int = 50000
-    
+
+    AVAILABLE_SUBSCRIPTION_PERIODS: str = "14,30,60,90,180,360"
+    AVAILABLE_RENEWAL_PERIODS: str = "30,90,180"
     PRICE_14_DAYS: int = 50000
     PRICE_30_DAYS: int = 99000
     PRICE_60_DAYS: int = 189000
@@ -91,6 +94,12 @@ class Settings(BaseSettings):
     YOOKASSA_WEBHOOK_PATH: str = "/yookassa-webhook"
     YOOKASSA_WEBHOOK_PORT: int = 8082
     YOOKASSA_WEBHOOK_SECRET: Optional[str] = None
+    PAYMENT_BALANCE_DESCRIPTION: str = "Пополнение баланса"
+    PAYMENT_SUBSCRIPTION_DESCRIPTION: str = "Оплата подписки"
+    PAYMENT_SERVICE_NAME: str = "Интернет-сервис"
+    PAYMENT_BALANCE_TEMPLATE: str = "{service_name} - {description}"
+    PAYMENT_SUBSCRIPTION_TEMPLATE: str = "{service_name} - {description}"
+
 
     CONNECT_BUTTON_MODE: str = "guide"
     MINIAPP_CUSTOM_URL: str = ""
@@ -216,6 +225,62 @@ class Settings(BaseSettings):
     
     def is_maintenance_auto_enable(self) -> bool:
         return self.MAINTENANCE_AUTO_ENABLE
+
+    def get_available_subscription_periods(self) -> List[int]:
+        try:
+            periods_str = self.AVAILABLE_SUBSCRIPTION_PERIODS
+            if not periods_str.strip():
+                return [30, 90, 180] 
+            
+            periods = []
+            for period_str in periods_str.split(','):
+                period_str = period_str.strip()
+                if period_str:
+                    period = int(period_str)
+                    if period in PERIOD_PRICES:
+                        periods.append(period)
+            
+            return periods if periods else [30, 90, 180]
+            
+        except (ValueError, AttributeError):
+            return [30, 90, 180]
+    
+    def get_available_renewal_periods(self) -> List[int]:
+        try:
+            periods_str = self.AVAILABLE_RENEWAL_PERIODS
+            if not periods_str.strip():
+                return [30, 90, 180] 
+            
+            periods = []
+            for period_str in periods_str.split(','):
+                period_str = period_str.strip()
+                if period_str:
+                    period = int(period_str)
+                    if period in PERIOD_PRICES:
+                        periods.append(period)
+            
+            return periods if periods else [30, 90, 180]
+            
+        except (ValueError, AttributeError):
+            return [30, 90, 180]
+
+    def get_balance_payment_description(self, amount_kopeks: int) -> str:
+        return self.PAYMENT_BALANCE_TEMPLATE.format(
+            service_name=self.PAYMENT_SERVICE_NAME,
+            description=f"{self.PAYMENT_BALANCE_DESCRIPTION} на {self.format_price(amount_kopeks)}"
+        )
+    
+    def get_subscription_payment_description(self, period_days: int, amount_kopeks: int) -> str:
+        return self.PAYMENT_SUBSCRIPTION_TEMPLATE.format(
+            service_name=self.PAYMENT_SERVICE_NAME,
+            description=f"{self.PAYMENT_SUBSCRIPTION_DESCRIPTION} на {period_days} дней"
+        )
+    
+    def get_custom_payment_description(self, description: str) -> str:
+        return self.PAYMENT_BALANCE_TEMPLATE.format(
+            service_name=self.PAYMENT_SERVICE_NAME,
+            description=description
+        )
     
     model_config = {
         "env_file": ".env",

app/database/crud/promocode.py

@@ -5,7 +5,7 @@ from sqlalchemy import select, and_, func
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 
-from app.database.models import PromoCode, PromoCodeUse, PromoCodeType
+from app.database.models import PromoCode, PromoCodeUse, PromoCodeType, User
 
 logger = logging.getLogger(__name__)
 
@@ -187,8 +187,13 @@ async def update_promocode(
 
 
 async def delete_promocode(db: AsyncSession, promocode: PromoCode) -> bool:
-    
     try:
+        from sqlalchemy import delete as sql_delete
+        
+        await db.execute(
+            sql_delete(PromoCodeUse).where(PromoCodeUse.promocode_id == promocode.id)
+        )
+        
         await db.delete(promocode)
         await db.commit()
         
@@ -222,15 +227,24 @@ async def get_promocode_statistics(db: AsyncSession, promocode_id: int) -> dict:
     today_uses = today_uses_result.scalar()
     
     recent_uses_result = await db.execute(
-        select(PromoCodeUse)
+        select(PromoCodeUse, User)
+        .join(User, PromoCodeUse.user_id == User.id)
         .where(PromoCodeUse.promocode_id == promocode_id)
         .order_by(PromoCodeUse.used_at.desc())
         .limit(10)
     )
-    recent_uses = recent_uses_result.scalars().all()
+    recent_uses_data = recent_uses_result.all()
+    
+    recent_uses = []
+    for use, user in recent_uses_data:
+        use.user_username = user.username
+        use.user_full_name = user.full_name
+        use.user_telegram_id = user.telegram_id
+        recent_uses.append(use)
     
     return {
         "total_uses": total_uses,
         "today_uses": today_uses,
         "recent_uses": recent_uses
-    }
+    }
+

app/database/crud/subscription.py

@@ -512,7 +512,7 @@ async def get_subscription_renewal_cost(
         if subscription.traffic_limit_gb > 0:
             traffic_cost = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
         
-        devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+        devices_cost = max(0, subscription.device_limit - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
         
         total_cost = base_price + servers_cost + traffic_cost + devices_cost
         

app/external/remnawave_api.py

@@ -8,6 +8,7 @@ import aiohttp
 import logging
 from dataclasses import dataclass
 from enum import Enum
+from urllib.parse import urlparse, urljoin
 
 logger = logging.getLogger(__name__)
 
@@ -33,7 +34,7 @@ class RemnaWaveUser:
     username: str
     status: UserStatus
     used_traffic_bytes: int
-    lifetime_used_traffic_bytes: int  # Новое поле
+    lifetime_used_traffic_bytes: int 
     traffic_limit_bytes: int
     traffic_limit_strategy: TrafficLimitStrategy
     expire_at: datetime
@@ -92,10 +93,12 @@ class RemnaWaveAPIError(Exception):
 
 class RemnaWaveAPI:
     
-    def __init__(self, base_url: str, api_key: str):
+    def __init__(self, base_url: str, api_key: str, secret_key: Optional[str] = None):
         self.base_url = base_url.rstrip('/')
         self.api_key = api_key
+        self.secret_key = secret_key 
         self.session: Optional[aiohttp.ClientSession] = None
+        self.authenticated = False 
         
     def _detect_connection_type(self) -> str:
         parsed = urlparse(self.base_url)
@@ -124,18 +127,29 @@ class RemnaWaveAPI:
             
         headers = {
             'Authorization': f'Bearer {self.api_key}',
-            'Content-Type': 'application/json'
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'X-Forwarded-Proto': 'https',
+            'X-Forwarded-For': '127.0.0.1',
+            'X-Real-IP': '127.0.0.1'
         }
         
+        cookies = None
+        if self.secret_key:
+            if ':' in self.secret_key:
+                key_name, key_value = self.secret_key.split(':', 1)
+                cookies = {key_name: key_value}
+                logger.debug(f"🍪 Используем куки: {key_name}=***")
+            else:
+                cookies = {self.secret_key: self.secret_key}
+                logger.debug(f"🍪 Используем куки: {self.secret_key}=***")
+        
         connector_kwargs = {}
         
         if conn_type == "local":
             logger.debug("🏠 Использую локальные заголовки proxy")
             headers.update({
-                'X-Forwarded-For': '127.0.0.1',
-                'X-Forwarded-Proto': 'https',
                 'X-Forwarded-Host': 'localhost',
-                'X-Real-IP': '127.0.0.1',
                 'Host': 'localhost'
             })
             
@@ -152,11 +166,18 @@ class RemnaWaveAPI:
             
         connector = aiohttp.TCPConnector(**connector_kwargs)
         
-        self.session = aiohttp.ClientSession(
-            timeout=aiohttp.ClientTimeout(total=30),
-            headers=headers,
-            connector=connector
-        )
+        session_kwargs = {
+            'timeout': aiohttp.ClientTimeout(total=30),
+            'headers': headers,
+            'connector': connector
+        }
+        
+        if cookies:
+            session_kwargs['cookies'] = cookies
+            
+        self.session = aiohttp.ClientSession(**session_kwargs)
+        self.authenticated = True 
+                
         return self
         
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -194,6 +215,8 @@ class RemnaWaveAPI:
                 
                 if response.status >= 400:
                     error_message = response_data.get('message', f'HTTP {response.status}')
+                    logger.error(f"API Error {response.status}: {error_message}")
+                    logger.error(f"Response: {response_text[:500]}")
                     raise RemnaWaveAPIError(
                         error_message, 
                         response.status, 

app/external/tribute.py

@@ -28,7 +28,6 @@ class TributeService:
             return None
         
         try:
-            
             payment_url = f"{self.donate_link}&user_id={user_id}"
             
             logger.info(f"Создана ссылка Tribute для пользователя {user_id}")
@@ -41,7 +40,7 @@ class TributeService:
     def verify_webhook_signature(self, payload: str, signature: str) -> bool:
         
         if not self.webhook_secret:
-            logger.warning("Webhook secret не настроен")
+            logger.warning("Webhook secret не настроен, пропускаем проверку")
             return True 
         
         try:
@@ -51,31 +50,54 @@ class TributeService:
                 hashlib.sha256
             ).hexdigest()
             
-            return hmac.compare_digest(signature, expected_signature)
+            is_valid = hmac.compare_digest(signature, expected_signature)
+            
+            if is_valid:
+                logger.info("✅ Подпись Tribute webhook проверена успешно")
+            else:
+                logger.error("❌ Неверная подпись Tribute webhook")
+            
+            return is_valid
             
         except Exception as e:
             logger.error(f"Ошибка проверки подписи webhook: {e}")
             return False
     
-    async def process_webhook(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    async def process_webhook(self, payload_or_data) -> Optional[Dict[str, Any]]:
         
         try:
+            logger.info(f"🔄 Начинаем обработку Tribute webhook")
             
-            payment_id = payload.get("id") or payload.get("payment_id")
-            status = payload.get("status")
-            amount_kopeks = payload.get("amount", 0) 
-            telegram_user_id = payload.get("telegram_user_id") or payload.get("user_id")
+            if isinstance(payload_or_data, str):
+                try:
+                    webhook_data = json.loads(payload_or_data)
+                    logger.info(f"📊 Распарсенные данные: {webhook_data}")
+                except json.JSONDecodeError as e:
+                    logger.error(f"❌ Ошибка парсинга JSON: {e}")
+                    return None
+            else:
+                webhook_data = payload_or_data
             
-            if not payment_id and "payload" in payload:
-                data = payload["payload"]
+            payment_id = None
+            status = None
+            amount_kopeks = 0
+            telegram_user_id = None
+            
+            payment_id = webhook_data.get("id") or webhook_data.get("payment_id")
+            status = webhook_data.get("status")
+            amount_kopeks = webhook_data.get("amount", 0) 
+            telegram_user_id = webhook_data.get("telegram_user_id") or webhook_data.get("user_id")
+            
+            if not payment_id and "payload" in webhook_data:
+                data = webhook_data["payload"]
                 payment_id = data.get("id") or data.get("payment_id")
                 status = data.get("status")
                 amount_kopeks = data.get("amount", 0) 
                 telegram_user_id = data.get("telegram_user_id") or data.get("user_id")
             
-            if not payment_id and "name" in payload:
-                event_name = payload.get("name")
-                data = payload.get("payload", {})
+            if not payment_id and "name" in webhook_data:
+                event_name = webhook_data.get("name")
+                data = webhook_data.get("payload", {})
                 payment_id = str(data.get("donation_request_id")) 
                 amount_kopeks = data.get("amount", 0) 
                 telegram_user_id = data.get("telegram_user_id")
@@ -87,22 +109,54 @@ class TributeService:
                 else:
                     status = "unknown"
             
-            logger.info(f"Обработка Tribute webhook: payment_id={payment_id}, status={status}, amount_kopeks={amount_kopeks}, user_id={telegram_user_id}")
+            logger.info(f"📝 Извлеченные данные: payment_id={payment_id}, status={status}, amount_kopeks={amount_kopeks}, user_id={telegram_user_id}")
             
             if not telegram_user_id:
-                logger.error("Не найден telegram_user_id в webhook данных")
+                logger.error("❌ Не найден telegram_user_id в webhook данных")
+                logger.error(f"🔍 Полные данные для отладки: {json.dumps(webhook_data, ensure_ascii=False, indent=2)}")
                 return None
             
-            return {
+            try:
+                telegram_user_id = int(telegram_user_id)
+            except (ValueError, TypeError):
+                logger.error(f"❌ Некорректный telegram_user_id: {telegram_user_id}")
+                return None
+            
+            result = {
                 "event_type": "payment",
                 "payment_id": payment_id or f"tribute_{telegram_user_id}_{amount_kopeks}",
-                "user_id": int(telegram_user_id),
-                "amount_kopeks": amount_kopeks,
+                "user_id": telegram_user_id,
+                "amount_kopeks": int(amount_kopeks) if amount_kopeks else 0,
                 "status": status or "paid",
-                "external_id": f"donation_{payment_id}"
+                "external_id": f"donation_{payment_id or 'unknown'}",
+                "payment_system": "tribute"
             }
             
+            logger.info(f"✅ Tribute webhook обработан успешно: {result}")
+            return result
+            
         except Exception as e:
-            logger.error(f"Ошибка обработки Tribute webhook: {e}")
-            logger.error(f"Webhook payload: {json.dumps(payload, ensure_ascii=False)}")
+            logger.error(f"❌ Ошибка обработки Tribute webhook: {e}", exc_info=True)
+            logger.error(f"🔍 Webhook data для отладки: {json.dumps(webhook_data, ensure_ascii=False, indent=2)}")
+            return None
+    
+    async def get_payment_status(self, payment_id: str) -> Optional[Dict[str, Any]]:
+        try:
+            logger.info(f"Запрос статуса платежа {payment_id}")
+            return {"status": "unknown", "payment_id": payment_id}
+        except Exception as e:
+            logger.error(f"Ошибка получения статуса платежа: {e}")
+            return None
+    
+    async def refund_payment(
+        self,
+        payment_id: str,
+        amount_kopeks: Optional[int] = None,
+        reason: str = "Возврат по запросу"
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            logger.info(f"Создание возврата для платежа {payment_id}")
+            return {"refund_id": f"refund_{payment_id}", "status": "pending"}
+        except Exception as e:
+            logger.error(f"Ошибка создания возврата: {e}")
             return None

app/external/webhook_server.py

@@ -1,4 +1,5 @@
 import logging
+import json
 from typing import Optional
 
 from aiohttp import web
@@ -26,9 +27,11 @@ class WebhookServer:
         self.app.router.add_post(settings.TRIBUTE_WEBHOOK_PATH, self._tribute_webhook_handler)
         self.app.router.add_get('/health', self._health_check)
         
+        self.app.router.add_options(settings.TRIBUTE_WEBHOOK_PATH, self._options_handler)
+        
         logger.info(f"Webhook сервер настроен:")
-        logger.info(f"  - Tribute webhook: {settings.TRIBUTE_WEBHOOK_PATH}")
-        logger.info(f"  - Health check: /health")
+        logger.info(f"  - Tribute webhook: POST {settings.TRIBUTE_WEBHOOK_PATH}")
+        logger.info(f"  - Health check: GET /health")
         
         return self.app
     
@@ -49,11 +52,11 @@ class WebhookServer:
             
             await self.site.start()
             
-            logger.info(f"✅ Webhook сервер запущен на порту {settings.TRIBUTE_WEBHOOK_PORT}")
-            logger.info(f"🎯 Tribute webhook URL: http://your-server:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+            logger.info(f"✅ Tribute webhook сервер запущен на порту {settings.TRIBUTE_WEBHOOK_PORT}")
+            logger.info(f"🎯 Tribute webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
             
         except Exception as e:
-            logger.error(f"❌ Ошибка запуска webhook сервера: {e}")
+            logger.error(f"❌ Ошибка запуска Tribute webhook сервера: {e}")
             raise
     
     async def stop(self):
@@ -61,31 +64,82 @@ class WebhookServer:
         try:
             if self.site:
                 await self.site.stop()
-                logger.info("Webhook сайт остановлен")
+                logger.info("Tribute webhook сайт остановлен")
             
             if self.runner:
                 await self.runner.cleanup()
-                logger.info("Webhook runner очищен")
+                logger.info("Tribute webhook runner очищен")
                 
         except Exception as e:
-            logger.error(f"Ошибка остановки webhook сервера: {e}")
+            logger.error(f"Ошибка остановки Tribute webhook сервера: {e}")
+    
+    async def _options_handler(self, request: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, X-Tribute-Signature',
+            }
+        )
     
     async def _tribute_webhook_handler(self, request: web.Request) -> web.Response:
         
         try:
+            logger.info(f"📥 Получен Tribute webhook: {request.method} {request.path}")
+            logger.info(f"📋 Headers: {dict(request.headers)}")
+            
             raw_body = await request.read()
+            
+            if not raw_body:
+                logger.warning("⚠️ Получен пустой webhook от Tribute")
+                return web.json_response(
+                    {"status": "error", "reason": "empty_body"},
+                    status=400
+                )
+            
             payload = raw_body.decode('utf-8')
+            logger.info(f"📄 Payload: {payload}")
+            
+            try:
+                webhook_data = json.loads(payload)
+                logger.info(f"📊 Распарсенные данные: {webhook_data}")
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Ошибка парсинга JSON: {e}")
+                return web.json_response(
+                    {"status": "error", "reason": "invalid_json"},
+                    status=400
+                )
             
             signature = request.headers.get('X-Tribute-Signature')
+            logger.info(f"🔐 Signature: {signature}")
+            
+            if signature and settings.TRIBUTE_WEBHOOK_SECRET:
+                from app.external.tribute import TributeService as TributeAPI
+                tribute_api = TributeAPI()
+                if not tribute_api.verify_webhook_signature(payload, signature):
+                    logger.error("❌ Неверная подпись Tribute webhook")
+                    return web.json_response(
+                        {"status": "error", "reason": "invalid_signature"},
+                        status=401
+                    )
             
             result = await self.tribute_service.process_webhook(payload, signature)
             
-            return web.json_response(result, status=200)
+            if result:
+                logger.info(f"✅ Tribute webhook обработан успешно: {result}")
+                return web.json_response({"status": "ok", "result": result}, status=200)
+            else:
+                logger.error("❌ Ошибка обработки Tribute webhook")
+                return web.json_response(
+                    {"status": "error", "reason": "processing_failed"},
+                    status=400
+                )
             
         except Exception as e:
-            logger.error(f"Ошибка обработки Tribute webhook: {e}")
+            logger.error(f"❌ Критическая ошибка обработки Tribute webhook: {e}", exc_info=True)
             return web.json_response(
-                {"status": "error", "reason": "internal_error"},
+                {"status": "error", "reason": "internal_error", "message": str(e)},
                 status=500
             )
     
@@ -94,5 +148,7 @@ class WebhookServer:
         return web.json_response({
             "status": "ok",
             "service": "tribute-webhooks",
-            "tribute_enabled": settings.TRIBUTE_ENABLED
-        })
+            "tribute_enabled": settings.TRIBUTE_ENABLED,
+            "port": settings.TRIBUTE_WEBHOOK_PORT,
+            "path": settings.TRIBUTE_WEBHOOK_PATH
+        })

app/external/yookassa_webhook.py

@@ -1,7 +1,9 @@
+import asyncio
 import logging
 import json
 import hashlib
 import hmac
+import base64
 from typing import Optional, Dict, Any
 from aiohttp import web
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -17,13 +19,69 @@ class YooKassaWebhookHandler:
 
     @staticmethod
     def verify_webhook_signature(body: str, signature: str, secret: str) -> bool:
-        expected_signature = hmac.new(
-            secret.encode('utf-8'),
-            body.encode('utf-8'),
-            hashlib.sha256
-        ).hexdigest()
-        
-        return hmac.compare_digest(signature, expected_signature)
+        try:
+            signature_parts = signature.strip().split(' ')
+            
+            if len(signature_parts) < 4:
+                logger.error(f"Неверный формат подписи YooKassa: {signature}")
+                return False
+            
+            version = signature_parts[0] 
+            payment_id = signature_parts[1] 
+            timestamp = signature_parts[2]  
+            received_signature = signature_parts[3]
+            
+            if version != "v1":
+                logger.error(f"Неподдерживаемая версия подписи: {version}")
+                return False
+            
+            logger.info(f"Проверка подписи v1 для платежа {payment_id}, timestamp: {timestamp}")
+            
+            
+            expected_signature_1 = hmac.new(
+                secret.encode('utf-8'),
+                body.encode('utf-8'),
+                hashlib.sha256
+            ).digest()
+            expected_signature_1_b64 = base64.b64encode(expected_signature_1).decode('utf-8')
+            
+            signed_payload_2 = f"{payment_id}.{timestamp}.{body}"
+            expected_signature_2 = hmac.new(
+                secret.encode('utf-8'),
+                signed_payload_2.encode('utf-8'),
+                hashlib.sha256
+            ).digest()
+            expected_signature_2_b64 = base64.b64encode(expected_signature_2).decode('utf-8')
+            
+            signed_payload_3 = f"{timestamp}.{body}"
+            expected_signature_3 = hmac.new(
+                secret.encode('utf-8'),
+                signed_payload_3.encode('utf-8'),
+                hashlib.sha256
+            ).digest()
+            expected_signature_3_b64 = base64.b64encode(expected_signature_3).decode('utf-8')
+            
+            logger.debug(f"Получена подпись: {received_signature}")
+            logger.debug(f"Ожидаемая подпись (вариант 1): {expected_signature_1_b64}")
+            logger.debug(f"Ожидаемая подпись (вариант 2): {expected_signature_2_b64}")
+            logger.debug(f"Ожидаемая подпись (вариант 3): {expected_signature_3_b64}")
+            
+            is_valid = (
+                hmac.compare_digest(received_signature, expected_signature_1_b64) or
+                hmac.compare_digest(received_signature, expected_signature_2_b64) or  
+                hmac.compare_digest(received_signature, expected_signature_3_b64)
+            )
+            
+            if is_valid:
+                logger.info("✅ Подпись YooKassa webhook проверена успешно")
+            else:
+                logger.warning("⚠️ Подпись YooKassa webhook не совпадает ни с одним вариантом")
+            
+            return is_valid
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки подписи YooKassa: {e}")
+            return False
     
     def __init__(self, payment_service: PaymentService):
         self.payment_service = payment_service
@@ -31,91 +89,116 @@ class YooKassaWebhookHandler:
     async def handle_webhook(self, request: web.Request) -> web.Response:
         
         try:
+            logger.info(f"📥 Получен YooKassa webhook: {request.method} {request.path}")
+            logger.info(f"📋 Headers: {dict(request.headers)}")
+            
             body = await request.text()
             
             if not body:
-                logger.warning("Получен пустой webhook от YooKassa")
+                logger.warning("⚠️ Получен пустой webhook от YooKassa")
                 return web.Response(status=400, text="Empty body")
             
-            if hasattr(settings, 'YOOKASSA_WEBHOOK_SECRET') and settings.YOOKASSA_WEBHOOK_SECRET:
-                signature = request.headers.get('X-YooKassa-Signature')
-                if not signature:
-                    logger.warning("Webhook без подписи")
-                    return web.Response(status=400, text="Missing signature")
+            logger.info(f"📄 Body: {body}")
+            
+            signature = request.headers.get('Signature') or request.headers.get('X-YooKassa-Signature')
+            
+            if settings.YOOKASSA_WEBHOOK_SECRET and signature:
+                logger.info(f"🔐 Получена подпись: {signature}")
                 
                 if not YooKassaWebhookHandler.verify_webhook_signature(body, signature, settings.YOOKASSA_WEBHOOK_SECRET):
-                    logger.error("Неверная подпись webhook")
-                    return web.Response(status=400, text="Invalid signature")
+                    logger.warning("❌ Подпись не совпала, но продолжаем обработку (режим отладки)")
+                else:
+                    logger.info("✅ Подпись webhook проверена успешно")
+                    
+            elif settings.YOOKASSA_WEBHOOK_SECRET and not signature:
+                logger.warning("⚠️ Webhook без подписи, но секрет настроен")
+                
+            elif signature and not settings.YOOKASSA_WEBHOOK_SECRET:
+                logger.info("ℹ️ Подпись получена, но проверка отключена (YOOKASSA_WEBHOOK_SECRET не настроен)")
+                
+            else:
+                logger.info("ℹ️ Проверка подписи отключена")
             
             try:
                 webhook_data = json.loads(body)
             except json.JSONDecodeError as e:
-                logger.error(f"Ошибка парсинга JSON webhook YooKassa: {e}")
+                logger.error(f"❌ Ошибка парсинга JSON webhook YooKassa: {e}")
                 return web.Response(status=400, text="Invalid JSON")
             
-            logger.info(f"Получен webhook YooKassa: {webhook_data.get('event', 'unknown_event')}")
-            logger.debug(f"Полные данные webhook: {webhook_data}")
+            logger.info(f"📊 Обработка webhook YooKassa: {webhook_data.get('event', 'unknown_event')}")
+            logger.debug(f"🔍 Полные данные webhook: {webhook_data}")
             
             event_type = webhook_data.get("event")
             if not event_type:
-                logger.warning("Webhook YooKassa без типа события")
+                logger.warning("⚠️ Webhook YooKassa без типа события")
                 return web.Response(status=400, text="No event type")
             
             if event_type not in ["payment.succeeded", "payment.waiting_for_capture"]:
-                logger.info(f"Игнорируем событие YooKassa: {event_type}")
+                logger.info(f"ℹ️ Игнорируем событие YooKassa: {event_type}")
                 return web.Response(status=200, text="OK")
             
-            async with get_db() as db:
-                success = await self.payment_service.process_yookassa_webhook(db, webhook_data)
-                
-                if success:
-                    logger.info(f"Успешно обработан webhook YooKassa: {event_type}")
-                    return web.Response(status=200, text="OK")
-                else:
-                    logger.error(f"Ошибка обработки webhook YooKassa: {event_type}")
-                    return web.Response(status=500, text="Processing error")
+            async for db in get_db():
+                try:
+                    success = await self.payment_service.process_yookassa_webhook(db, webhook_data)
+                    
+                    if success:
+                        logger.info(f"✅ Успешно обработан webhook YooKassa: {event_type}")
+                        return web.Response(status=200, text="OK")
+                    else:
+                        logger.error(f"❌ Ошибка обработки webhook YooKassa: {event_type}")
+                        return web.Response(status=500, text="Processing error")
+                        
+                finally:
+                    await db.close()
         
         except Exception as e:
-            logger.error(f"Критическая ошибка обработки webhook YooKassa: {e}", exc_info=True)
+            logger.error(f"❌ Критическая ошибка обработки webhook YooKassa: {e}", exc_info=True)
             return web.Response(status=500, text="Internal server error")
     
     def setup_routes(self, app: web.Application) -> None:
         
         webhook_path = settings.YOOKASSA_WEBHOOK_PATH
         app.router.add_post(webhook_path, self.handle_webhook)
+        app.router.add_get(webhook_path, self._get_handler) 
+        app.router.add_options(webhook_path, self._options_handler) 
         
-        logger.info(f"Настроен webhook YooKassa на пути: {webhook_path}")
+        logger.info(f"✅ Настроен YooKassa webhook на пути: POST {webhook_path}")
+    
+    async def _get_handler(self, request: web.Request) -> web.Response:
+        return web.json_response({
+            "status": "ok",
+            "message": "YooKassa webhook endpoint is working",
+            "method": "GET",
+            "path": request.path,
+            "note": "Use POST method for actual webhooks"
+        })
+    
+    async def _options_handler(self, request: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, X-YooKassa-Signature',
+            }
+        )
 
 
 def create_yookassa_webhook_app(payment_service: PaymentService) -> web.Application:
     
     app = web.Application()
     
-    async def logging_middleware(request, handler):
-        start_time = request.loop.time()
-        
-        try:
-            response = await handler(request)
-            process_time = request.loop.time() - start_time
-            
-            logger.info(f"YooKassa webhook {request.method} {request.path_qs} "
-                       f"-> {response.status} ({process_time:.3f}s)")
-            
-            return response
-        
-        except Exception as e:
-            process_time = request.loop.time() - start_time
-            logger.error(f"YooKassa webhook {request.method} {request.path_qs} "
-                        f"-> ERROR ({process_time:.3f}s): {e}")
-            raise
-    
-    app.middlewares.append(logging_middleware)
-    
     webhook_handler = YooKassaWebhookHandler(payment_service)
     webhook_handler.setup_routes(app)
     
     async def health_check(request):
-        return web.json_response({"status": "ok", "service": "yookassa_webhook"})
+        return web.json_response({
+            "status": "ok", 
+            "service": "yookassa_webhook",
+            "port": settings.YOOKASSA_WEBHOOK_PORT,
+            "path": settings.YOOKASSA_WEBHOOK_PATH,
+            "enabled": settings.is_yookassa_enabled()
+        })
     
     app.router.add_get("/health", health_check)
     
@@ -125,12 +208,10 @@ def create_yookassa_webhook_app(payment_service: PaymentService) -> web.Applicat
 async def start_yookassa_webhook_server(payment_service: PaymentService) -> None:
     
     if not settings.is_yookassa_enabled():
-        logger.info("YooKassa отключен, webhook сервер не запускается")
+        logger.info("ℹ️ YooKassa отключена, webhook сервер не запускается")
         return
     
     try:
-        from aiohttp import web
-        
         app = create_yookassa_webhook_app(payment_service)
         
         runner = web.AppRunner(app)
@@ -138,15 +219,25 @@ async def start_yookassa_webhook_server(payment_service: PaymentService) -> None
         
         site = web.TCPSite(
             runner, 
-            host='0.0.0.0', 
+            host='0.0.0.0',  
             port=settings.YOOKASSA_WEBHOOK_PORT
         )
         
         await site.start()
         
-        logger.info(f"YooKassa webhook сервер запущен на порту {settings.YOOKASSA_WEBHOOK_PORT}")
-        logger.info(f"Webhook URL: http://localhost:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
+        logger.info(f"✅ YooKassa webhook сервер запущен на порту {settings.YOOKASSA_WEBHOOK_PORT}")
+        logger.info(f"🎯 YooKassa webhook URL: http://0.0.0.0:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
+        
+        try:
+            while True:
+                await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            logger.info("🛑 YooKassa webhook сервер получил сигнал остановки")
+        finally:
+            await site.stop()
+            await runner.cleanup()
+            logger.info("✅ YooKassa webhook сервер остановлен")
         
     except Exception as e:
-        logger.error(f"Ошибка запуска YooKassa webhook сервера: {e}", exc_info=True)
+        logger.error(f"❌ Ошибка запуска YooKassa webhook сервера: {e}", exc_info=True)
         raise

app/handlers/admin/messages.py

@@ -45,7 +45,8 @@ async def show_messages_menu(
     
     await callback.message.edit_text(
         text,
-        reply_markup=get_admin_messages_keyboard(db_user.language)
+        reply_markup=get_admin_messages_keyboard(db_user.language),
+        parse_mode="HTML"  
     )
     await callback.answer()
 
@@ -60,7 +61,8 @@ async def show_broadcast_targets(
     await callback.message.edit_text(
         "🎯 <b>Выбор целевой аудитории</b>\n\n"
         "Выберите категорию пользователей для рассылки:",
-        reply_markup=get_broadcast_target_keyboard(db_user.language)
+        reply_markup=get_broadcast_target_keyboard(db_user.language),
+        parse_mode="HTML" 
     )
     await callback.answer()
 
@@ -118,7 +120,8 @@ async def show_messages_history(
     
     await callback.message.edit_text(
         text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"  
     )
     await callback.answer()
 
@@ -135,7 +138,7 @@ async def show_custom_broadcast(
     stats = await get_users_statistics(db)
     
     text = f"""
-🔍 <b>Рассылка по критериям</b>
+📝 <b>Рассылка по критериям</b>
 
 📊 <b>Доступные фильтры:</b>
 
@@ -158,7 +161,8 @@ async def show_custom_broadcast(
     
     await callback.message.edit_text(
         text,
-        reply_markup=get_custom_criteria_keyboard(db_user.language)
+        reply_markup=get_custom_criteria_keyboard(db_user.language),
+        parse_mode="HTML" 
     )
     await callback.answer()
 
@@ -196,7 +200,8 @@ async def select_custom_criteria(
         f"<i>Поддерживается HTML разметка</i>",
         reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
             [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_messages")]
-        ])
+        ]),
+        parse_mode="HTML" 
     )
     
     await state.set_state(AdminStates.waiting_for_broadcast_message)
@@ -233,7 +238,8 @@ async def select_broadcast_target(
         f"<i>Поддерживается HTML разметка</i>",
         reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
             [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_messages")]
-        ])
+        ]),
+        parse_mode="HTML" 
     )
     
     await state.set_state(AdminStates.waiting_for_broadcast_message)
@@ -284,7 +290,8 @@ async def process_broadcast_message(
     
     await message.answer(
         preview_text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"  
     )
     await state.set_state(AdminStates.confirming_broadcast)
 
@@ -304,7 +311,8 @@ async def confirm_broadcast(
     await callback.message.edit_text(
         "📨 Начинаю рассылку...\n\n"
         "⏳ Это может занять несколько минут.",
-        reply_markup=None
+        reply_markup=None,
+        parse_mode="HTML" 
     )
     
     if target.startswith('custom_'):
@@ -367,7 +375,8 @@ async def confirm_broadcast(
         result_text,
         reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
             [types.InlineKeyboardButton(text="📨 К рассылкам", callback_data="admin_messages")]
-        ])
+        ]),
+        parse_mode="HTML" 
     )
     
     await state.clear()
@@ -548,4 +557,4 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(show_custom_broadcast, F.data == "admin_msg_custom")
     dp.callback_query.register(select_custom_criteria, F.data.startswith("criteria_"))
     
-    dp.message.register(process_broadcast_message, AdminStates.waiting_for_broadcast_message)
+    dp.message.register(process_broadcast_message, AdminStates.waiting_for_broadcast_message)

app/handlers/admin/promocodes.py

@@ -6,7 +6,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings
 from app.states import AdminStates
-from app.database.models import User, PromoCodeType
+from app.database.models import PromoCode, PromoCodeUse, PromoCodeType, User
 from app.keyboards.admin import (
     get_admin_promocodes_keyboard, get_promocode_type_keyboard,
     get_admin_pagination_keyboard, get_confirmation_keyboard
@@ -77,6 +77,7 @@ async def show_promocodes_list(
         return
     
     text = f"🎫 <b>Список промокодов</b> (стр. {page}/{total_pages})\n\n"
+    keyboard = []
     
     for promo in promocodes:
         status_emoji = "✅" if promo.is_active else "❌"
@@ -93,9 +94,14 @@ async def show_promocodes_list(
         if promo.valid_until:
             text += f"⏰ До: {format_datetime(promo.valid_until)}\n"
         
-        text += f"🔧 Управление: /promo_{promo.id}\n\n"
-    
-    keyboard = []
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text=f"🎫 {promo.code}", 
+                callback_data=f"promo_manage_{promo.id}"
+            )
+        ])
+        
+        text += "\n" 
     
     if total_pages > 1:
         pagination_row = get_admin_pagination_keyboard(
@@ -182,128 +188,75 @@ async def show_promocode_management(
     )
     await callback.answer()
 
-
 @admin_required
 @error_handler
-async def toggle_promocode_status(
+async def show_promocode_edit_menu(
     callback: types.CallbackQuery,
     db_user: User,
     db: AsyncSession
 ):
-    promo_id = int(callback.data.split('_')[-1])
-    
-    promo = await db.get(PromoCode, promo_id)
-    if not promo:
-        await callback.answer("❌ Промокод не найден", show_alert=True)
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
         return
     
-    new_status = not promo.is_active
-    await update_promocode(db, promo, is_active=new_status)
-    
-    status_text = "активирован" if new_status else "деактивирован"
-    await callback.answer(f"✅ Промокод {status_text}", show_alert=True)
-    
-    await show_promocode_management(callback, db_user, db)
-
-
-@admin_required
-@error_handler
-async def confirm_delete_promocode(
-    callback: types.CallbackQuery,
-    db_user: User,
-    db: AsyncSession
-):
-    promo_id = int(callback.data.split('_')[-1])
-    
     promo = await db.get(PromoCode, promo_id)
     if not promo:
         await callback.answer("❌ Промокод не найден", show_alert=True)
         return
     
     text = f"""
-⚠️ <b>Подтверждение удаления</b>
+✏️ <b>Редактирование промокода</b> <code>{promo.code}</code>
 
-Вы действительно хотите удалить промокод <code>{promo.code}</code>?
-
-<b>Внимание:</b> Это действие нельзя отменить!
+💰 <b>Текущие параметры:</b>
 """
     
-    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+    if promo.type == PromoCodeType.BALANCE.value:
+        text += f"• Бонус: {settings.format_price(promo.balance_bonus_kopeks)}\n"
+    elif promo.type in [PromoCodeType.SUBSCRIPTION_DAYS.value, PromoCodeType.TRIAL_SUBSCRIPTION.value]:
+        text += f"• Дней: {promo.subscription_days}\n"
+    
+    text += f"• Использований: {promo.current_uses}/{promo.max_uses}\n"
+    
+    if promo.valid_until:
+        text += f"• До: {format_datetime(promo.valid_until)}\n"
+    else:
+        text += f"• Срок: бессрочно\n"
+    
+    text += f"\nВыберите параметр для изменения:"
+    
+    keyboard = [
         [
             types.InlineKeyboardButton(
-                text="✅ Да, удалить", 
-                callback_data=f"promo_delete_confirm_{promo.id}"
-            ),
+                text="📅 Дата окончания", 
+                callback_data=f"promo_edit_date_{promo.id}"
+            )
+        ],
+        [
             types.InlineKeyboardButton(
-                text="❌ Отмена", 
-                callback_data=f"promo_manage_{promo.id}"
+                text="📊 Количество использований", 
+                callback_data=f"promo_edit_uses_{promo.id}"
             )
         ]
-    ])
+    ]
     
-    await callback.message.edit_text(text, reply_markup=keyboard)
-    await callback.answer()
-
-
-@admin_required
-@error_handler
-async def delete_promocode_confirmed(
-    callback: types.CallbackQuery,
-    db_user: User,
-    db: AsyncSession
-):
-    promo_id = int(callback.data.split('_')[-1])
+    if promo.type == PromoCodeType.BALANCE.value:
+        keyboard.insert(1, [
+            types.InlineKeyboardButton(
+                text="💰 Сумма бонуса", 
+                callback_data=f"promo_edit_amount_{promo.id}"
+            )
+        ])
+    elif promo.type in [PromoCodeType.SUBSCRIPTION_DAYS.value, PromoCodeType.TRIAL_SUBSCRIPTION.value]:
+        keyboard.insert(1, [
+            types.InlineKeyboardButton(
+                text="📅 Количество дней", 
+                callback_data=f"promo_edit_days_{promo.id}"
+            )
+        ])
     
-    promo = await db.get(PromoCode, promo_id)
-    if not promo:
-        await callback.answer("❌ Промокод не найден", show_alert=True)
-        return
-    
-    code = promo.code
-    success = await delete_promocode(db, promo)
-    
-    if success:
-        await callback.answer(f"✅ Промокод {code} удален", show_alert=True)
-        await show_promocodes_list(callback, db_user, db)
-    else:
-        await callback.answer("❌ Ошибка удаления промокода", show_alert=True)
-
-
-@admin_required
-@error_handler
-async def show_promocode_stats(
-    callback: types.CallbackQuery,
-    db_user: User,
-    db: AsyncSession
-):
-    promo_id = int(callback.data.split('_')[-1])
-    
-    promo = await db.get(PromoCode, promo_id)
-    if not promo:
-        await callback.answer("❌ Промокод не найден", show_alert=True)
-        return
-    
-    stats = await get_promocode_statistics(db, promo_id)
-    
-    text = f"""
-📊 <b>Статистика промокода</b> <code>{promo.code}</code>
-
-📈 <b>Общая статистика:</b>
-- Всего использований: {stats['total_uses']}
-- Использований сегодня: {stats['today_uses']}
-- Осталось использований: {promo.max_uses - promo.current_uses}
-
-📅 <b>Последние использования:</b>
-"""
-    
-    for use in stats['recent_uses'][:5]:
-        use_date = format_datetime(use.used_at)
-        text += f"- {use_date} (ID: {use.user_id})\n"
-    
-    if not stats['recent_uses']:
-        text += "- Пока не было использований\n"
-    
-    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+    keyboard.extend([
         [
             types.InlineKeyboardButton(
                 text="⬅️ Назад", 
@@ -312,7 +265,160 @@ async def show_promocode_stats(
         ]
     ])
     
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_edit_promocode_date(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
+        return
+    
+    await state.update_data(
+        editing_promo_id=promo_id,
+        edit_action="date"
+    )
+    
+    text = f"""
+📅 <b>Изменение даты окончания промокода</b>
+
+Введите количество дней до окончания (от текущего момента):
+• Введите <b>0</b> для бессрочного промокода
+• Введите положительное число для установки срока
+
+<i>Например: 30 (промокод будет действовать 30 дней)</i>
+
+ID промокода: {promo_id}
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"promo_edit_{promo_id}")]
+    ])
+    
     await callback.message.edit_text(text, reply_markup=keyboard)
+    await state.set_state(AdminStates.setting_promocode_expiry)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_edit_promocode_amount(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
+        return
+    
+    await state.update_data(
+        editing_promo_id=promo_id,
+        edit_action="amount"
+    )
+    
+    text = f"""
+💰 <b>Изменение суммы бонуса промокода</b>
+
+Введите новую сумму в рублях:
+<i>Например: 500</i>
+
+ID промокода: {promo_id}
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"promo_edit_{promo_id}")]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await state.set_state(AdminStates.setting_promocode_value)
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def start_edit_promocode_days(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    # ИСПРАВЛЕНИЕ: берем последний элемент как ID
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
+        return
+    
+    await state.update_data(
+        editing_promo_id=promo_id,
+        edit_action="days"
+    )
+    
+    text = f"""
+📅 <b>Изменение количества дней подписки</b>
+
+Введите новое количество дней:
+<i>Например: 30</i>
+
+ID промокода: {promo_id}
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"promo_edit_{promo_id}")]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await state.set_state(AdminStates.setting_promocode_value)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_edit_promocode_uses(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
+        return
+    
+    await state.update_data(
+        editing_promo_id=promo_id,
+        edit_action="uses"
+    )
+    
+    text = f"""
+📊 <b>Изменение максимального количества использований</b>
+
+Введите новое количество использований:
+• Введите <b>0</b> для безлимитных использований
+• Введите положительное число для ограничения
+
+<i>Например: 100</i>
+
+ID промокода: {promo_id}
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"promo_edit_{promo_id}")]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await state.set_state(AdminStates.setting_promocode_uses)
     await callback.answer()
 
 
@@ -375,7 +481,6 @@ async def process_promocode_code(
         await message.answer("❌ Код должен содержать только латинские буквы и цифры (3-20 символов)")
         return
     
-    from app.database.crud.promocode import get_promocode_by_code
     existing = await get_promocode_by_code(db, code)
     if existing:
         await message.answer("❌ Промокод с таким кодом уже существует")
@@ -411,12 +516,18 @@ async def process_promocode_code(
 async def process_promocode_value(
     message: types.Message,
     db_user: User,
-    state: FSMContext
+    state: FSMContext,
+    db: AsyncSession
 ):
+    data = await state.get_data()
+    
+    if data.get('editing_promo_id'):
+        await handle_edit_value(message, db_user, state, db)
+        return
+    
     try:
         value = int(message.text.strip())
         
-        data = await state.get_data()
         promo_type = data.get('promocode_type')
         
         if promo_type == "balance" and (value < 1 or value > 10000):
@@ -437,13 +548,72 @@ async def process_promocode_value(
         await message.answer("❌ Введите корректное число")
 
 
+async def handle_edit_value(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    promo_id = data.get('editing_promo_id')
+    edit_action = data.get('edit_action')
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await message.answer("❌ Промокод не найден")
+        await state.clear()
+        return
+    
+    try:
+        value = int(message.text.strip())
+        
+        if edit_action == "amount":
+            if value < 1 or value > 10000:
+                await message.answer("❌ Сумма должна быть от 1 до 10,000 рублей")
+                return
+            
+            await update_promocode(db, promo, balance_bonus_kopeks=value * 100)
+            await message.answer(
+                f"✅ Сумма бонуса изменена на {value}₽",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🎫 К промокоду", callback_data=f"promo_manage_{promo_id}")]
+                ])
+            )
+            
+        elif edit_action == "days":
+            if value < 1 or value > 3650:
+                await message.answer("❌ Количество дней должно быть от 1 до 3650")
+                return
+            
+            await update_promocode(db, promo, subscription_days=value)
+            await message.answer(
+                f"✅ Количество дней изменено на {value}",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🎫 К промокоду", callback_data=f"promo_manage_{promo_id}")]
+                ])
+            )
+        
+        await state.clear()
+        logger.info(f"Промокод {promo.code} отредактирован администратором {db_user.telegram_id}: {edit_action} = {value}")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число")
+
+
 @admin_required
 @error_handler
 async def process_promocode_uses(
     message: types.Message,
     db_user: User,
-    state: FSMContext
+    state: FSMContext,
+    db: AsyncSession
 ):
+    data = await state.get_data()
+    
+    if data.get('editing_promo_id'):
+        await handle_edit_uses(message, db_user, state, db)
+        return
+    
     try:
         max_uses = int(message.text.strip())
         
@@ -465,6 +635,54 @@ async def process_promocode_uses(
         await message.answer("❌ Введите корректное число")
 
 
+async def handle_edit_uses(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    promo_id = data.get('editing_promo_id')
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await message.answer("❌ Промокод не найден")
+        await state.clear()
+        return
+    
+    try:
+        max_uses = int(message.text.strip())
+        
+        if max_uses < 0 or max_uses > 100000:
+            await message.answer("❌ Количество использований должно быть от 0 до 100,000")
+            return
+        
+        if max_uses == 0:
+            max_uses = 999999
+        
+        if max_uses < promo.current_uses:
+            await message.answer(
+                f"❌ Новый лимит ({max_uses}) не может быть меньше текущих использований ({promo.current_uses})"
+            )
+            return
+        
+        await update_promocode(db, promo, max_uses=max_uses)
+        
+        uses_text = "безлимитное" if max_uses == 999999 else str(max_uses)
+        await message.answer(
+            f"✅ Максимальное количество использований изменено на {uses_text}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🎫 К промокоду", callback_data=f"promo_manage_{promo_id}")]
+            ])
+        )
+        
+        await state.clear()
+        logger.info(f"Промокод {promo.code} отредактирован администратором {db_user.telegram_id}: max_uses = {max_uses}")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число")
+
+
 @admin_required
 @error_handler
 async def process_promocode_expiry(
@@ -473,6 +691,12 @@ async def process_promocode_expiry(
     state: FSMContext,
     db: AsyncSession
 ):
+    data = await state.get_data()
+    
+    if data.get('editing_promo_id'):
+        await handle_edit_expiry(message, db_user, state, db)
+        return
+    
     try:
         expiry_days = int(message.text.strip())
         
@@ -480,7 +704,6 @@ async def process_promocode_expiry(
             await message.answer("❌ Срок действия должен быть от 0 до 3650 дней")
             return
         
-        data = await state.get_data()
         code = data.get('promocode_code')
         promo_type = data.get('promocode_type')
         value = data.get('promocode_value', 0)
@@ -544,6 +767,209 @@ async def process_promocode_expiry(
         await message.answer("❌ Введите корректное число дней")
 
 
+async def handle_edit_expiry(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    promo_id = data.get('editing_promo_id')
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await message.answer("❌ Промокод не найден")
+        await state.clear()
+        return
+    
+    try:
+        expiry_days = int(message.text.strip())
+        
+        if expiry_days < 0 or expiry_days > 3650:
+            await message.answer("❌ Срок действия должен быть от 0 до 3650 дней")
+            return
+        
+        valid_until = None
+        if expiry_days > 0:
+            valid_until = datetime.utcnow() + timedelta(days=expiry_days)
+        
+        await update_promocode(db, promo, valid_until=valid_until)
+        
+        if valid_until:
+            expiry_text = f"до {format_datetime(valid_until)}"
+        else:
+            expiry_text = "бессрочно"
+            
+        await message.answer(
+            f"✅ Срок действия промокода изменен: {expiry_text}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🎫 К промокоду", callback_data=f"promo_manage_{promo_id}")]
+            ])
+        )
+        
+        await state.clear()
+        logger.info(f"Промокод {promo.code} отредактирован администратором {db_user.telegram_id}: expiry = {expiry_days} дней")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число дней")
+
+
+@admin_required
+@error_handler
+async def toggle_promocode_status(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    new_status = not promo.is_active
+    await update_promocode(db, promo, is_active=new_status)
+    
+    status_text = "активирован" if new_status else "деактивирован"
+    await callback.answer(f"✅ Промокод {status_text}", show_alert=True)
+    
+    await show_promocode_management(callback, db_user, db)
+
+
+@admin_required
+@error_handler
+async def confirm_delete_promocode(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
+        return
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    text = f"""
+⚠️ <b>Подтверждение удаления</b>
+
+Вы действительно хотите удалить промокод <code>{promo.code}</code>?
+
+📊 <b>Информация о промокоде:</b>
+• Использований: {promo.current_uses}/{promo.max_uses}
+• Статус: {'Активен' if promo.is_active else 'Неактивен'}
+
+<b>⚠️ Внимание:</b> Это действие нельзя отменить!
+
+ID: {promo_id}
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(
+                text="✅ Да, удалить", 
+                callback_data=f"promo_delete_confirm_{promo.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="❌ Отмена", 
+                callback_data=f"promo_manage_{promo.id}"
+            )
+        ]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def delete_promocode_confirmed(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        promo_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
+        return
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    code = promo.code
+    success = await delete_promocode(db, promo)
+    
+    if success:
+        await callback.answer(f"✅ Промокод {code} удален", show_alert=True)
+        await show_promocodes_list(callback, db_user, db)
+    else:
+        await callback.answer("❌ Ошибка удаления промокода", show_alert=True)
+
+
+@admin_required
+@error_handler
+async def show_promocode_stats(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    stats = await get_promocode_statistics(db, promo_id)
+    
+    text = f"""
+📊 <b>Статистика промокода</b> <code>{promo.code}</code>
+
+📈 <b>Общая статистика:</b>
+- Всего использований: {stats['total_uses']}
+- Использований сегодня: {stats['today_uses']}
+- Осталось использований: {promo.max_uses - promo.current_uses}
+
+📅 <b>Последние использования:</b>
+"""
+    
+    if stats['recent_uses']:
+        for use in stats['recent_uses'][:5]:
+            use_date = format_datetime(use.used_at)
+            
+            if hasattr(use, 'user_username') and use.user_username:
+                user_display = f"@{use.user_username}"
+            elif hasattr(use, 'user_full_name') and use.user_full_name:
+                user_display = use.user_full_name
+            elif hasattr(use, 'user_telegram_id'):
+                user_display = f"ID{use.user_telegram_id}"
+            else:
+                user_display = f"ID{use.user_id}"
+            
+            text += f"- {use_date} | {user_display}\n"
+    else:
+        text += "- Пока не было использований\n"
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(
+                text="⬅️ Назад", 
+                callback_data=f"promo_manage_{promo.id}"
+            )
+        ]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await callback.answer()
+
+
 def register_handlers(dp: Dispatcher):
     dp.callback_query.register(show_promocodes_menu, F.data == "admin_promocodes")
     dp.callback_query.register(show_promocodes_list, F.data == "admin_promo_list")
@@ -552,11 +978,22 @@ def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(show_promocode_management, F.data.startswith("promo_manage_"))
     dp.callback_query.register(toggle_promocode_status, F.data.startswith("promo_toggle_"))
-    dp.callback_query.register(confirm_delete_promocode, F.data.startswith("promo_delete_"))
-    dp.callback_query.register(delete_promocode_confirmed, F.data.startswith("promo_delete_confirm_"))
     dp.callback_query.register(show_promocode_stats, F.data.startswith("promo_stats_"))
     
+    dp.callback_query.register(start_edit_promocode_date, F.data.startswith("promo_edit_date_"))
+    dp.callback_query.register(start_edit_promocode_amount, F.data.startswith("promo_edit_amount_"))
+    dp.callback_query.register(start_edit_promocode_days, F.data.startswith("promo_edit_days_"))
+    dp.callback_query.register(start_edit_promocode_uses, F.data.startswith("promo_edit_uses_"))
+    
+    dp.callback_query.register(
+        show_promocode_edit_menu, 
+        F.data.regexp(r"^promo_edit_\d+$")
+    )
+    
+    dp.callback_query.register(delete_promocode_confirmed, F.data.startswith("promo_delete_confirm_"))
+    dp.callback_query.register(confirm_delete_promocode, F.data.startswith("promo_delete_"))
+    
     dp.message.register(process_promocode_code, AdminStates.creating_promocode)
     dp.message.register(process_promocode_value, AdminStates.setting_promocode_value)
     dp.message.register(process_promocode_uses, AdminStates.setting_promocode_uses)
-    dp.message.register(process_promocode_expiry, AdminStates.setting_promocode_expiry)
+    dp.message.register(process_promocode_expiry, AdminStates.setting_promocode_expiry)

app/handlers/admin/remnawave.py

@@ -1322,53 +1322,22 @@ async def show_sync_options(
     text = """
 🔄 <b>Синхронизация с RemnaWave</b>
 
-Выберите тип синхронизации:
-
-🔄 <b>Синхронизировать всех</b>
-• Полная синхронизация всех пользователей
-• Создание новых пользователей из панели
-• Обновление данных существующих
-• Удаление неактуальных подписок
+🔄 <b>Полная синхронизация выполняет:</b>
+• Создание новых пользователей из панели в боте
+• Обновление данных существующих пользователей  
+• Деактивация подписок пользователей, отсутствующих в панели
+• Сохранение балансов пользователей
 • ⏱️ Время выполнения: 2-5 минут
 
-🆕 <b>Только новых</b>
-• Создание пользователей из панели, которых нет в боте
-• Быстрое добавление при массовой регистрации
-• ⏱️ Время выполнения: 30 секунд - 2 минуты
-
-📈 <b>Обновить данные</b>
-• Обновление информации о трафике и подписках
-• Синхронизация статуса и лимитов
-• Обновление подключенных сквадов
-• ⏱️ Время выполнения: 1-3 минуты
-
-🔍 <b>Валидация подписок</b>
-• Проверка и исправление проблем в данных
-• Восстановление отсутствующих полей
-• Исправление некорректных статусов
-
-🧹 <b>Мягкая очистка</b>  
-• Деактивация подписок отсутствующих в панели
-• Сохранение транзакций и истории
-
-🗑️ <b>ПРИНУДИТЕЛЬНАЯ ОЧИСТКА</b>
-• ⚠️ ОПАСНО: Полное удаление данных пользователей
-• Удаление транзакций, балансов, рефералов  
-• Только при серьезных проблемах синхронизации
-
 ⚠️ <b>Важно:</b>
 • Во время синхронизации не выполняйте другие операции
 • При полной синхронизации подписки пользователей, отсутствующих в панели, будут деактивированы
 • Рекомендуется делать полную синхронизацию ежедневно
+• Баланс пользователей НЕ удаляется
 """
     
     keyboard = [
-        [types.InlineKeyboardButton(text="🔄 Синхронизировать всех", callback_data="sync_all_users")],
-        [types.InlineKeyboardButton(text="🆕 Только новых", callback_data="sync_new_users")],
-        [types.InlineKeyboardButton(text="📈 Обновить данные", callback_data="sync_update_data")],
-        [types.InlineKeyboardButton(text="🔍 Валидация подписок", callback_data="sync_validate")],
-        [types.InlineKeyboardButton(text="🧹 Мягкая очистка", callback_data="sync_cleanup")],
-        [types.InlineKeyboardButton(text="🗑️ ПРИНУДИТЕЛЬНАЯ ОЧИСТКА", callback_data="confirm_force_cleanup")],
+        [types.InlineKeyboardButton(text="🔄 Запустить полную синхронизацию", callback_data="sync_all_users")],
         [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
     ]
     
@@ -1378,6 +1347,104 @@ async def show_sync_options(
     )
     await callback.answer()
 
+@admin_required
+@error_handler
+async def sync_all_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    """Выполняет полную синхронизацию всех пользователей"""
+    
+    progress_text = """
+🔄 <b>Выполняется полная синхронизация...</b>
+
+📋 Этапы:
+• Загрузка ВСЕХ пользователей из панели RemnaWave
+• Создание новых пользователей в боте
+• Обновление существующих пользователей
+• Деактивация подписок отсутствующих пользователей
+• Сохранение балансов
+
+⏳ Пожалуйста, подождите...
+"""
+    
+    await callback.message.edit_text(progress_text, reply_markup=None)
+    
+    remnawave_service = RemnaWaveService()
+    stats = await remnawave_service.sync_users_from_panel(db, "all")
+    
+    total_operations = stats['created'] + stats['updated'] + stats.get('deleted', 0)
+    
+    if stats['errors'] == 0:
+        status_emoji = "✅"
+        status_text = "успешно завершена"
+    elif stats['errors'] < total_operations:
+        status_emoji = "⚠️"
+        status_text = "завершена с предупреждениями"
+    else:
+        status_emoji = "❌"
+        status_text = "завершена с ошибками"
+    
+    text = f"""
+{status_emoji} <b>Полная синхронизация {status_text}</b>
+
+📊 <b>Результат:</b>
+• 🆕 Создано: {stats['created']}
+• 🔄 Обновлено: {stats['updated']}  
+• 🗑️ Деактивировано: {stats.get('deleted', 0)}
+• ❌ Ошибок: {stats['errors']}
+"""
+    
+    if stats.get('deleted', 0) > 0:
+        text += f"""
+
+🗑️ <b>Деактивированные подписки:</b>
+Деактивированы подписки пользователей, которые
+отсутствуют в панели RemnaWave.
+💰 Балансы пользователей сохранены.
+"""
+    
+    if stats['errors'] > 0:
+        text += f"""
+
+⚠️ <b>Внимание:</b>
+Некоторые операции завершились с ошибками.
+Проверьте логи для получения подробной информации.
+"""
+    
+    text += f"""
+
+💡 <b>Рекомендации:</b>
+• Полная синхронизация выполнена
+• Рекомендуется запускать раз в день
+• Все пользователи из панели синхронизированы
+"""
+    
+    keyboard = []
+    
+    if stats['errors'] > 0:
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text="🔄 Повторить синхронизацию", 
+                callback_data="sync_all_users"
+            )
+        ])
+    
+    keyboard.extend([
+        [
+            types.InlineKeyboardButton(text="📊 Статистика системы", callback_data="admin_rw_system"),
+            types.InlineKeyboardButton(text="🌐 Ноды", callback_data="admin_rw_nodes")
+        ],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
 @admin_required
 @error_handler
 async def show_sync_recommendations(
@@ -1844,39 +1911,22 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(manage_node, F.data.startswith("node_restart_"))
     dp.callback_query.register(restart_all_nodes, F.data == "admin_restart_all_nodes")
     dp.callback_query.register(show_sync_options, F.data == "admin_rw_sync")
-    dp.callback_query.register(sync_users, F.data.startswith("sync_"))
-    dp.callback_query.register(show_sync_recommendations, F.data == "sync_recommendations")
-    dp.callback_query.register(validate_subscriptions, F.data == "sync_validate") 
-    dp.callback_query.register(cleanup_subscriptions, F.data == "sync_cleanup")
-    dp.callback_query.register(confirm_force_cleanup, F.data == "confirm_force_cleanup")
-    dp.callback_query.register(force_cleanup_all_orphaned_users, F.data == "force_cleanup_orphaned")
+    dp.callback_query.register(sync_all_users, F.data == "sync_all_users")
     dp.callback_query.register(show_squads_management, F.data == "admin_rw_squads")
-    
     dp.callback_query.register(show_squad_details, F.data.startswith("admin_squad_manage_"))
-    
     dp.callback_query.register(manage_squad_action, F.data.startswith("squad_add_users_"))
     dp.callback_query.register(manage_squad_action, F.data.startswith("squad_remove_users_"))
     dp.callback_query.register(manage_squad_action, F.data.startswith("squad_delete_"))
-    
     dp.callback_query.register(show_squad_edit_menu, F.data.startswith("squad_edit_") & ~F.data.startswith("squad_edit_inbounds_"))
-    
     dp.callback_query.register(show_squad_inbounds_selection, F.data.startswith("squad_edit_inbounds_"))
     dp.callback_query.register(show_squad_rename_form, F.data.startswith("squad_rename_"))
-    
     dp.callback_query.register(cancel_squad_rename, F.data.startswith("cancel_rename_"))
-    
     dp.callback_query.register(toggle_squad_inbound, F.data.startswith("sqd_tgl_"))
     dp.callback_query.register(save_squad_inbounds, F.data.startswith("sqd_save_"))
-    
     dp.callback_query.register(show_squad_edit_menu_short, F.data.startswith("sqd_edit_"))
-    
-    
     dp.callback_query.register(start_squad_creation, F.data == "admin_squad_create")
-    
     dp.callback_query.register(cancel_squad_creation, F.data == "cancel_squad_create")
-    
     dp.callback_query.register(toggle_create_inbound, F.data.startswith("create_tgl_"))
-    
     dp.callback_query.register(finish_squad_creation, F.data == "create_squad_finish")
     
     dp.message.register(

app/handlers/admin/subscriptions.py

@@ -306,13 +306,13 @@ async def show_pricing_settings(
 """
     
     keyboard = [
-        [
-            types.InlineKeyboardButton(text="📅 Периоды", callback_data="admin_edit_period_prices"),
-            types.InlineKeyboardButton(text="📈 Трафик", callback_data="admin_edit_traffic_prices")
-        ],
-        [
-            types.InlineKeyboardButton(text="📱 Устройства", callback_data="admin_edit_device_price")
-        ],
+      #  [
+      #      types.InlineKeyboardButton(text="📅 Периоды", callback_data="admin_edit_period_prices"),
+      #      types.InlineKeyboardButton(text="📈 Трафик", callback_data="admin_edit_traffic_prices")
+      #  ],
+      #  [
+      #      types.InlineKeyboardButton(text="📱 Устройства", callback_data="admin_edit_device_price")
+      #  ],
         [
             types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
         ]
@@ -405,8 +405,7 @@ async def show_countries_management(
     
     keyboard = [
         [
-            types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_countries"),
-            types.InlineKeyboardButton(text="⚙️ API настройки", callback_data="admin_rw_api")
+            types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_countries")
         ],
         [
             types.InlineKeyboardButton(text="📊 Статистика нод", callback_data="admin_rw_nodes"),
@@ -495,4 +494,4 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(
         handle_subscriptions_pagination, 
         F.data.startswith("admin_subs_list_page_")
-    )
+    )

app/handlers/balance.py

@@ -412,7 +412,7 @@ async def process_yookassa_payment_amount(
             db=db,
             user_id=db_user.id,
             amount_kopeks=amount_kopeks,
-            description=f"Пополнение баланса VPN на {settings.format_price(amount_kopeks)}",
+            description=settings.get_balance_payment_description(amount_kopeks),
             receipt_email=None,
             receipt_phone=None,
             metadata={
@@ -500,14 +500,14 @@ async def check_yookassa_payment_status(
         emoji = status_emoji.get(payment.status, "❓")
         status = status_text.get(payment.status, "Неизвестно")
         
-        message_text = (f"💳 <b>Статус платежа</b>\n\n"
+        message_text = (f"💳 Статус платежа:\n\n"
                        f"🆔 ID: {payment.yookassa_payment_id[:8]}...\n"
                        f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n"
                        f"📊 Статус: {emoji} {status}\n"
                        f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}\n")
         
         if payment.is_succeeded:
-            message_text += "\n✅ Платеж успешно завершен!\nСредства зачислены на баланс."
+            message_text += "\n✅ Платеж успешно завершен!\n\nСредства зачислены на баланс."
         elif payment.is_pending:
             message_text += "\n⏳ Платеж ожидает оплаты. Нажмите кнопку 'Оплатить' выше."
         elif payment.is_failed:

app/handlers/referral.py

@@ -85,13 +85,7 @@ async def create_invite_message(
         [
             types.InlineKeyboardButton(
                 text="📤 Поделиться",
-                switch_inline_query=invite_text
-            )
-        ],
-        [
-            types.InlineKeyboardButton(
-                text="📋 Скопировать ссылку",
-                callback_data="copy_referral_link"
+                switch_inline_query=invite_text 
             )
         ],
         [
@@ -104,7 +98,7 @@ async def create_invite_message(
     
     await callback.message.edit_text(
         f"📝 <b>Приглашение создано!</b>\n\n"
-        f"Используйте кнопку ниже для отправки приглашения или скопируйте текст:\n\n"
+        f"Нажмите кнопку «📤 Поделиться» чтобы отправить приглашение в любой чат, или скопируйте текст ниже:\n\n"
         f"<code>{invite_text}</code>",
         reply_markup=keyboard,
         parse_mode="HTML"
@@ -112,20 +106,6 @@ async def create_invite_message(
     await callback.answer()
 
 
-async def copy_referral_link(
-    callback: types.CallbackQuery,
-    db_user: User
-):
-    
-    bot_username = (await callback.bot.get_me()).username
-    referral_link = f"https://t.me/{bot_username}?start={db_user.referral_code}"
-    
-    await callback.answer(
-        f"Ссылка скопирована: {referral_link}",
-        show_alert=True
-    )
-
-
 def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(
@@ -137,8 +117,3 @@ def register_handlers(dp: Dispatcher):
         create_invite_message,
         F.data == "referral_create_invite"
     )
-    
-    dp.callback_query.register(
-        copy_referral_link,
-        F.data == "copy_referral_link"
-    )

app/handlers/start.py

@@ -1,4 +1,5 @@
 import logging
+from datetime import datetime
 from aiogram import Dispatcher, types, F
 from aiogram.filters import Command, StateFilter
 from aiogram.fsm.context import FSMContext
@@ -20,6 +21,62 @@ from app.utils.user_utils import generate_unique_referral_code
 logger = logging.getLogger(__name__)
 
 
+async def handle_potential_referral_code(
+    message: types.Message, 
+    state: FSMContext, 
+    db: AsyncSession
+):
+    current_state = await state.get_state()
+    logger.info(f"🔍 REFERRAL CHECK: Проверка сообщения '{message.text}' в состоянии {current_state}")
+    
+    if current_state not in [
+        RegistrationStates.waiting_for_rules_accept.state,
+        RegistrationStates.waiting_for_referral_code.state,
+        None 
+    ]:
+        return False
+    
+    user = await get_user_by_telegram_id(db, message.from_user.id)
+    if user and user.status == UserStatus.ACTIVE.value:
+        return False
+    
+    potential_code = message.text.strip()
+    if len(potential_code) < 4 or len(potential_code) > 20:
+        return False
+    
+    referrer = await get_user_by_referral_code(db, potential_code)
+    if not referrer:
+        await message.answer(
+            "❌ Неверный реферальный код.\n\n"
+            "💡 Если у вас есть реферальный код, убедитесь что он введен правильно.\n"
+            "⏭️ Для продолжения регистрации без реферального кода используйте команду /start"
+        )
+        return True 
+    
+    data = await state.get_data() or {}
+    data['referral_code'] = potential_code
+    data['referrer_id'] = referrer.id
+    await state.set_data(data)
+    
+    await message.answer("✅ Реферальный код принят!")
+    logger.info(f"✅ Реферальный код {potential_code} применен для пользователя {message.from_user.id}")
+    
+    if current_state != RegistrationStates.waiting_for_referral_code.state:
+        language = data.get('language', 'ru')
+        texts = get_texts(language)
+        
+        await message.answer(
+            texts.RULES_TEXT,
+            reply_markup=get_rules_keyboard(language)
+        )
+        await state.set_state(RegistrationStates.waiting_for_rules_accept)
+        logger.info("📋 Правила отправлены после ввода реферального кода")
+    else:
+        await complete_registration(message, state, db)
+    
+    return True 
+
+
 async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession, db_user=None):
     logger.info(f"🚀 START: Обработка /start от {message.from_user.id}")
     
@@ -36,6 +93,37 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
     
     if user and user.status != UserStatus.DELETED.value:
         logger.info(f"✅ Активный пользователь найден: {user.telegram_id}")
+        
+        profile_updated = False
+        
+        if user.username != message.from_user.username:
+            old_username = user.username
+            user.username = message.from_user.username
+            logger.info(f"📝 Username обновлен: '{old_username}' → '{user.username}'")
+            profile_updated = True
+        
+        if user.first_name != message.from_user.first_name:
+            old_first_name = user.first_name
+            user.first_name = message.from_user.first_name
+            logger.info(f"📝 Имя обновлено: '{old_first_name}' → '{user.first_name}'")
+            profile_updated = True
+        
+        if user.last_name != message.from_user.last_name:
+            old_last_name = user.last_name
+            user.last_name = message.from_user.last_name
+            logger.info(f"📝 Фамилия обновлена: '{old_last_name}' → '{user.last_name}'")
+            profile_updated = True
+        
+        user.last_activity = datetime.utcnow()
+        
+        if profile_updated:
+            user.updated_at = datetime.utcnow()
+            await db.commit()
+            await db.refresh(user)
+            logger.info(f"💾 Профиль пользователя {user.telegram_id} обновлен")
+        else:
+            await db.commit()
+        
         texts = get_texts(user.language)
         
         if referral_code and not user.referred_by_id:
@@ -107,6 +195,13 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
             user.remnawave_uuid = None
             user.has_had_paid_subscription = False
             user.referred_by_id = None
+            
+            user.username = message.from_user.username
+            user.first_name = message.from_user.first_name
+            user.last_name = message.from_user.last_name
+            user.updated_at = datetime.utcnow()
+            user.last_activity = datetime.utcnow()
+            
             from app.utils.user_utils import generate_unique_referral_code
             user.referral_code = await generate_unique_referral_code(db, user.telegram_id)
             
@@ -299,6 +394,10 @@ async def complete_registration_from_callback(
         logger.warning(f"⚠️ Пользователь {callback.from_user.id} уже активен! Показываем главное меню.")
         texts = get_texts(existing_user.language)
         
+        data = await state.get_data()
+        if data.get('referral_code') and not existing_user.referred_by_id:
+            await callback.message.answer("ℹ️ Вы уже зарегистрированы в системе. Реферальная ссылка не может быть применена.")
+        
         has_active_subscription = existing_user.subscription is not None
         subscription_is_active = False
         
@@ -362,7 +461,7 @@ async def complete_registration_from_callback(
         user = existing_user
         logger.info(f"✅ Пользователь {callback.from_user.id} восстановлен")
         
-    else:
+    elif not existing_user:
         logger.info(f"🆕 Создаем нового пользователя {callback.from_user.id}")
         
         referral_code = await generate_unique_referral_code(db, callback.from_user.id)
@@ -377,6 +476,20 @@ async def complete_registration_from_callback(
             referred_by_id=referrer_id,
             referral_code=referral_code 
         )
+    else:
+        logger.info(f"🔄 Обновляем существующего пользователя {callback.from_user.id}")
+        existing_user.status = UserStatus.ACTIVE.value
+        existing_user.language = language
+        if referrer_id and not existing_user.referred_by_id:
+            existing_user.referred_by_id = referrer_id
+        
+        from datetime import datetime
+        existing_user.updated_at = datetime.utcnow()
+        existing_user.last_activity = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(existing_user)
+        user = existing_user
     
     if referrer_id:
         try:
@@ -451,6 +564,42 @@ async def complete_registration(
     
     existing_user = await get_user_by_telegram_id(db, message.from_user.id)
     
+    if existing_user and existing_user.status == UserStatus.ACTIVE.value:
+        logger.warning(f"⚠️ Пользователь {message.from_user.id} уже активен! Показываем главное меню.")
+        texts = get_texts(existing_user.language)
+        
+        data = await state.get_data()
+        if data.get('referral_code') and not existing_user.referred_by_id:
+            await message.answer("ℹ️ Вы уже зарегистрированы в системе. Реферальная ссылка не может быть применена.")
+        
+        has_active_subscription = existing_user.subscription is not None
+        subscription_is_active = False
+        
+        if existing_user.subscription:
+            subscription_is_active = existing_user.subscription.is_active
+        
+        try:
+            await message.answer(
+                texts.MAIN_MENU.format(
+                    user_name=existing_user.full_name,
+                    balance=texts.format_price(existing_user.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,
+                    has_active_subscription=has_active_subscription,
+                    subscription_is_active=subscription_is_active
+                )
+            )
+        except Exception as e:
+            logger.error(f"Ошибка при показе главного меню существующему пользователю: {e}")
+            await message.answer(f"Добро пожаловать, {existing_user.full_name}!")
+        
+        await state.clear()
+        return
+    
     data = await state.get_data()
     language = data.get('language', 'ru')
     texts = get_texts(language)
@@ -483,7 +632,7 @@ async def complete_registration(
         user = existing_user
         logger.info(f"✅ Пользователь {message.from_user.id} восстановлен")
         
-    else:
+    elif not existing_user:
         logger.info(f"🆕 Создаем нового пользователя {message.from_user.id}")
         
         referral_code = await generate_unique_referral_code(db, message.from_user.id)
@@ -498,6 +647,20 @@ async def complete_registration(
             referred_by_id=referrer_id,
             referral_code=referral_code
         )
+    else:
+        logger.info(f"🔄 Обновляем существующего пользователя {message.from_user.id}")
+        existing_user.status = UserStatus.ACTIVE.value
+        existing_user.language = language
+        if referrer_id and not existing_user.referred_by_id:
+            existing_user.referred_by_id = referrer_id
+        
+        from datetime import datetime
+        existing_user.updated_at = datetime.utcnow()
+        existing_user.last_activity = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(existing_user)
+        user = existing_user
     
     if referrer_id:
         try:
@@ -614,4 +777,13 @@ def register_handlers(dp: Dispatcher):
     )
     logger.info("✅ Зарегистрирован process_referral_code_input")
     
+    dp.message.register(
+        handle_potential_referral_code,
+        StateFilter(
+            RegistrationStates.waiting_for_rules_accept,
+            RegistrationStates.waiting_for_referral_code
+        )
+    )
+    logger.info("✅ Зарегистрирован handle_potential_referral_code")
+    
     logger.info("🔧 === КОНЕЦ регистрации обработчиков start.py ===")

app/handlers/subscription.py

@@ -198,7 +198,7 @@ async def get_subscription_cost(subscription, db: AsyncSession) -> int:
             )
         
         traffic_cost = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
-        devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+        devices_cost = max(0, subscription.device_limit - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
         
         total_cost = base_cost + servers_cost + traffic_cost + devices_cost
         
@@ -328,7 +328,7 @@ async def start_subscription_purchase(
     initial_data = {
         'period_days': None,
         'countries': [],
-        'devices': 1,
+        'devices': settings.DEFAULT_DEVICE_LIMIT, 
         'total_price': 0
     }
     
@@ -349,6 +349,9 @@ async def handle_add_countries(
     db: AsyncSession,
     state: FSMContext
 ):
+    if not await _should_show_countries_management():
+        await callback.answer("ℹ️ Управление серверами недоступно - доступен только один сервер", show_alert=True)
+        return
     
     texts = get_texts(db_user.language)
     subscription = db_user.subscription
@@ -366,7 +369,7 @@ async def handle_add_countries(
             current_countries_names.append(country['name'])
     
     text = "🌍 <b>Управление странами подписки</b>\n\n"
-    text += f"📍 <b>Текущие страны ({len(current_countries)}):</b>\n"
+    text += f"📋 <b>Текущие страны ({len(current_countries)}):</b>\n"
     if current_countries_names:
         text += "\n".join(f"• {name}" for name in current_countries_names)
     else:
@@ -409,11 +412,11 @@ async def get_countries_price_by_uuids_fallback(country_uuids: List[str], db: As
                     total_price += price
                     prices_list.append(price)
                 else:
-                    default_price = 1000
+                    default_price = 0
                     total_price += default_price
                     prices_list.append(default_price)
             except Exception:
-                default_price = 1000
+                default_price = 0
                 total_price += default_price
                 prices_list.append(default_price)
         
@@ -421,7 +424,7 @@ async def get_countries_price_by_uuids_fallback(country_uuids: List[str], db: As
         
     except Exception as e:
         logger.error(f"Ошибка fallback функции: {e}")
-        default_prices = [1000] * len(country_uuids)
+        default_prices = [0] * len(country_uuids)
         return sum(default_prices), default_prices
 
 async def handle_manage_country(
@@ -667,36 +670,57 @@ async def handle_extend_subscription(
     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
     
     if subscription.days_left > 3:
-        await callback.answer("❌ Продление доступно за 3 дня до окончания подписки", show_alert=True)
+        await callback.answer("⌛ Продление доступно за 3 дня до окончания подписки", show_alert=True)
         return
     
     subscription_service = SubscriptionService()
     
+    available_periods = settings.get_available_renewal_periods()
     renewal_prices = {}
-    for days in [30, 90, 180]:
-        price = await subscription_service.calculate_renewal_price(subscription, days, db)
-        renewal_prices[days] = price
+    
+    for days in available_periods:
+        try:
+            price = await subscription_service.calculate_renewal_price(subscription, days, db)
+            renewal_prices[days] = price
+        except Exception as e:
+            logger.error(f"Ошибка расчета цены для периода {days}: {e}")
+            continue
+    
+    if not renewal_prices:
+        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"
     
     await callback.message.edit_text(
-        f"⏰ <b>Продление подписки</b>\n\n"
+        f"⏰ Продление подписки\n\n"
         f"Осталось дней: {subscription.days_left}\n\n"
         f"<b>Ваша текущая конфигурация:</b>\n"
         f"🌍 Серверов: {len(subscription.connected_squads)}\n"
         f"📊 Трафик: {texts.format_traffic(subscription.traffic_limit_gb)}\n"
         f"📱 Устройств: {subscription.device_limit}\n\n"
         f"<b>Выберите период продления:</b>\n"
-        f"📅 30 дней - {texts.format_price(renewal_prices[30])}\n"
-        f"📅 90 дней - {texts.format_price(renewal_prices[90])}\n"
-        f"📅 180 дней - {texts.format_price(renewal_prices[180])}\n\n"
+        f"{prices_text.rstrip()}\n\n"
         f"💡 <i>Цена включает все ваши текущие серверы и настройки</i>",
         reply_markup=get_extend_subscription_keyboard_with_prices(db_user.language, renewal_prices),
         parse_mode="HTML"
@@ -1134,12 +1158,24 @@ async def select_period(
         )
         await state.set_state(SubscriptionStates.selecting_traffic)
     else:
-        countries = await _get_available_countries()
-        await callback.message.edit_text(
-            texts.SELECT_COUNTRIES,
-            reply_markup=get_countries_keyboard(countries, [], db_user.language)
-        )
-        await state.set_state(SubscriptionStates.selecting_countries)
+        if await _should_show_countries_management():
+            countries = await _get_available_countries()
+            await callback.message.edit_text(
+                texts.SELECT_COUNTRIES,
+                reply_markup=get_countries_keyboard(countries, [], db_user.language)
+            )
+            await state.set_state(SubscriptionStates.selecting_countries)
+        else:
+            countries = await _get_available_countries()
+            available_countries = [c for c in countries if c.get('is_available', True)]
+            data['countries'] = [available_countries[0]['uuid']] if available_countries else []
+            await state.set_data(data)
+            
+            await callback.message.edit_text(
+                texts.SELECT_DEVICES,
+                reply_markup=get_devices_keyboard(1, db_user.language)
+            )
+            await state.set_state(SubscriptionStates.selecting_devices)
     
     await callback.answer()
 
@@ -1216,7 +1252,6 @@ async def select_traffic(
     state: FSMContext,
     db_user: User
 ):
-    
     traffic_gb = int(callback.data.split('_')[1])
     texts = get_texts(db_user.language)
     
@@ -1225,14 +1260,25 @@ async def select_traffic(
     data['total_price'] += TRAFFIC_PRICES[traffic_gb]
     await state.set_data(data)
     
-    countries = await _get_available_countries()
+    if await _should_show_countries_management():
+        countries = await _get_available_countries()
+        await callback.message.edit_text(
+            texts.SELECT_COUNTRIES,
+            reply_markup=get_countries_keyboard(countries, [], db_user.language)
+        )
+        await state.set_state(SubscriptionStates.selecting_countries)
+    else:
+        countries = await _get_available_countries()
+        available_countries = [c for c in countries if c.get('is_available', True)]
+        data['countries'] = [available_countries[0]['uuid']] if available_countries else []
+        await state.set_data(data)
+        
+        await callback.message.edit_text(
+            texts.SELECT_DEVICES,
+            reply_markup=get_devices_keyboard(1, db_user.language)
+        )
+        await state.set_state(SubscriptionStates.selecting_devices)
     
-    await callback.message.edit_text(
-        texts.SELECT_COUNTRIES,
-        reply_markup=get_countries_keyboard(countries, [], db_user.language)
-    )
-    
-    await state.set_state(SubscriptionStates.selecting_countries)
     await callback.answer()
 
 
@@ -1323,7 +1369,7 @@ async def select_devices(
         if c['uuid'] in data['countries']
     )
     
-    devices_price = (devices - 1) * settings.PRICE_PER_DEVICE
+    devices_price = max(0, devices - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
     
     data['devices'] = devices
     data['total_price'] = base_price + countries_price + devices_price
@@ -1368,7 +1414,7 @@ async def devices_continue(
     else:
         traffic_price = TRAFFIC_PRICES.get(data['traffic_gb'], 0)
     
-    devices_price = (data['devices'] - 1) * settings.PRICE_PER_DEVICE
+    devices_price = max(0, data['devices'] - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
     total_price = base_price + traffic_price + countries_price + devices_price
     
     data['total_price'] = total_price
@@ -1428,7 +1474,7 @@ async def confirm_purchase(
             countries_price += country['price_kopeks']
             server_prices.append(country['price_kopeks'])
     
-    devices_price = (data['devices'] - 1) * settings.PRICE_PER_DEVICE
+    devices_price = max(0, data['devices'] - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
     
     if settings.is_traffic_fixed():
         traffic_price = TRAFFIC_PRICES.get(settings.get_fixed_traffic_limit(), 0)
@@ -1646,9 +1692,11 @@ async def handle_subscription_settings(
 Выберите что хотите изменить:
 """
     
+    show_countries = await _should_show_countries_management()
+    
     await callback.message.edit_text(
         settings_text,
-        reply_markup=get_subscription_settings_keyboard(db_user.language),
+        reply_markup=get_subscription_settings_keyboard(db_user.language, show_countries),
         parse_mode="HTML"
     )
     await callback.answer()
@@ -1837,7 +1885,7 @@ async def _get_available_countries():
                 countries.append({
                     "uuid": squad["uuid"],
                     "name": squad_name,
-                    "price_kopeks": 1000, 
+                    "price_kopeks": 0, 
                     "is_available": True
                 })
         
@@ -1968,6 +2016,15 @@ async def handle_add_country_to_subscription(
     
     await callback.answer()
 
+async def _should_show_countries_management() -> bool:
+    try:
+        countries = await _get_available_countries()
+        available_countries = [c for c in countries if c.get('is_available', True)]
+        return len(available_countries) > 1
+    except Exception as e:
+        logger.error(f"Ошибка проверки доступных серверов: {e}")
+        return True
+
 
 async def confirm_add_countries_to_subscription(
     callback: types.CallbackQuery,
@@ -2186,7 +2243,7 @@ async def handle_connect_subscription(
     subscription = db_user.subscription
     
     if not subscription or not subscription.subscription_url:
-        await callback.answer("❌ У вас нет активной подписки или ссылка еще генерируется", show_alert=True)
+        await callback.answer("⚠ У вас нет активной подписки или ссылка еще генерируется", show_alert=True)
         return
     
     connect_mode = settings.CONNECT_BUTTON_MODE
@@ -2195,13 +2252,10 @@ async def handle_connect_subscription(
         keyboard = InlineKeyboardMarkup(inline_keyboard=[
             [
                 InlineKeyboardButton(
-                    text="🔗 Открыть подписку", 
+                    text="🔗 Открыть подписку в мини-приложении", 
                     web_app=types.WebAppInfo(url=subscription.subscription_url)
                 )
             ],
-            [
-                InlineKeyboardButton(text="📋 Показать ссылку", callback_data="open_subscription_link")
-            ],
             [
                 InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
             ]
@@ -2209,9 +2263,9 @@ async def handle_connect_subscription(
         
         await callback.message.edit_text(
             f"""
-🔗 <b>Подключить подписку</b>
+📱 <b>Подключить подписку</b>
 
-📱 Нажмите кнопку ниже, чтобы открыть подписку в мини-приложении Telegram:
+🚀 Нажмите кнопку ниже, чтобы открыть подписку в мини-приложении Telegram:
             """,
             reply_markup=keyboard,
             parse_mode="HTML"
@@ -2219,7 +2273,7 @@ async def handle_connect_subscription(
         
     elif connect_mode == "miniapp_custom":
         if not settings.MINIAPP_CUSTOM_URL:
-            await callback.answer("❌ Кастомная ссылка для мини-приложения не настроена", show_alert=True)
+            await callback.answer("⚠ Кастомная ссылка для мини-приложения не настроена", show_alert=True)
             return
             
         keyboard = InlineKeyboardMarkup(inline_keyboard=[
@@ -2229,9 +2283,6 @@ async def handle_connect_subscription(
                     web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
                 )
             ],
-            [
-                InlineKeyboardButton(text="📋 Показать ссылку подписки", callback_data="open_subscription_link")
-            ],
             [
                 InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
             ]
@@ -2242,9 +2293,6 @@ async def handle_connect_subscription(
 🚀 <b>Подключить подписку</b>
 
 📱 Нажмите кнопку ниже, чтобы открыть приложение:
-
-📋 <b>Ссылка подписки:</b>
-<code>{subscription.subscription_url}</code>
             """,
             reply_markup=keyboard,
             parse_mode="HTML"

app/keyboards/admin.py

@@ -599,3 +599,11 @@ def get_maintenance_keyboard(language: str = "ru", is_active: bool = False, moni
     ]
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_sync_simplified_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = [
+        [InlineKeyboardButton(text="🔄 Полная синхронизация", callback_data="sync_all_users")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

app/keyboards/inline.py

@@ -1,4 +1,5 @@
 from typing import List, Optional
+from aiogram import types
 from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
 
 from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
@@ -107,15 +108,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([
@@ -142,27 +156,31 @@ def get_subscription_keyboard(
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
-def get_subscription_settings_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+def get_subscription_settings_keyboard(language: str = "ru", show_countries_management: bool = True) -> InlineKeyboardMarkup:
     from app.config import settings
     
     texts = get_texts(language)
-    keyboard = [
-        [
+    keyboard = []
+    
+    if show_countries_management:
+        keyboard.append([
             InlineKeyboardButton(text="🌍 Добавить страны", callback_data="subscription_add_countries")
-        ],
+        ])
+    
+    keyboard.extend([
         [
             InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices")
         ],
         [
             InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices")
         ]
-    ]
+    ])
     
     if settings.is_traffic_selectable():
-        keyboard.insert(1, [
+        keyboard.insert(-2, [
             InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic")
         ])
-        keyboard.insert(2, [
+        keyboard.insert(-2, [
             InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic")
         ])
     
@@ -187,19 +205,25 @@ def get_subscription_period_keyboard(language: str = "ru") -> InlineKeyboardMark
     texts = get_texts(language)
     keyboard = []
     
-    periods = [
-        (14, texts.PERIOD_14_DAYS),
-        (30, texts.PERIOD_30_DAYS),
-        (60, texts.PERIOD_60_DAYS),
-        (90, texts.PERIOD_90_DAYS),
-        (180, texts.PERIOD_180_DAYS),
-        (360, texts.PERIOD_360_DAYS)
-    ]
+    available_periods = settings.get_available_subscription_periods()
     
-    for days, text in periods:
-        keyboard.append([
-            InlineKeyboardButton(text=text, callback_data=f"period_{days}")
-        ])
+    period_texts = {
+        14: texts.PERIOD_14_DAYS,
+        30: texts.PERIOD_30_DAYS,
+        60: texts.PERIOD_60_DAYS,
+        90: texts.PERIOD_90_DAYS,
+        180: texts.PERIOD_180_DAYS,
+        360: texts.PERIOD_360_DAYS
+    }
+    
+    for days in available_periods:
+        if days in period_texts:
+            keyboard.append([
+                InlineKeyboardButton(
+                    text=period_texts[days], 
+                    callback_data=f"period_{days}"
+                )
+            ])
     
     keyboard.append([
         InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
@@ -281,14 +305,19 @@ 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
+    end_devices = max(start_devices + 3, 6) 
+    
+    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)
+        
         keyboard.append([
             InlineKeyboardButton(
-                text=f"{emoji} {devices} устройство{_get_device_suffix(devices)}{price_text}",
+                text=f"{emoji} {devices} {device_word}{price_text}",
                 callback_data=f"devices_{devices}"
             )
         ])
@@ -300,6 +329,13 @@ def get_devices_keyboard(current: int, language: str = "ru") -> InlineKeyboardMa
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
+def _get_device_declension(count: int) -> str:
+    if count % 10 == 1 and count % 100 != 11:
+        return "устройство"
+    elif count % 10 in [2, 3, 4] and count % 100 not in [12, 13, 14]:
+        return "устройства"
+    else:
+        return "устройств"
 
 def get_subscription_confirm_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
@@ -494,16 +530,6 @@ def get_pagination_keyboard(
     
     return keyboard
 
-
-def _get_device_suffix(count: int) -> str:
-    if count == 1:
-        return ""
-    elif 2 <= count <= 4:
-        return "а"
-    else:
-        return ""
-
-
 def get_confirmation_keyboard(
     confirm_data: str,
     cancel_data: str = "cancel",
@@ -624,9 +650,11 @@ def get_add_devices_keyboard(current_devices: int, language: str = "ru") -> Inli
         price = add_count * settings.PRICE_PER_DEVICE
         total_devices = current_devices + add_count
         
+        add_device_word = _get_device_declension(add_count)
+        
         keyboard.append([
             InlineKeyboardButton(
-                text=f"📱 +{add_count} устройство{_get_device_suffix(add_count)} (итого: {total_devices}) - {settings.format_price(price)}",
+                text=f"📱 +{add_count} {add_device_word} (итого: {total_devices}) - {settings.format_price(price)}",
                 callback_data=f"add_devices_{add_count}"
             )
         ])
@@ -869,29 +897,31 @@ def get_specific_app_keyboard(
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
-    from app.localization.texts import get_texts
     texts = get_texts(language)
+    keyboard = []
     
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(
-                text=f"📅 30 дней - {texts.format_price(prices[30])}", 
-                callback_data="extend_period_30"
-            )
-        ],
-        [
-            InlineKeyboardButton(
-                text=f"📅 90 дней - {texts.format_price(prices[90])}", 
-                callback_data="extend_period_90"
-            )
-        ],
-        [
-            InlineKeyboardButton(
-                text=f"📅 180 дней - {texts.format_price(prices[180])}", 
-                callback_data="extend_period_180"
-            )
-        ],
-        [
-            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
-        ]
+    available_periods = settings.get_available_renewal_periods()
+    
+    period_display = {
+        14: "14 дней",
+        30: "30 дней", 
+        60: "60 дней",
+        90: "90 дней",
+        180: "180 дней",
+        360: "360 дней"
+    }
+    
+    for days in available_periods:
+        if days in prices and days in period_display:
+            keyboard.append([
+                InlineKeyboardButton(
+                    text=f"📅 {period_display[days]} - {texts.format_price(prices[days])}", 
+                    callback_data=f"extend_period_{days}"
+                )
+            ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
     ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

app/middlewares/auth.py

@@ -1,4 +1,5 @@
 import logging
+from datetime import datetime
 from typing import Callable, Dict, Any, Awaitable
 from aiogram import BaseMiddleware
 from aiogram.types import Message, CallbackQuery, TelegramObject, User as TgUser
@@ -56,7 +57,7 @@ class AuthMiddleware(BaseMiddleware):
                     )
                     
                     if is_registration_process:
-                        logger.info(f"📝 Пропускаем пользователя {user.id} в процессе регистрации")
+                        logger.info(f"🔍 Пропускаем пользователя {user.id} в процессе регистрации")
                         data['db'] = db
                         data['db_user'] = None
                         data['is_admin'] = False
@@ -124,8 +125,33 @@ class AuthMiddleware(BaseMiddleware):
                             logger.info(f"❌ Удаленный пользователь {user.id} попытался использовать бота без /start")
                             return
                     
-                    from datetime import datetime
+                    
+                    profile_updated = False
+                    
+                    if db_user.username != user.username:
+                        old_username = db_user.username
+                        db_user.username = user.username
+                        logger.info(f"📝 [Middleware] Username обновлен для {user.id}: '{old_username}' → '{db_user.username}'")
+                        profile_updated = True
+                    
+                    if db_user.first_name != user.first_name:
+                        old_first_name = db_user.first_name
+                        db_user.first_name = user.first_name
+                        logger.info(f"📝 [Middleware] Имя обновлено для {user.id}: '{old_first_name}' → '{db_user.first_name}'")
+                        profile_updated = True
+                    
+                    if db_user.last_name != user.last_name:
+                        old_last_name = db_user.last_name
+                        db_user.last_name = user.last_name
+                        logger.info(f"📝 [Middleware] Фамилия обновлена для {user.id}: '{old_last_name}' → '{db_user.last_name}'")
+                        profile_updated = True
+                    
                     db_user.last_activity = datetime.utcnow()
+                    
+                    if profile_updated:
+                        db_user.updated_at = datetime.utcnow()
+                        logger.info(f"💾 [Middleware] Профиль пользователя {user.id} обновлен в middleware")
+                    
                     await db.commit()
 
                 data['db'] = db

app/services/maintenance_service.py

@@ -28,8 +28,15 @@ class MaintenanceService:
         self._status = MaintenanceStatus(is_active=False)
         self._check_task: Optional[asyncio.Task] = None
         self._is_checking = False
-        self._max_consecutive_failures = 3 
+        self._max_consecutive_failures = 3
+        self._bot = None 
+        self._last_notification_sent = None 
         
+    def set_bot(self, bot):
+        """Устанавливает ссылку на бота для отправки уведомлений"""
+        self._bot = bot
+        logger.info("Бот установлен для maintenance_service")
+    
     @property
     def status(self) -> MaintenanceStatus:
         return self._status
@@ -51,6 +58,51 @@ class MaintenanceService:
         else:
             return settings.get_maintenance_message()
     
+    async def _notify_admins(self, message: str, alert_type: str = "info"):
+        """Отправка уведомлений администраторам"""
+        if not self._bot:
+            logger.warning("Бот не установлен, уведомления не могут быть отправлены")
+            return
+        
+        cache_key = f"maintenance_notification_{alert_type}"
+        if await cache.get(cache_key):
+            return
+        
+        admin_ids = settings.get_admin_ids()
+        if not admin_ids:
+            logger.warning("Список администраторов пуст")
+            return
+        
+        emoji_map = {
+            "error": "🚨",
+            "warning": "⚠️", 
+            "success": "✅",
+            "info": "ℹ️"
+        }
+        emoji = emoji_map.get(alert_type, "ℹ️")
+        
+        formatted_message = f"{emoji} <b>Maintenance Service</b>\n\n{message}"
+        
+        success_count = 0
+        for admin_id in admin_ids:
+            try:
+                await self._bot.send_message(
+                    chat_id=admin_id,
+                    text=formatted_message,
+                    parse_mode="HTML"
+                )
+                success_count += 1
+                await asyncio.sleep(0.1) 
+                
+            except Exception as e:
+                logger.error(f"Ошибка отправки уведомления админу {admin_id}: {e}")
+        
+        if success_count > 0:
+            logger.info(f"Уведомление отправлено {success_count} администраторам")
+            await cache.set(cache_key, True, expire=300)
+        else:
+            logger.error("Не удалось отправить уведомления ни одному администратору")
+    
     async def enable_maintenance(self, reason: Optional[str] = None, auto: bool = False) -> bool:
         try:
             if self._status.is_active:
@@ -64,6 +116,18 @@ class MaintenanceService:
             
             await self._save_status_to_cache()
             
+            notification_msg = f"""
+Режим технических работ ВКЛЮЧЕН
+
+📋 <b>Причина:</b> {self._status.reason}
+🤖 <b>Автоматически:</b> {'Да' if auto else 'Нет'}
+🕐 <b>Время:</b> {self._status.enabled_at.strftime('%d.%m.%Y %H:%M:%S')}
+
+Обычные пользователи временно не смогут использовать бота.
+"""
+            
+            await self._notify_admins(notification_msg, "warning" if auto else "info")
+            
             logger.warning(f"🔧 Режим техработ ВКЛЮЧЕН. Причина: {self._status.reason}")
             return True
             
@@ -77,6 +141,11 @@ class MaintenanceService:
                 logger.info("Режим техработ уже выключен")
                 return True
             
+            was_auto = self._status.auto_enabled
+            duration = None
+            if self._status.enabled_at:
+                duration = datetime.utcnow() - self._status.enabled_at
+            
             self._status.is_active = False
             self._status.enabled_at = None
             self._status.reason = None
@@ -85,6 +154,27 @@ class MaintenanceService:
             
             await self._save_status_to_cache()
             
+            duration_str = ""
+            if duration:
+                hours = int(duration.total_seconds() // 3600)
+                minutes = int((duration.total_seconds() % 3600) // 60)
+                if hours > 0:
+                    duration_str = f"\n⏱️ <b>Длительность:</b> {hours}ч {minutes}мин"
+                else:
+                    duration_str = f"\n⏱️ <b>Длительность:</b> {minutes}мин"
+            
+            notification_msg = f"""
+Режим технических работ ВЫКЛЮЧЕН
+
+🤖 <b>Автоматически:</b> {'Да' if was_auto else 'Нет'}
+🕐 <b>Время:</b> {datetime.utcnow().strftime('%d.%m.%Y %H:%M:%S')}
+{duration_str}
+
+Сервис снова доступен для пользователей.
+"""
+            
+            await self._notify_admins(notification_msg, "success")
+            
             logger.info("✅ Режим техработ ВЫКЛЮЧЕН")
             return True
             
@@ -102,6 +192,17 @@ class MaintenanceService:
             
             self._check_task = asyncio.create_task(self._monitoring_loop())
             logger.info(f"🔄 Запущен мониторинг API RemnaWave (интервал: {settings.get_maintenance_check_interval()}с)")
+            
+            await self._notify_admins(f"""
+Мониторинг технических работ запущен
+
+🔄 <b>Интервал проверки:</b> {settings.get_maintenance_check_interval()} секунд
+🤖 <b>Автовключение:</b> {'Включено' if settings.is_maintenance_auto_enable() else 'Отключено'}
+🎯 <b>Порог ошибок:</b> {self._max_consecutive_failures}
+
+Система будет следить за доступностью API.
+""", "info")
+            
             return True
             
         except Exception as e:
@@ -117,7 +218,8 @@ class MaintenanceService:
                 except asyncio.CancelledError:
                     pass
             
-            logger.info("⏹️ Мониторинг API остановлен")
+            await self._notify_admins("Мониторинг технических работ остановлен", "info")
+            logger.info("ℹ️ Мониторинг API остановлен")
             return True
             
         except Exception as e:
@@ -138,6 +240,18 @@ class MaintenanceService:
                 is_connected = await test_api_connection(api)
                 
                 if is_connected:
+                    # API восстановилось
+                    if not self._status.api_status:
+                        await self._notify_admins(f"""
+API RemnaWave восстановлено!
+
+✅ <b>Статус:</b> Доступно
+🕐 <b>Время восстановления:</b> {self._status.last_check.strftime('%H:%M:%S')}
+🔄 <b>Неудачных попыток было:</b> {self._status.consecutive_failures}
+
+API снова отвечает на запросы.
+""", "success")
+                    
                     self._status.api_status = True
                     self._status.consecutive_failures = 0
                     
@@ -147,9 +261,21 @@ class MaintenanceService:
                     
                     return True
                 else:
+                    was_available = self._status.api_status
                     self._status.api_status = False
                     self._status.consecutive_failures += 1
                     
+                    if was_available:
+                        await self._notify_admins(f"""
+API RemnaWave недоступно!
+
+❌ <b>Статус:</b> Недоступно
+🕐 <b>Время обнаружения:</b> {self._status.last_check.strftime('%H:%M:%S')}
+🔄 <b>Попытка:</b> {self._status.consecutive_failures}
+
+Началась серия неудачных проверок API.
+""", "error")
+                    
                     if (self._status.consecutive_failures >= self._max_consecutive_failures and
                         not self._status.is_active and
                         settings.is_maintenance_auto_enable()):
@@ -163,6 +289,17 @@ class MaintenanceService:
                     
         except Exception as e:
             logger.error(f"Ошибка проверки API: {e}")
+            
+            if self._status.api_status:
+                await self._notify_admins(f"""
+Ошибка при проверке API RemnaWave
+
+❌ <b>Ошибка:</b> {str(e)}
+🕐 <b>Время:</b> {datetime.utcnow().strftime('%H:%M:%S')}
+
+Не удалось выполнить проверку доступности API.
+""", "error")
+            
             self._status.api_status = False
             self._status.consecutive_failures += 1
             return False
@@ -216,7 +353,7 @@ class MaintenanceService:
             if status_data.get("last_check"):
                 self._status.last_check = datetime.fromisoformat(status_data["last_check"])
             
-            logger.info(f"📥 Состояние техработ загружено из кеша: активен={self._status.is_active}")
+            logger.info(f"🔥 Состояние техработ загружено из кеша: активен={self._status.is_active}")
             
         except Exception as e:
             logger.error(f"Ошибка загрузки состояния из кеша: {e}")
@@ -232,7 +369,8 @@ class MaintenanceService:
             "consecutive_failures": self._status.consecutive_failures,
             "monitoring_active": self._check_task is not None and not self._check_task.done(),
             "auto_enable_configured": settings.is_maintenance_auto_enable(),
-            "check_interval": settings.get_maintenance_check_interval()
+            "check_interval": settings.get_maintenance_check_interval(),
+            "bot_connected": self._bot is not None
         }
     
     async def force_api_check(self) -> Dict[str, Any]:

app/services/payment_service.py

@@ -11,7 +11,7 @@ from app.config import settings
 from app.services.yookassa_service import YooKassaService
 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
+from app.database.crud.user import add_user_balance, get_user_by_id
 from app.database.models import TransactionType, PaymentMethod
 
 logger = logging.getLogger(__name__)
@@ -186,22 +186,27 @@ class PaymentService:
                     db, yookassa_payment_id, transaction.id
                 )
                 
-                from app.database.crud.user import add_user_balance
-                await add_user_balance(db, updated_payment.user_id, updated_payment.amount_kopeks)
-                
-                if self.bot:
-                    try:
-                        await self.bot.send_message(
-                            updated_payment.user.telegram_id,
-                            f"✅ <b>Пополнение успешно!</b>\n\n"
-                            f"💰 Сумма: {settings.format_price(updated_payment.amount_kopeks)}\n"
-                            f"🏦 Способ: Банковская карта\n"
-                            f"🆔 Транзакция: {yookassa_payment_id[:8]}...\n\n"
-                            f"Баланс пополнен автоматически!",
-                            parse_mode="HTML"
-                        )
-                    except Exception as e:
-                        logger.error(f"Ошибка отправки уведомления о пополнении: {e}")
+                user = await get_user_by_id(db, updated_payment.user_id)
+                if user:
+                    await add_user_balance(db, user, updated_payment.amount_kopeks, f"Пополнение YooKassa: {updated_payment.amount_kopeks/100:.2f}₽")
+                    
+                    if self.bot:
+                        try:
+                            await self.bot.send_message(
+                                user.telegram_id,
+                                f"✅ <b>Пополнение успешно!</b>\n\n"
+                                f"💰 Сумма: {settings.format_price(updated_payment.amount_kopeks)}\n"
+                                f"🏦 Способ: Банковская карта\n"
+                                f"🆔 Транзакция: {yookassa_payment_id[:8]}...\n\n"
+                                f"Баланс пополнен автоматически!",
+                                parse_mode="HTML"
+                            )
+                            logger.info(f"✅ Отправлено уведомление пользователю {user.telegram_id} о пополнении на {updated_payment.amount_kopeks/100:.2f}₽")
+                        except Exception as e:
+                            logger.error(f"Ошибка отправки уведомления о пополнении: {e}")
+                else:
+                    logger.error(f"Пользователь с ID {updated_payment.user_id} не найден при пополнении баланса")
+                    return False
             
             return True
             
@@ -233,15 +238,17 @@ class PaymentService:
                 transaction_id=transaction.id
             )
             
-            await add_user_balance(db, payment.user_id, payment.amount_kopeks)
+            user = await get_user_by_id(db, payment.user_id)
+            if user:
+                await add_user_balance(db, user, payment.amount_kopeks, f"Пополнение YooKassa: {payment.amount_kopeks/100:.2f}₽")
             
             logger.info(f"Успешно обработан платеж YooKassa {payment.yookassa_payment_id}: "
                        f"пользователь {payment.user_id} получил {payment.amount_kopeks/100}₽")
             
-            if self.bot:
+            if self.bot and user:
                 try:
                     await self._send_payment_success_notification(
-                        payment.user.telegram_id, 
+                        user.telegram_id, 
                         payment.amount_kopeks
                     )
                 except Exception as e:

app/services/referral_service.py

@@ -20,7 +20,7 @@ async def process_referral_registration(
         referrer = await get_user_by_id(db, referrer_id)
         
         if not new_user or not referrer:
-            logger.error(f"Пользователи не найдены: {new_user_id}, {referrer_id}")
+            logger.error(f"Пользователи не найдены: new_user_id={new_user_id}, referrer_id={referrer_id}")
             return False
         
         if new_user.referred_by_id != referrer_id:
@@ -81,9 +81,13 @@ async def process_referral_purchase(
         
         logger.info(f"🔍 Покупка реферала {user_id}: первая = {is_first_purchase}, сумма = {purchase_amount_kopeks/100}₽")
         
-        if is_first_purchase:
+        if is_first_purchase and settings.REFERRAL_REGISTRATION_REWARD > 0:
             reward_amount = settings.REFERRAL_REGISTRATION_REWARD
             
+            if reward_amount > 1000000: 
+                logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: reward_amount = {reward_amount} слишком большой! Проверьте настройки REFERRAL_REGISTRATION_REWARD")
+                reward_amount = 10000 
+            
             await add_user_balance(
                 db, referrer, reward_amount,
                 f"Реферальная награда за первую покупку {user.full_name}"
@@ -100,12 +104,18 @@ async def process_referral_purchase(
             
             logger.info(f"🎉 Первая покупка реферала: {referrer.telegram_id} получил {reward_amount/100}₽")
         
-        commission_amount = int(purchase_amount_kopeks * settings.REFERRAL_COMMISSION_PERCENT / 100)
+        if not (0 <= settings.REFERRAL_COMMISSION_PERCENT <= 100):
+            logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: REFERRAL_COMMISSION_PERCENT = {settings.REFERRAL_COMMISSION_PERCENT} некорректный! Должен быть от 0 до 100")
+            commission_percent = 10 
+        else:
+            commission_percent = settings.REFERRAL_COMMISSION_PERCENT
+            
+        commission_amount = int(purchase_amount_kopeks * commission_percent / 100)
         
         if commission_amount > 0:
             await add_user_balance(
                 db, referrer, commission_amount,
-                f"Комиссия {settings.REFERRAL_COMMISSION_PERCENT}% с покупки {user.full_name}"
+                f"Комиссия {commission_percent}% с покупки {user.full_name}"
             )
             
             await create_referral_earning(
@@ -128,6 +138,8 @@ async def process_referral_purchase(
         
     except Exception as e:
         logger.error(f"Ошибка обработки покупки реферала: {e}")
+        import traceback
+        logger.error(f"Полный traceback: {traceback.format_exc()}")
         return False
 
 
@@ -141,7 +153,7 @@ async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
         invited_count_result = await db.execute(
             select(func.count(User.id)).where(User.referred_by_id == user_id)
         )
-        invited_count = invited_count_result.scalar()
+        invited_count = invited_count_result.scalar() or 0
         
         paid_referrals_result = await db.execute(
             select(func.count(User.id)).where(
@@ -149,13 +161,13 @@ async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
                 User.has_had_paid_subscription == True
             )
         )
-        paid_referrals_count = paid_referrals_result.scalar()
+        paid_referrals_count = paid_referrals_result.scalar() or 0
         
-        total_earned = await get_referral_earnings_sum(db, user_id)
+        total_earned = await get_referral_earnings_sum(db, user_id) or 0
         
         from datetime import datetime, timedelta
         month_ago = datetime.utcnow() - timedelta(days=30)
-        month_earned = await get_referral_earnings_sum(db, user_id, start_date=month_ago)
+        month_earned = await get_referral_earnings_sum(db, user_id, start_date=month_ago) or 0
         
         return {
             "invited_count": invited_count,
@@ -171,4 +183,4 @@ async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
             "paid_referrals_count": 0,
             "total_earned_kopeks": 0,
             "month_earned_kopeks": 0
-        }
+        }

app/services/remnawave_service.py

@@ -2,6 +2,8 @@ import logging
 from typing import Dict, List, Any, Optional
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import delete
+from datetime import datetime, timedelta
+import re
 
 from app.config import settings
 from app.external.remnawave_api import (
@@ -23,8 +25,37 @@ class RemnaWaveService:
     def __init__(self):
         self.api = RemnaWaveAPI(
             base_url=settings.REMNAWAVE_API_URL,
-            api_key=settings.REMNAWAVE_API_KEY
+            api_key=settings.REMNAWAVE_API_KEY,
+            secret_key=settings.REMNAWAVE_SECRET_KEY
         )
+
+    def _parse_remnawave_date(self, date_str: str) -> datetime:
+        if not date_str:
+            return datetime.utcnow() + timedelta(days=30)
+        
+        try:
+            
+            cleaned_date = date_str.strip()
+            
+            if cleaned_date.endswith('Z'):
+                cleaned_date = cleaned_date[:-1] + '+00:00'
+            
+            if '+00:00+00:00' in cleaned_date:
+                cleaned_date = cleaned_date.replace('+00:00+00:00', '+00:00')
+            
+            cleaned_date = re.sub(r'(\+\d{2}:\d{2})\+\d{2}:\d{2}$', r'\1', cleaned_date)
+            
+            parsed_date = datetime.fromisoformat(cleaned_date)
+            
+            if parsed_date.tzinfo is not None:
+                parsed_date = parsed_date.replace(tzinfo=None)
+            
+            logger.debug(f"Успешно распарсена дата: {date_str} -> {parsed_date}")
+            return parsed_date
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Не удалось распарсить дату '{date_str}': {e}. Используем дефолтную дату.")
+            return datetime.utcnow() + timedelta(days=30)
     
     async def get_system_statistics(self) -> Dict[str, Any]:
             try:
@@ -58,7 +89,6 @@ class RemnaWaveService:
                         logger.error(f"Ошибка получения статистики нод: {e}")
                         nodes_stats = {}
                 
-                    from datetime import datetime
                 
                     total_download = sum(node.get('downloadBytes', 0) for node in realtime_usage)
                     total_upload = sum(node.get('uploadBytes', 0) for node in realtime_usage)
@@ -199,7 +229,6 @@ class RemnaWaveService:
                     'GBPS': 1024 ** 3
                 }
             
-                import re
                 match = re.match(r'([0-9.,]+)([A-Z]+)', bandwidth_str)
                 if match:
                     value_str = match.group(1).replace(',', '.') 
@@ -397,212 +426,185 @@ class RemnaWaveService:
     async def sync_users_from_panel(self, db: AsyncSession, sync_type: str = "all") -> Dict[str, int]:
         try:
             stats = {"created": 0, "updated": 0, "errors": 0, "deleted": 0}
-        
-            logger.info(f"🔄 Начинаем синхронизацию типа: {sync_type}")
-        
-            async with self.api as api:
-                panel_users_data = await api._make_request('GET', '/api/users')
-                panel_users = panel_users_data['response']['users']
             
-                logger.info(f"👥 Найдено пользователей в панели: {len(panel_users)}")
+            logger.info(f"🔄 Начинаем синхронизацию типа: {sync_type}")
+            
+            async with self.api as api:
+                panel_users = []
+                start = 0
+                size = 100 
                 
-                bot_users = await get_users_list(db, offset=0, limit=10000)
-                bot_users_by_telegram_id = {user.telegram_id: user for user in bot_users}
-                
-                panel_telegram_ids = set()
-                
-                for i, panel_user in enumerate(panel_users):
-                    try:
-                        telegram_id = panel_user.get('telegramId')
-                        if not telegram_id:
-                            logger.debug(f"➡️ Пропускаем пользователя без telegram_id")
-                            continue
-                        
-                        panel_telegram_ids.add(telegram_id)
-                        
-                        logger.info(f"🔄 Обрабатываем пользователя {i+1}/{len(panel_users)}: {telegram_id}")
+                while True:
+                    logger.info(f"📥 Загружаем пользователей: start={start}, size={size}")
                     
-                        db_user = bot_users_by_telegram_id.get(telegram_id)
+                    response = await api.get_all_users(start=start, size=size)
+                    users_batch = response['users']
+                    total_users = response['total']
                     
-                        if not db_user:
-                            if sync_type in ["new_only", "all"]:
-                                logger.info(f"🆕 Создание пользователя для telegram_id {telegram_id}")
-                                
-                                from app.database.crud.user import create_user
+                    logger.info(f"📊 Получено {len(users_batch)} пользователей из {total_users}")
+                    
+                    for user_obj in users_batch:
+                        user_dict = {
+                            'uuid': user_obj.uuid,
+                            'shortUuid': user_obj.short_uuid,
+                            'username': user_obj.username,
+                            'status': user_obj.status.value,
+                            'telegramId': user_obj.telegram_id,
+                            'expireAt': user_obj.expire_at.isoformat() + 'Z',
+                            'trafficLimitBytes': user_obj.traffic_limit_bytes,
+                            'usedTrafficBytes': user_obj.used_traffic_bytes,
+                            'hwidDeviceLimit': user_obj.hwid_device_limit,
+                            'subscriptionUrl': user_obj.subscription_url,
+                            'activeInternalSquads': user_obj.active_internal_squads
+                        }
+                        panel_users.append(user_dict)
+                    
+                    if len(users_batch) < size:
+                        break
+                        
+                    start += size
+                    
+                    if start > total_users:
+                        break
+                
+                logger.info(f"✅ Всего загружено пользователей из панели: {len(panel_users)}")
+            
+            bot_users = await get_users_list(db, offset=0, limit=10000)
+            bot_users_by_telegram_id = {user.telegram_id: user for user in bot_users}
+            
+            logger.info(f"📊 Пользователей в боте: {len(bot_users)}")
+            
+            panel_users_with_tg = [
+                user for user in panel_users 
+                if user.get('telegramId') is not None
+            ]
+            
+            logger.info(f"📊 Пользователей в панели с Telegram ID: {len(panel_users_with_tg)}")
+            
+            panel_telegram_ids = set()
+            
+            for i, panel_user in enumerate(panel_users_with_tg):
+                try:
+                    telegram_id = panel_user.get('telegramId')
+                    if not telegram_id:
+                        continue
+                    
+                    panel_telegram_ids.add(telegram_id)
+                    
+                    if (i + 1) % 10 == 0: 
+                        logger.info(f"🔄 Обрабатываем пользователя {i+1}/{len(panel_users_with_tg)}: {telegram_id}")
+                    
+                    db_user = bot_users_by_telegram_id.get(telegram_id)
+                    
+                    if not db_user:
+                        if sync_type in ["new_only", "all"]:
+                            logger.info(f"🆕 Создание пользователя для telegram_id {telegram_id}")
                             
-                                db_user = await create_user(
-                                    db=db,
-                                    telegram_id=telegram_id,
-                                    username=panel_user.get('username') or f"user_{telegram_id}",
-                                    first_name=f"Panel User {telegram_id}",
-                                    language="ru"
-                                )
+                            from app.database.crud.user import create_user
                             
+                            db_user = await create_user(
+                                db=db,
+                                telegram_id=telegram_id,
+                                username=panel_user.get('username') or f"user_{telegram_id}",
+                                first_name=f"Panel User {telegram_id}",
+                                language="ru"
+                            )
+                            
+                            await update_user(db, db_user, remnawave_uuid=panel_user.get('uuid'))
+                            
+                            await self._create_subscription_from_panel_data(db, db_user, panel_user)
+                            
+                            stats["created"] += 1
+                            logger.info(f"✅ Создан пользователь {telegram_id} с подпиской")
+                    
+                    else:
+                        if sync_type in ["update_only", "all"]:
+                            logger.debug(f"🔄 Обновление пользователя {telegram_id}")
+                            
+                            if not db_user.remnawave_uuid:
                                 await update_user(db, db_user, remnawave_uuid=panel_user.get('uuid'))
                             
-                                await self._create_subscription_from_panel_data(db, db_user, panel_user)
+                            await self._update_subscription_from_panel_data(db, db_user, panel_user)
                             
-                                stats["created"] += 1
-                                logger.info(f"✅ Создан пользователь {telegram_id} с подпиской")
+                            stats["updated"] += 1
+                            logger.debug(f"✅ Обновлён пользователь {telegram_id}")
                             
-                        else:
-                            if sync_type in ["update_only", "all"]:
-                                logger.debug(f"🔄 Обновление пользователя {telegram_id}")
-                            
-                                if not db_user.remnawave_uuid:
-                                    await update_user(db, db_user, remnawave_uuid=panel_user.get('uuid'))
-                            
-                                await self._update_subscription_from_panel_data(db, db_user, panel_user)
-                            
-                                stats["updated"] += 1
-                                logger.debug(f"✅ Обновлён пользователь {telegram_id}")
-                            
-                    except Exception as user_error:
-                        logger.error(f"❌ Ошибка обработки пользователя {telegram_id}: {user_error}")
-                        stats["errors"] += 1
-                        continue
+                except Exception as user_error:
+                    logger.error(f"❌ Ошибка обработки пользователя {telegram_id}: {user_error}")
+                    stats["errors"] += 1
+                    continue
+            
+            if sync_type == "all":
+                logger.info("🗑️ Деактивация подписок пользователей, отсутствующих в панели...")
                 
-                if sync_type == "all":
-                    logger.info("🗑️ ПОЛНАЯ очистка подписок пользователей, отсутствующих в панели...")
-                    
-                    for telegram_id, db_user in bot_users_by_telegram_id.items():
-                        if telegram_id not in panel_telegram_ids and db_user.subscription:
-                            try:
-                                logger.info(f"🗑️ ПОЛНАЯ очистка данных подписки пользователя {telegram_id} (нет в панели)")
-                                
-                                subscription = db_user.subscription
-                                
-                                if db_user.remnawave_uuid:
-                                    try:
+                for telegram_id, db_user in bot_users_by_telegram_id.items():
+                    if telegram_id not in panel_telegram_ids and db_user.subscription:
+                        try:
+                            logger.info(f"🗑️ Деактивация подписки пользователя {telegram_id} (нет в панели)")
+                            
+                            subscription = db_user.subscription
+                            
+                            if db_user.remnawave_uuid:
+                                try:
+                                    async with self.api as api:
                                         devices_reset = await api.reset_user_devices(db_user.remnawave_uuid)
                                         if devices_reset:
                                             logger.info(f"🔧 Сброшены HWID устройства для пользователя {telegram_id}")
-                                        else:
-                                            logger.warning(f"⚠️ Не удалось сбросить HWID устройства для пользователя {telegram_id}")
-                                    except Exception as hwid_error:
-                                        logger.error(f"❌ Ошибка сброса HWID устройств для {telegram_id}: {hwid_error}")
+                                except Exception as hwid_error:
+                                    logger.error(f"❌ Ошибка сброса HWID устройств для {telegram_id}: {hwid_error}")
+                            
+                            try:
+                                from sqlalchemy import delete
+                                from app.database.models import SubscriptionServer
                                 
-                                try:
-                                    from app.database.crud.subscription import get_subscription_server_ids, remove_subscription_servers
-                                    from sqlalchemy import delete
-                                    from app.database.models import SubscriptionServer
-                                    
-                                    await db.execute(
-                                        delete(SubscriptionServer).where(
-                                            SubscriptionServer.subscription_id == subscription.id
-                                        )
+                                await db.execute(
+                                    delete(SubscriptionServer).where(
+                                        SubscriptionServer.subscription_id == subscription.id
                                     )
-                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ записи SubscriptionServer для подписки {subscription.id}")
-                                    
-                                except Exception as servers_error:
-                                    logger.warning(f"⚠️ Не удалось удалить серверы подписки: {servers_error}")
-                                
-                                try:
-                                    from sqlalchemy import delete
-                                    from app.database.models import Transaction
-                                    
-                                    await db.execute(
-                                        delete(Transaction).where(Transaction.user_id == db_user.id)
-                                    )
-                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ транзакции пользователя {telegram_id}")
-                                    
-                                except Exception as transactions_error:
-                                    logger.warning(f"⚠️ Не удалось удалить транзакции: {transactions_error}")
-                                
-                                try:
-                                    from sqlalchemy import delete
-                                    from app.database.models import ReferralEarning
-                                    
-                                    await db.execute(
-                                        delete(ReferralEarning).where(ReferralEarning.user_id == db_user.id)
-                                    )
-                                    await db.execute(
-                                        delete(ReferralEarning).where(ReferralEarning.referral_id == db_user.id)
-                                    )
-                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ реферальные доходы пользователя {telegram_id}")
-                                    
-                                except Exception as referral_error:
-                                    logger.warning(f"⚠️ Не удалось удалить реферальные доходы: {referral_error}")
-                                
-                                try:
-                                    from sqlalchemy import delete
-                                    from app.database.models import PromoCodeUse
-                                    
-                                    await db.execute(
-                                        delete(PromoCodeUse).where(PromoCodeUse.user_id == db_user.id)
-                                    )
-                                    logger.info(f"🗑️ УДАЛЕНЫ ВСЕ использования промокодов пользователя {telegram_id}")
-                                    
-                                except Exception as promo_error:
-                                    logger.warning(f"⚠️ Не удалось удалить использования промокодов: {promo_error}")
-                                
-                                try:
-                                    db_user.balance_kopeks = 0
-                                    logger.info(f"💰 Сброшен баланс пользователя {telegram_id}")
-                                except Exception as balance_error:
-                                    logger.warning(f"⚠️ Не удалось сбросить баланс: {balance_error}")
-                                
-                                from app.database.models import SubscriptionStatus
-                                from datetime import datetime
-                                
-                                subscription.status = SubscriptionStatus.DISABLED.value
-                                subscription.is_trial = True 
-                                subscription.end_date = datetime.utcnow()
-                                subscription.traffic_limit_gb = 0
-                                subscription.traffic_used_gb = 0.0
-                                subscription.device_limit = 1
-                                subscription.connected_squads = []
-                                subscription.autopay_enabled = False
-                                subscription.autopay_days_before = 3
-                                subscription.remnawave_short_uuid = None
-                                subscription.subscription_url = ""
-                                
-                                db_user.remnawave_uuid = None
-                                db_user.has_had_paid_subscription = False 
-                                db_user.used_promocodes = 0 
-                                
-                                await db.commit()
-                                
-                                stats["deleted"] += 1
-                                logger.info(f"✅ ПОЛНОСТЬЮ очищены ВСЕ данные подписки пользователя {telegram_id}")
-                                
-                            except Exception as delete_error:
-                                logger.error(f"❌ Ошибка полной очистки данных подписки {telegram_id}: {delete_error}")
-                                stats["errors"] += 1
-                                await db.rollback()
-        
-            logger.info(f"🎯 Синхронизация завершена: создано {stats['created']}, обновлено {stats['updated']}, удалено {stats['deleted']}, ошибок {stats['errors']}")
+                                )
+                                logger.info(f"🗑️ Удалены серверы подписки для {telegram_id}")
+                            except Exception as servers_error:
+                                logger.warning(f"⚠️ Не удалось удалить серверы подписки: {servers_error}")
+                            
+                            from app.database.models import SubscriptionStatus
+                            
+                            subscription.status = SubscriptionStatus.DISABLED.value
+                            subscription.is_trial = True 
+                            subscription.end_date = datetime.utcnow()
+                            subscription.traffic_limit_gb = 0
+                            subscription.traffic_used_gb = 0.0
+                            subscription.device_limit = 1
+                            subscription.connected_squads = []
+                            subscription.autopay_enabled = False
+                            subscription.remnawave_short_uuid = None
+                            subscription.subscription_url = ""
+                            
+                            db_user.remnawave_uuid = None
+                            
+                            await db.commit()
+                            
+                            stats["deleted"] += 1
+                            logger.info(f"✅ Деактивирована подписка пользователя {telegram_id} (сохранен баланс)")
+                            
+                        except Exception as delete_error:
+                            logger.error(f"❌ Ошибка деактивации подписки {telegram_id}: {delete_error}")
+                            stats["errors"] += 1
+                            await db.rollback()
+            
+            logger.info(f"🎯 Синхронизация завершена: создано {stats['created']}, обновлено {stats['updated']}, деактивировано {stats['deleted']}, ошибок {stats['errors']}")
             return stats
         
         except Exception as e:
             logger.error(f"❌ Критическая ошибка синхронизации пользователей: {e}")
             return {"created": 0, "updated": 0, "errors": 1, "deleted": 0}
 
-
-
     async def _create_subscription_from_panel_data(self, db: AsyncSession, user, panel_user):
         try:
             from app.database.crud.subscription import create_subscription
             from app.database.models import SubscriptionStatus
-            from datetime import datetime, timedelta
-            import pytz
         
             expire_at_str = panel_user.get('expireAt', '')
-            try:
-                if expire_at_str:
-                    if expire_at_str.endswith('Z'):
-                        expire_at_str = expire_at_str[:-1] + '+00:00'
-                
-                    expire_at = datetime.fromisoformat(expire_at_str)
-                
-                    if expire_at.tzinfo is not None:
-                        expire_at = expire_at.replace(tzinfo=None)
-                    
-                else:
-                    expire_at = datetime.utcnow() + timedelta(days=30)
-            except Exception as date_error:
-                logger.warning(f"⚠️ Ошибка парсинга даты {expire_at_str}: {date_error}")
-                expire_at = datetime.utcnow() + timedelta(days=30)
+            expire_at = self._parse_remnawave_date(expire_at_str)
         
             panel_status = panel_user.get('status', 'ACTIVE')
             current_time = datetime.utcnow()
@@ -672,7 +674,6 @@ class RemnaWaveService:
         try:
             from app.database.crud.subscription import get_subscription_by_user_id
             from app.database.models import SubscriptionStatus
-            from datetime import datetime, timedelta
         
             subscription = await get_subscription_by_user_id(db, user.id)
             
@@ -683,19 +684,12 @@ class RemnaWaveService:
             panel_status = panel_user.get('status', 'ACTIVE')
             expire_at_str = panel_user.get('expireAt', '')
             
-            try:
-                if expire_at_str:
-                    if expire_at_str.endswith('Z'):
-                        expire_at_str = expire_at_str[:-1] + '+00:00'
-                    expire_at = datetime.fromisoformat(expire_at_str)
-                    if expire_at.tzinfo is not None:
-                        expire_at = expire_at.replace(tzinfo=None)
-                    
-                    if abs((subscription.end_date - expire_at).total_seconds()) > 60: 
-                        subscription.end_date = expire_at
-                        logger.debug(f"Обновлена дата окончания подписки до {expire_at}")
-            except Exception as date_error:
-                logger.warning(f"⚠️ Ошибка парсинга даты при обновлении {expire_at_str}: {date_error}")
+            if expire_at_str:
+                expire_at = self._parse_remnawave_date(expire_at_str)
+                
+                if abs((subscription.end_date - expire_at).total_seconds()) > 60: 
+                    subscription.end_date = expire_at
+                    logger.debug(f"Обновлена дата окончания подписки до {expire_at}")
             
             current_time = datetime.utcnow()
             if panel_status == 'ACTIVE' and subscription.end_date > current_time:
@@ -1001,7 +995,6 @@ class RemnaWaveService:
                     node_realtime = stats
                     break
             
-            from datetime import datetime, timedelta
             end_date = datetime.now()
             start_date = end_date - timedelta(days=7)
             
@@ -1089,7 +1082,6 @@ class RemnaWaveService:
                 logger.error(f"❌ Ошибка удаления связанных записей: {records_error}")
             
             try:
-                from datetime import datetime
                 
                 user.balance_kopeks = 0
                 user.remnawave_uuid = None
@@ -1213,7 +1205,6 @@ class RemnaWaveService:
         
             from app.database.crud.subscription import get_all_subscriptions
             from app.database.models import SubscriptionStatus
-            from datetime import datetime
         
             page = 1
             limit = 100
@@ -1266,7 +1257,6 @@ class RemnaWaveService:
             
             from app.database.crud.subscription import get_all_subscriptions
             from app.database.models import SubscriptionStatus
-            from datetime import datetime
         
             page = 1
             limit = 100

app/services/subscription_service.py

@@ -249,7 +249,7 @@ class SubscriptionService:
                 server_prices.append(0)
                 logger.warning(f"⚠️ Сервер ID {server_id} недоступен")
 
-        devices_price = max(0, devices - 1) * settings.PRICE_PER_DEVICE
+        devices_price = max(0, devices - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
         
         total_price = base_price + traffic_price + total_servers_price + devices_price
         
@@ -277,7 +277,7 @@ 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)
             
@@ -364,7 +364,7 @@ class SubscriptionService:
                     prices_list.append(price)
                     logger.debug(f"🏷️ Страна {server.display_name}: {price/100}₽")
                 else:
-                    default_price = 1000  
+                    default_price = 0  
                     total_price += default_price
                     prices_list.append(default_price)
                     logger.warning(f"⚠️ Сервер {country_uuid} недоступен, используем базовую цену: {default_price/100}₽")
@@ -374,7 +374,7 @@ class SubscriptionService:
             
         except Exception as e:
             logger.error(f"Ошибка получения цен стран: {e}")
-            default_prices = [1000] * len(country_uuids)
+            default_prices = [0] * len(country_uuids)
             return sum(default_prices), default_prices
     
     async def _get_countries_price(self, country_uuids: List[str], db: AsyncSession) -> int:

docker-compose.yml

@@ -0,0 +1,77 @@
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: remnawave_bot_db
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB:-remnawave_bot}
+      POSTGRES_USER: ${POSTGRES_USER:-remnawave_user}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-secure_password_123}
+      POSTGRES_INITDB_ARGS: "--encoding=UTF8"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - bot_network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-remnawave_user} -d ${POSTGRES_DB:-remnawave_bot}"]
+      interval: 30s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+  redis:
+    image: redis:7-alpine
+    container_name: remnawave_bot_redis
+    restart: unless-stopped
+    command: redis-server --appendonly yes
+    volumes:
+      - redis_data:/data
+    networks:
+      - bot_network
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  bot:
+    image: fr1ngg/remnawave-bedolaga-telegram-bot:latest
+    container_name: remnawave_bot
+    restart: unless-stopped
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    env_file:
+      - .env
+    environment:
+      DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:-remnawave_user}:${POSTGRES_PASSWORD:-secure_password_123}@postgres:5432/${POSTGRES_DB:-remnawave_bot}
+      REDIS_URL: redis://redis:6379/0
+    volumes:
+      - ./logs:/app/logs:rw
+      - ./data:/app/data:rw
+      - /etc/timezone:/etc/timezone:ro
+      - /etc/localtime:/etc/localtime:ro
+    ports:
+      - "${TRIBUTE_WEBHOOK_PORT:-8081}:8081"
+      - "${YOOKASSA_WEBHOOK_PORT:-8082}:8082"
+    networks:
+      - bot_network
+    user: "1000:1000"
+    command: >
+      bash -c "
+        mkdir -p /app/logs /app/data &&
+        python main.py
+      "
+
+volumes:
+  postgres_data:
+  redis_data:
+
+networks:
+  bot_network:
+    driver: bridge
+    ipam:
+      config:
+        - subnet: 172.20.0.0/16

main.py

@@ -12,7 +12,9 @@ from app.config import settings
 from app.database.database import init_db
 from app.services.monitoring_service import monitoring_service
 from app.services.maintenance_service import maintenance_service
+from app.services.payment_service import PaymentService
 from app.external.webhook_server import WebhookServer
+from app.external.yookassa_webhook import start_yookassa_webhook_server
 from app.database.universal_migration import run_universal_migration
 
 
@@ -44,6 +46,7 @@ async def main():
     signal.signal(signal.SIGTERM, killer.exit_gracefully)
     
     webhook_server = None
+    yookassa_server_task = None
     monitoring_task = None
     maintenance_task = None
     polling_task = None
@@ -74,34 +77,68 @@ async def main():
         bot, dp = await setup_bot()
         
         monitoring_service.bot = bot
+        maintenance_service.set_bot(bot) 
+        logger.info("🔗 Бот подключен к сервисам мониторинга и техработ")
+        
+        payment_service = PaymentService(bot)
         
         if settings.TRIBUTE_ENABLED:
-            logger.info("🌐 Запуск webhook сервера для Tribute...")
+            logger.info("🌐 Запуск Tribute webhook сервера...")
             webhook_server = WebhookServer(bot)
             await webhook_server.start()
         else:
             logger.info("ℹ️ Tribute отключен, webhook сервер не запускается")
         
-        logger.info("🔍 Запуск службы мониторинга...")
+        if settings.is_yookassa_enabled():
+            logger.info("💳 Запуск YooKassa webhook сервера...")
+            yookassa_server_task = asyncio.create_task(
+                start_yookassa_webhook_server(payment_service)
+            )
+        else:
+            logger.info("ℹ️ YooKassa отключена, webhook сервер не запускается")
+        
+        logger.info("📊 Запуск службы мониторинга...")
         monitoring_task = asyncio.create_task(monitoring_service.start_monitoring())
         
-        logger.info("🔧 Запуск службы техработ...")
-        maintenance_task = asyncio.create_task(maintenance_service.start_monitoring())
+        logger.info("🔧 Проверка службы техработ...")
+        if not maintenance_service._check_task or maintenance_service._check_task.done():
+            logger.info("🔧 Запуск службы техработ...")
+            maintenance_task = asyncio.create_task(maintenance_service.start_monitoring())
+        else:
+            logger.info("🔧 Служба техработ уже запущена")
+            maintenance_task = None
         
         logger.info("🔄 Запуск polling...")
         polling_task = asyncio.create_task(dp.start_polling(bot, skip_updates=True))
         
+        logger.info("=" * 50)
+        logger.info("🎯 Активные webhook endpoints:")
+        if settings.TRIBUTE_ENABLED:
+            logger.info(f"   Tribute: {settings.WEBHOOK_URL}:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+        if settings.is_yookassa_enabled():
+            logger.info(f"   YooKassa: {settings.WEBHOOK_URL}:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
+        logger.info("=" * 50)
+        
         try:
             while not killer.exit:
                 await asyncio.sleep(1)
                 
+                if yookassa_server_task and yookassa_server_task.done():
+                    exception = yookassa_server_task.exception()
+                    if exception:
+                        logger.error(f"YooKassa webhook сервер завершился с ошибкой: {exception}")
+                        logger.info("🔄 Перезапуск YooKassa webhook сервера...")
+                        yookassa_server_task = asyncio.create_task(
+                            start_yookassa_webhook_server(payment_service)
+                        )
+                
                 if monitoring_task.done():
                     exception = monitoring_task.exception()
                     if exception:
                         logger.error(f"Служба мониторинга завершилась с ошибкой: {exception}")
                         monitoring_task = asyncio.create_task(monitoring_service.start_monitoring())
                         
-                if maintenance_task.done():
+                if maintenance_task and maintenance_task.done():
                     exception = maintenance_task.exception()
                     if exception:
                         logger.error(f"Служба техработ завершилась с ошибкой: {exception}")
@@ -123,8 +160,16 @@ async def main():
     finally:
         logger.info("🛑 Начинается корректное завершение работы...")
         
+        if yookassa_server_task and not yookassa_server_task.done():
+            logger.info("ℹ️ Остановка YooKassa webhook сервера...")
+            yookassa_server_task.cancel()
+            try:
+                await yookassa_server_task
+            except asyncio.CancelledError:
+                pass
+        
         if monitoring_task and not monitoring_task.done():
-            logger.info("⏹️ Остановка службы мониторинга...")
+            logger.info("ℹ️ Остановка службы мониторинга...")
             monitoring_service.stop_monitoring()
             monitoring_task.cancel()
             try:
@@ -133,7 +178,7 @@ async def main():
                 pass
         
         if maintenance_task and not maintenance_task.done():
-            logger.info("⏹️ Остановка службы техработ...")
+            logger.info("ℹ️ Остановка службы техработ...")
             await maintenance_service.stop_monitoring()
             maintenance_task.cancel()
             try:
@@ -142,7 +187,7 @@ async def main():
                 pass
         
         if polling_task and not polling_task.done():
-            logger.info("⏹️ Остановка polling...")
+            logger.info("ℹ️ Остановка polling...")
             polling_task.cancel()
             try:
                 await polling_task
@@ -150,7 +195,7 @@ async def main():
                 pass
         
         if webhook_server:
-            logger.info("⏹️ Остановка webhook сервера...")
+            logger.info("ℹ️ Остановка Tribute webhook сервера...")
             await webhook_server.stop()
         
         if 'bot' in locals():