Merge pull request #39 from Fr1ngg/dev

Антихлебная валидация HTML разметки при создании сообщения в меню

.env.example

@@ -7,6 +7,11 @@ BOT_TOKEN=
 ADMIN_IDS=
 SUPPORT_USERNAME=@support
 
+# Уведомления администраторов
+ADMIN_NOTIFICATIONS_ENABLED=true
+ADMIN_NOTIFICATIONS_CHAT_ID=-1001234567890   # Замени на ID твоего канала (-100) - ПРЕФИКС ЗАКРЫТОГО КАНАЛА! ВСТАВИТЬ СВОЙ ID СРАЗУ ПОСЛЕ (-100) БЕЗ ПРОБЕЛОВ!
+ADMIN_NOTIFICATIONS_TOPIC_ID=123             # Опционально: ID топика
+
 # ===== DATABASE =====
 # Для Docker используйте PostgreSQL:
 DATABASE_URL=postgresql+asyncpg://remnawave_user:secure_password_123@postgres:5432/remnawave_bot
@@ -80,10 +85,15 @@ TRAFFIC_PACKAGES_CONFIG="5:2000:false,10:3500:false,25:7000:false,50:11000:true,
 PRICE_PER_DEVICE=5000
 
 # ===== РЕФЕРАЛЬНАЯ СИСТЕМА =====
-REFERRAL_REGISTRATION_REWARD=10000
-REFERRED_USER_REWARD=10000
+REFERRAL_MINIMUM_TOPUP_KOPEKS=10000
+REFERRAL_FIRST_TOPUP_BONUS_KOPEKS=10000
+REFERRAL_INVITER_BONUS_KOPEKS=10000
 REFERRAL_COMMISSION_PERCENT=25
 
+# Уведомления
+REFERRAL_NOTIFICATIONS_ENABLED=true
+REFERRAL_NOTIFICATION_RETRY_ATTEMPTS=3
+
 # ===== АВТОПРОДЛЕНИЕ =====
 AUTOPAY_WARNING_DAYS=3,1
 DEFAULT_AUTOPAY_DAYS_BEFORE=3
@@ -98,7 +108,6 @@ TELEGRAM_STARS_RATE_RUB=1.3
 # Tribute (https://tribute.app)
 TRIBUTE_ENABLED=false
 TRIBUTE_API_KEY=
-TRIBUTE_WEBHOOK_SECRET=your_webhook_secret
 TRIBUTE_DONATE_LINK=
 TRIBUTE_WEBHOOK_PATH=/tribute-webhook
 TRIBUTE_WEBHOOK_PORT=8081

Dockerfile

@@ -1,43 +1,29 @@
 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 necessary directories and set permissions
 RUN mkdir -p logs data && \
-    chown -R app:app /app && \
-    chmod -R 755 /app && \
-    chmod -R 777 logs
+    chown -R app:app /app
 
-# Switch to non-root user
 USER app
 
-# Set environment variables
 ENV PYTHONPATH=/app
 ENV PYTHONUNBUFFERED=1
 
-# Expose webhook ports
-EXPOSE 8081
-EXPOSE 8082
+EXPOSE 8081 8082
 
-# 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

@@ -23,7 +23,8 @@ from app.handlers.admin import (
     monitoring as admin_monitoring, referrals as admin_referrals,
     rules as admin_rules, remnawave as admin_remnawave,
     statistics as admin_statistics, servers as admin_servers,
-    maintenance as admin_maintenance  
+    maintenance as admin_maintenance,
+    user_messages as admin_user_messages 
 )
 from app.handlers.stars_payments import register_stars_handlers
 
@@ -97,6 +98,7 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     admin_remnawave.register_handlers(dp)
     admin_statistics.register_handlers(dp)
     admin_maintenance.register_handlers(dp)
+    admin_user_messages.register_handlers(dp) 
 
     common.register_handlers(dp)
     

app/config.py

@@ -10,6 +10,10 @@ class Settings(BaseSettings):
     BOT_TOKEN: str
     ADMIN_IDS: str = ""
     SUPPORT_USERNAME: str = "@support"
+
+    ADMIN_NOTIFICATIONS_ENABLED: bool = False
+    ADMIN_NOTIFICATIONS_CHAT_ID: Optional[str] = None
+    ADMIN_NOTIFICATIONS_TOPIC_ID: Optional[int] = None
     
     DATABASE_URL: str
     REDIS_URL: str = "redis://localhost:6379/0"
@@ -62,9 +66,14 @@ class Settings(BaseSettings):
     TRAFFIC_SELECTION_MODE: str = "selectable" 
     FIXED_TRAFFIC_LIMIT_GB: int = 100 
     
-    REFERRAL_REGISTRATION_REWARD: int = 5000
-    REFERRED_USER_REWARD: int = 2500
-    REFERRAL_COMMISSION_PERCENT: int = 10
+    REFERRAL_MINIMUM_TOPUP_KOPEKS: int = 10000 
+    REFERRAL_FIRST_TOPUP_BONUS_KOPEKS: int = 10000 
+    REFERRAL_INVITER_BONUS_KOPEKS: int = 10000 
+    REFERRAL_COMMISSION_PERCENT: int = 25 
+
+    REFERRAL_NOTIFICATIONS_ENABLED: bool = True
+    REFERRAL_NOTIFICATION_RETRY_ATTEMPTS: int = 3
+    REFERRED_USER_REWARD: int = 0 
     
     AUTOPAY_WARNING_DAYS: str = "3,1"
     
@@ -84,7 +93,6 @@ class Settings(BaseSettings):
     
     TRIBUTE_ENABLED: bool = False
     TRIBUTE_API_KEY: Optional[str] = None
-    TRIBUTE_WEBHOOK_SECRET: Optional[str] = None
     TRIBUTE_DONATE_LINK: Optional[str] = None
     TRIBUTE_WEBHOOK_PATH: str = "/tribute-webhook"
     TRIBUTE_WEBHOOK_PORT: int = 8081
@@ -296,6 +304,32 @@ class Settings(BaseSettings):
     
     def rubles_to_stars(self, rubles: float) -> int:
         return max(1, int(rubles / self.get_stars_rate()))
+
+    def get_admin_notifications_chat_id(self) -> Optional[int]:
+        if not self.ADMIN_NOTIFICATIONS_CHAT_ID:
+            return None
+        
+        try:
+            return int(self.ADMIN_NOTIFICATIONS_CHAT_ID)
+        except (ValueError, TypeError):
+            return None
+    
+    def is_admin_notifications_enabled(self) -> bool:
+        return (self.ADMIN_NOTIFICATIONS_ENABLED and 
+                self.get_admin_notifications_chat_id() is not None)
+
+    def get_referral_settings(self) -> Dict:
+        return {
+            "minimum_topup_kopeks": self.REFERRAL_MINIMUM_TOPUP_KOPEKS,
+            "first_topup_bonus_kopeks": self.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS,
+            "inviter_bonus_kopeks": self.REFERRAL_INVITER_BONUS_KOPEKS,
+            "commission_percent": self.REFERRAL_COMMISSION_PERCENT,
+            "notifications_enabled": self.REFERRAL_NOTIFICATIONS_ENABLED,
+            "referred_user_reward": self.REFERRED_USER_REWARD
+        }
+    
+    def is_referral_notifications_enabled(self) -> bool:
+        return self.REFERRAL_NOTIFICATIONS_ENABLED
     
     def get_traffic_packages(self) -> List[Dict]:
         import logging

app/database/crud/referral.py

@@ -91,6 +91,7 @@ async def get_referral_earnings_sum(
 
 
 async def get_referral_statistics(db: AsyncSession) -> dict:
+    
     users_with_referrals_result = await db.execute(
         select(func.count(func.distinct(User.id)))
         .where(User.referred_by_id.isnot(None))
@@ -117,41 +118,72 @@ async def get_referral_statistics(db: AsyncSession) -> dict:
     
     total_paid = referral_paid + transaction_paid
     
-    top_referrers_result = await db.execute(
+    referrals_stats_result = await db.execute(
         select(
             User.referred_by_id.label('referrer_id'),
-            func.count(User.id).label('referrals_count'),
-            func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0).label('referral_earnings'),
-            func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('transaction_earnings')
-        )
-        .outerjoin(
-            ReferralEarning, 
-            ReferralEarning.user_id == User.referred_by_id
-        )
-        .outerjoin(
-            Transaction,
-            and_(
-                Transaction.user_id == User.referred_by_id,
-                Transaction.type == TransactionType.REFERRAL_REWARD.value
-            )
-        )
-        .where(
-            and_(
-                User.referred_by_id.isnot(None),
-                User.referred_by_id != User.id 
-            )
+            func.count(User.id).label('referrals_count')
         )
+        .where(User.referred_by_id.isnot(None))
         .group_by(User.referred_by_id)
-        .order_by(func.count(User.id).desc())
-        .limit(5)
     )
-    top_referrers_raw = top_referrers_result.all()
+    referrals_stats = {row.referrer_id: row.referrals_count for row in referrals_stats_result.all()}
+    
+    referral_earnings_result = await db.execute(
+        select(
+            ReferralEarning.user_id.label('referrer_id'),
+            func.sum(ReferralEarning.amount_kopeks).label('referral_earnings')
+        )
+        .group_by(ReferralEarning.user_id)
+    )
+    referral_earnings = {row.referrer_id: row.referral_earnings for row in referral_earnings_result.all()}
+    
+    transaction_earnings_result = await db.execute(
+        select(
+            Transaction.user_id.label('referrer_id'),
+            func.sum(Transaction.amount_kopeks).label('transaction_earnings')
+        )
+        .where(Transaction.type == TransactionType.REFERRAL_REWARD.value)
+        .group_by(Transaction.user_id)
+    )
+    transaction_earnings = {row.referrer_id: row.transaction_earnings for row in transaction_earnings_result.all()}
+    
+    top_referrers_data = {}
+    
+    for referrer_id, count in referrals_stats.items():
+        if referrer_id not in top_referrers_data:
+            top_referrers_data[referrer_id] = {
+                'referrals_count': 0,
+                'total_earned': 0
+            }
+        top_referrers_data[referrer_id]['referrals_count'] = count
+    
+    for referrer_id, earnings in referral_earnings.items():
+        if referrer_id not in top_referrers_data:
+            top_referrers_data[referrer_id] = {
+                'referrals_count': 0,
+                'total_earned': 0
+            }
+        top_referrers_data[referrer_id]['total_earned'] += earnings or 0
+    
+    for referrer_id, earnings in transaction_earnings.items():
+        if referrer_id not in top_referrers_data:
+            top_referrers_data[referrer_id] = {
+                'referrals_count': 0,
+                'total_earned': 0
+            }
+        top_referrers_data[referrer_id]['total_earned'] += earnings or 0
+    
+    sorted_referrers = sorted(
+        top_referrers_data.items(),
+        key=lambda x: (x[1]['total_earned'], x[1]['referrals_count']),
+        reverse=True
+    )
     
     top_referrers = []
-    for row in top_referrers_raw:
+    for referrer_id, stats in sorted_referrers[:5]:
         user_result = await db.execute(
             select(User.id, User.username, User.first_name, User.last_name, User.telegram_id)
-            .where(User.id == row.referrer_id)
+            .where(User.id == referrer_id)
         )
         user = user_result.first()
         
@@ -166,23 +198,22 @@ async def get_referral_statistics(db: AsyncSession) -> dict:
             else:
                 display_name = f"ID{user.telegram_id}"
             
-            total_earned = (row.referral_earnings or 0) + (row.transaction_earnings or 0)
-            
             top_referrers.append({
-                "user_id": row.referrer_id,
+                "user_id": user.telegram_id, 
                 "display_name": display_name,
                 "username": user.username,
-                "total_earned_kopeks": total_earned,
-                "referrals_count": row.referrals_count
+                "telegram_id": user.telegram_id,
+                "total_earned_kopeks": stats['total_earned'],
+                "referrals_count": stats['referrals_count']
             })
     
-    today = datetime.utcnow().date()
+    today = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
     
-    today_referral_earnings = await db.execute(
+    today_referral_earnings_result = await db.execute(
         select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
         .where(ReferralEarning.created_at >= today)
     )
-    today_transaction_earnings = await db.execute(
+    today_transaction_earnings_result = await db.execute(
         select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
         .where(
             and_(
@@ -191,14 +222,14 @@ async def get_referral_statistics(db: AsyncSession) -> dict:
             )
         )
     )
-    today_earnings = today_referral_earnings.scalar() + today_transaction_earnings.scalar()
+    today_earnings = today_referral_earnings_result.scalar() + today_transaction_earnings_result.scalar()
     
     week_ago = datetime.utcnow() - timedelta(days=7)
-    week_referral_earnings = await db.execute(
+    week_referral_earnings_result = await db.execute(
         select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
         .where(ReferralEarning.created_at >= week_ago)
     )
-    week_transaction_earnings = await db.execute(
+    week_transaction_earnings_result = await db.execute(
         select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
         .where(
             and_(
@@ -207,14 +238,14 @@ async def get_referral_statistics(db: AsyncSession) -> dict:
             )
         )
     )
-    week_earnings = week_referral_earnings.scalar() + week_transaction_earnings.scalar()
+    week_earnings = week_referral_earnings_result.scalar() + week_transaction_earnings_result.scalar()
     
     month_ago = datetime.utcnow() - timedelta(days=30)
-    month_referral_earnings = await db.execute(
+    month_referral_earnings_result = await db.execute(
         select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
         .where(ReferralEarning.created_at >= month_ago)
     )
-    month_transaction_earnings = await db.execute(
+    month_transaction_earnings_result = await db.execute(
         select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
         .where(
             and_(
@@ -223,7 +254,9 @@ async def get_referral_statistics(db: AsyncSession) -> dict:
             )
         )
     )
-    month_earnings = month_referral_earnings.scalar() + month_transaction_earnings.scalar()
+    month_earnings = month_referral_earnings_result.scalar() + month_transaction_earnings_result.scalar()
+    
+    logger.info(f"Реферальная статистика: {users_with_referrals} рефералов, {active_referrers} рефереров, выплачено {total_paid} копеек")
     
     return {
         "users_with_referrals": users_with_referrals,
@@ -248,13 +281,17 @@ async def get_user_referral_stats(db: AsyncSession, user_id: int) -> dict:
     month_ago = datetime.utcnow() - timedelta(days=30)
     month_earned = await get_referral_earnings_sum(db, user_id, start_date=month_ago)
     
+    from app.database.models import Subscription, SubscriptionStatus
+    current_time = datetime.utcnow()
+    
     active_referrals_result = await db.execute(
         select(func.count(User.id))
-        .join(User.subscription)
+        .join(Subscription, User.id == Subscription.user_id)
         .where(
             and_(
                 User.referred_by_id == user_id,
-                User.subscription.has()
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date > current_time
             )
         )
     )
@@ -265,4 +302,4 @@ async def get_user_referral_stats(db: AsyncSession, user_id: int) -> dict:
         "active_referrals": active_referrals,
         "total_earned_kopeks": total_earned,
         "month_earned_kopeks": month_earned
-    }
+    }

app/database/crud/subscription.py

@@ -354,6 +354,37 @@ async def get_subscriptions_statistics(db: AsyncSession) -> dict:
     )
     purchased_month = month_result.scalar()
     
+    try:
+        from app.database.crud.subscription_conversion import get_conversion_statistics
+        conversion_stats = await get_conversion_statistics(db)
+        
+        trial_to_paid_conversion = conversion_stats.get("conversion_rate", 0)
+        renewals_count = conversion_stats.get("month_conversions", 0)
+        
+        logger.info(f"📊 Статистика конверсии из таблицы conversions:")
+        logger.info(f"   Общее количество конверсий: {conversion_stats.get('total_conversions', 0)}")
+        logger.info(f"   Процент конверсии: {trial_to_paid_conversion}%")
+        logger.info(f"   Конверсий за месяц: {renewals_count}")
+        
+    except ImportError:
+        logger.warning("⚠️ Таблица subscription_conversions не найдена, используем старую логику")
+        
+        users_with_paid_result = await db.execute(
+            select(func.count(User.id))
+            .where(User.has_had_paid_subscription == True)
+        )
+        users_with_paid = users_with_paid_result.scalar()
+        
+        total_users_result = await db.execute(select(func.count(User.id)))
+        total_users = total_users_result.scalar()
+        
+        if total_users > 0:
+            trial_to_paid_conversion = round((users_with_paid / total_users) * 100, 1)
+        else:
+            trial_to_paid_conversion = 0
+            
+        renewals_count = 0
+    
     return {
         "total_subscriptions": total_subscriptions,
         "active_subscriptions": active_subscriptions,
@@ -361,10 +392,11 @@ async def get_subscriptions_statistics(db: AsyncSession) -> dict:
         "paid_subscriptions": paid_subscriptions,
         "purchased_today": purchased_today,
         "purchased_week": purchased_week,
-        "purchased_month": purchased_month
+        "purchased_month": purchased_month,
+        "trial_to_paid_conversion": trial_to_paid_conversion, 
+        "renewals_count": renewals_count 
     }
 
-
 async def update_subscription_usage(
     db: AsyncSession,
     subscription: Subscription,

app/database/crud/subscription_conversion.py

@@ -0,0 +1,118 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List
+from sqlalchemy import select, func
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import SubscriptionConversion, User
+
+logger = logging.getLogger(__name__)
+
+
+async def create_subscription_conversion(
+    db: AsyncSession,
+    user_id: int,
+    trial_duration_days: int,
+    payment_method: str,
+    first_payment_amount_kopeks: int,
+    first_paid_period_days: int
+) -> SubscriptionConversion:
+    
+    conversion = SubscriptionConversion(
+        user_id=user_id,
+        converted_at=datetime.utcnow(),
+        trial_duration_days=trial_duration_days,
+        payment_method=payment_method,
+        first_payment_amount_kopeks=first_payment_amount_kopeks,
+        first_paid_period_days=first_paid_period_days
+    )
+    
+    db.add(conversion)
+    await db.commit()
+    await db.refresh(conversion)
+    
+    logger.info(f"✅ Создана запись о конверсии для пользователя {user_id}: {trial_duration_days} дн. → {first_paid_period_days} дн. за {first_payment_amount_kopeks/100}₽")
+    
+    return conversion
+
+
+async def get_conversion_by_user_id(
+    db: AsyncSession,
+    user_id: int
+) -> Optional[SubscriptionConversion]:
+    
+    result = await db.execute(
+        select(SubscriptionConversion)
+        .where(SubscriptionConversion.user_id == user_id)
+        .order_by(SubscriptionConversion.converted_at.desc())
+        .limit(1)
+    )
+    
+    return result.scalar_one_or_none()
+
+
+async def get_conversion_statistics(db: AsyncSession) -> dict:
+    
+    total_conversions_result = await db.execute(
+        select(func.count(SubscriptionConversion.id))
+    )
+    total_conversions = total_conversions_result.scalar()
+    
+    users_with_paid_result = await db.execute(
+        select(func.count(User.id))
+        .where(User.has_had_paid_subscription == True)
+    )
+    users_with_paid = users_with_paid_result.scalar()
+    
+    if total_conversions > 0:
+        conversion_rate = round((total_conversions / max(total_conversions, users_with_paid)) * 100, 1)
+    elif users_with_paid > 0:
+        conversion_rate = 100.0
+    else:
+        conversion_rate = 0.0
+    
+    avg_trial_duration_result = await db.execute(
+        select(func.avg(SubscriptionConversion.trial_duration_days))
+    )
+    avg_trial_duration = avg_trial_duration_result.scalar() or 0
+    
+    avg_first_payment_result = await db.execute(
+        select(func.avg(SubscriptionConversion.first_payment_amount_kopeks))
+    )
+    avg_first_payment = avg_first_payment_result.scalar() or 0
+    
+    month_ago = datetime.utcnow() - timedelta(days=30)
+    month_conversions_result = await db.execute(
+        select(func.count(SubscriptionConversion.id))
+        .where(SubscriptionConversion.converted_at >= month_ago)
+    )
+    month_conversions = month_conversions_result.scalar()
+    
+    logger.info(f"📊 Статистика конверсий:")
+    logger.info(f"   Всего записей о конверсиях: {total_conversions}")
+    logger.info(f"   Пользователей с платными подписками: {users_with_paid}")
+    logger.info(f"   Рассчитанная конверсия: {conversion_rate}%")
+    
+    return {
+        "total_conversions": total_conversions,
+        "conversion_rate": conversion_rate,
+        "avg_trial_duration_days": round(avg_trial_duration, 1),
+        "avg_first_payment_rubles": round((avg_first_payment or 0) / 100, 2),
+        "month_conversions": month_conversions
+    }
+
+
+async def get_users_had_trial_count(db: AsyncSession) -> int:
+    
+    conversions_count_result = await db.execute(
+        select(func.count(func.distinct(SubscriptionConversion.user_id)))
+    )
+    conversions_count = conversions_count_result.scalar()
+    
+    paid_users_result = await db.execute(
+        select(func.count(User.id))
+        .where(User.has_had_paid_subscription == True)
+    )
+    paid_users_count = paid_users_result.scalar()
+    
+    return max(conversions_count, paid_users_count)

app/database/crud/transaction.py

@@ -277,12 +277,12 @@ async def get_revenue_by_period(
     
     return [{"date": row.date, "amount_kopeks": row.amount} for row in result]
 
+
 async def find_tribute_transactions_by_payment_id(
     db: AsyncSession, 
     payment_id: str, 
     user_telegram_id: Optional[int] = None
 ) -> List[Transaction]:
-    """Найти все Tribute транзакции по payment_id"""
     
     query = select(Transaction).options(selectinload(Transaction.user))
     
@@ -313,18 +313,27 @@ async def check_tribute_payment_duplicate(
     amount_kopeks: int,
     user_telegram_id: int
 ) -> Optional[Transaction]:
+    cutoff_time = datetime.utcnow() - timedelta(hours=24)
     
-    transactions = await find_tribute_transactions_by_payment_id(
-        db, payment_id, user_telegram_id
-    )
+    exact_external_id = f"donation_{payment_id}"
     
-    for transaction in transactions:
-        if (transaction.amount_kopeks == amount_kopeks and 
-            transaction.is_completed and
-            transaction.user.telegram_id == user_telegram_id):
-            return transaction
+    query = select(Transaction).options(selectinload(Transaction.user)).where(
+        and_(
+            Transaction.payment_method == PaymentMethod.TRIBUTE.value,
+            Transaction.external_id == exact_external_id, 
+            Transaction.amount_kopeks == amount_kopeks,
+            Transaction.is_completed == True,
+            Transaction.created_at >= cutoff_time  
+        )
+    ).join(User).where(User.telegram_id == user_telegram_id)
     
-    return None
+    result = await db.execute(query)
+    transaction = result.scalar_one_or_none()
+    
+    if transaction:
+        logger.info(f"🔍 Найден дубликат платежа в течение 24ч: {transaction.id}")
+    
+    return transaction
 
 
 async def create_unique_tribute_transaction(
@@ -334,7 +343,6 @@ async def create_unique_tribute_transaction(
     amount_kopeks: int,
     description: str
 ) -> Transaction:
-    """Создать уникальную Tribute транзакцию с защитой от дубликатов"""
     
     external_id = f"donation_{payment_id}"
     

app/database/crud/user.py

@@ -48,7 +48,6 @@ async def get_user_by_telegram_id(db: AsyncSession, telegram_id: int) -> Optiona
 
 
 async def get_user_by_referral_code(db: AsyncSession, referral_code: str) -> Optional[User]:
-    
     result = await db.execute(
         select(User).where(User.referral_code == referral_code)
     )
@@ -92,7 +91,8 @@ async def create_user(
         referred_by_id=referred_by_id,
         referral_code=referral_code,
         balance_kopeks=0,
-        has_had_paid_subscription=False
+        has_had_paid_subscription=False,
+        has_made_first_topup=False 
     )
     
     db.add(user)
@@ -125,27 +125,31 @@ async def add_user_balance(
     db: AsyncSession,
     user: User,
     amount_kopeks: int,
-    description: str = "Пополнение баланса"
+    description: str = "Пополнение баланса",
+    create_transaction: bool = True,
+    bot = None 
 ) -> bool:
     try:
         old_balance = user.balance_kopeks
         user.balance_kopeks += amount_kopeks
         user.updated_at = datetime.utcnow()
         
-        from app.database.crud.transaction import create_transaction
-        from app.database.models import TransactionType
-        
-        await create_transaction(
-            db=db,
-            user_id=user.id,
-            type=TransactionType.DEPOSIT,
-            amount_kopeks=amount_kopeks,
-            description=description
-        )
+        if create_transaction:
+            from app.database.crud.transaction import create_transaction as create_trans
+            from app.database.models import TransactionType
+            
+            await create_trans(
+                db=db,
+                user_id=user.id,
+                type=TransactionType.DEPOSIT,
+                amount_kopeks=amount_kopeks,
+                description=description
+            )
         
         await db.commit()
         await db.refresh(user)
         
+        
         logger.info(f"💰 Баланс пользователя {user.telegram_id} изменен: {old_balance} → {user.balance_kopeks} (изменение: +{amount_kopeks})")
         return True
         
@@ -154,6 +158,7 @@ async def add_user_balance(
         await db.rollback()
         return False
 
+
 async def add_user_balance_by_id(
     db: AsyncSession,
     telegram_id: int, 
@@ -171,11 +176,7 @@ async def add_user_balance_by_id(
     except Exception as e:
         logger.error(f"Ошибка пополнения баланса пользователя {telegram_id}: {e}")
         return False
-        
-    except Exception as e:
-        logger.error(f"❌ Ошибка пополнения баланса пользователя {user_id}: {e}")
-        await db.rollback()
-        return False
+
 
 async def subtract_user_balance(
     db: AsyncSession, 

app/database/crud/user_message.py

@@ -0,0 +1,157 @@
+import logging
+import random
+from datetime import datetime
+from typing import Optional, List
+from sqlalchemy import select, func, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import UserMessage
+
+logger = logging.getLogger(__name__)
+
+
+async def create_user_message(
+    db: AsyncSession,
+    message_text: str,
+    created_by: int,
+    is_active: bool = True,
+    sort_order: int = 0
+) -> UserMessage:
+    message = UserMessage(
+        message_text=message_text,
+        is_active=is_active,
+        sort_order=sort_order,
+        created_by=created_by
+    )
+    
+    db.add(message)
+    await db.commit()
+    await db.refresh(message)
+    
+    logger.info(f"✅ Создано сообщение ID {message.id} пользователем {created_by}")
+    return message
+
+
+async def get_user_message_by_id(db: AsyncSession, message_id: int) -> Optional[UserMessage]:
+    result = await db.execute(
+        select(UserMessage).where(UserMessage.id == message_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_active_user_messages(db: AsyncSession) -> List[UserMessage]:
+    result = await db.execute(
+        select(UserMessage)
+        .where(UserMessage.is_active == True)
+        .order_by(UserMessage.sort_order.asc(), UserMessage.created_at.desc())
+    )
+    return result.scalars().all()
+
+
+async def get_random_active_message(db: AsyncSession) -> Optional[str]:
+    active_messages = await get_active_user_messages(db)
+    
+    if not active_messages:
+        return None
+    
+    random_message = random.choice(active_messages)
+    return random_message.message_text
+
+
+async def get_all_user_messages(
+    db: AsyncSession,
+    offset: int = 0,
+    limit: int = 50
+) -> List[UserMessage]:
+    result = await db.execute(
+        select(UserMessage)
+        .order_by(UserMessage.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+    return result.scalars().all()
+
+
+async def get_user_messages_count(db: AsyncSession) -> int:
+    result = await db.execute(select(func.count(UserMessage.id)))
+    return result.scalar()
+
+
+async def update_user_message(
+    db: AsyncSession,
+    message_id: int,
+    message_text: Optional[str] = None,
+    is_active: Optional[bool] = None,
+    sort_order: Optional[int] = None
+) -> Optional[UserMessage]:
+    message = await get_user_message_by_id(db, message_id)
+    
+    if not message:
+        return None
+    
+    if message_text is not None:
+        message.message_text = message_text
+    
+    if is_active is not None:
+        message.is_active = is_active
+    
+    if sort_order is not None:
+        message.sort_order = sort_order
+    
+    message.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(message)
+    
+    logger.info(f"📝 Обновлено сообщение ID {message_id}")
+    return message
+
+
+async def toggle_user_message_status(
+    db: AsyncSession,
+    message_id: int
+) -> Optional[UserMessage]:
+    message = await get_user_message_by_id(db, message_id)
+    
+    if not message:
+        return None
+    
+    message.is_active = not message.is_active
+    message.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(message)
+    
+    status_text = "активировано" if message.is_active else "деактивировано"
+    logger.info(f"🔄 Сообщение ID {message_id} {status_text}")
+    
+    return message
+
+
+async def delete_user_message(db: AsyncSession, message_id: int) -> bool:
+    message = await get_user_message_by_id(db, message_id)
+    
+    if not message:
+        return False
+    
+    await db.delete(message)
+    await db.commit()
+    
+    logger.info(f"🗑️ Удалено сообщение ID {message_id}")
+    return True
+
+
+async def get_user_messages_stats(db: AsyncSession) -> dict:
+    total_result = await db.execute(select(func.count(UserMessage.id)))
+    total_messages = total_result.scalar()
+    
+    active_result = await db.execute(
+        select(func.count(UserMessage.id)).where(UserMessage.is_active == True)
+    )
+    active_messages = active_result.scalar()
+    
+    return {
+        "total_messages": total_messages,
+        "active_messages": active_messages,
+        "inactive_messages": total_messages - active_messages
+    }

app/database/models.py

@@ -7,7 +7,7 @@ from sqlalchemy import (
     ForeignKey, Float, JSON, BigInteger
 )
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import relationship, Mapped
+from sqlalchemy.orm import relationship, Mapped, mapped_column
 from sqlalchemy.sql import func
 
 
@@ -125,6 +125,7 @@ class User(Base):
     trojan_password = Column(String(255), nullable=True)
     vless_uuid = Column(String(255), nullable=True)
     ss_password = Column(String(255), nullable=True)
+    has_made_first_topup: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
     
     @property
     def balance_rubles(self) -> float:
@@ -333,6 +334,33 @@ class Transaction(Base):
     def amount_rubles(self) -> float:
         return self.amount_kopeks / 100
 
+class SubscriptionConversion(Base):
+    __tablename__ = "subscription_conversions"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    
+    converted_at = Column(DateTime, default=func.now())
+    
+    trial_duration_days = Column(Integer, nullable=True)
+    
+    payment_method = Column(String(50), nullable=True)
+    
+    first_payment_amount_kopeks = Column(Integer, nullable=True)
+    
+    first_paid_period_days = Column(Integer, nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    
+    user = relationship("User", backref="subscription_conversions")
+    
+    @property
+    def first_payment_amount_rubles(self) -> float:
+        return (self.first_payment_amount_kopeks or 0) / 100
+    
+    def __repr__(self):
+        return f"<SubscriptionConversion(user_id={self.user_id}, converted_at={self.converted_at})>"
+
 
 class PromoCode(Base):
     __tablename__ = "promocodes"
@@ -554,3 +582,24 @@ class SubscriptionServer(Base):
     
     subscription = relationship("Subscription", backref="subscription_servers")
     server_squad = relationship("ServerSquad", backref="subscription_servers")
+
+class UserMessage(Base):
+    __tablename__ = "user_messages"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    
+    message_text = Column(Text, nullable=False)
+    
+    is_active = Column(Boolean, default=True)
+    
+    sort_order = Column(Integer, default=0)
+    
+    created_by = Column(Integer, ForeignKey("users.id"), nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    creator = relationship("User", backref="created_messages")
+    
+    def __repr__(self):
+        return f"<UserMessage(id={self.id}, active={self.is_active}, text='{self.message_text[:50]}...')>"

app/database/universal_migration.py

@@ -241,6 +241,132 @@ async def add_remnawave_v2_columns():
         logger.error(f"Ошибка при добавлении колонок RemnaWave v2.1.5: {e}")
         return 0
 
+async def add_referral_system_columns():
+    logger.info("=== МИГРАЦИЯ РЕФЕРАЛЬНОЙ СИСТЕМЫ ===")
+    
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+            
+            column_exists = await check_column_exists('users', 'has_made_first_topup')
+            
+            if not column_exists:
+                logger.info("Добавление колонки has_made_first_topup в таблицу users")
+                
+                if db_type == 'sqlite':
+                    column_def = 'BOOLEAN DEFAULT 0'
+                else:
+                    column_def = 'BOOLEAN DEFAULT FALSE'
+                
+                await conn.execute(text(f"ALTER TABLE users ADD COLUMN has_made_first_topup {column_def}"))
+                logger.info("Колонка has_made_first_topup успешно добавлена")
+                
+                logger.info("Обновление существующих пользователей...")
+                
+                if db_type == 'sqlite':
+                    update_sql = """
+                        UPDATE users 
+                        SET has_made_first_topup = 1 
+                        WHERE balance_kopeks > 0 OR has_had_paid_subscription = 1
+                    """
+                else:
+                    update_sql = """
+                        UPDATE users 
+                        SET has_made_first_topup = TRUE 
+                        WHERE balance_kopeks > 0 OR has_had_paid_subscription = TRUE
+                    """
+                
+                result = await conn.execute(text(update_sql))
+                updated_count = result.rowcount
+                
+                logger.info(f"Обновлено {updated_count} пользователей с has_made_first_topup = TRUE")
+                logger.info("✅ Миграция реферальной системы завершена")
+                
+                return True
+            else:
+                logger.info("Колонка has_made_first_topup уже существует")
+                return True
+                
+    except Exception as e:
+        logger.error(f"Ошибка миграции реферальной системы: {e}")
+        return False
+
+async def create_subscription_conversions_table():
+    
+    table_exists = await check_table_exists('subscription_conversions')
+    if table_exists:
+        logger.info("Таблица subscription_conversions уже существует")
+        return True
+    
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+            
+            if db_type == 'sqlite':
+                create_sql = """
+                CREATE TABLE subscription_conversions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id INTEGER NOT NULL,
+                    converted_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    trial_duration_days INTEGER NULL,
+                    payment_method VARCHAR(50) NULL,
+                    first_payment_amount_kopeks INTEGER NULL,
+                    first_paid_period_days INTEGER NULL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                );
+                
+                CREATE INDEX idx_subscription_conversions_user_id ON subscription_conversions(user_id);
+                CREATE INDEX idx_subscription_conversions_converted_at ON subscription_conversions(converted_at);
+                """
+                
+            elif db_type == 'postgresql':
+                create_sql = """
+                CREATE TABLE subscription_conversions (
+                    id SERIAL PRIMARY KEY,
+                    user_id INTEGER NOT NULL,
+                    converted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    trial_duration_days INTEGER NULL,
+                    payment_method VARCHAR(50) NULL,
+                    first_payment_amount_kopeks INTEGER NULL,
+                    first_paid_period_days INTEGER NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                );
+                
+                CREATE INDEX idx_subscription_conversions_user_id ON subscription_conversions(user_id);
+                CREATE INDEX idx_subscription_conversions_converted_at ON subscription_conversions(converted_at);
+                """
+                
+            elif db_type == 'mysql':
+                create_sql = """
+                CREATE TABLE subscription_conversions (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    user_id INT NOT NULL,
+                    converted_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    trial_duration_days INT NULL,
+                    payment_method VARCHAR(50) NULL,
+                    first_payment_amount_kopeks INT NULL,
+                    first_paid_period_days INT NULL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                );
+                
+                CREATE INDEX idx_subscription_conversions_user_id ON subscription_conversions(user_id);
+                CREATE INDEX idx_subscription_conversions_converted_at ON subscription_conversions(converted_at);
+                """
+            else:
+                logger.error(f"Неподдерживаемый тип БД для создания таблицы: {db_type}")
+                return False
+            
+            await conn.execute(text(create_sql))
+            logger.info("✅ Таблица subscription_conversions успешно создана")
+            return True
+            
+    except Exception as e:
+        logger.error(f"Ошибка создания таблицы subscription_conversions: {e}")
+        return False
+
 async def fix_subscription_duplicates_universal():
     
     async with engine.begin() as conn:
@@ -321,7 +447,6 @@ async def fix_subscription_duplicates_universal():
             raise
 
 async def run_universal_migration():
-    
     logger.info("=== НАЧАЛО УНИВЕРСАЛЬНОЙ МИГРАЦИИ ===")
     
     try:
@@ -330,6 +455,10 @@ async def run_universal_migration():
         
         await add_remnawave_v2_columns()
         
+        referral_migration_success = await add_referral_system_columns()
+        if not referral_migration_success:
+            logger.warning("⚠️ Проблемы с миграцией реферальной системы")
+        
         logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ YOOKASSA ===")
         yookassa_created = await create_yookassa_payments_table()
         if yookassa_created:
@@ -337,6 +466,13 @@ async def run_universal_migration():
         else:
             logger.warning("⚠️ Проблемы с таблицей YooKassa payments")
         
+        logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ КОНВЕРСИЙ ПОДПИСОК ===")
+        conversions_created = await create_subscription_conversions_table()
+        if conversions_created:
+            logger.info("✅ Таблица subscription_conversions готова")
+        else:
+            logger.warning("⚠️ Проблемы с таблицей subscription_conversions")
+        
         async with engine.begin() as conn:
             total_subs = await conn.execute(text("SELECT COUNT(*) FROM subscriptions"))
             unique_users = await conn.execute(text("SELECT COUNT(DISTINCT user_id) FROM subscriptions"))
@@ -349,6 +485,7 @@ async def run_universal_migration():
             
             if total_count == unique_count:
                 logger.info("База данных уже в корректном состоянии")
+                logger.info("=== МИГРАЦИЯ ЗАВЕРШЕНА УСПЕШНО ===")
                 return True
         
         deleted_count = await fix_subscription_duplicates_universal()
@@ -368,8 +505,90 @@ async def run_universal_migration():
                 return False
             else:
                 logger.info("=== МИГРАЦИЯ ЗАВЕРШЕНА УСПЕШНО ===")
+                logger.info("✅ Реферальная система обновлена")
+                logger.info("✅ RemnaWave v2.1.5 колонки добавлены")
+                logger.info("✅ YooKassa таблица готова")
+                logger.info("✅ Таблица конверсий подписок создана")
+                logger.info("✅ Дубликаты подписок исправлены")
                 return True
                 
     except Exception as e:
         logger.error(f"=== ОШИБКА ВЫПОЛНЕНИЯ МИГРАЦИИ: {e} ===")
-        return False
+        return False
+
+async def check_migration_status():
+    logger.info("=== ПРОВЕРКА СТАТУСА МИГРАЦИЙ ===")
+    
+    try:
+        status = {
+            "has_made_first_topup_column": False,
+            "yookassa_table": False,
+            "remnawave_v2_columns": False,
+            "subscription_duplicates": False,
+            "subscription_conversions_table": False
+        }
+        
+        status["has_made_first_topup_column"] = await check_column_exists('users', 'has_made_first_topup')
+        
+        status["yookassa_table"] = await check_table_exists('yookassa_payments')
+        
+        status["subscription_conversions_table"] = await check_table_exists('subscription_conversions')
+        
+        remnawave_columns = ['lifetime_used_traffic_bytes', 'last_remnawave_sync', 'trojan_password', 'vless_uuid', 'ss_password']
+        remnawave_status = []
+        for col in remnawave_columns:
+            exists = await check_column_exists('users', col)
+            remnawave_status.append(exists)
+        status["remnawave_v2_columns"] = all(remnawave_status)
+        
+        async with engine.begin() as conn:
+            duplicates_check = await conn.execute(text("""
+                SELECT COUNT(*) FROM (
+                    SELECT user_id, COUNT(*) as count 
+                    FROM subscriptions 
+                    GROUP BY user_id 
+                    HAVING COUNT(*) > 1
+                ) as dups
+            """))
+            duplicates_count = duplicates_check.fetchone()[0]
+            status["subscription_duplicates"] = (duplicates_count == 0)
+        
+        check_names = {
+            "has_made_first_topup_column": "Колонка реферальной системы",
+            "yookassa_table": "Таблица YooKassa payments",
+            "subscription_conversions_table": "Таблица конверсий подписок",
+            "remnawave_v2_columns": "Колонки RemnaWave v2.1.5",
+            "subscription_duplicates": "Отсутствие дубликатов подписок"
+        }
+        
+        for check_key, check_status in status.items():
+            check_name = check_names.get(check_key, check_key)
+            icon = "✅" if check_status else "❌"
+            logger.info(f"{icon} {check_name}: {'OK' if check_status else 'ТРЕБУЕТ ВНИМАНИЯ'}")
+        
+        all_good = all(status.values())
+        if all_good:
+            logger.info("🎉 Все миграции выполнены успешно!")
+            
+            try:
+                async with engine.begin() as conn:
+                    conversions_count = await conn.execute(text("SELECT COUNT(*) FROM subscription_conversions"))
+                    users_count = await conn.execute(text("SELECT COUNT(*) FROM users"))
+                    
+                    conv_count = conversions_count.fetchone()[0]
+                    usr_count = users_count.fetchone()[0]
+                    
+                    logger.info(f"📊 Статистика: {usr_count} пользователей, {conv_count} конверсий записано")
+            except Exception as stats_error:
+                logger.debug(f"Не удалось получить дополнительную статистику: {stats_error}")
+                
+        else:
+            logger.warning("⚠️ Некоторые миграции требуют внимания")
+            missing_migrations = [check_names[k] for k, v in status.items() if not v]
+            logger.warning(f"Требуют выполнения: {', '.join(missing_migrations)}")
+        
+        return status
+        
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса миграций: {e}")
+        return None

app/external/remnawave_api.py

@@ -123,7 +123,7 @@ class RemnaWaveAPI:
     async def __aenter__(self):
         conn_type = self._detect_connection_type()
         
-        logger.info(f"🔗 Подключение к RemnaWave: {self.base_url} (тип: {conn_type})")
+        logger.info(f"🔗 Подключение к Remnawave: {self.base_url} (тип: {conn_type})")
             
         headers = {
             'Authorization': f'Bearer {self.api_key}',

app/external/tribute.py

@@ -10,10 +10,9 @@ logger = logging.getLogger(__name__)
 
 
 class TributeService:
-    
+
     def __init__(self):
         self.api_key = settings.TRIBUTE_API_KEY
-        self.webhook_secret = settings.TRIBUTE_WEBHOOK_SECRET
         self.donate_link = settings.TRIBUTE_DONATE_LINK
     
     async def create_payment_link(
@@ -38,27 +37,27 @@ class TributeService:
             return None
     
     def verify_webhook_signature(self, payload: str, signature: str) -> bool:
-        
-        if not self.webhook_secret:
-            logger.warning("Webhook secret не настроен, пропускаем проверку")
-            return True 
-        
+
+        if not self.api_key:
+            logger.warning("API key не настроен, пропускаем проверку")
+            return True
+
         try:
             expected_signature = hmac.new(
-                self.webhook_secret.encode(),
+                self.api_key.encode(),
                 payload.encode(),
                 hashlib.sha256
             ).hexdigest()
-            
+
             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

app/external/webhook_server.py

@@ -79,7 +79,7 @@ class WebhookServer:
             headers={
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
-                'Access-Control-Allow-Headers': 'Content-Type, X-Tribute-Signature',
+                'Access-Control-Allow-Headers': 'Content-Type, trbt-signature',
             }
         )
     
@@ -111,10 +111,17 @@ class WebhookServer:
                     status=400
                 )
             
-            signature = request.headers.get('X-Tribute-Signature')
+            signature = request.headers.get('trbt-signature')
             logger.info(f"🔐 Signature: {signature}")
-            
-            if signature and settings.TRIBUTE_WEBHOOK_SECRET:
+
+            if not signature:
+                logger.error("❌ Отсутствует заголовок подписи Tribute webhook")
+                return web.json_response(
+                    {"status": "error", "reason": "missing_signature"},
+                    status=401
+                )
+
+            if settings.TRIBUTE_API_KEY:
                 from app.external.tribute import TributeService as TributeAPI
                 tribute_api = TributeAPI()
                 if not tribute_api.verify_webhook_signature(payload, signature):
@@ -123,8 +130,8 @@ class WebhookServer:
                         {"status": "error", "reason": "invalid_signature"},
                         status=401
                     )
-            
-            result = await self.tribute_service.process_webhook(payload, signature)
+
+            result = await self.tribute_service.process_webhook(payload)
             
             if result:
                 logger.info(f"✅ Tribute webhook обработан успешно: {result}")

app/handlers/admin/maintenance.py

@@ -16,6 +16,7 @@ logger = logging.getLogger(__name__)
 
 class MaintenanceStates(StatesGroup):
     waiting_for_reason = State()
+    waiting_for_notification_message = State()
 
 
 @admin_required
@@ -30,6 +31,14 @@ async def show_maintenance_panel(
     
     status_info = maintenance_service.get_status_info()
     
+    try:
+        from app.services.remnawave_service import RemnaWaveService
+        rw_service = RemnaWaveService()
+        panel_status = await rw_service.get_panel_status_summary()
+    except Exception as e:
+        logger.error(f"Ошибка получения статуса панели: {e}")
+        panel_status = {"description": "❓ Не удалось проверить", "has_issues": True}
+    
     status_emoji = "🔧" if status_info["is_active"] else "✅"
     status_text = "Включен" if status_info["is_active"] else "Выключен"
     
@@ -55,14 +64,19 @@ async def show_maintenance_panel(
     if status_info["consecutive_failures"] > 0:
         failures_info = f"\n⚠️ <b>Неудачных проверок подряд:</b> {status_info['consecutive_failures']}"
     
+    panel_info = f"\n🌐 <b>Панель Remnawave:</b> {panel_status['description']}"
+    if panel_status.get("response_time"):
+        panel_info += f"\n⚡ <b>Время отклика:</b> {panel_status['response_time']}с"
+    
     message_text = f"""
-🔧 <b>Режим технических работ</b>
+🔧 <b>Управление техническими работами</b>
 
-{status_emoji} <b>Статус:</b> {status_text}
-{api_emoji} <b>API RemnaWave:</b> {api_text}
+{status_emoji} <b>Режим техработ:</b> {status_text}
+{api_emoji} <b>API Remnawave:</b> {api_text}
 {monitoring_emoji} <b>Мониторинг:</b> {monitoring_text}
 ⏱️ <b>Интервал проверки:</b> {status_info['check_interval']}с
 🤖 <b>Автовключение:</b> {'Включено' if status_info['auto_enable_configured'] else 'Отключено'}
+{panel_info}
 {enabled_info}
 {last_check_info}
 {failures_info}
@@ -72,7 +86,12 @@ async def show_maintenance_panel(
     
     await callback.message.edit_text(
         message_text,
-        reply_markup=get_maintenance_keyboard(db_user.language, status_info["is_active"], status_info["monitoring_active"])
+        reply_markup=get_maintenance_keyboard(
+            db_user.language, 
+            status_info["is_active"], 
+            status_info["monitoring_active"],
+            panel_status.get("has_issues", False)
+        )
     )
     await callback.answer()
 
@@ -186,6 +205,166 @@ async def force_api_check(
     await show_maintenance_panel(callback, db_user, db, None)
 
 
+@admin_required
+@error_handler
+async def check_panel_status(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    await callback.answer("Проверка статуса панели...", show_alert=False)
+    
+    try:
+        from app.services.remnawave_service import RemnaWaveService
+        rw_service = RemnaWaveService()
+        
+        status_data = await rw_service.check_panel_health()
+        
+        status_text = {
+            "online": "🟢 Панель работает нормально",
+            "offline": "🔴 Панель недоступна", 
+            "degraded": "🟡 Панель работает со сбоями"
+        }.get(status_data["status"], "❓ Статус неизвестен")
+        
+        message_parts = [
+            f"🌐 <b>Статус панели Remnawave</b>\n",
+            f"{status_text}",
+            f"⚡ Время отклика: {status_data.get('response_time', 0)}с",
+            f"👥 Пользователей онлайн: {status_data.get('users_online', 0)}",
+            f"🖥️ Нод онлайн: {status_data.get('nodes_online', 0)}/{status_data.get('total_nodes', 0)}"
+        ]
+        
+        if status_data.get("api_error"):
+            message_parts.append(f"❌ Ошибка: {status_data['api_error'][:100]}")
+        
+        message = "\n".join(message_parts)
+        
+        await callback.message.answer(message, parse_mode="HTML")
+        
+    except Exception as e:
+        await callback.message.answer(f"❌ Ошибка проверки статуса: {str(e)}")
+
+
+@admin_required
+@error_handler
+async def send_manual_notification(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    await state.set_state(MaintenanceStates.waiting_for_notification_message)
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(text="🟢 Онлайн", callback_data="manual_notify_online"),
+            types.InlineKeyboardButton(text="🔴 Офлайн", callback_data="manual_notify_offline")
+        ],
+        [
+            types.InlineKeyboardButton(text="🟡 Проблемы", callback_data="manual_notify_degraded"),
+            types.InlineKeyboardButton(text="🔧 Обслуживание", callback_data="manual_notify_maintenance")
+        ],
+        [types.InlineKeyboardButton(text="❌ Отмена", callback_data="maintenance_panel")]
+    ])
+    
+    await callback.message.edit_text(
+        "📢 <b>Ручная отправка уведомления</b>\n\nВыберите статус для уведомления:",
+        reply_markup=keyboard
+    )
+
+
+@admin_required
+@error_handler
+async def handle_manual_notification(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    status_map = {
+        "manual_notify_online": "online",
+        "manual_notify_offline": "offline", 
+        "manual_notify_degraded": "degraded",
+        "manual_notify_maintenance": "maintenance"
+    }
+    
+    status = status_map.get(callback.data)
+    if not status:
+        await callback.answer("Неизвестный статус")
+        return
+    
+    await state.update_data(notification_status=status)
+    
+    status_names = {
+        "online": "🟢 Онлайн",
+        "offline": "🔴 Офлайн",
+        "degraded": "🟡 Проблемы", 
+        "maintenance": "🔧 Обслуживание"
+    }
+    
+    await callback.message.edit_text(
+        f"📢 <b>Отправка уведомления: {status_names[status]}</b>\n\n"
+        f"Введите сообщение для уведомления или отправьте /skip для отправки без дополнительного текста:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data="maintenance_panel")]
+        ])
+    )
+
+
+@admin_required
+@error_handler
+async def process_notification_message(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    current_state = await state.get_state()
+    
+    if current_state != MaintenanceStates.waiting_for_notification_message:
+        return
+    
+    data = await state.get_data()
+    status = data.get("notification_status")
+    
+    if not status:
+        await message.answer("Ошибка: статус не выбран")
+        await state.clear()
+        return
+    
+    notification_message = ""
+    if message.text and message.text != "/skip":
+        notification_message = message.text[:300]
+    
+    try:
+        from app.services.remnawave_service import RemnaWaveService
+        rw_service = RemnaWaveService()
+        
+        success = await rw_service.send_manual_status_notification(
+            message.bot, 
+            status, 
+            notification_message
+        )
+        
+        if success:
+            await message.answer("✅ Уведомление отправлено")
+        else:
+            await message.answer("❌ Ошибка отправки уведомления")
+            
+    except Exception as e:
+        logger.error(f"Ошибка отправки ручного уведомления: {e}")
+        await message.answer(f"❌ Ошибка: {str(e)}")
+    
+    await state.clear()
+    
+    await message.answer(
+        "Вернуться к панели техработ:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔧 Панель техработ", callback_data="maintenance_panel")]
+        ])
+    )
+
+
 @admin_required
 @error_handler
 async def back_to_admin_panel(
@@ -224,6 +403,21 @@ def register_handlers(dp: Dispatcher):
         F.data == "maintenance_check_api"
     )
     
+    dp.callback_query.register(
+        check_panel_status,
+        F.data == "maintenance_check_panel"
+    )
+    
+    dp.callback_query.register(
+        send_manual_notification,
+        F.data == "maintenance_manual_notify"
+    )
+    
+    dp.callback_query.register(
+        handle_manual_notification,
+        F.data.startswith("manual_notify_")
+    )
+    
     dp.callback_query.register(
         back_to_admin_panel,
         F.data == "admin_panel"
@@ -233,3 +427,8 @@ def register_handlers(dp: Dispatcher):
         process_maintenance_reason,
         MaintenanceStates.waiting_for_reason
     )
+    
+    dp.message.register(
+        process_notification_message,
+        MaintenanceStates.waiting_for_notification_message
+    )

app/handlers/admin/promocodes.py

@@ -969,6 +969,38 @@ async def show_promocode_stats(
     await callback.message.edit_text(text, reply_markup=keyboard)
     await callback.answer()
 
+@admin_required
+@error_handler
+async def show_general_promocode_stats(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    total_codes = await get_promocodes_count(db)
+    active_codes = await get_promocodes_count(db, is_active=True)
+    
+    text = f"""
+📊 <b>Общая статистика промокодов</b>
+
+📈 <b>Основные показатели:</b>
+- Всего промокодов: {total_codes}
+- Активных: {active_codes}
+- Неактивных: {total_codes - active_codes}
+
+Для детальной статистики выберите конкретный промокод из списка.
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(text="🎫 К промокодам", callback_data="admin_promo_list")
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_promocodes")
+        ]
+    ])
+    
+    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")
@@ -984,6 +1016,7 @@ def register_handlers(dp: Dispatcher):
     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_general_promocode_stats, F.data == "admin_promo_general_stats")
     
     dp.callback_query.register(
         show_promocode_edit_menu, 
@@ -997,3 +1030,4 @@ def register_handlers(dp: Dispatcher):
     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)
+    

app/handlers/admin/referrals.py

@@ -1,6 +1,7 @@
 import logging
 from aiogram import Dispatcher, types, F
 from sqlalchemy.ext.asyncio import AsyncSession
+import datetime
 
 from app.config import settings
 from app.database.models import User
@@ -19,54 +20,197 @@ async def show_referral_statistics(
     db_user: User,
     db: AsyncSession
 ):
-    stats = await get_referral_statistics(db)
-    
-    avg_per_referrer = 0
-    if stats['active_referrers'] > 0:
-        avg_per_referrer = stats['total_paid_kopeks'] / stats['active_referrers']
-    
-    text = f"""
+    try:
+        stats = await get_referral_statistics(db)
+        
+        avg_per_referrer = 0
+        if stats.get('active_referrers', 0) > 0:
+            avg_per_referrer = stats.get('total_paid_kopeks', 0) / stats['active_referrers']
+        
+        current_time = datetime.datetime.now().strftime("%H:%M:%S")
+        
+        text = f"""
 🤝 <b>Реферальная статистика</b>
 
 <b>Общие показатели:</b>
-- Пользователей с рефералами: {stats['users_with_referrals']}
-- Активных рефереров: {stats['active_referrers']}
-- Выплачено всего: {settings.format_price(stats['total_paid_kopeks'])}
+- Пользователей с рефералами: {stats.get('users_with_referrals', 0)}
+- Активных рефереров: {stats.get('active_referrers', 0)}
+- Выплачено всего: {settings.format_price(stats.get('total_paid_kopeks', 0))}
 
 <b>За период:</b>
-- Сегодня: {settings.format_price(stats['today_earnings_kopeks'])}
-- За неделю: {settings.format_price(stats['week_earnings_kopeks'])}
-- За месяц: {settings.format_price(stats['month_earnings_kopeks'])}
+- Сегодня: {settings.format_price(stats.get('today_earnings_kopeks', 0))}
+- За неделю: {settings.format_price(stats.get('week_earnings_kopeks', 0))}
+- За месяц: {settings.format_price(stats.get('month_earnings_kopeks', 0))}
 
 <b>Средние показатели:</b>
 - На одного реферера: {settings.format_price(int(avg_per_referrer))}
 
 <b>Топ-5 рефереров:</b>
 """
-    
-    for i, referrer in enumerate(stats['top_referrers'][:5], 1):
-        text += f"{i}. ID {referrer['user_id']}: {settings.format_price(referrer['total_earned_kopeks'])} ({referrer['referrals_count']} реф.)\n"
-    
-    if not stats['top_referrers']:
-        text += "Нет данных\n"
-    
-    text += f"""
+        
+        top_referrers = stats.get('top_referrers', [])
+        if top_referrers:
+            for i, referrer in enumerate(top_referrers[:5], 1):
+                earned = referrer.get('total_earned_kopeks', 0)
+                count = referrer.get('referrals_count', 0)
+                user_id = referrer.get('user_id', 'N/A')
+                
+                if count > 0:
+                    text += f"{i}. ID {user_id}: {settings.format_price(earned)} ({count} реф.)\n"
+                else:
+                    logger.warning(f"Реферер {user_id} имеет {count} рефералов, но есть в топе")
+        else:
+            text += "Нет данных\n"
+        
+        text += f"""
 
-<b>Настройки:</b>
-- Бонус за регистрацию: {settings.format_price(settings.REFERRAL_REGISTRATION_REWARD)}
+<b>Настройки реферальной системы:</b>
+- Минимальное пополнение: {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}
+- Бонус за первое пополнение: {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}
+- Бонус пригласившему: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}
 - Бонус новому пользователю: {settings.format_price(settings.REFERRED_USER_REWARD)}
-- Комиссия: {settings.REFERRAL_COMMISSION_PERCENT}%
+- Комиссия с покупок: {settings.REFERRAL_COMMISSION_PERCENT}%
+- Уведомления: {'✅ Включены' if settings.REFERRAL_NOTIFICATIONS_ENABLED else '❌ Отключены'}
+
+<i>🕐 Обновлено: {current_time}</i>
 """
-    
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
             [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_referrals")],
+            [types.InlineKeyboardButton(text="👥 Топ рефереров", callback_data="admin_referrals_top")],
+            [types.InlineKeyboardButton(text="⚙️ Настройки", callback_data="admin_referrals_settings")],
             [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")]
         ])
-    )
+        
+        try:
+            await callback.message.edit_text(text, reply_markup=keyboard)
+            await callback.answer("Обновлено")
+        except Exception as edit_error:
+            if "message is not modified" in str(edit_error):
+                await callback.answer("Данные актуальны")
+            else:
+                logger.error(f"Ошибка редактирования сообщения: {edit_error}")
+                await callback.answer("Ошибка обновления")
+        
+    except Exception as e:
+        logger.error(f"Ошибка в show_referral_statistics: {e}", exc_info=True)
+        
+        current_time = datetime.datetime.now().strftime("%H:%M:%S")
+        text = f"""
+🤝 <b>Реферальная статистика</b>
+
+❌ <b>Ошибка загрузки данных</b>
+
+<b>Текущие настройки:</b>
+- Минимальное пополнение: {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}
+- Бонус за первое пополнение: {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}
+- Бонус пригласившему: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}
+- Бонус новому пользователю: {settings.format_price(settings.REFERRED_USER_REWARD)}
+- Комиссия с покупок: {settings.REFERRAL_COMMISSION_PERCENT}%
+
+<i>🕐 Время: {current_time}</i>
+"""
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Повторить", callback_data="admin_referrals")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")]
+        ])
+        
+        try:
+            await callback.message.edit_text(text, reply_markup=keyboard)
+        except:
+            pass
+        await callback.answer("Произошла ошибка при загрузке статистики")
+
+
+@admin_required
+@error_handler
+async def show_top_referrers(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        stats = await get_referral_statistics(db)
+        top_referrers = stats.get('top_referrers', [])
+        
+        text = "🏆 <b>Топ рефереров</b>\n\n"
+        
+        if top_referrers:
+            for i, referrer in enumerate(top_referrers[:20], 1): 
+                earned = referrer.get('total_earned_kopeks', 0)
+                count = referrer.get('referrals_count', 0)
+                display_name = referrer.get('display_name', 'N/A')
+                username = referrer.get('username', '')
+                telegram_id = referrer.get('telegram_id', 'N/A')
+                
+                if username:
+                    display_text = f"@{username} (ID{telegram_id})"
+                elif display_name and display_name != f"ID{telegram_id}":
+                    display_text = f"{display_name} (ID{telegram_id})"
+                else:
+                    display_text = f"ID{telegram_id}"
+                
+                emoji = ""
+                if i == 1:
+                    emoji = "🥇 "
+                elif i == 2:
+                    emoji = "🥈 "
+                elif i == 3:
+                    emoji = "🥉 "
+                
+                text += f"{emoji}{i}. {display_text}\n"
+                text += f"   💰 {settings.format_price(earned)} | 👥 {count} реф.\n\n"
+        else:
+            text += "Нет данных о рефererах\n"
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⬅️ К статистике", callback_data="admin_referrals")]
+        ])
+        
+        await callback.message.edit_text(text, reply_markup=keyboard)
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"Ошибка в show_top_referrers: {e}", exc_info=True)
+        await callback.answer("Ошибка загрузки топа рефереров")
+
+
+@admin_required
+@error_handler
+async def show_referral_settings(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    text = f"""
+⚙️ <b>Настройки реферальной системы</b>
+
+<b>Бонусы и награды:</b>
+• Минимальная сумма пополнения для участия: {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}
+• Бонус за первое пополнение реферала: {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}
+• Бонус пригласившему за первое пополнение: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}
+• Бонус новому пользователю при регистрации: {settings.format_price(settings.REFERRED_USER_REWARD)}
+
+<b>Комиссионные:</b>
+• Процент с каждой покупки реферала: {settings.REFERRAL_COMMISSION_PERCENT}%
+
+<b>Уведомления:</b>
+• Статус: {'✅ Включены' if settings.REFERRAL_NOTIFICATIONS_ENABLED else '❌ Отключены'}
+• Попытки отправки: {getattr(settings, 'REFERRAL_NOTIFICATION_RETRY_ATTEMPTS', 3)}
+
+<i>💡 Для изменения настроек отредактируйте файл .env и перезапустите бота</i>
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="⬅️ К статистике", callback_data="admin_referrals")]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
     await callback.answer()
 
 
 def register_handlers(dp: Dispatcher):
-    dp.callback_query.register(show_referral_statistics, F.data == "admin_referrals")
+    dp.callback_query.register(show_referral_statistics, F.data == "admin_referrals")
+    dp.callback_query.register(show_top_referrers, F.data == "admin_referrals_top")
+    dp.callback_query.register(show_referral_settings, F.data == "admin_referrals_settings")

app/handlers/admin/remnawave.py

@@ -34,7 +34,7 @@ async def show_remnawave_menu(
    status_emoji = "✅" if connection_test["status"] == "connected" else "❌"
    
    text = f"""
-🖥️ <b>Управление RemnaWave</b>
+🖥️ <b>Управление Remnawave</b>
 
 📡 <b>Соединение:</b> {status_emoji} {connection_test["message"]}
 🌐 <b>URL:</b> <code>{settings.REMNAWAVE_API_URL}</code>
@@ -116,7 +116,7 @@ async def show_system_stats(
            return f" (🔺 {difference_str})"
    
    text = f"""
-📊 <b>Детальная статистика RemnaWave</b>
+📊 <b>Детальная статистика Remnawave</b>
 
 🖥️ <b>Сервер:</b>
 - CPU: {server_info.get('cpu_cores', 0)} ядер ({server_info.get('cpu_physical_cores', 0)} физ.)
@@ -238,7 +238,7 @@ async def show_traffic_stats(
             return f" 🔺 {diff_str}"
     
     text = f"""
-📊 <b>Статистика трафика RemnaWave</b>
+📊 <b>Статистика трафика Remnawave</b>
 
 ⚡ <b>Реалтайм данные:</b>
 - Скачивание: {format_bytes(total_realtime_download)}
@@ -1247,7 +1247,7 @@ async def finish_squad_creation(
             f"Сквад готов к использованию!",
             reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
                 [types.InlineKeyboardButton(text="📋 Список сквадов", callback_data="admin_rw_squads")],
-                [types.InlineKeyboardButton(text="⬅️ К панели RemnaWave", callback_data="admin_remnawave")]
+                [types.InlineKeyboardButton(text="⬅️ К панели Remnawave", callback_data="admin_remnawave")]
             ])
         )
         await callback.answer("✅ Сквад создан!")
@@ -1320,7 +1320,7 @@ async def show_sync_options(
     db: AsyncSession
 ):
     text = """
-🔄 <b>Синхронизация с RemnaWave</b>
+🔄 <b>Синхронизация с Remnawave</b>
 
 🔄 <b>Полная синхронизация выполняет:</b>
 • Создание новых пользователей из панели в боте
@@ -1360,7 +1360,7 @@ async def sync_all_users(
 🔄 <b>Выполняется полная синхронизация...</b>
 
 📋 Этапы:
-• Загрузка ВСЕХ пользователей из панели RemnaWave
+• Загрузка ВСЕХ пользователей из панели Remnawave
 • Создание новых пользователей в боте
 • Обновление существующих пользователей
 • Деактивация подписок отсутствующих пользователей
@@ -1401,7 +1401,7 @@ async def sync_all_users(
 
 🗑️ <b>Деактивированные подписки:</b>
 Деактивированы подписки пользователей, которые
-отсутствуют в панели RemnaWave.
+отсутствуют в панели Remnawave.
 💰 Балансы пользователей сохранены.
 """
     
@@ -1546,7 +1546,7 @@ async def validate_subscriptions(
     if stats['fixed'] > 0:
         text += "\n✅ <b>Исправленные проблемы:</b>\n"
         text += "• Статусы просроченных подписок\n"
-        text += "• Отсутствующие данные RemnaWave\n" 
+        text += "• Отсутствующие данные Remnawave\n" 
         text += "• Некорректные лимиты трафика\n"
         text += "• Настройки устройств\n"
     
@@ -1600,7 +1600,7 @@ async def cleanup_subscriptions(
     if stats['deactivated'] > 0:
         text += f"\n🗑️ <b>Деактивированные подписки:</b>\n"
         text += f"Отключены подписки пользователей, которые\n"
-        text += f"отсутствуют в панели RemnaWave.\n"
+        text += f"отсутствуют в панели Remnawave.\n"
     else:
         text += f"\n✅ Все подписки актуальны!\nНеактуальных подписок не найдено."
     
@@ -1664,8 +1664,8 @@ async def force_cleanup_all_orphaned_users(
 • Удалены использования промокодов
 • Сброшены балансы к нулю
 • Удалены подключенные серверы
-• Сброшены HWID устройства в RemnaWave
-• Очищены RemnaWave UUID
+• Сброшены HWID устройства в Remnawave
+• Очищены Remnawave UUID
 """
     else:
         text += f"\n✅ Неактуальных подписок не найдено!\nВсе пользователи синхронизированы с панелью."
@@ -1703,8 +1703,8 @@ async def confirm_force_cleanup(
 • ВСЕ использования промокодов
 • ВСЕ подключенные серверы подписок
 • ВСЕ балансы (сброс к нулю)
-• ВСЕ HWID устройства в RemnaWave
-• ВСЕ RemnaWave UUID и ссылки
+• ВСЕ HWID устройства в Remnawave
+• ВСЕ Remnawave UUID и ссылки
 
 ⚡ <b>Это действие НЕОБРАТИМО!</b>
 
@@ -1813,7 +1813,7 @@ async def sync_users(
    if sync_type == "all_users" and 'deleted' in stats and stats['deleted'] > 0:
        text += f"\n🗑️ <b>Удаленные подписки:</b>\n"
        text += f"Деактивированы подписки пользователей,\n"
-       text += f"которые отсутствуют в панели RemnaWave."
+       text += f"которые отсутствуют в панели Remnawave."
    
    text += f"\n\n💡 <b>Рекомендации:</b>\n"
    if sync_type == "all_users":

app/handlers/admin/servers.py

@@ -51,9 +51,6 @@ async def show_servers_menu(
             types.InlineKeyboardButton(text="📊 Синхронизировать счетчики", callback_data="admin_servers_sync_counts"),
             types.InlineKeyboardButton(text="📈 Подробная статистика", callback_data="admin_servers_stats")
         ],
-        [
-            types.InlineKeyboardButton(text="➕ Добавить сервер", callback_data="admin_servers_add")
-        ],
         [
             types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
         ]
@@ -130,10 +127,6 @@ async def show_servers_list(
         keyboard.append(nav_row)
     
     keyboard.extend([
-        [
-            types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_servers_list"),
-            types.InlineKeyboardButton(text="➕ Добавить", callback_data="admin_servers_add")
-        ],
         [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
     ])
     
@@ -154,7 +147,7 @@ async def sync_servers_with_remnawave(
 ):
     
     await callback.message.edit_text(
-        "🔄 Синхронизация с RemnaWave...\n\nПодождите, это может занять время.",
+        "🔄 Синхронизация с Remnawave...\n\nПодождите, это может занять время.",
         reply_markup=None
     )
     
@@ -164,7 +157,7 @@ async def sync_servers_with_remnawave(
         
         if not squads:
             await callback.message.edit_text(
-                "❌ Не удалось получить данные о сквадах из RemnaWave.\n\nПроверьте настройки API.",
+                "❌ Не удалось получить данные о сквадах из Remnawave.\n\nПроверьте настройки API.",
                 reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
                     [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
                 ])
@@ -959,4 +952,4 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(delete_server_confirm, F.data.startswith("admin_server_delete_") & ~F.data.contains("confirm"))
     dp.callback_query.register(delete_server_execute, F.data.startswith("admin_server_delete_confirm_"))
     
-    dp.callback_query.register(handle_servers_pagination, F.data.startswith("admin_servers_list_page_"))
+    dp.callback_query.register(handle_servers_pagination, F.data.startswith("admin_servers_list_page_"))

app/handlers/admin/statistics.py

@@ -50,6 +50,8 @@ async def show_users_statistics(
     total_users = stats['total_users']
     active_rate = format_percentage(stats['active_users'] / total_users * 100 if total_users > 0 else 0)
     
+    current_time = format_datetime(datetime.utcnow())
+    
     text = f"""
 👥 <b>Статистика пользователей</b>
 
@@ -66,16 +68,27 @@ async def show_users_statistics(
 <b>Активность:</b>
 - Коэффициент активности: {active_rate}
 - Рост за месяц: +{stats['new_month']} ({format_percentage(stats['new_month'] / total_users * 100 if total_users > 0 else 0)})
+
+<b>Обновлено:</b> {current_time}
 """
     
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_users")],
-            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
-        ])
-    )
-    await callback.answer()
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_users")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+    ])
+    
+    try:
+        await callback.message.edit_text(text, reply_markup=keyboard)
+    except Exception as e:
+        if "message is not modified" in str(e):
+            await callback.answer("📊 Данные актуальны", show_alert=False)
+        else:
+            logger.error(f"Ошибка обновления статистики пользователей: {e}")
+            await callback.answer("❌ Ошибка обновления данных", show_alert=True)
+            return
+    
+    await callback.answer("✅ Статистика обновлена")
+
 
 
 @admin_required
@@ -89,6 +102,7 @@ async def show_subscriptions_statistics(
     
     total_subs = stats['total_subscriptions']
     conversion_rate = format_percentage(stats['paid_subscriptions'] / total_subs * 100 if total_subs > 0 else 0)
+    current_time = format_datetime(datetime.utcnow())
     
     text = f"""
 📱 <b>Статистика подписок</b>
@@ -107,16 +121,24 @@ async def show_subscriptions_statistics(
 - Сегодня: {stats['purchased_today']}
 - За неделю: {stats['purchased_week']}
 - За месяц: {stats['purchased_month']}
+
+<b>Обновлено:</b> {current_time}
 """
     
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_subs")],
-            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
-        ])
-    )
-    await callback.answer()
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_subs")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+    ])
+    
+    try:
+        await callback.message.edit_text(text, reply_markup=keyboard)
+        await callback.answer("✅ Статистика обновлена")
+    except Exception as e:
+        if "message is not modified" in str(e):
+            await callback.answer("📊 Данные актуальны", show_alert=False)
+        else:
+            logger.error(f"Ошибка обновления статистики подписок: {e}")
+            await callback.answer("❌ Ошибка обновления данных", show_alert=True)
 
 
 @admin_required
@@ -131,6 +153,7 @@ async def show_revenue_statistics(
     
     month_stats = await get_transactions_statistics(db, month_start, now)
     all_time_stats = await get_transactions_statistics(db)
+    current_time = format_datetime(datetime.utcnow())
     
     text = f"""
 💰 <b>Статистика доходов</b>
@@ -156,15 +179,23 @@ async def show_revenue_statistics(
         if method and data['count'] > 0:
             text += f"• {method}: {data['count']} ({settings.format_price(data['amount'])})\n"
     
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-            [types.InlineKeyboardButton(text="📈 Период", callback_data="admin_revenue_period")],
-            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_revenue")],
-            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
-        ])
-    )
-    await callback.answer()
+    text += f"\n<b>Обновлено:</b> {current_time}"
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+      # [types.InlineKeyboardButton(text="📈 Период", callback_data="admin_revenue_period")],
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_revenue")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+    ])
+    
+    try:
+        await callback.message.edit_text(text, reply_markup=keyboard)
+        await callback.answer("✅ Статистика обновлена")
+    except Exception as e:
+        if "message is not modified" in str(e):
+            await callback.answer("📊 Данные актуальны", show_alert=False)
+        else:
+            logger.error(f"Ошибка обновления статистики доходов: {e}")
+            await callback.answer("❌ Ошибка обновления данных", show_alert=True)
 
 
 @admin_required
@@ -175,6 +206,7 @@ async def show_referral_statistics(
     db: AsyncSession
 ):
     stats = await get_referral_statistics(db)
+    current_time = format_datetime(datetime.utcnow())
     
     avg_per_referrer = 0
     if stats['active_referrers'] > 0:
@@ -194,7 +226,7 @@ async def show_referral_statistics(
 - За месяц: {settings.format_price(stats['month_earnings_kopeks'])}
 
 <b>Средние показатели:</b>
-- На одного реферера: {settings.format_price(int(avg_per_referrer))}
+- На одного рефререра: {settings.format_price(int(avg_per_referrer))}
 
 <b>Топ рефереры:</b>
 """
@@ -208,14 +240,22 @@ async def show_referral_statistics(
     else:
         text += "Пока нет активных рефереров"
     
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_referrals")],
-            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
-        ])
-    )
-    await callback.answer()
+    text += f"\n<b>Обновлено:</b> {current_time}"
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_referrals")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+    ])
+    
+    try:
+        await callback.message.edit_text(text, reply_markup=keyboard)
+        await callback.answer("✅ Статистика обновлена")
+    except Exception as e:
+        if "message is not modified" in str(e):
+            await callback.answer("📊 Данные актуальны", show_alert=False)
+        else:
+            logger.error(f"Ошибка обновления реферальной статистики: {e}")
+            await callback.answer("❌ Ошибка обновления данных", show_alert=True)
 
 
 @admin_required
@@ -232,6 +272,7 @@ async def show_summary_statistics(
     now = datetime.utcnow()
     month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
     revenue_stats = await get_transactions_statistics(db, month_start, now)
+    current_time = format_datetime(datetime.utcnow())
     
     conversion_rate = 0
     if user_stats['total_users'] > 0:
@@ -263,18 +304,23 @@ async def show_summary_statistics(
 - Пользователи: +{user_stats['new_month']} за месяц
 - Продажи: +{sub_stats['purchased_month']} за месяц
 
-<b>Обновлено:</b> {format_datetime(datetime.utcnow())}
+<b>Обновлено:</b> {current_time}
 """
     
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_summary")],
-            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
-        ])
-    )
-    await callback.answer()
-
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_summary")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+    ])
+    
+    try:
+        await callback.message.edit_text(text, reply_markup=keyboard)
+        await callback.answer("✅ Статистика обновлена")
+    except Exception as e:
+        if "message is not modified" in str(e):
+            await callback.answer("📊 Данные актуальны", show_alert=False)
+        else:
+            logger.error(f"Ошибка обновления общей статистики: {e}")
+            await callback.answer("❌ Ошибка обновления данных", show_alert=True)
 
 @admin_required
 @error_handler
@@ -347,4 +393,4 @@ def register_handlers(dp: Dispatcher):
         dp.callback_query.register(
             show_revenue_by_period,
             F.data == f"period_{period}"
-        )
+        )

app/handlers/admin/subscriptions.py

@@ -260,11 +260,11 @@ async def show_subscriptions_stats(
 """
     
     keyboard = [
-        [
-            types.InlineKeyboardButton(text="📊 Экспорт данных", callback_data="admin_subs_export"),
-            types.InlineKeyboardButton(text="📈 Графики", callback_data="admin_subs_charts")
-        ],
-        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_stats")],
+       # [
+       #     types.InlineKeyboardButton(text="📊 Экспорт данных", callback_data="admin_subs_export"),
+       #     types.InlineKeyboardButton(text="📈 Графики", callback_data="admin_subs_charts")
+       # ],
+       # [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_stats")],
         [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")]
     ]
     

app/handlers/admin/user_messages.py

@@ -0,0 +1,584 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.filters import StateFilter
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.user_message import (
+    create_user_message, get_all_user_messages, get_user_message_by_id,
+    update_user_message, delete_user_message, toggle_user_message_status,
+    get_user_messages_stats
+)
+from app.database.models import User
+from app.keyboards.admin import get_admin_main_keyboard
+from app.utils.decorators import admin_required, error_handler
+from app.localization.texts import get_texts
+
+logger = logging.getLogger(__name__)
+
+
+class UserMessageStates(StatesGroup):
+    waiting_for_message_text = State()
+    waiting_for_edit_text = State()
+
+
+def get_user_messages_keyboard(language: str = "ru"):
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text="📝 Добавить сообщение",
+                callback_data="add_user_message"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="📋 Список сообщений",
+                callback_data="list_user_messages:0"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="📊 Статистика",
+                callback_data="user_messages_stats"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="🔙 Назад в админку",
+                callback_data="admin_panel"
+            )
+        ]
+    ])
+
+
+def get_message_actions_keyboard(message_id: int, is_active: bool, language: str = "ru"):
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+    
+    status_text = "🔴 Деактивировать" if is_active else "🟢 Активировать"
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text="✏️ Редактировать",
+                callback_data=f"edit_user_message:{message_id}"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=status_text,
+                callback_data=f"toggle_user_message:{message_id}"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="🗑️ Удалить",
+                callback_data=f"delete_user_message:{message_id}"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="🔙 К списку",
+                callback_data="list_user_messages:0"
+            )
+        ]
+    ])
+
+
+@admin_required
+@error_handler
+async def show_user_messages_panel(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    text = (
+        "📢 <b>Управление сообщениями в главном меню</b>\n\n"
+        "Здесь вы можете добавлять сообщения, которые будут показываться пользователям "
+        "в главном меню между информацией о подписке и кнопками действий.\n\n"
+        "• Сообщения поддерживают HTML теги\n"
+        "• Можно создать несколько сообщений\n"
+        "• Активные сообщения показываются случайно\n"
+        "• Неактивные сообщения не показываются"
+    )
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_user_messages_keyboard(db_user.language),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def add_user_message_start(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    from app.utils.validators import get_html_help_text
+    
+    await callback.message.edit_text(
+        f"📝 <b>Добавление нового сообщения</b>\n\n"
+        f"Введите текст сообщения, которое будет показываться в главном меню.\n\n"
+        f"{get_html_help_text()}\n\n"
+        f"Отправьте /cancel для отмены.",
+        parse_mode="HTML"
+    )
+    
+    await state.set_state(UserMessageStates.waiting_for_message_text)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_new_message_text(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    if message.text == "/cancel":
+        await state.clear()
+        await message.answer(
+            "❌ Добавление сообщения отменено.",
+            reply_markup=get_user_messages_keyboard(db_user.language)
+        )
+        return
+    
+    message_text = message.text.strip()
+    
+    if len(message_text) > 4000:
+        await message.answer(
+            "❌ Сообщение слишком длинное. Максимум 4000 символов.\n"
+            "Попробуйте еще раз или отправьте /cancel для отмены."
+        )
+        return
+    
+    from app.utils.validators import validate_html_tags, get_html_help_text
+    
+    is_valid, error_msg = validate_html_tags(message_text)
+    if not is_valid:
+        await message.answer(
+            f"❌ Ошибка в HTML разметке: {error_msg}\n\n"
+            f"Исправьте ошибку и попробуйте еще раз, или отправьте /cancel для отмены.",
+            parse_mode=None 
+        )
+        return
+    
+    try:
+        new_message = await create_user_message(
+            db=db,
+            message_text=message_text,
+            created_by=db_user.id,
+            is_active=True
+        )
+        
+        await state.clear()
+        
+        await message.answer(
+            f"✅ <b>Сообщение добавлено!</b>\n\n"
+            f"<b>ID:</b> {new_message.id}\n"
+            f"<b>Статус:</b> {'🟢 Активно' if new_message.is_active else '🔴 Неактивно'}\n"
+            f"<b>Создано:</b> {new_message.created_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+            f"<b>Предварительный просмотр:</b>\n"
+            f"<blockquote>{message_text}</blockquote>",
+            reply_markup=get_user_messages_keyboard(db_user.language),
+            parse_mode="HTML"
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания сообщения: {e}")
+        await state.clear()
+        await message.answer(
+            "❌ Произошла ошибка при создании сообщения. Попробуйте еще раз.",
+            reply_markup=get_user_messages_keyboard(db_user.language)
+        )
+
+@admin_required
+@error_handler
+async def list_user_messages(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    page = 0
+    if ":" in callback.data:
+        try:
+            page = int(callback.data.split(":")[1])
+        except (ValueError, IndexError):
+            page = 0
+    
+    limit = 5
+    offset = page * limit
+    
+    messages = await get_all_user_messages(db, offset=offset, limit=limit)
+    
+    if not messages:
+        await callback.message.edit_text(
+            "📋 <b>Список сообщений</b>\n\n"
+            "Сообщений пока нет. Добавьте первое сообщение!",
+            reply_markup=get_user_messages_keyboard(db_user.language),
+            parse_mode="HTML"
+        )
+        await callback.answer()
+        return
+    
+    text = "📋 <b>Список сообщений</b>\n\n"
+    
+    for msg in messages:
+        status_emoji = "🟢" if msg.is_active else "🔴"
+        preview = msg.message_text[:100] + "..." if len(msg.message_text) > 100 else msg.message_text
+        preview = preview.replace('<', '&lt;').replace('>', '&gt;')
+        
+        text += (
+            f"{status_emoji} <b>ID {msg.id}</b>\n"
+            f"{preview}\n"
+            f"📅 {msg.created_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+        )
+    
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+    
+    keyboard = []
+    
+    for msg in messages:
+        status_emoji = "🟢" if msg.is_active else "🔴"
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"{status_emoji} ID {msg.id}",
+                callback_data=f"view_user_message:{msg.id}"
+            )
+        ])
+    
+    nav_buttons = []
+    if page > 0:
+        nav_buttons.append(
+            InlineKeyboardButton(
+                text="⬅️ Назад",
+                callback_data=f"list_user_messages:{page-1}"
+            )
+        )
+    
+    nav_buttons.append(
+        InlineKeyboardButton(
+            text="➕ Добавить",
+            callback_data="add_user_message"
+        )
+    )
+    
+    if len(messages) == limit:  
+        nav_buttons.append(
+            InlineKeyboardButton(
+                text="Вперед ➡️",
+                callback_data=f"list_user_messages:{page+1}"
+            )
+        )
+    
+    if nav_buttons:
+        keyboard.append(nav_buttons)
+    
+    keyboard.append([
+        InlineKeyboardButton(
+            text="🔙 Назад",
+            callback_data="user_messages_panel"
+        )
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def view_user_message(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        message_id = int(callback.data.split(":")[1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Неверный ID сообщения", show_alert=True)
+        return
+    
+    message = await get_user_message_by_id(db, message_id)
+    
+    if not message:
+        await callback.answer("❌ Сообщение не найдено", show_alert=True)
+        return
+    
+    status_text = "🟢 Активно" if message.is_active else "🔴 Неактивно"
+    
+    text = (
+        f"📋 <b>Сообщение ID {message.id}</b>\n\n"
+        f"<b>Статус:</b> {status_text}\n"
+        f"<b>Создано:</b> {message.created_at.strftime('%d.%m.%Y %H:%M')}\n"
+        f"<b>Обновлено:</b> {message.updated_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+        f"<b>Содержимое:</b>\n"
+        f"<blockquote>{message.message_text}</blockquote>"
+    )
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_message_actions_keyboard(
+            message_id, message.is_active, db_user.language
+        ),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_message_status(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        message_id = int(callback.data.split(":")[1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Неверный ID сообщения", show_alert=True)
+        return
+    
+    message = await toggle_user_message_status(db, message_id)
+    
+    if not message:
+        await callback.answer("❌ Сообщение не найдено", show_alert=True)
+        return
+    
+    status_text = "активировано" if message.is_active else "деактивировано"
+    await callback.answer(f"✅ Сообщение {status_text}")
+    
+    await view_user_message(callback, db_user, db)
+
+
+@admin_required
+@error_handler
+async def delete_message_confirm(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    """Подтвердить удаление сообщения"""
+    try:
+        message_id = int(callback.data.split(":")[1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Неверный ID сообщения", show_alert=True)
+        return
+    
+    success = await delete_user_message(db, message_id)
+    
+    if success:
+        await callback.answer("✅ Сообщение удалено")
+        await list_user_messages(
+            types.CallbackQuery(
+                id=callback.id,
+                from_user=callback.from_user,
+                chat_instance=callback.chat_instance,
+                data="list_user_messages:0",
+                message=callback.message
+            ),
+            db_user,
+            db
+        )
+    else:
+        await callback.answer("❌ Ошибка удаления сообщения", show_alert=True)
+
+
+@admin_required
+@error_handler
+async def show_messages_stats(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    stats = await get_user_messages_stats(db)
+    
+    text = (
+        "📊 <b>Статистика сообщений</b>\n\n"
+        f"📝 Всего сообщений: <b>{stats['total_messages']}</b>\n"
+        f"🟢 Активных: <b>{stats['active_messages']}</b>\n"
+        f"🔴 Неактивных: <b>{stats['inactive_messages']}</b>\n\n"
+        "Активные сообщения показываются пользователям случайным образом "
+        "в главном меню между информацией о подписке и кнопками действий."
+    )
+    
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+    
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text="🔙 Назад",
+                callback_data="user_messages_panel"
+            )
+        ]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def edit_user_message_start(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        message_id = int(callback.data.split(":")[1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Неверный ID сообщения", show_alert=True)
+        return
+    
+    message = await get_user_message_by_id(db, message_id)
+    
+    if not message:
+        await callback.answer("❌ Сообщение не найдено", show_alert=True)
+        return
+    
+    await callback.message.edit_text(
+        f"✏️ <b>Редактирование сообщения ID {message.id}</b>\n\n"
+        f"<b>Текущий текст:</b>\n"
+        f"<blockquote>{message.message_text}</blockquote>\n\n"
+        f"Введите новый текст сообщения или отправьте /cancel для отмены:",
+        parse_mode="HTML"
+    )
+    
+    await state.set_data({"editing_message_id": message_id})
+    await state.set_state(UserMessageStates.waiting_for_edit_text)
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def process_edit_message_text(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    if message.text == "/cancel":
+        await state.clear()
+        await message.answer(
+            "❌ Редактирование отменено.",
+            reply_markup=get_user_messages_keyboard(db_user.language)
+        )
+        return
+    
+    data = await state.get_data()
+    message_id = data.get("editing_message_id")
+    
+    if not message_id:
+        await state.clear()
+        await message.answer("❌ Ошибка: ID сообщения не найден")
+        return
+    
+    new_text = message.text.strip()
+    
+    if len(new_text) > 4000:
+        await message.answer(
+            "❌ Сообщение слишком длинное. Максимум 4000 символов.\n"
+            "Попробуйте еще раз или отправьте /cancel для отмены."
+        )
+        return
+    
+    try:
+        updated_message = await update_user_message(
+            db=db,
+            message_id=message_id,
+            message_text=new_text
+        )
+        
+        if updated_message:
+            await state.clear()
+            await message.answer(
+                f"✅ <b>Сообщение обновлено!</b>\n\n"
+                f"<b>ID:</b> {updated_message.id}\n"
+                f"<b>Обновлено:</b> {updated_message.updated_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+                f"<b>Новый текст:</b>\n"
+                f"<blockquote>{new_text}</blockquote>",
+                reply_markup=get_user_messages_keyboard(db_user.language),
+                parse_mode="HTML"
+            )
+        else:
+            await state.clear()
+            await message.answer(
+                "❌ Сообщение не найдено или ошибка обновления.",
+                reply_markup=get_user_messages_keyboard(db_user.language)
+            )
+        
+    except Exception as e:
+        logger.error(f"Ошибка обновления сообщения: {e}")
+        await state.clear()
+        await message.answer(
+            "❌ Произошла ошибка при обновлении сообщения.",
+            reply_markup=get_user_messages_keyboard(db_user.language)
+        )
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_user_messages_panel,
+        F.data == "user_messages_panel"
+    )
+    
+    dp.callback_query.register(
+        add_user_message_start,
+        F.data == "add_user_message"
+    )
+    
+    dp.message.register(
+        process_new_message_text,
+        StateFilter(UserMessageStates.waiting_for_message_text)
+    )
+
+    dp.callback_query.register(
+        edit_user_message_start,
+        F.data.startswith("edit_user_message:")
+    )
+    
+    dp.message.register(
+        process_edit_message_text,
+        StateFilter(UserMessageStates.waiting_for_edit_text)
+    )
+    
+    dp.callback_query.register(
+        list_user_messages,
+        F.data.startswith("list_user_messages")
+    )
+    
+    dp.callback_query.register(
+        view_user_message,
+        F.data.startswith("view_user_message:")
+    )
+    
+    dp.callback_query.register(
+        toggle_message_status,
+        F.data.startswith("toggle_user_message:")
+    )
+    
+    dp.callback_query.register(
+        delete_message_confirm,
+        F.data.startswith("delete_user_message:")
+    )
+    
+    dp.callback_query.register(
+        show_messages_stats,
+        F.data == "user_messages_stats"
+    )

app/handlers/admin/users.py

@@ -1,6 +1,7 @@
 import logging
 from datetime import datetime
 from aiogram import Dispatcher, types, F
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -292,6 +293,12 @@ async def show_user_subscription(
                     text="📊 Трафик", 
                     callback_data=f"admin_sub_traffic_{user_id}"
                 )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text="🔄 Тип подписки", 
+                    callback_data=f"admin_sub_change_type_{user_id}"
+                )
             ]
         ]
         
@@ -827,6 +834,8 @@ async def show_user_statistics(
     user = profile["user"]
     subscription = profile["subscription"]
     
+    referral_stats = await get_detailed_referral_stats(db, user.id)
+    
     text = f"📊 <b>Статистика пользователя</b>\n\n"
     text += f"👤 {user.full_name} (ID: <code>{user.telegram_id}</code>)\n\n"
     
@@ -839,7 +848,7 @@ async def show_user_statistics(
     text += f"<b>Подписка:</b>\n"
     if subscription:
         sub_status = "✅ Активна" if subscription.is_active else "❌ Неактивна"
-        sub_type = " (триал)" if subscription.is_trial else " (платная)"
+        sub_type = " (пробная)" if subscription.is_trial else " (платная)"
         text += f"• Статус: {sub_status}{sub_type}\n"
         text += f"• Трафик: {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
         text += f"• Устройства: {subscription.device_limit}\n"
@@ -848,11 +857,39 @@ async def show_user_statistics(
         text += f"• Отсутствует\n"
     
     text += f"\n<b>Реферальная программа:</b>\n"
+    
     if user.referred_by_id:
-        text += f"• Пришел по рефералке\n"
+        referrer = await get_user_by_id(db, user.referred_by_id)
+        if referrer:
+            text += f"• Пришел по реферальной ссылке от <b>{referrer.full_name}</b>\n"
+        else:
+            text += f"• Пришел по реферальной ссылке (реферер не найден)\n"
     else:
         text += f"• Прямая регистрация\n"
-    text += f"• Реферальный код: <code>{user.referral_code}</code>\n"
+    
+    text += f"• Реферальный код: <code>{user.referral_code}</code>\n\n"
+    
+    if referral_stats['invited_count'] > 0:
+        text += f"<b>Доходы от рефералов:</b>\n"
+        text += f"• Всего приглашено: {referral_stats['invited_count']}\n"
+        text += f"• Активных рефералов: {referral_stats['active_referrals']}\n"
+        text += f"• Общий доход: {settings.format_price(referral_stats['total_earned_kopeks'])}\n"
+        text += f"• Доход за месяц: {settings.format_price(referral_stats['month_earned_kopeks'])}\n"
+        
+        if referral_stats['referrals_detail']:
+            text += f"\n<b>Детали по рефералам:</b>\n"
+            for detail in referral_stats['referrals_detail'][:5]: 
+                referral_name = detail['referral_name']
+                earned = settings.format_price(detail['total_earned_kopeks'])
+                status = "🟢" if detail['is_active'] else "🔴"
+                text += f"• {status} {referral_name}: {earned}\n"
+            
+            if len(referral_stats['referrals_detail']) > 5:
+                text += f"• ... и еще {len(referral_stats['referrals_detail']) - 5} рефералов\n"
+    else:
+        text += f"<b>Реферальная программа:</b>\n"
+        text += f"• Рефералов нет\n"
+        text += f"• Доходов нет\n"
     
     await callback.message.edit_text(
         text,
@@ -862,6 +899,64 @@ async def show_user_statistics(
     )
     await callback.answer()
 
+
+async def get_detailed_referral_stats(db: AsyncSession, user_id: int) -> dict:
+    from app.database.crud.referral import get_user_referral_stats, get_referral_earnings_by_user
+    from sqlalchemy import select, func
+    from sqlalchemy.orm import selectinload
+    
+    base_stats = await get_user_referral_stats(db, user_id)
+    
+    referrals_query = select(User).options(
+        selectinload(User.subscription)
+    ).where(User.referred_by_id == user_id)
+    
+    referrals_result = await db.execute(referrals_query)
+    referrals = referrals_result.scalars().all()
+    
+    earnings_by_referral = {}
+    all_earnings = await get_referral_earnings_by_user(db, user_id)
+    
+    for earning in all_earnings:
+        referral_id = earning.referral_id
+        if referral_id not in earnings_by_referral:
+            earnings_by_referral[referral_id] = 0
+        earnings_by_referral[referral_id] += earning.amount_kopeks
+    
+    referrals_detail = []
+    current_time = datetime.utcnow()
+    
+    for referral in referrals:
+        earned = earnings_by_referral.get(referral.id, 0)
+        
+        is_active = False
+        if referral.subscription:
+            from app.database.models import SubscriptionStatus
+            is_active = (
+                referral.subscription.status == SubscriptionStatus.ACTIVE.value and 
+                referral.subscription.end_date > current_time
+            )
+        
+        referrals_detail.append({
+            'referral_id': referral.id,
+            'referral_name': referral.full_name,
+            'referral_telegram_id': referral.telegram_id,
+            'total_earned_kopeks': earned,
+            'is_active': is_active,
+            'registration_date': referral.created_at,
+            'has_subscription': bool(referral.subscription)
+        })
+    
+    referrals_detail.sort(key=lambda x: x['total_earned_kopeks'], reverse=True)
+    
+    return {
+        'invited_count': base_stats['invited_count'],
+        'active_referrals': base_stats['active_referrals'], 
+        'total_earned_kopeks': base_stats['total_earned_kopeks'],
+        'month_earned_kopeks': base_stats['month_earned_kopeks'],
+        'referrals_detail': referrals_detail
+    }
+    
 @admin_required
 @error_handler
 async def extend_user_subscription(
@@ -2118,6 +2213,133 @@ async def cleanup_inactive_users(
     )
     await callback.answer()
 
+@admin_required
+@error_handler
+async def change_subscription_type(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    profile = await user_service.get_user_profile(db, user_id)
+    
+    if not profile or not profile["subscription"]:
+        await callback.answer("❌ Пользователь или подписка не найдены", show_alert=True)
+        return
+    
+    subscription = profile["subscription"]
+    current_type = "🎁 Триал" if subscription.is_trial else "💎 Платная"
+    
+    text = f"🔄 <b>Смена типа подписки</b>\n\n"
+    text += f"👤 {profile['user'].full_name}\n"
+    text += f"📱 Текущий тип: {current_type}\n\n"
+    text += f"Выберите новый тип подписки:"
+    
+    keyboard = []
+    
+    if subscription.is_trial:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="💎 Сделать платной", 
+                callback_data=f"admin_sub_type_paid_{user_id}"
+            )
+        ])
+    else:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="🎁 Сделать триальной", 
+                callback_data=f"admin_sub_type_trial_{user_id}"
+            )
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(
+            text="⬅️ Назад", 
+            callback_data=f"admin_user_subscription_{user_id}"
+        )
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def change_subscription_type_confirm(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    new_type = parts[-2]  # 'paid' или 'trial'
+    user_id = int(parts[-1])
+    
+    success = await _change_subscription_type(db, user_id, new_type, db_user.id)
+    
+    if success:
+        type_text = "платной" if new_type == "paid" else "триальной"
+        await callback.message.edit_text(
+            f"✅ Тип подписки успешно изменен на {type_text}",
+            reply_markup=InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка изменения типа подписки",
+            reply_markup=InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+async def _change_subscription_type(db: AsyncSession, user_id: int, new_type: str, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id
+        from app.services.subscription_service import SubscriptionService
+        
+        subscription = await get_subscription_by_user_id(db, user_id)
+        if not subscription:
+            logger.error(f"Подписка не найдена для пользователя {user_id}")
+            return False
+        
+        new_is_trial = (new_type == "trial")
+        
+        if subscription.is_trial == new_is_trial:
+            logger.info(f"Тип подписки уже установлен корректно для пользователя {user_id}")
+            return True
+        
+        old_type = "триальной" if subscription.is_trial else "платной"
+        new_type_text = "триальной" if new_is_trial else "платной"
+        
+        subscription.is_trial = new_is_trial
+        subscription.updated_at = datetime.utcnow()
+        
+        if not new_is_trial and subscription.is_trial:
+            user = await get_user_by_id(db, user_id)
+            if user:
+                user.has_had_paid_subscription = True
+        
+        await db.commit()
+        
+        subscription_service = SubscriptionService()
+        await subscription_service.update_remnawave_user(db, subscription)
+        
+        logger.info(f"Админ {admin_id} изменил тип подписки пользователя {user_id}: {old_type} -> {new_type_text}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка изменения типа подписки: {e}")
+        await db.rollback()
+        return False
+
 
 def register_handlers(dp: Dispatcher):
     
@@ -2341,3 +2563,13 @@ def register_handlers(dp: Dispatcher):
         reset_user_devices,
         F.data.startswith("admin_user_reset_devices_confirm_")
     )
+
+    dp.callback_query.register(
+        change_subscription_type,
+        F.data.startswith("admin_sub_change_type_")
+    )
+    
+    dp.callback_query.register(
+        change_subscription_type_confirm,
+        F.data.startswith("admin_sub_type_")
+    )

app/handlers/balance.py

@@ -527,6 +527,7 @@ async def check_yookassa_payment_status(
         await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
 
 
+
 def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(

app/handlers/menu.py

@@ -10,6 +10,7 @@ from app.keyboards.inline import get_main_menu_keyboard
 from app.localization.texts import get_texts
 from app.database.models import User
 from app.utils.user_utils import mark_user_as_had_paid_subscription
+from app.database.crud.user_message import get_random_active_message
 
 logger = logging.getLogger(__name__)
 
@@ -31,10 +32,7 @@ async def show_main_menu(
     if db_user.subscription:
         subscription_is_active = db_user.subscription.is_active
     
-    menu_text = texts.MAIN_MENU.format(
-        user_name=db_user.full_name,
-        subscription_status=_get_subscription_status(db_user, texts)
-    )
+    menu_text = await get_main_menu_text(db_user, texts, db)
     
     await callback.message.edit_text(
         menu_text,
@@ -45,7 +43,8 @@ async def show_main_menu(
             has_active_subscription=has_active_subscription,
             subscription_is_active=subscription_is_active,
             balance_kopeks=db_user.balance_kopeks 
-        )
+        ),
+        parse_mode="HTML" 
     )
     await callback.answer()
 
@@ -100,10 +99,31 @@ async def handle_back_to_menu(
     db_user: User,
     db: AsyncSession
 ):
-    
     await state.clear()
     
-    await show_main_menu(callback, db_user, db)
+    texts = get_texts(db_user.language)
+    
+    has_active_subscription = db_user.subscription is not None
+    subscription_is_active = False
+    
+    if db_user.subscription:
+        subscription_is_active = db_user.subscription.is_active
+    
+    menu_text = await get_main_menu_text(db_user, texts, db)
+    
+    await callback.message.edit_text(
+        menu_text,
+        reply_markup=get_main_menu_keyboard(
+            language=db_user.language,
+            is_admin=settings.is_admin(db_user.telegram_id),
+            has_had_paid_subscription=db_user.has_had_paid_subscription,
+            has_active_subscription=has_active_subscription,
+            subscription_is_active=subscription_is_active,
+            balance_kopeks=db_user.balance_kopeks
+        ),
+        parse_mode="HTML"
+    )
+    await callback.answer()
 
 
 def _get_subscription_status(user: User, texts) -> str:
@@ -136,6 +156,31 @@ def _get_subscription_status(user: User, texts) -> str:
         else:
             return f"💎 Активна\n⚠️ истекает сегодня!"
 
+async def get_main_menu_text(user, texts, db: AsyncSession):
+    
+    base_text = texts.MAIN_MENU.format(
+        user_name=user.full_name,
+        subscription_status=_get_subscription_status(user, texts)
+    )
+    
+    try:
+        random_message = await get_random_active_message(db)
+        if random_message:
+            if "Выберите действие:" in base_text:
+                parts = base_text.split("Выберите действие:")
+                if len(parts) == 2:
+                    return f"{parts[0]}\n{random_message}\n\nВыберите действие:{parts[1]}"
+            
+            if "Выберите действие:" in base_text:
+                return base_text.replace("Выберите действие:", f"\n{random_message}\n\nВыберите действие:")
+            else:
+                return f"{base_text}\n\n{random_message}"
+                
+    except Exception as e:
+        logger.error(f"Ошибка получения случайного сообщения: {e}")
+    
+    return base_text
+
 
 def register_handlers(dp: Dispatcher):
     

app/handlers/referral.py

@@ -3,11 +3,10 @@ from aiogram import Dispatcher, types, F
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings
-from app.database.crud.referral import get_referral_earnings_sum
 from app.database.models import User
 from app.keyboards.inline import get_referral_keyboard, get_back_keyboard
 from app.localization.texts import get_texts
-from app.utils.user_utils import get_user_referral_summary
+from app.utils.user_utils import get_user_referral_summary, get_detailed_referral_list, get_referral_analytics
 
 logger = logging.getLogger(__name__)
 
@@ -17,7 +16,6 @@ async def show_referral_info(
     db_user: User,
     db: AsyncSession
 ):
-    
     texts = get_texts(db_user.language)
     
     summary = await get_user_referral_summary(db, db_user.id)
@@ -28,30 +26,58 @@ async def show_referral_info(
     referral_text = f"👥 <b>Реферальная программа</b>\n\n"
     
     referral_text += f"📊 <b>Ваша статистика:</b>\n"
-    referral_text += f"• Приглашено пользователей: {summary['invited_count']}\n"
-    referral_text += f"• Купили подписку: {summary['paid_referrals_count']}\n"
-    referral_text += f"• Заработано всего: {texts.format_price(summary['total_earned_kopeks'])}\n"
-    referral_text += f"• За последний месяц: {texts.format_price(summary['month_earned_kopeks'])}\n\n"
+    referral_text += f"• Приглашено пользователей: <b>{summary['invited_count']}</b>\n"
+    referral_text += f"• Сделали первое пополнение: <b>{summary['paid_referrals_count']}</b>\n"
+    referral_text += f"• Активных рефералов: <b>{summary['active_referrals_count']}</b>\n"
+    referral_text += f"• Конверсия: <b>{summary['conversion_rate']}%</b>\n"
+    referral_text += f"• Заработано всего: <b>{texts.format_price(summary['total_earned_kopeks'])}</b>\n"
+    referral_text += f"• За последний месяц: <b>{texts.format_price(summary['month_earned_kopeks'])}</b>\n\n"
     
     referral_text += f"🎁 <b>Как работают награды:</b>\n"
-    referral_text += f"• Новый пользователь получает: {texts.format_price(settings.REFERRED_USER_REWARD)}\n"
-    referral_text += f"• Вы получаете при первой покупке реферала: {texts.format_price(settings.REFERRAL_REGISTRATION_REWARD)}\n"
-    referral_text += f"• Комиссия с каждой покупки реферала: {settings.REFERRAL_COMMISSION_PERCENT}%\n\n"
+    referral_text += f"• Новый пользователь получает: <b>{texts.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}</b> при первом пополнении от <b>{texts.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}</b>\n"
+    referral_text += f"• Вы получаете при первом пополнении реферала: <b>{texts.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}</b>\n"
+    referral_text += f"• Комиссия с каждого пополнения реферала: <b>{settings.REFERRAL_COMMISSION_PERCENT}%</b>\n\n"
     
     referral_text += f"🔗 <b>Ваша реферальная ссылка:</b>\n"
     referral_text += f"<code>{referral_link}</code>\n\n"
     referral_text += f"🆔 <b>Ваш код:</b> <code>{db_user.referral_code}</code>\n\n"
     
     if summary['recent_earnings']:
-        referral_text += f"💰 <b>Последние начисления:</b>\n"
-        for earning in summary['recent_earnings'][:3]: 
-            reason_text = {
-                "referral_first_purchase": "🎉 Первая покупка",
-                "referral_commission": "💰 Комиссия",
-                "referral_registration_pending": "⏳ Ожидание покупки"
-            }.get(earning['reason'], earning['reason'])
-            
-            referral_text += f"• {reason_text}: {texts.format_price(earning['amount_kopeks'])} от {earning['referral_name']}\n"
+        meaningful_earnings = [
+            earning for earning in summary['recent_earnings'][:5] 
+            if earning['amount_kopeks'] > 0
+        ]
+        
+        if meaningful_earnings:
+            referral_text += f"💰 <b>Последние начисления:</b>\n"
+            for earning in meaningful_earnings[:3]: 
+                reason_text = {
+                    "referral_first_topup": "🎉 Первое пополнение",
+                    "referral_commission_topup": "💰 Комиссия с пополнения", 
+                    "referral_commission": "💰 Комиссия с покупки"
+                }.get(earning['reason'], earning['reason'])
+                
+                referral_text += f"• {reason_text}: <b>{texts.format_price(earning['amount_kopeks'])}</b> от {earning['referral_name']}\n"
+            referral_text += "\n"
+    
+    if summary['earnings_by_type']:
+        referral_text += f"📈 <b>Доходы по типам:</b>\n"
+        
+        if 'referral_first_topup' in summary['earnings_by_type']:
+            data = summary['earnings_by_type']['referral_first_topup']
+            if data['total_amount_kopeks'] > 0:
+                referral_text += f"• Бонусы за первые пополнения: <b>{data['count']}</b> ({texts.format_price(data['total_amount_kopeks'])})\n"
+        
+        if 'referral_commission_topup' in summary['earnings_by_type']:
+            data = summary['earnings_by_type']['referral_commission_topup']
+            if data['total_amount_kopeks'] > 0:
+                referral_text += f"• Комиссии с пополнений: <b>{data['count']}</b> ({texts.format_price(data['total_amount_kopeks'])})\n"
+        
+        if 'referral_commission' in summary['earnings_by_type']:
+            data = summary['earnings_by_type']['referral_commission']
+            if data['total_amount_kopeks'] > 0:
+                referral_text += f"• Комиссии с покупок: <b>{data['count']}</b> ({texts.format_price(data['total_amount_kopeks'])})\n"
+        
         referral_text += "\n"
     
     referral_text += "📢 Приглашайте друзей и зарабатывайте!"
@@ -64,36 +90,136 @@ async def show_referral_info(
     await callback.answer()
 
 
+async def show_detailed_referral_list(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    texts = get_texts(db_user.language)
+    
+    referrals_data = await get_detailed_referral_list(db, db_user.id, limit=10, offset=(page - 1) * 10)
+    
+    if not referrals_data['referrals']:
+        await callback.message.edit_text(
+            "📋 У вас пока нет рефералов.\n\nПоделитесь своей реферальной ссылкой, чтобы начать зарабатывать!",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_referrals")]
+            ])
+        )
+        await callback.answer()
+        return
+    
+    text = f"👥 <b>Ваши рефералы</b> (стр. {referrals_data['current_page']}/{referrals_data['total_pages']})\n\n"
+    
+    for i, referral in enumerate(referrals_data['referrals'], 1):
+        status_emoji = "🟢" if referral['status'] == 'active' else "🔴"
+        
+        topup_emoji = "💰" if referral['has_made_first_topup'] else "⏳"
+        
+        text += f"{i}. {status_emoji} <b>{referral['full_name']}</b>\n"
+        text += f"   {topup_emoji} Пополнений: {referral['topups_count']}\n"
+        text += f"   💎 Заработано с него: {texts.format_price(referral['total_earned_kopeks'])}\n"
+        text += f"   📅 Регистрация: {referral['days_since_registration']} дн. назад\n"
+        
+        if referral['days_since_activity'] is not None:
+            text += f"   🕐 Активность: {referral['days_since_activity']} дн. назад\n"
+        else:
+            text += f"   🕐 Активность: давно\n"
+        
+        text += "\n"
+    
+    keyboard = []
+    nav_buttons = []
+    
+    if referrals_data['has_prev']:
+        nav_buttons.append(types.InlineKeyboardButton(
+            text="⬅️ Назад", 
+            callback_data=f"referral_list_page_{page - 1}"
+        ))
+    
+    if referrals_data['has_next']:
+        nav_buttons.append(types.InlineKeyboardButton(
+            text="Вперед ➡️", 
+            callback_data=f"referral_list_page_{page + 1}"
+        ))
+    
+    if nav_buttons:
+        keyboard.append(nav_buttons)
+    
+    keyboard.append([types.InlineKeyboardButton(
+        text=texts.BACK, 
+        callback_data="menu_referrals"
+    )])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+async def show_referral_analytics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    analytics = await get_referral_analytics(db, db_user.id)
+    
+    text = f"📊 <b>Аналитика рефералов</b>\n\n"
+    
+    text += f"💰 <b>Доходы по периодам:</b>\n"
+    text += f"• Сегодня: {texts.format_price(analytics['earnings_by_period']['today'])}\n"
+    text += f"• За неделю: {texts.format_price(analytics['earnings_by_period']['week'])}\n"
+    text += f"• За месяц: {texts.format_price(analytics['earnings_by_period']['month'])}\n"
+    text += f"• За квартал: {texts.format_price(analytics['earnings_by_period']['quarter'])}\n\n"
+    
+    if analytics['top_referrals']:
+        text += f"🏆 <b>Топ-{len(analytics['top_referrals'])} рефералов:</b>\n"
+        for i, ref in enumerate(analytics['top_referrals'], 1):
+            text += f"{i}. {ref['referral_name']}: {texts.format_price(ref['total_earned_kopeks'])} ({ref['earnings_count']} начислений)\n"
+        text += "\n"
+    
+    text += "📈 Продолжайте развивать свою реферальную сеть!"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_referrals")]
+        ]),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
 async def create_invite_message(
     callback: types.CallbackQuery,
     db_user: User
 ):
-    
     texts = get_texts(db_user.language)
     
     bot_username = (await callback.bot.get_me()).username
     referral_link = f"https://t.me/{bot_username}?start={db_user.referral_code}"
     
     invite_text = f"🎉 Присоединяйся к VPN сервису!\n\n"
-    invite_text += f"💎 При регистрации по моей ссылке ты получишь {texts.format_price(settings.REFERRED_USER_REWARD)} на баланс!\n\n"
+    invite_text += f"💎 При первом пополнении от {texts.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)} ты получишь {texts.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)} бонусом на баланс!\n\n"
     invite_text += f"🚀 Быстрое подключение\n"
     invite_text += f"🌍 Серверы по всему миру\n"
     invite_text += f"🔒 Надежная защита\n\n"
     invite_text += f"👇 Переходи по ссылке:\n{referral_link}"
     
     keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
-        [
-            types.InlineKeyboardButton(
-                text="📤 Поделиться",
-                switch_inline_query=invite_text 
-            )
-        ],
-        [
-            types.InlineKeyboardButton(
-                text=texts.BACK,
-                callback_data="menu_referrals"
-            )
-        ]
+        [types.InlineKeyboardButton(
+            text="📤 Поделиться",
+            switch_inline_query=invite_text 
+        )],
+        [types.InlineKeyboardButton(
+            text=texts.BACK,
+            callback_data="menu_referrals"
+        )]
     ])
     
     await callback.message.edit_text(
@@ -117,3 +243,20 @@ def register_handlers(dp: Dispatcher):
         create_invite_message,
         F.data == "referral_create_invite"
     )
+    
+    dp.callback_query.register(
+        show_detailed_referral_list,
+        F.data == "referral_list"
+    )
+    
+    dp.callback_query.register(
+        show_referral_analytics,
+        F.data == "referral_analytics"
+    )
+    
+    dp.callback_query.register(
+        lambda callback, db_user, db: show_detailed_referral_list(
+            callback, db_user, db, int(callback.data.split('_')[-1])
+        ),
+        F.data.startswith("referral_list_page_")
+    )

app/handlers/start.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime
-from aiogram import Dispatcher, types, F
+from aiogram import Dispatcher, types, F, Bot
 from aiogram.filters import Command, StateFilter
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -17,6 +17,8 @@ from app.keyboards.inline import (
 from app.localization.texts import get_texts
 from app.services.referral_service import process_referral_registration
 from app.utils.user_utils import generate_unique_referral_code
+from app.database.crud.user_message import get_random_active_message
+
 
 logger = logging.getLogger(__name__)
 
@@ -135,11 +137,10 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
         if user.subscription:
             subscription_is_active = user.subscription.is_active
         
+        menu_text = await get_main_menu_text(user, texts, db)
+        
         await message.answer(
-            texts.MAIN_MENU.format(
-                user_name=user.full_name,
-                subscription_status=_get_subscription_status(user, texts)
-            ),
+            menu_text,
             reply_markup=get_main_menu_keyboard(
                 language=user.language,
                 is_admin=settings.is_admin(user.telegram_id),
@@ -147,7 +148,8 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
                 has_active_subscription=has_active_subscription,
                 subscription_is_active=subscription_is_active,
                 balance_kopeks=user.balance_kopeks 
-            )
+            ),
+            parse_mode="HTML"
         )
         await state.clear()
         return
@@ -386,7 +388,6 @@ async def complete_registration_from_callback(
     state: FSMContext, 
     db: AsyncSession
 ):
-    
     logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {callback.from_user.id}")
     
     existing_user = await get_user_by_telegram_id(db, callback.from_user.id)
@@ -405,30 +406,24 @@ async def complete_registration_from_callback(
         if existing_user.subscription:
             subscription_is_active = existing_user.subscription.is_active
         
-        user_name = existing_user.full_name
-        user_telegram_id = existing_user.telegram_id
-        user_language = existing_user.language
-        has_had_paid_subscription = existing_user.has_had_paid_subscription
-        balance_kopeks = existing_user.balance_kopeks
+        menu_text = await get_main_menu_text(existing_user, texts, db)
         
         try:
             await callback.message.answer(
-                texts.MAIN_MENU.format(
-                    user_name=user_name,
-                    subscription_status=_get_subscription_status(existing_user, texts)
-                ),
+                menu_text,
                 reply_markup=get_main_menu_keyboard(
-                    language=user_language,
-                    is_admin=settings.is_admin(user_telegram_id),
-                    has_had_paid_subscription=has_had_paid_subscription,
+                    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,
-                    balance_kopeks=balance_kopeks
-                )
+                    balance_kopeks=existing_user.balance_kopeks
+                ),
+                parse_mode="HTML"
             )
         except Exception as e:
             logger.error(f"Ошибка при показе главного меню существующему пользователю: {e}")
-            await callback.message.answer(f"Добро пожаловать, {user_name}!")
+            await callback.message.answer(f"Добро пожаловать, {existing_user.full_name}!")
         
         await state.clear()
         return
@@ -497,9 +492,8 @@ async def complete_registration_from_callback(
     
     if referrer_id:
         try:
-            await process_referral_registration(db, user.id, referrer_id)
-            bonus_message = f"🎉 Вы получили {settings.REFERRED_USER_REWARD/100}₽ за регистрацию по реферальной ссылке!"
-            await callback.message.answer(bonus_message)
+            await process_referral_registration(db, user.id, referrer_id, callback.bot)
+            logger.info(f"✅ Реферальная регистрация обработана для {user.id}")
         except Exception as e:
             logger.error(f"Ошибка при обработке реферальной регистрации: {e}")
     
@@ -507,63 +501,56 @@ async def complete_registration_from_callback(
     
     has_active_subscription = False 
     subscription_is_active = False
-    user_name = user.full_name
-    balance_kopeks = user.balance_kopeks
-    user_telegram_id = user.telegram_id
-    user_language = user.language
-    has_had_paid_subscription = user.has_had_paid_subscription
+    
+    menu_text = await get_main_menu_text_simple(user.full_name, texts, db)
     
     try:
         await callback.message.answer(
-            texts.MAIN_MENU.format(
-                user_name=user_name,
-                subscription_status=_get_subscription_status_simple(texts)
-            ),
+            menu_text,
             reply_markup=get_main_menu_keyboard(
-                language=user_language,
-                is_admin=settings.is_admin(user_telegram_id),
-                has_had_paid_subscription=has_had_paid_subscription,
+                language=user.language,
+                is_admin=settings.is_admin(user.telegram_id),
+                has_had_paid_subscription=user.has_had_paid_subscription,
                 has_active_subscription=has_active_subscription,
                 subscription_is_active=subscription_is_active,
-                balance_kopeks=balance_kopeks
-            )
+                balance_kopeks=user.balance_kopeks
+            ),
+            parse_mode="HTML"
         )
-        logger.info(f"✅ Главное меню отправлено для пользователя {user_telegram_id}")
+        logger.info(f"✅ Главное меню отправлено для пользователя {user.telegram_id}")
     except Exception as e:
         logger.error(f"Ошибка при отправке главного меню: {e}")
         try:
-            balance_rubles = balance_kopeks / 100
+            balance_rubles = user.balance_kopeks / 100
             await callback.message.answer(
-                f"Добро пожаловать, {user_name}!\n"
+                f"Добро пожаловать, {user.full_name}!\n"
                 f"Баланс: {balance_rubles:.2f} ₽\n"
                 f"Подписка: Нет активной подписки",
                 reply_markup=get_main_menu_keyboard(
-                    language=user_language,
-                    is_admin=settings.is_admin(user_telegram_id),
-                    has_had_paid_subscription=has_had_paid_subscription,
+                    language=user.language,
+                    is_admin=settings.is_admin(user.telegram_id),
+                    has_had_paid_subscription=user.has_had_paid_subscription,
                     has_active_subscription=has_active_subscription,
                     subscription_is_active=subscription_is_active,
-                    balance_kopeks=balance_kopeks
+                    balance_kopeks=user.balance_kopeks
                 )
             )
-            logger.info(f"✅ Fallback главное меню отправлено для пользователя {user_telegram_id}")
+            logger.info(f"✅ Fallback главное меню отправлено для пользователя {user.telegram_id}")
         except Exception as fallback_error:
             logger.error(f"⛔ Критическая ошибка при отправке fallback меню: {fallback_error}")
             try:
-                await callback.message.answer(f"Добро пожаловать, {user_name}! Регистрация завершена.")
-                logger.info(f"✅ Простое приветствие отправлено для пользователя {user_telegram_id}")
+                await callback.message.answer(f"Добро пожаловать, {user.full_name}! Регистрация завершена.")
+                logger.info(f"✅ Простое приветствие отправлено для пользователя {user.telegram_id}")
             except Exception as final_error:
                 logger.error(f"⛔ Критическая ошибка при отправке простого сообщения: {final_error}")
     
-    logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
-
+    logger.info(f"✅ Регистрация завершена для пользователя: {user.telegram_id}")
 
 async def complete_registration(
     message: types.Message, 
     state: FSMContext, 
     db: AsyncSession
 ):
-    
     logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {message.from_user.id}")
     
     existing_user = await get_user_by_telegram_id(db, message.from_user.id)
@@ -582,30 +569,24 @@ async def complete_registration(
         if existing_user.subscription:
             subscription_is_active = existing_user.subscription.is_active
         
-        user_name = existing_user.full_name
-        user_telegram_id = existing_user.telegram_id
-        user_language = existing_user.language
-        has_had_paid_subscription = existing_user.has_had_paid_subscription
-        balance_kopeks = existing_user.balance_kopeks
+        menu_text = await get_main_menu_text(existing_user, texts, db)
         
         try:
             await message.answer(
-                texts.MAIN_MENU.format(
-                    user_name=user_name,
-                    subscription_status=_get_subscription_status(existing_user, texts)
-                ),
+                menu_text,
                 reply_markup=get_main_menu_keyboard(
-                    language=user_language,
-                    is_admin=settings.is_admin(user_telegram_id),
-                    has_had_paid_subscription=has_had_paid_subscription,
+                    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,
-                    balance_kopeks=balance_kopeks
-                )
+                    balance_kopeks=existing_user.balance_kopeks
+                ),
+                parse_mode="HTML"
             )
         except Exception as e:
             logger.error(f"Ошибка при показе главного меню существующему пользователю: {e}")
-            await message.answer(f"Добро пожаловать, {user_name}!")
+            await message.answer(f"Добро пожаловать, {existing_user.full_name}!")
         
         await state.clear()
         return
@@ -674,9 +655,8 @@ async def complete_registration(
     
     if referrer_id:
         try:
-            await process_referral_registration(db, user.id, referrer_id)
-            bonus_message = f"🎉 Вы получили {settings.REFERRED_USER_REWARD/100}₽ за регистрацию по реферальной ссылке!"
-            await message.answer(bonus_message)
+            await process_referral_registration(db, user.id, referrer_id, message.bot)
+            logger.info(f"✅ Реферальная регистрация обработана для {user.id}")
         except Exception as e:
             logger.error(f"Ошибка при обработке реферальной регистрации: {e}")
     
@@ -684,55 +664,51 @@ async def complete_registration(
     
     has_active_subscription = False
     subscription_is_active = False
-    user_name = user.full_name
-    balance_kopeks = user.balance_kopeks
-    user_telegram_id = user.telegram_id
-    user_language = user.language
-    has_had_paid_subscription = user.has_had_paid_subscription
+    
+    menu_text = await get_main_menu_text_simple(user.full_name, texts, db)
     
     try:
         await message.answer(
-            texts.MAIN_MENU.format(
-                user_name=user_name,
-                subscription_status=_get_subscription_status_simple(texts)
-            ),
+            menu_text,
             reply_markup=get_main_menu_keyboard(
-                language=user_language,
-                is_admin=settings.is_admin(user_telegram_id),
-                has_had_paid_subscription=has_had_paid_subscription,
+                language=user.language,
+                is_admin=settings.is_admin(user.telegram_id),
+                has_had_paid_subscription=user.has_had_paid_subscription,
                 has_active_subscription=has_active_subscription,
                 subscription_is_active=subscription_is_active,
-                balance_kopeks=balance_kopeks
-            )
+                balance_kopeks=user.balance_kopeks
+            ),
+            parse_mode="HTML"
         )
-        logger.info(f"✅ Главное меню отправлено для пользователя {user_telegram_id}")
+        logger.info(f"✅ Главное меню отправлено для пользователя {user.telegram_id}")
     except Exception as e:
         logger.error(f"Ошибка при отправке главного меню: {e}")
         try:
-            balance_rubles = balance_kopeks / 100
+            balance_rubles = user.balance_kopeks / 100
             await message.answer(
-                f"Добро пожаловать, {user_name}!\n"
+                f"Добро пожаловать, {user.full_name}!\n"
                 f"Баланс: {balance_rubles:.2f} ₽\n"
                 f"Подписка: Нет активной подписки",
                 reply_markup=get_main_menu_keyboard(
-                    language=user_language,
-                    is_admin=settings.is_admin(user_telegram_id),
-                    has_had_paid_subscription=has_had_paid_subscription,
+                    language=user.language,
+                    is_admin=settings.is_admin(user.telegram_id),
+                    has_had_paid_subscription=user.has_had_paid_subscription,
                     has_active_subscription=has_active_subscription,
                     subscription_is_active=subscription_is_active,
-                    balance_kopeks=balance_kopeks
-                )
+                    balance_kopeks=user.balance_kopeks
+                ),
+                parse_mode="HTML"
             )
-            logger.info(f"✅ Fallback главное меню отправлено для пользователя {user_telegram_id}")
+            logger.info(f"✅ Fallback главное меню отправлено для пользователя {user.telegram_id}")
         except Exception as fallback_error:
             logger.error(f"⛔ Критическая ошибка при отправке fallback меню: {fallback_error}")
             try:
-                await message.answer(f"Добро пожаловать, {user_name}! Регистрация завершена.")
-                logger.info(f"✅ Простое приветствие отправлено для пользователя {user_telegram_id}")
+                await message.answer(f"Добро пожаловать, {user.full_name}! Регистрация завершена.")
+                logger.info(f"✅ Простое приветствие отправлено для пользователя {user.telegram_id}")
             except:
                 pass
     
-    logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
+    logger.info(f"✅ Регистрация завершена для пользователя: {user.telegram_id}")
 
 
 def _get_subscription_status(user, texts):
@@ -791,6 +767,55 @@ def get_referral_code_keyboard(language: str):
         )]
     ])
 
+async def get_main_menu_text(user, texts, db: AsyncSession):
+    
+    base_text = texts.MAIN_MENU.format(
+        user_name=user.full_name,
+        subscription_status=_get_subscription_status(user, texts)
+    )
+    
+    try:
+        random_message = await get_random_active_message(db)
+        if random_message:
+            if "Выберите действие:" in base_text:
+                parts = base_text.split("Выберите действие:")
+                if len(parts) == 2:
+                    return f"{parts[0]}\n{random_message}\n\nВыберите действие:{parts[1]}"
+            
+            if "Выберите действие:" in base_text:
+                return base_text.replace("Выберите действие:", f"\n{random_message}\n\nВыберите действие:")
+            else:
+                return f"{base_text}\n\n{random_message}"
+                
+    except Exception as e:
+        logger.error(f"Ошибка получения случайного сообщения: {e}")
+    
+    return base_text
+
+async def get_main_menu_text_simple(user_name, texts, db: AsyncSession):
+    
+    base_text = texts.MAIN_MENU.format(
+        user_name=user_name,
+        subscription_status=_get_subscription_status_simple(texts)
+    )
+    
+    try:
+        random_message = await get_random_active_message(db)
+        if random_message:
+            if "Выберите действие:" in base_text:
+                parts = base_text.split("Выберите действие:")
+                if len(parts) == 2:
+                    return f"{parts[0]}\n{random_message}\n\nВыберите действие:{parts[1]}"
+            
+            if "Выберите действие:" in base_text:
+                return base_text.replace("Выберите действие:", f"\n{random_message}\n\nВыберите действие:")
+            else:
+                return f"{base_text}\n\n{random_message}"
+                
+    except Exception as e:
+        logger.error(f"Ошибка получения случайного сообщения: {e}")
+    
+    return base_text
 
 def register_handlers(dp: Dispatcher):
     

app/handlers/subscription.py

@@ -21,7 +21,7 @@ from app.database.crud.user import subtract_user_balance
 from app.database.crud.transaction import create_transaction, get_user_transactions
 from app.database.models import (
     User, TransactionType, SubscriptionStatus, 
-    SubscriptionServer  
+    SubscriptionServer, Subscription 
 )
 from app.keyboards.inline import (
     get_subscription_keyboard, get_trial_keyboard,
@@ -38,8 +38,8 @@ from app.keyboards.inline import (
 )
 from app.localization.texts import get_texts
 from app.services.remnawave_service import RemnaWaveService
+from app.services.admin_notification_service import AdminNotificationService
 from app.services.subscription_service import SubscriptionService
-from app.services.referral_service import process_referral_purchase
 from app.utils.pricing_utils import (
     calculate_months_from_days,
     get_remaining_months,
@@ -350,6 +350,8 @@ async def activate_trial(
     db_user: User,
     db: AsyncSession
 ):
+    from app.services.admin_notification_service import AdminNotificationService
+    
     texts = get_texts(db_user.language)
     
     if db_user.subscription or db_user.has_had_paid_subscription:
@@ -372,23 +374,52 @@ async def activate_trial(
         
         await db.refresh(db_user)
         
+        try:
+            notification_service = AdminNotificationService(callback.bot)
+            await notification_service.send_trial_activation_notification(db, db_user, subscription)
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о триале: {e}")
+        
         if remnawave_user and hasattr(subscription, 'subscription_url') and subscription.subscription_url:
             trial_success_text = f"{texts.TRIAL_ACTIVATED}\n\n"
-            trial_success_text += f"🔗 <b>Ваша ссылка для подключения:</b>\n"
+            trial_success_text += f"🔗 <b>Ваша ссылка для импорта в VPN приложениe:</b>\n"
             trial_success_text += f"<code>{subscription.subscription_url}</code>\n\n"
             trial_success_text += f"📱 Нажмите кнопку ниже, чтобы получить инструкцию по настройке VPN на вашем устройстве"
-    
-            connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                [
-                    InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
-                ],
-                [
-                    InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")
-                ],
-                [
-                    InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")
-                ]
-            ])
+
+            connect_mode = settings.CONNECT_BUTTON_MODE
+
+            if connect_mode == "miniapp_subscription":
+                connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [
+                        InlineKeyboardButton(
+                            text="🔗 Подключиться",
+                            web_app=types.WebAppInfo(url=subscription.subscription_url),
+                        )
+                    ],
+                    [InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")],
+                    [InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")],
+                ])
+            elif connect_mode == "miniapp_custom":
+                if not settings.MINIAPP_CUSTOM_URL:
+                    await callback.answer("⚠ Кастомная ссылка для мини-приложения не настроена", show_alert=True)
+                    return
+
+                connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [
+                        InlineKeyboardButton(
+                            text="🔗 Подключиться",
+                            web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL),
+                        )
+                    ],
+                    [InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")],
+                    [InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")],
+                ])
+            else:
+                connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")],
+                    [InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")],
+                    [InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")],
+                ])
     
             await callback.message.edit_text(
                 trial_success_text,
@@ -604,7 +635,6 @@ async def apply_countries_changes(
     
     countries = await _get_available_countries()
     
-    # Рассчитываем оставшиеся месяцы подписки для новых серверов
     months_to_pay = get_remaining_months(subscription.end_date)
     
     cost_per_month = 0
@@ -623,7 +653,6 @@ async def apply_countries_changes(
     
     total_cost, charged_months = calculate_prorated_price(cost_per_month, subscription.end_date)
     
-    # Рассчитываем цены для каждого сервера за весь период
     for country in countries:
         if country['uuid'] in added:
             server_price_per_month = country['price_kopeks']
@@ -676,17 +705,6 @@ async def apply_countries_changes(
         subscription_service = SubscriptionService()
         await subscription_service.update_remnawave_user(db, subscription)
         
-        if total_cost > 0:
-            try:
-                await process_referral_purchase(
-                    db=db,
-                    user_id=db_user.id,
-                    purchase_amount_kopeks=total_cost,
-                    transaction_id=None
-                )
-            except Exception as e:
-                logger.error(f"Ошибка обработки реферальной покупки: {e}")
-        
         await db.refresh(subscription)
         
         success_text = "✅ <b>Страны успешно обновлены!</b>\n\n"
@@ -954,15 +972,6 @@ async def confirm_add_traffic(
             description=f"Добавление {traffic_gb} ГБ трафика на {charged_months} мес"
         )
         
-        try:
-            await process_referral_purchase(
-                db=db,
-                user_id=db_user.id,
-                purchase_amount_kopeks=price,
-                transaction_id=None
-            )
-        except Exception as e:
-            logger.error(f"Ошибка обработки реферальной покупки: {e}")
         
         await db.refresh(db_user)
         await db.refresh(subscription)
@@ -1051,15 +1060,6 @@ async def confirm_add_devices(
             description=f"Добавление {devices_count} устройств на {charged_months} мес"
         )
         
-        try:
-            await process_referral_purchase(
-                db=db,
-                user_id=db_user.id,
-                purchase_amount_kopeks=price,
-                transaction_id=None
-            )
-        except Exception as e:
-            logger.error(f"Ошибка обработки реферальной покупки: {e}")
         
         await db.refresh(db_user)
         await db.refresh(subscription)
@@ -1090,6 +1090,7 @@ async def confirm_extend_subscription(
     db: AsyncSession
 ):
     from app.utils.pricing_utils import calculate_months_from_days, validate_pricing_calculation
+    from app.services.admin_notification_service import AdminNotificationService
     
     days = int(callback.data.split('_')[2])
     texts = get_texts(db_user.language)
@@ -1101,6 +1102,8 @@ async def confirm_extend_subscription(
     
     months_in_period = calculate_months_from_days(days)
     
+    old_end_date = subscription.end_date
+    
     try:
         from app.config import PERIOD_PRICES
         
@@ -1131,7 +1134,7 @@ async def confirm_extend_subscription(
         
         logger.info(f"💰 Расчет продления подписки {subscription.id} на {days} дней ({months_in_period} мес):")
         logger.info(f"   📅 Период {days} дней: {base_price/100}₽")
-        logger.info(f"   🌍 Серверы: {servers_price_per_month/100}₽/мес × {months_in_period} = {total_servers_price/100}₽")
+        logger.info(f"   🌐 Серверы: {servers_price_per_month/100}₽/мес × {months_in_period} = {total_servers_price/100}₽")
         logger.info(f"   📱 Устройства: {devices_price_per_month/100}₽/мес × {months_in_period} = {total_devices_price/100}₽")
         logger.info(f"   📊 Трафик: {traffic_price_per_month/100}₽/мес × {months_in_period} = {total_traffic_price/100}₽")
         logger.info(f"   💎 ИТОГО: {price/100}₽")
@@ -1186,7 +1189,7 @@ async def confirm_extend_subscription(
         except Exception as e:
             logger.error(f"⚠ ИСКЛЮЧЕНИЕ ПРИ ОБНОВЛЕНИИ REMNAWAVE: {e}")
         
-        await create_transaction(
+        transaction = await create_transaction(
             db=db,
             user_id=db_user.id,
             type=TransactionType.SUBSCRIPTION_PAYMENT,
@@ -1195,14 +1198,12 @@ async def confirm_extend_subscription(
         )
         
         try:
-            await process_referral_purchase(
-                db=db,
-                user_id=db_user.id,
-                purchase_amount_kopeks=price,
-                transaction_id=None
+            notification_service = AdminNotificationService(callback.bot)
+            await notification_service.send_subscription_extension_notification(
+                db, db_user, subscription, transaction, days, old_end_date
             )
         except Exception as e:
-            logger.error(f"⚠ ОШИБКА ОБРАБОТКИ РЕФЕРАЛОВ: {e}")
+            logger.error(f"Ошибка отправки уведомления о продлении: {e}")
         
         await callback.message.edit_text(
             f"✅ Подписка успешно продлена!\n\n"
@@ -1479,8 +1480,7 @@ async def get_subscription_info_text(subscription, texts, db_user, db: AsyncSess
         info_text += f"\n💰 <b>Стоимость подписки в месяц:</b> {texts.format_price(subscription_cost)}"
     
     if subscription_url and subscription_url != "Генерируется...":
-        info_text += f"\n\n🔗 <b>Ссылка для подключения:</b>\n<code>{subscription_url}</code>"
-        info_text += f"\n\n📱 Скопируйте ссылку и добавьте в ваше VPN приложение"
+        info_text += f"\n\n🔗 <b>Ваша ссылка для импорта в VPN приложениe:</b>\n<code>{subscription_url}</code>"
     
     return info_text
 
@@ -1743,6 +1743,7 @@ async def confirm_purchase(
     db: AsyncSession
 ):
     from app.utils.pricing_utils import calculate_months_from_days, validate_pricing_calculation
+    from app.services.admin_notification_service import AdminNotificationService
     
     data = await state.get_data()
     texts = get_texts(db_user.language)
@@ -1817,10 +1818,31 @@ async def confirm_purchase(
             return
         
         existing_subscription = db_user.subscription
+        was_trial_conversion = False
         
         if existing_subscription:
             logger.info(f"Обновляем существующую подписку пользователя {db_user.telegram_id}")
             
+            if existing_subscription.is_trial:
+                logger.info(f"Конверсия из триала в платную для пользователя {db_user.telegram_id}")
+                was_trial_conversion = True
+                
+                trial_duration = (datetime.utcnow() - existing_subscription.start_date).days
+                
+                try:
+                    from app.database.crud.subscription_conversion import create_subscription_conversion
+                    await create_subscription_conversion(
+                        db=db,
+                        user_id=db_user.id,
+                        trial_duration_days=trial_duration,
+                        payment_method="balance",
+                        first_payment_amount_kopeks=final_price,
+                        first_paid_period_days=data['period_days']
+                    )
+                    logger.info(f"Записана конверсия: {trial_duration} дн. триал → {data['period_days']} дн. платная за {final_price/100}₽")
+                except Exception as conversion_error:
+                    logger.error(f"Ошибка записи конверсии: {conversion_error}")
+            
             existing_subscription.is_trial = False
             existing_subscription.status = SubscriptionStatus.ACTIVE.value
             existing_subscription.traffic_limit_gb = final_traffic_gb
@@ -1875,7 +1897,7 @@ async def confirm_purchase(
             logger.error(f"Не удалось создать/обновить RemnaWave пользователя для {db_user.telegram_id}")
             remnawave_user = await subscription_service.create_remnawave_user(db, subscription)
         
-        await create_transaction(
+        transaction = await create_transaction(
             db=db,
             user_id=db_user.id,
             type=TransactionType.SUBSCRIPTION_PAYMENT,
@@ -1884,35 +1906,56 @@ async def confirm_purchase(
         )
         
         try:
-            await process_referral_purchase(
-                db=db,
-                user_id=db_user.id,
-                purchase_amount_kopeks=final_price,
-                transaction_id=None 
+            notification_service = AdminNotificationService(callback.bot)
+            await notification_service.send_subscription_purchase_notification(
+                db, db_user, subscription, transaction, data['period_days'], was_trial_conversion
             )
         except Exception as e:
-            logger.error(f"Ошибка обработки реферальной покупки: {e}")
+            logger.error(f"Ошибка отправки уведомления о покупке: {e}")
         
         await db.refresh(db_user)
         await db.refresh(subscription)
         
         if remnawave_user and hasattr(subscription, 'subscription_url') and subscription.subscription_url:
             success_text = f"{texts.SUBSCRIPTION_PURCHASED}\n\n"
-            success_text += f"📗 <b>Ваша ссылка для подключения:</b>\n"
+            success_text += f"Ваша ссылка для импорта в VPN приложение:\n"
             success_text += f"<code>{subscription.subscription_url}</code>\n\n"
-            success_text += f"📱 Нажмите кнопку ниже, чтобы получить инструкцию по настройке VPN на вашем устройстве"
-    
-            connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                [
-                    InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
-                ],
-                [
-                    InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")
-                ],
-                [
-                    InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")
-                ]
-            ])
+            success_text += f"Нажмите кнопку ниже, чтобы получить инструкцию по настройке VPN на вашем устройстве"
+
+            connect_mode = settings.CONNECT_BUTTON_MODE
+
+            if connect_mode == "miniapp_subscription":
+                connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [
+                        InlineKeyboardButton(
+                            text="Подключиться",
+                            web_app=types.WebAppInfo(url=subscription.subscription_url),
+                        )
+                    ],
+                    [InlineKeyboardButton(text="Моя подписка", callback_data="menu_subscription")],
+                    [InlineKeyboardButton(text="В главное меню", callback_data="back_to_menu")],
+                ])
+            elif connect_mode == "miniapp_custom":
+                if not settings.MINIAPP_CUSTOM_URL:
+                    await callback.answer("Кастомная ссылка для мини-приложения не настроена", show_alert=True)
+                    return
+
+                connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [
+                        InlineKeyboardButton(
+                            text="Подключиться",
+                            web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL),
+                        )
+                    ],
+                    [InlineKeyboardButton(text="Моя подписка", callback_data="menu_subscription")],
+                    [InlineKeyboardButton(text="В главное меню", callback_data="back_to_menu")],
+                ])
+            else:
+                connect_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [InlineKeyboardButton(text="Подключиться", callback_data="subscription_connect")],
+                    [InlineKeyboardButton(text="Моя подписка", callback_data="menu_subscription")],
+                    [InlineKeyboardButton(text="В главное меню", callback_data="back_to_menu")],
+                ])
     
             await callback.message.edit_text(
                 success_text,
@@ -1921,11 +1964,11 @@ async def confirm_purchase(
             )
         else:
             await callback.message.edit_text(
-                f"{texts.SUBSCRIPTION_PURCHASED}\n\n⚠️ Ссылка генерируется, перейдите в раздел 'Моя подписка' через несколько секунд.",
+                f"{texts.SUBSCRIPTION_PURCHASED}\n\nСсылка генерируется, перейдите в раздел 'Моя подписка' через несколько секунд.",
                 reply_markup=get_back_keyboard(db_user.language)
             )
         
-        logger.info(f"✅ Пользователь {db_user.telegram_id} купил подписку на {data['period_days']} дней за {final_price/100}₽")
+        logger.info(f"Пользователь {db_user.telegram_id} купил подписку на {data['period_days']} дней за {final_price/100}₽")
         
     except Exception as e:
         logger.error(f"Ошибка покупки подписки: {e}")
@@ -1986,15 +2029,6 @@ async def add_traffic(
             description=f"Добавление {traffic_gb} ГБ трафика"
         )
         
-        try:
-            await process_referral_purchase(
-                db=db,
-                user_id=db_user.id,
-                purchase_amount_kopeks=price,
-                transaction_id=None
-            )
-        except Exception as e:
-            logger.error(f"Ошибка обработки реферальной покупки: {e}")
         
         await db.refresh(db_user)
         await db.refresh(subscription)
@@ -2493,17 +2527,6 @@ async def confirm_add_countries_to_subscription(
         subscription_service = SubscriptionService()
         await subscription_service.update_remnawave_user(db, subscription)
         
-        if new_countries and total_price > 0:
-            try:
-                await process_referral_purchase(
-                    db=db,
-                    user_id=db_user.id,
-                    purchase_amount_kopeks=total_price,
-                    transaction_id=None
-                )
-            except Exception as e:
-                logger.error(f"Ошибка обработки реферальной покупки: {e}")
-        
         await db.refresh(db_user)
         await db.refresh(subscription)
         
@@ -2649,7 +2672,7 @@ async def handle_connect_subscription(
         keyboard = InlineKeyboardMarkup(inline_keyboard=[
             [
                 InlineKeyboardButton(
-                    text="🔗 Открыть подписку в мини-приложении", 
+                    text="🔗 Подключиться", 
                     web_app=types.WebAppInfo(url=subscription.subscription_url)
                 )
             ],
@@ -2676,7 +2699,7 @@ async def handle_connect_subscription(
         keyboard = InlineKeyboardMarkup(inline_keyboard=[
             [
                 InlineKeyboardButton(
-                    text="🚀 Открыть приложение", 
+                    text="🔗 Подключиться", 
                     web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
                 )
             ],
@@ -2971,6 +2994,55 @@ def get_reset_devices_confirm_keyboard(language: str = "ru") -> InlineKeyboardMa
         ]
     ])
 
+async def send_trial_notification(callback: types.CallbackQuery, db: AsyncSession, db_user: User, subscription: Subscription):
+    try:
+        notification_service = AdminNotificationService(callback.bot)
+        await notification_service.send_trial_activation_notification(db, db_user, subscription)
+    except Exception as e:
+        logger.error(f"Ошибка отправки уведомления о триале: {e}")
+
+async def send_purchase_notification(
+    callback: types.CallbackQuery, 
+    db: AsyncSession,
+    db_user: User, 
+    subscription: Subscription, 
+    transaction_id: int,
+    period_days: int,
+    was_trial_conversion: bool = False
+):
+    try:
+        from app.database.crud.transaction import get_transaction_by_id
+        
+        transaction = await get_transaction_by_id(db, transaction_id)
+        if transaction:
+            notification_service = AdminNotificationService(callback.bot)
+            await notification_service.send_subscription_purchase_notification(
+                db, db_user, subscription, transaction, period_days, was_trial_conversion
+            )
+    except Exception as e:
+        logger.error(f"Ошибка отправки уведомления о покупке: {e}")
+
+async def send_extension_notification(
+    callback: types.CallbackQuery,
+    db: AsyncSession,
+    db_user: User,
+    subscription: Subscription,
+    transaction_id: int,
+    extended_days: int,
+    old_end_date: datetime
+):
+    try:
+        from app.database.crud.transaction import get_transaction_by_id
+        
+        transaction = await get_transaction_by_id(db, transaction_id)
+        if transaction:
+            notification_service = AdminNotificationService(callback.bot)
+            await notification_service.send_subscription_extension_notification(
+                db, db_user, subscription, transaction, extended_days, old_end_date
+            )
+    except Exception as e:
+        logger.error(f"Ошибка отправки уведомления о продлении: {e}")
+
 
 def register_handlers(dp: Dispatcher):
     update_traffic_prices()

app/handlers/webhooks.py

@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 async def tribute_webhook(request):
     try:
-        signature = request.headers.get('X-Signature', '')
+        signature = request.headers.get('trbt-signature', '')
         payload = await request.text()
         
         tribute_service = TributeService()

app/keyboards/admin.py

@@ -28,6 +28,9 @@ def get_admin_main_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
             InlineKeyboardButton(text=texts.ADMIN_STATISTICS, callback_data="admin_statistics"),
             InlineKeyboardButton(text="🔧 Техработы", callback_data="maintenance_panel")
         ],
+        [
+            InlineKeyboardButton(text="📢 Сообщения в меню", callback_data="user_messages_panel")
+        ],
         [
             InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
         ]
@@ -76,7 +79,7 @@ def get_admin_promocodes_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
             InlineKeyboardButton(text="➕ Создать", callback_data="admin_promo_create")
         ],
         [
-            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_promo_stats")
+            InlineKeyboardButton(text="📊 Общая статистика", callback_data="admin_promo_general_stats")
         ],
         [
             InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
@@ -580,25 +583,72 @@ def get_admin_pagination_keyboard(
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
-def get_maintenance_keyboard(language: str = "ru", is_active: bool = False, monitoring_active: bool = False) -> InlineKeyboardMarkup:
+def get_maintenance_keyboard(
+    language: str, 
+    is_maintenance_active: bool, 
+    is_monitoring_active: bool,
+    panel_has_issues: bool = False
+) -> InlineKeyboardMarkup:
+    keyboard = []
     
-    if language == "en":
-        toggle_text = "🔴 Disable maintenance" if is_active else "🔧 Enable maintenance"
-        monitoring_text = "⏹️ Stop monitoring" if monitoring_active else "🔄 Start monitoring"
-        check_api_text = "🔍 Check API"
-        back_text = "⬅️ Back to admin"
+    if is_maintenance_active:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="🟢 Выключить техработы", 
+                callback_data="maintenance_toggle"
+            )
+        ])
     else:
-        toggle_text = "🔴 Выключить техработы" if is_active else "🔧 Включить техработы"
-        monitoring_text = "⏹️ Остановить мониторинг" if monitoring_active else "🔄 Запустить мониторинг"
-        check_api_text = "🔍 Проверить API"
-        back_text = "⬅️ Назад в админку"
+        keyboard.append([
+            InlineKeyboardButton(
+                text="🔧 Включить техработы", 
+                callback_data="maintenance_toggle"
+            )
+        ])
     
-    keyboard = [
-        [InlineKeyboardButton(text=toggle_text, callback_data="maintenance_toggle")],
-        [InlineKeyboardButton(text=monitoring_text, callback_data="maintenance_monitoring")],
-        [InlineKeyboardButton(text=check_api_text, callback_data="maintenance_check_api")],
-        [InlineKeyboardButton(text=back_text, callback_data="admin_panel")]
-    ]
+    if is_monitoring_active:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="⏹️ Остановить мониторинг", 
+                callback_data="maintenance_monitoring"
+            )
+        ])
+    else:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="▶️ Запустить мониторинг", 
+                callback_data="maintenance_monitoring"
+            )
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(
+            text="🔍 Проверить API", 
+            callback_data="maintenance_check_api"
+        ),
+        InlineKeyboardButton(
+            text="🌐 Статус панели" + ("⚠️" if panel_has_issues else ""), 
+            callback_data="maintenance_check_panel"
+        )
+    ])
+    
+    keyboard.append([
+        InlineKeyboardButton(
+            text="📢 Отправить уведомление", 
+            callback_data="maintenance_manual_notify"
+        )
+    ])
+    
+    keyboard.append([
+        InlineKeyboardButton(
+            text="🔄 Обновить", 
+            callback_data="maintenance_panel"
+        ),
+        InlineKeyboardButton(
+            text="◀️ Назад", 
+            callback_data="admin_panel"
+        )
+    ])
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 

app/keyboards/inline.py

@@ -122,7 +122,7 @@ def get_subscription_keyboard(
             if connect_mode == "miniapp_subscription":
                 keyboard.append([
                     InlineKeyboardButton(
-                        text="🚀 Открыть в мини-приложении",
+                        text="🔗 Подключиться",
                         web_app=types.WebAppInfo(url=subscription.subscription_url)
                     )
                 ])
@@ -130,7 +130,7 @@ def get_subscription_keyboard(
                 if settings.MINIAPP_CUSTOM_URL:
                     keyboard.append([
                         InlineKeyboardButton(
-                            text="🚀 Открыть приложение",
+                            text="🔗 Подключиться",
                             web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
                         )
                     ])
@@ -525,14 +525,35 @@ def get_subscription_expiring_keyboard(subscription_id: int, language: str = "ru
 
 def get_referral_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
-    return InlineKeyboardMarkup(inline_keyboard=[
+    
+    keyboard = [
         [
-            InlineKeyboardButton(text=texts.CREATE_INVITE, callback_data="referral_create_invite")
+            InlineKeyboardButton(
+                text="📝 Создать приглашение",
+                callback_data="referral_create_invite"
+            )
         ],
         [
-            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+            InlineKeyboardButton(
+                text="👥 Список рефералов",
+                callback_data="referral_list"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="📊 Аналитика",
+                callback_data="referral_analytics"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=texts.BACK,
+                callback_data="back_to_menu" 
+            )
         ]
-    ])
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
 def get_support_keyboard(language: str = "ru") -> InlineKeyboardMarkup:

app/middlewares/auth.py

@@ -44,16 +44,18 @@ class AuthMiddleware(BaseMiddleware):
                         current_state = await state.get_state()
                     
                     registration_states = [
-                        RegistrationStates.waiting_for_rules_accept,
-                        RegistrationStates.waiting_for_referral_code
+                        RegistrationStates.waiting_for_rules_accept.state,
+                        RegistrationStates.waiting_for_referral_code.state
                     ]
-                    
+
                     is_registration_process = (
                         (isinstance(event, Message) and event.text and event.text.startswith('/start'))
-                        or (isinstance(event, CallbackQuery) and current_state and 
-                            any(str(state) in str(current_state) for state in registration_states))
-                        or (isinstance(event, CallbackQuery) and event.data and 
-                            (event.data in ['rules_accept', 'rules_decline', 'referral_skip']))
+                        or (current_state in registration_states)
+                        or (
+                            isinstance(event, CallbackQuery)
+                            and event.data
+                            and (event.data in ['rules_accept', 'rules_decline', 'referral_skip'])
+                        )
                     )
                     
                     if is_registration_process:
@@ -93,16 +95,18 @@ class AuthMiddleware(BaseMiddleware):
                             current_state = await state.get_state()
                         
                         registration_states = [
-                            RegistrationStates.waiting_for_rules_accept,
-                            RegistrationStates.waiting_for_referral_code
+                            RegistrationStates.waiting_for_rules_accept.state,
+                            RegistrationStates.waiting_for_referral_code.state
                         ]
-                        
+
                         is_start_or_registration = (
                             (isinstance(event, Message) and event.text and event.text.startswith('/start'))
-                            or (isinstance(event, CallbackQuery) and current_state and 
-                                any(str(state) in str(current_state) for state in registration_states))
-                            or (isinstance(event, CallbackQuery) and event.data and 
-                                (event.data in ['rules_accept', 'rules_decline', 'referral_skip']))
+                            or (current_state in registration_states)
+                            or (
+                                isinstance(event, CallbackQuery)
+                                and event.data
+                                and (event.data in ['rules_accept', 'rules_decline', 'referral_skip'])
+                            )
                         )
                         
                         if is_start_or_registration:

app/services/admin_notification_service.py

@@ -0,0 +1,638 @@
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+from aiogram import Bot
+from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User, Subscription, Transaction
+from app.database.crud.user import get_user_by_id
+
+logger = logging.getLogger(__name__)
+
+
+class AdminNotificationService:
+    
+    def __init__(self, bot: Bot):
+        self.bot = bot
+        self.chat_id = getattr(settings, 'ADMIN_NOTIFICATIONS_CHAT_ID', None)
+        self.topic_id = getattr(settings, 'ADMIN_NOTIFICATIONS_TOPIC_ID', None)
+        self.enabled = getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False)
+    
+    async def _get_referrer_info(self, db: AsyncSession, referred_by_id: Optional[int]) -> str:
+        if not referred_by_id:
+            return "Нет"
+        
+        try:
+            referrer = await get_user_by_id(db, referred_by_id)
+            if not referrer:
+                return f"ID {referred_by_id} (не найден)"
+            
+            if referrer.username:
+                return f"@{referrer.username} (ID: {referred_by_id})"
+            else:
+                return f"ID {referrer.telegram_id}"
+                
+        except Exception as e:
+            logger.error(f"Ошибка получения данных рефера {referred_by_id}: {e}")
+            return f"ID {referred_by_id}"
+    
+    async def send_trial_activation_notification(
+        self,
+        db: AsyncSession,
+        user: User,
+        subscription: Subscription
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            user_status = "🆕 Новый" if not user.has_had_paid_subscription else "🔄 Существующий"
+            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
+            
+            message = f"""🎯 <b>АКТИВАЦИЯ ТРИАЛА</b>
+
+👤 <b>Пользователь:</b> {user.full_name}
+🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>
+📱 <b>Username:</b> @{user.username or 'отсутствует'}
+👥 <b>Статус:</b> {user_status}
+
+⏰ <b>Параметры триала:</b>
+📅 Период: {settings.TRIAL_DURATION_DAYS} дней
+📊 Трафик: {settings.TRIAL_TRAFFIC_LIMIT_GB} ГБ
+📱 Устройства: {settings.TRIAL_DEVICE_LIMIT}
+🌐 Сервер: {subscription.connected_squads[0] if subscription.connected_squads else 'По умолчанию'}
+
+📆 <b>Действует до:</b> {subscription.end_date.strftime('%d.%m.%Y %H:%M')}
+🔗 <b>Реферер:</b> {referrer_info}
+
+⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о триале: {e}")
+            return False
+    
+    async def send_subscription_purchase_notification(
+        self,
+        db: AsyncSession,
+        user: User,
+        subscription: Subscription,
+        transaction: Transaction,
+        period_days: int,
+        was_trial_conversion: bool = False
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            event_type = "🔄 КОНВЕРСИЯ ИЗ ТРИАЛА" if was_trial_conversion else "💎 ПОКУПКА ПОДПИСКИ"
+            
+            if was_trial_conversion:
+                user_status = "🎯 Конверсия из триала"
+            elif user.has_had_paid_subscription:
+                user_status = "🔄 Продление/Обновление"
+            else:
+                user_status = "🆕 Первая покупка"
+            
+            servers_info = await self._get_servers_info(subscription.connected_squads)
+            payment_method = self._get_payment_method_display(transaction.payment_method)
+            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
+            
+            message = f"""💎 <b>{event_type}</b>
+
+👤 <b>Пользователь:</b> {user.full_name}
+🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>
+📱 <b>Username:</b> @{user.username or 'отсутствует'}
+👥 <b>Статус:</b> {user_status}
+
+💰 <b>Платеж:</b>
+💵 Сумма: {settings.format_price(transaction.amount_kopeks)}
+💳 Способ: {payment_method}
+🆔 ID транзакции: {transaction.id}
+
+📱 <b>Параметры подписки:</b>
+📅 Период: {period_days} дней
+📊 Трафик: {self._format_traffic(subscription.traffic_limit_gb)}
+📱 Устройства: {subscription.device_limit}
+🌐 Серверы: {servers_info}
+
+📆 <b>Действует до:</b> {subscription.end_date.strftime('%d.%m.%Y %H:%M')}
+💰 <b>Баланс после покупки:</b> {settings.format_price(user.balance_kopeks)}
+🔗 <b>Реферер:</b> {referrer_info}
+
+⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о покупке: {e}")
+            return False
+    
+    async def send_balance_topup_notification(
+        self,
+        db: AsyncSession,
+        user: User,
+        transaction: Transaction,
+        old_balance: int
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            topup_status = "🆕 Первое пополнение" if not user.has_made_first_topup else "🔄 Пополнение"
+            payment_method = self._get_payment_method_display(transaction.payment_method)
+            balance_change = user.balance_kopeks - old_balance
+            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
+            
+            message = f"""💰 <b>ПОПОЛНЕНИЕ БАЛАНСА</b>
+
+👤 <b>Пользователь:</b> {user.full_name}
+🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>
+📱 <b>Username:</b> @{user.username or 'отсутствует'}
+💳 <b>Статус:</b> {topup_status}
+
+💰 <b>Детали пополнения:</b>
+💵 Сумма: {settings.format_price(transaction.amount_kopeks)}
+💳 Способ: {payment_method}
+🆔 ID транзакции: {transaction.id}
+
+💰 <b>Баланс:</b>
+📉 Было: {settings.format_price(old_balance)}
+📈 Стало: {settings.format_price(user.balance_kopeks)}
+➕ Изменение: +{settings.format_price(balance_change)}
+
+🔗 <b>Реферер:</b> {referrer_info}
+📱 <b>Подписка:</b> {self._get_subscription_status(user)}
+
+⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о пополнении: {e}")
+            return False
+    
+    async def send_subscription_extension_notification(
+        self,
+        db: AsyncSession,
+        user: User,
+        subscription: Subscription,
+        transaction: Transaction,
+        extended_days: int,
+        old_end_date: datetime
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            payment_method = self._get_payment_method_display(transaction.payment_method)
+            servers_info = await self._get_servers_info(subscription.connected_squads)
+            
+            message = f"""⏰ <b>ПРОДЛЕНИЕ ПОДПИСКИ</b>
+
+👤 <b>Пользователь:</b> {user.full_name}
+🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>
+📱 <b>Username:</b> @{user.username or 'отсутствует'}
+
+💰 <b>Платеж:</b>
+💵 Сумма: {settings.format_price(transaction.amount_kopeks)}
+💳 Способ: {payment_method}
+🆔 ID транзакции: {transaction.id}
+
+📅 <b>Продление:</b>
+➕ Добавлено дней: {extended_days}
+📆 Было до: {old_end_date.strftime('%d.%m.%Y %H:%M')}
+📆 Стало до: {subscription.end_date.strftime('%d.%m.%Y %H:%M')}
+
+📱 <b>Текущие параметры:</b>
+📊 Трафик: {self._format_traffic(subscription.traffic_limit_gb)}
+📱 Устройства: {subscription.device_limit}
+🌐 Серверы: {servers_info}
+
+💰 <b>Баланс после операции:</b> {settings.format_price(user.balance_kopeks)}
+
+⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о продлении: {e}")
+            return False
+    
+    async def _send_message(self, text: str) -> bool:
+        if not self.chat_id:
+            logger.warning("ADMIN_NOTIFICATIONS_CHAT_ID не настроен")
+            return False
+        
+        try:
+            message_kwargs = {
+                'chat_id': self.chat_id,
+                'text': text,
+                'parse_mode': 'HTML',
+                'disable_web_page_preview': True
+            }
+            
+            if self.topic_id:
+                message_kwargs['message_thread_id'] = self.topic_id
+            
+            await self.bot.send_message(**message_kwargs)
+            logger.info(f"Уведомление отправлено в чат {self.chat_id}")
+            return True
+            
+        except TelegramForbiddenError:
+            logger.error(f"Бот не имеет прав для отправки в чат {self.chat_id}")
+            return False
+        except TelegramBadRequest as e:
+            logger.error(f"Ошибка отправки уведомления: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Неожиданная ошибка при отправке уведомления: {e}")
+            return False
+    
+    def _is_enabled(self) -> bool:
+        return self.enabled and bool(self.chat_id)
+    
+    def _get_payment_method_display(self, payment_method: Optional[str]) -> str:
+        method_names = {
+            'telegram_stars': '⭐ Telegram Stars',
+            'yookassa': '💳 YooKassa (карта)',
+            'tribute': '💎 Tribute (карта)',
+            'manual': '🛠️ Вручную (админ)',
+            'balance': '💰 С баланса'
+        }
+        
+        if not payment_method:
+            return '💰 С баланса'
+            
+        return method_names.get(payment_method, f'💰 С баланса')
+    
+    def _format_traffic(self, traffic_gb: int) -> str:
+        if traffic_gb == 0:
+            return "∞ Безлимит"
+        return f"{traffic_gb} ГБ"
+    
+    def _get_subscription_status(self, user: User) -> str:
+        if not user.subscription:
+            return "❌ Нет подписки"
+        
+        sub = user.subscription
+        if sub.is_trial:
+            return f"🎯 Триал (до {sub.end_date.strftime('%d.%m')})"
+        elif sub.is_active:
+            return f"✅ Активна (до {sub.end_date.strftime('%d.%m')})"
+        else:
+            return "❌ Неактивна"
+    
+    async def _get_servers_info(self, squad_uuids: list) -> str:
+        if not squad_uuids:
+            return "❌ Нет серверов"
+        
+        try:
+            from app.handlers.subscription import get_servers_display_names
+            servers_names = await get_servers_display_names(squad_uuids)
+            return f"{len(squad_uuids)} шт. ({servers_names})"
+        except Exception as e:
+            logger.warning(f"Не удалось получить названия серверов: {e}")
+            return f"{len(squad_uuids)} шт."
+
+
+    async def send_maintenance_status_notification(
+        self,
+        event_type: str,
+        status: str,
+        details: Dict[str, Any] = None
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            details = details or {}
+            
+            if event_type == "enable":
+                if details.get("auto_enabled", False):
+                    icon = "⚠️"
+                    title = "АВТОМАТИЧЕСКОЕ ВКЛЮЧЕНИЕ ТЕХРАБОТ"
+                    alert_type = "warning"
+                else:
+                    icon = "🔧"
+                    title = "ВКЛЮЧЕНИЕ ТЕХРАБОТ"
+                    alert_type = "info"
+                    
+            elif event_type == "disable":
+                icon = "✅"
+                title = "ОТКЛЮЧЕНИЕ ТЕХРАБОТ"
+                alert_type = "success"
+                
+            elif event_type == "api_status":
+                if status == "online":
+                    icon = "🟢"
+                    title = "API REMNAWAVE ВОССТАНОВЛЕНО"
+                    alert_type = "success"
+                else:
+                    icon = "🔴"
+                    title = "API REMNAWAVE НЕДОСТУПНО"
+                    alert_type = "error"
+                    
+            elif event_type == "monitoring":
+                if status == "started":
+                    icon = "🔍"
+                    title = "МОНИТОРИНГ ЗАПУЩЕН"
+                    alert_type = "info"
+                else:
+                    icon = "⏹️"
+                    title = "МОНИТОРИНГ ОСТАНОВЛЕН"
+                    alert_type = "info"
+            else:
+                icon = "ℹ️"
+                title = "СИСТЕМА ТЕХРАБОТ"
+                alert_type = "info"
+            
+            message_parts = [f"{icon} <b>{title}</b>", ""]
+            
+            if event_type == "enable":
+                if details.get("reason"):
+                    message_parts.append(f"📋 <b>Причина:</b> {details['reason']}")
+                
+                if details.get("enabled_at"):
+                    enabled_at = details["enabled_at"]
+                    if isinstance(enabled_at, str):
+                        from datetime import datetime
+                        enabled_at = datetime.fromisoformat(enabled_at)
+                    message_parts.append(f"🕐 <b>Время включения:</b> {enabled_at.strftime('%d.%m.%Y %H:%M:%S')}")
+                
+                message_parts.append(f"🤖 <b>Автоматически:</b> {'Да' if details.get('auto_enabled', False) else 'Нет'}")
+                message_parts.append("")
+                message_parts.append("❗ Обычные пользователи временно не могут использовать бота.")
+                
+            elif event_type == "disable":
+                if details.get("disabled_at"):
+                    disabled_at = details["disabled_at"]
+                    if isinstance(disabled_at, str):
+                        from datetime import datetime
+                        disabled_at = datetime.fromisoformat(disabled_at)
+                    message_parts.append(f"🕐 <b>Время отключения:</b> {disabled_at.strftime('%d.%m.%Y %H:%M:%S')}")
+                
+                if details.get("duration"):
+                    duration = details["duration"]
+                    if isinstance(duration, (int, float)):
+                        hours = int(duration // 3600)
+                        minutes = int((duration % 3600) // 60)
+                        if hours > 0:
+                            duration_str = f"{hours}ч {minutes}мин"
+                        else:
+                            duration_str = f"{minutes}мин"
+                        message_parts.append(f"⏱️ <b>Длительность:</b> {duration_str}")
+                
+                message_parts.append(f"🤖 <b>Было автоматическим:</b> {'Да' if details.get('was_auto', False) else 'Нет'}")
+                message_parts.append("")
+                message_parts.append("✅ Сервис снова доступен для пользователей.")
+                
+            elif event_type == "api_status":
+                message_parts.append(f"🔗 <b>API URL:</b> {details.get('api_url', 'неизвестно')}")
+                
+                if status == "online":
+                    if details.get("response_time"):
+                        message_parts.append(f"⚡ <b>Время отклика:</b> {details['response_time']} сек")
+                        
+                    if details.get("consecutive_failures", 0) > 0:
+                        message_parts.append(f"🔄 <b>Неудачных попыток было:</b> {details['consecutive_failures']}")
+                        
+                    message_parts.append("")
+                    message_parts.append("API снова отвечает на запросы.")
+                    
+                else: 
+                    if details.get("consecutive_failures"):
+                        message_parts.append(f"🔄 <b>Попытка №:</b> {details['consecutive_failures']}")
+                        
+                    if details.get("error"):
+                        error_msg = str(details["error"])[:100]  
+                        message_parts.append(f"❌ <b>Ошибка:</b> {error_msg}")
+                        
+                    message_parts.append("")
+                    message_parts.append("⚠️ Началась серия неудачных проверок API.")
+                    
+            elif event_type == "monitoring":
+                if status == "started":
+                    if details.get("check_interval"):
+                        message_parts.append(f"🔄 <b>Интервал проверки:</b> {details['check_interval']} сек")
+                        
+                    if details.get("auto_enable_configured") is not None:
+                        auto_enable = "Включено" if details["auto_enable_configured"] else "Отключено"
+                        message_parts.append(f"🤖 <b>Автовключение:</b> {auto_enable}")
+                        
+                    if details.get("max_failures"):
+                        message_parts.append(f"🎯 <b>Порог ошибок:</b> {details['max_failures']}")
+                        
+                    message_parts.append("")
+                    message_parts.append("Система будет следить за доступностью API.")
+                    
+                else:  
+                    message_parts.append("Автоматический мониторинг API остановлен.")
+            
+            from datetime import datetime
+            message_parts.append("")
+            message_parts.append(f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>")
+            
+            message = "\n".join(message_parts)
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о техработах: {e}")
+            return False
+    
+    async def send_remnawave_panel_status_notification(
+        self,
+        status: str,
+        details: Dict[str, Any] = None
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            details = details or {}
+            
+            status_config = {
+                "online": {"icon": "🟢", "title": "ПАНЕЛЬ REMNAWAVE ДОСТУПНА", "alert_type": "success"},
+                "offline": {"icon": "🔴", "title": "ПАНЕЛЬ REMNAWAVE НЕДОСТУПНА", "alert_type": "error"},
+                "degraded": {"icon": "🟡", "title": "ПАНЕЛЬ REMNAWAVE РАБОТАЕТ СО СБОЯМИ", "alert_type": "warning"},
+                "maintenance": {"icon": "🔧", "title": "ПАНЕЛЬ REMNAWAVE НА ОБСЛУЖИВАНИИ", "alert_type": "info"}
+            }
+            
+            config = status_config.get(status, status_config["offline"])
+            
+            message_parts = [
+                f"{config['icon']} <b>{config['title']}</b>",
+                ""
+            ]
+            
+            if details.get("api_url"):
+                message_parts.append(f"🔗 <b>URL:</b> {details['api_url']}")
+                
+            if details.get("response_time"):
+                message_parts.append(f"⚡ <b>Время отклика:</b> {details['response_time']} сек")
+                
+            if details.get("last_check"):
+                last_check = details["last_check"]
+                if isinstance(last_check, str):
+                    from datetime import datetime
+                    last_check = datetime.fromisoformat(last_check)
+                message_parts.append(f"🕐 <b>Последняя проверка:</b> {last_check.strftime('%H:%M:%S')}")
+                
+            if status == "online":
+                if details.get("uptime"):
+                    message_parts.append(f"⏱️ <b>Время работы:</b> {details['uptime']}")
+                    
+                if details.get("users_online"):
+                    message_parts.append(f"👥 <b>Пользователей онлайн:</b> {details['users_online']}")
+                    
+                message_parts.append("")
+                message_parts.append("✅ Все системы работают нормально.")
+                
+            elif status == "offline":
+                if details.get("error"):
+                    error_msg = str(details["error"])[:150]
+                    message_parts.append(f"❌ <b>Ошибка:</b> {error_msg}")
+                    
+                if details.get("consecutive_failures"):
+                    message_parts.append(f"🔄 <b>Неудачных попыток:</b> {details['consecutive_failures']}")
+                    
+                message_parts.append("")
+                message_parts.append("⚠️ Панель недоступна. Проверьте соединение и статус сервера.")
+                
+            elif status == "degraded":
+                if details.get("issues"):
+                    issues = details["issues"]
+                    if isinstance(issues, list):
+                        message_parts.append("⚠️ <b>Обнаруженные проблемы:</b>")
+                        for issue in issues[:3]: 
+                            message_parts.append(f"   • {issue}")
+                    else:
+                        message_parts.append(f"⚠️ <b>Проблема:</b> {issues}")
+                        
+                message_parts.append("")
+                message_parts.append("Панель работает, но возможны задержки или сбои.")
+                
+            elif status == "maintenance":
+                if details.get("maintenance_reason"):
+                    message_parts.append(f"🔧 <b>Причина:</b> {details['maintenance_reason']}")
+                    
+                if details.get("estimated_duration"):
+                    message_parts.append(f"⏰ <b>Ожидаемая длительность:</b> {details['estimated_duration']}")
+                    
+                message_parts.append("")
+                message_parts.append("Панель временно недоступна для обслуживания.")
+            
+            from datetime import datetime
+            message_parts.append("")
+            message_parts.append(f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>")
+            
+            message = "\n".join(message_parts)
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о статусе панели Remnawave: {e}")
+            return False
+
+    async def send_remnawave_panel_status_notification(
+        self,
+        status: str,
+        details: Dict[str, Any] = None
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+        
+        try:
+            details = details or {}
+            
+            status_config = {
+                "online": {"icon": "🟢", "title": "ПАНЕЛЬ REMNAWAVE ДОСТУПНА", "alert_type": "success"},
+                "offline": {"icon": "🔴", "title": "ПАНЕЛЬ REMNAWAVE НЕДОСТУПНА", "alert_type": "error"},
+                "degraded": {"icon": "🟡", "title": "ПАНЕЛЬ REMNAWAVE РАБОТАЕТ СО СБОЯМИ", "alert_type": "warning"},
+                "maintenance": {"icon": "🔧", "title": "ПАНЕЛЬ REMNAWAVE НА ОБСЛУЖИВАНИИ", "alert_type": "info"}
+            }
+            
+            config = status_config.get(status, status_config["offline"])
+            
+            message_parts = [
+                f"{config['icon']} <b>{config['title']}</b>",
+                ""
+            ]
+            
+            if details.get("api_url"):
+                message_parts.append(f"🔗 <b>URL:</b> {details['api_url']}")
+                
+            if details.get("response_time"):
+                message_parts.append(f"⚡ <b>Время отклика:</b> {details['response_time']} сек")
+                
+            if details.get("last_check"):
+                last_check = details["last_check"]
+                if isinstance(last_check, str):
+                    from datetime import datetime
+                    last_check = datetime.fromisoformat(last_check)
+                message_parts.append(f"🕐 <b>Последняя проверка:</b> {last_check.strftime('%H:%M:%S')}")
+                
+            if status == "online":
+                if details.get("uptime"):
+                    message_parts.append(f"⏱️ <b>Время работы:</b> {details['uptime']}")
+                    
+                if details.get("users_online"):
+                    message_parts.append(f"👥 <b>Пользователей онлайн:</b> {details['users_online']}")
+                    
+                message_parts.append("")
+                message_parts.append("✅ Все системы работают нормально.")
+                
+            elif status == "offline":
+                if details.get("error"):
+                    error_msg = str(details["error"])[:150]
+                    message_parts.append(f"❌ <b>Ошибка:</b> {error_msg}")
+                    
+                if details.get("consecutive_failures"):
+                    message_parts.append(f"🔄 <b>Неудачных попыток:</b> {details['consecutive_failures']}")
+                    
+                message_parts.append("")
+                message_parts.append("⚠️ Панель недоступна. Проверьте соединение и статус сервера.")
+                
+            elif status == "degraded":
+                if details.get("issues"):
+                    issues = details["issues"]
+                    if isinstance(issues, list):
+                        message_parts.append("⚠️ <b>Обнаруженные проблемы:</b>")
+                        for issue in issues[:3]: 
+                            message_parts.append(f"   • {issue}")
+                    else:
+                        message_parts.append(f"⚠️ <b>Проблема:</b> {issues}")
+                        
+                message_parts.append("")
+                message_parts.append("Панель работает, но возможны задержки или сбои.")
+                
+            elif status == "maintenance":
+                if details.get("maintenance_reason"):
+                    message_parts.append(f"🔧 <b>Причина:</b> {details['maintenance_reason']}")
+                    
+                if details.get("estimated_duration"):
+                    message_parts.append(f"⏰ <b>Ожидаемая длительность:</b> {details['estimated_duration']}")
+                    
+                if details.get("manual_message"):
+                    message_parts.append(f"💬 <b>Сообщение:</b> {details['manual_message']}")
+                    
+                message_parts.append("")
+                message_parts.append("Панель временно недоступна для обслуживания.")
+            
+            from datetime import datetime
+            message_parts.append("")
+            message_parts.append(f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>")
+            
+            message = "\n".join(message_parts)
+            
+            return await self._send_message(message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о статусе панели Remnawave: {e}")
+            return False
+
+

app/services/maintenance_service.py

@@ -33,7 +33,6 @@ class MaintenanceService:
         self._last_notification_sent = None 
         
     def set_bot(self, bot):
-        """Устанавливает ссылку на бота для отправки уведомлений"""
         self._bot = bot
         logger.info("Бот установлен для maintenance_service")
     
@@ -58,12 +57,49 @@ class MaintenanceService:
         else:
             return settings.get_maintenance_message()
     
+    async def _send_admin_notification(self, message: str, alert_type: str = "info"):
+        if not self._bot:
+            logger.warning("Бот не установлен, уведомления не могут быть отправлены")
+            return False
+        
+        try:
+            from app.services.admin_notification_service import AdminNotificationService
+            
+            notification_service = AdminNotificationService(self._bot)
+            
+            if not notification_service._is_enabled():
+                logger.debug("Уведомления администраторов отключены")
+                return False
+            
+            emoji_map = {
+                "error": "🚨",
+                "warning": "⚠️", 
+                "success": "✅",
+                "info": "ℹ️"
+            }
+            emoji = emoji_map.get(alert_type, "ℹ️")
+            
+            formatted_message = f"{emoji} <b>ТЕХНИЧЕСКИЕ РАБОТЫ</b>\n\n{message}\n\n⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"
+            
+            return await notification_service._send_message(formatted_message)
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления через AdminNotificationService: {e}")
+            return False
+    
     async def _notify_admins(self, message: str, alert_type: str = "info"):
-        """Отправка уведомлений администраторам"""
         if not self._bot:
             logger.warning("Бот не установлен, уведомления не могут быть отправлены")
             return
         
+        notification_sent = await self._send_admin_notification(message, alert_type)
+        
+        if notification_sent:
+            logger.info("Уведомление успешно отправлено через AdminNotificationService")
+            return
+        
+        logger.info("Отправляем уведомление напрямую администраторам")
+        
         cache_key = f"maintenance_notification_{alert_type}"
         if await cache.get(cache_key):
             return
@@ -116,15 +152,13 @@ class MaintenanceService:
             
             await self._save_status_to_cache()
             
-            notification_msg = f"""
-Режим технических работ ВКЛЮЧЕН
+            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")
             
@@ -163,15 +197,13 @@ class MaintenanceService:
                 else:
                     duration_str = f"\n⏱️ <b>Длительность:</b> {minutes}мин"
             
-            notification_msg = f"""
-Режим технических работ ВЫКЛЮЧЕН
+            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")
             
@@ -191,17 +223,15 @@ class MaintenanceService:
             await self._load_status_from_cache()
             
             self._check_task = asyncio.create_task(self._monitoring_loop())
-            logger.info(f"🔄 Запущен мониторинг API RemnaWave (интервал: {settings.get_maintenance_check_interval()}с)")
+            logger.info(f"🔄 Запущен мониторинг API Remnawave (интервал: {settings.get_maintenance_check_interval()}с)")
             
-            await self._notify_admins(f"""
-Мониторинг технических работ запущен
+            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")
+Система будет следить за доступностью API.""", "info")
             
             return True
             
@@ -240,17 +270,14 @@ 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 восстановлено!
+                        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")
+API снова отвечает на запросы.""", "success")
                     
                     self._status.api_status = True
                     self._status.consecutive_failures = 0
@@ -266,15 +293,13 @@ API снова отвечает на запросы.
                     self._status.consecutive_failures += 1
                     
                     if was_available:
-                        await self._notify_admins(f"""
-API RemnaWave недоступно!
+                        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")
+Началась серия неудачных проверок API.""", "error")
                     
                     if (self._status.consecutive_failures >= self._max_consecutive_failures and
                         not self._status.is_active and
@@ -291,14 +316,12 @@ API RemnaWave недоступно!
             logger.error(f"Ошибка проверки API: {e}")
             
             if self._status.api_status:
-                await self._notify_admins(f"""
-Ошибка при проверке API RemnaWave
+                await self._notify_admins(f"""Ошибка при проверке API Remnawave
 
 ❌ <b>Ошибка:</b> {str(e)}
 🕐 <b>Время:</b> {datetime.utcnow().strftime('%H:%M:%S')}
 
-Не удалось выполнить проверку доступности API.
-""", "error")
+Не удалось выполнить проверку доступности API.""", "error")
             
             self._status.api_status = False
             self._status.consecutive_failures += 1
@@ -401,6 +424,33 @@ API RemnaWave недоступно!
                 "checked_at": end_time,
                 "consecutive_failures": self._status.consecutive_failures
             }
+    
+    async def send_remnawave_status_notification(self, status: str, details: str = "") -> bool:
+        try:
+            status_emojis = {
+                "online": "🟢",
+                "offline": "🔴", 
+                "warning": "🟡",
+                "error": "⚠️"
+            }
+            
+            emoji = status_emojis.get(status, "ℹ️")
+            
+            message = f"""Статус панели Remnawave изменился
+
+{emoji} <b>Статус:</b> {status.upper()}
+🔗 <b>URL:</b> {settings.REMNAWAVE_API_URL}
+{details}"""
+            
+            alert_type = "error" if status in ["offline", "error"] else "info"
+            await self._notify_admins(message, alert_type)
+            
+            logger.info(f"Отправлено уведомление о статусе Remnawave: {status}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о статусе Remnawave: {e}")
+            return False
 
 
 maintenance_service = MaintenanceService()

app/services/payment_service.py

@@ -80,12 +80,38 @@ class PaymentService:
             
             user = await get_user_by_id(db, user_id)
             if user:
-                await add_user_balance(
-                    db, 
-                    user, 
-                    amount_kopeks, 
-                    f"Пополнение Stars: {rubles_amount:.2f}₽ ({stars_amount} ⭐)"
-                )
+                old_balance = user.balance_kopeks
+                
+                user.balance_kopeks += amount_kopeks
+                user.updated_at = datetime.utcnow()
+                
+                await db.commit()
+                await db.refresh(user)
+                
+                logger.info(f"💰 Баланс пользователя {user.telegram_id} изменен: {old_balance} → {user.balance_kopeks} (изменение: +{amount_kopeks})")
+                
+                description_for_referral = f"Пополнение Stars: {rubles_amount:.2f}₽ ({stars_amount} ⭐)"
+                logger.info(f"🔍 Проверка реферальной логики для описания: '{description_for_referral}'")
+                
+                if any(word in description_for_referral.lower() for word in ["пополнение", "stars", "yookassa", "topup"]) and not any(word in description_for_referral.lower() for word in ["комиссия", "бонус"]):
+                    logger.info(f"🔞 Вызов process_referral_topup для пользователя {user_id}")
+                    try:
+                        from app.services.referral_service import process_referral_topup
+                        await process_referral_topup(db, user_id, amount_kopeks, self.bot)
+                    except Exception as e:
+                        logger.error(f"Ошибка обработки реферального пополнения: {e}")
+                else:
+                    logger.info(f"❌ Описание '{description_for_referral}' не подходит для реферальной логики")
+                
+                if self.bot:
+                    try:
+                        from app.services.admin_notification_service import AdminNotificationService
+                        notification_service = AdminNotificationService(self.bot)
+                        await notification_service.send_balance_topup_notification(
+                            db, user, transaction, old_balance
+                        )
+                    except Exception as e:
+                        logger.error(f"Ошибка отправки уведомления о пополнении Stars: {e}")
                 
                 if self.bot:
                     try:
@@ -94,7 +120,7 @@ class PaymentService:
                             f"✅ <b>Пополнение успешно!</b>\n\n"
                             f"⭐ Звезд: {stars_amount}\n"
                             f"💰 Сумма: {settings.format_price(amount_kopeks)}\n"
-                            f"🏦 Способ: Telegram Stars\n"
+                            f"🦊 Способ: Telegram Stars\n"
                             f"🆔 Транзакция: {telegram_payment_charge_id[:8]}...\n\n"
                             f"Баланс пополнен автоматически!",
                             parse_mode="HTML"
@@ -252,7 +278,29 @@ class PaymentService:
                 
                 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}₽")
+                    old_balance = user.balance_kopeks
+                    
+                    user.balance_kopeks += updated_payment.amount_kopeks
+                    user.updated_at = datetime.utcnow()
+                    
+                    await db.commit()
+                    await db.refresh(user)
+                    
+                    try:
+                        from app.services.referral_service import process_referral_topup
+                        await process_referral_topup(db, user.id, updated_payment.amount_kopeks, self.bot)
+                    except Exception as e:
+                        logger.error(f"Ошибка обработки реферального пополнения YooKassa: {e}")
+                    
+                    if self.bot:
+                        try:
+                            from app.services.admin_notification_service import AdminNotificationService
+                            notification_service = AdminNotificationService(self.bot)
+                            await notification_service.send_balance_topup_notification(
+                                db, user, transaction, old_balance
+                            )
+                        except Exception as e:
+                            logger.error(f"Ошибка отправки уведомления о пополнении YooKassa: {e}")
                     
                     if self.bot:
                         try:
@@ -260,7 +308,7 @@ class PaymentService:
                                 user.telegram_id,
                                 f"✅ <b>Пополнение успешно!</b>\n\n"
                                 f"💰 Сумма: {settings.format_price(updated_payment.amount_kopeks)}\n"
-                                f"🦐 Способ: Банковская карта\n"
+                                f"🦊 Способ: Банковская карта\n"
                                 f"🆔 Транзакция: {yookassa_payment_id[:8]}...\n\n"
                                 f"Баланс пополнен автоматически!",
                                 parse_mode="HTML"
@@ -381,17 +429,17 @@ class PaymentService:
         signature: str
     ) -> bool:
         
-        if not settings.TRIBUTE_WEBHOOK_SECRET:
+        if not settings.TRIBUTE_API_KEY:
             return False
-        
+
         try:
             message = str(data).encode()
             expected_signature = hmac.new(
-                settings.TRIBUTE_WEBHOOK_SECRET.encode(),
+                settings.TRIBUTE_API_KEY.encode(),
                 message,
                 hashlib.sha256
             ).hexdigest()
-            
+
             return hmac.compare_digest(signature, expected_signature)
             
         except Exception as e:

app/services/referral_service.py

@@ -1,20 +1,34 @@
 import logging
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, delete
+from aiogram import Bot
 
 from app.config import settings
 from app.database.crud.user import add_user_balance, get_user_by_id
 from app.database.crud.referral import create_referral_earning
-from app.database.models import TransactionType
+from app.database.models import TransactionType, ReferralEarning
 
 logger = logging.getLogger(__name__)
 
 
+async def send_referral_notification(
+    bot: Bot,
+    user_id: int,
+    message: str
+):
+    try:
+        await bot.send_message(user_id, message, parse_mode="HTML")
+        logger.info(f"✅ Уведомление отправлено пользователю {user_id}")
+    except Exception as e:
+        logger.error(f"❌ Ошибка отправки уведомления пользователю {user_id}: {e}")
+
+
 async def process_referral_registration(
     db: AsyncSession,
     new_user_id: int,
-    referrer_id: int
+    referrer_id: int,
+    bot: Bot = None
 ):
-    
     try:
         new_user = await get_user_by_id(db, new_user_id)
         referrer = await get_user_by_id(db, referrer_id)
@@ -27,14 +41,6 @@ async def process_referral_registration(
             logger.error(f"Пользователь {new_user_id} не привязан к рефереру {referrer_id}")
             return False
         
-        if settings.REFERRED_USER_REWARD > 0:
-            await add_user_balance(
-                db, new_user, settings.REFERRED_USER_REWARD,
-                f"Бонус за регистрацию по реферальной ссылке"
-            )
-            
-            logger.info(f"💰 Новый пользователь {new_user_id} получил бонус {settings.REFERRED_USER_REWARD/100}₽")
-        
         await create_referral_earning(
             db=db,
             user_id=referrer_id,
@@ -43,7 +49,26 @@ async def process_referral_registration(
             reason="referral_registration_pending"
         )
         
-        logger.info(f"✅ Обработана реферальная регистрация: {new_user_id} -> {referrer_id}")
+        if bot:
+            referral_notification = (
+                f"🎉 <b>Добро пожаловать!</b>\n\n"
+                f"Вы перешли по реферальной ссылке пользователя <b>{referrer.full_name}</b>!\n\n"
+                f"💰 При первом пополнении от {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)} "
+                f"вы получите бонус {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}!\n\n"
+                f"🎁 Ваш реферер также получит награду за ваше первое пополнение."
+            )
+            await send_referral_notification(bot, new_user.telegram_id, referral_notification)
+            
+            inviter_notification = (
+                f"👥 <b>Новый реферал!</b>\n\n"
+                f"По вашей ссылке зарегистрировался пользователь <b>{new_user.full_name}</b>!\n\n"
+                f"💰 Когда он пополнит баланс от {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}, "
+                f"вы получите {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}\n\n"
+                f"📈 С каждого последующего пополнения вы будете получать {settings.REFERRAL_COMMISSION_PERCENT}% комиссии."
+            )
+            await send_referral_notification(bot, referrer.telegram_id, inviter_notification)
+        
+        logger.info(f"✅ Зарегистрирован реферал {new_user_id} для {referrer_id}. Бонусы будут выданы после пополнения.")
         return True
         
     except Exception as e:
@@ -51,61 +76,144 @@ async def process_referral_registration(
         return False
 
 
-async def process_referral_purchase(
+async def process_referral_topup(
     db: AsyncSession,
-    user_id: int,
-    purchase_amount_kopeks: int,
-    transaction_id: int = None
+    user_id: int, 
+    topup_amount_kopeks: int,
+    bot: Bot = None
 ):
-    
     try:
         user = await get_user_by_id(db, user_id)
         if not user or not user.referred_by_id:
             logger.info(f"Пользователь {user_id} не является рефералом")
-            return False
+            return True
+        
+        if topup_amount_kopeks < settings.REFERRAL_MINIMUM_TOPUP_KOPEKS:
+            logger.info(f"Пополнение {user_id} на {topup_amount_kopeks/100}₽ меньше минимума")
+            return True
         
         referrer = await get_user_by_id(db, user.referred_by_id)
         if not referrer:
             logger.error(f"Реферер {user.referred_by_id} не найден")
             return False
         
-        from app.database.crud.referral import get_referral_earnings_by_referral
-        existing_earnings = await get_referral_earnings_by_referral(db, user_id)
-        
-        purchase_earnings = [
-            earning for earning in existing_earnings 
-            if earning.reason in ["referral_first_purchase", "referral_commission"]
-        ]
-        
-        is_first_purchase = len(purchase_earnings) == 0
-        
-        logger.info(f"🔍 Покупка реферала {user_id}: первая = {is_first_purchase}, сумма = {purchase_amount_kopeks/100}₽")
-        
-        if is_first_purchase and settings.REFERRAL_REGISTRATION_REWARD > 0:
-            reward_amount = settings.REFERRAL_REGISTRATION_REWARD
+        if not user.has_made_first_topup:
+            user.has_made_first_topup = True
+            await db.commit()
             
-            if reward_amount > 1000000: 
-                logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: reward_amount = {reward_amount} слишком большой! Проверьте настройки REFERRAL_REGISTRATION_REWARD")
-                reward_amount = 10000 
+            try:
+                await db.execute(
+                    delete(ReferralEarning).where(
+                        ReferralEarning.user_id == referrer.id,
+                        ReferralEarning.referral_id == user.id, 
+                        ReferralEarning.reason == "referral_registration_pending"
+                    )
+                )
+                await db.commit()
+                logger.info(f"🗑️ Удалена запись 'ожидание пополнения' для реферала {user.id}")
+            except Exception as e:
+                logger.error(f"Ошибка удаления записи ожидания: {e}")
             
-            await add_user_balance(
-                db, referrer, reward_amount,
-                f"Реферальная награда за первую покупку {user.full_name}"
-            )
+            if settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS > 0:
+                await add_user_balance(
+                    db, user, settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS,
+                    f"Бонус за первое пополнение по реферальной программе",
+                    bot=bot
+                )
+                logger.info(f"💰 Реферал {user.id} получил бонус {settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS/100}₽")
+                
+                if bot:
+                    bonus_notification = (
+                        f"🎉 <b>Бонус получен!</b>\n\n"
+                        f"За первое пополнение вы получили бонус "
+                        f"{settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}!\n\n"
+                        f"💎 Средства зачислены на ваш баланс."
+                    )
+                    await send_referral_notification(bot, user.telegram_id, bonus_notification)
             
-            await create_referral_earning(
-                db=db,
-                user_id=referrer.id,
-                referral_id=user_id,
-                amount_kopeks=reward_amount,
-                reason="referral_first_purchase",
-                referral_transaction_id=transaction_id
-            )
-            
-            logger.info(f"🎉 Первая покупка реферала: {referrer.telegram_id} получил {reward_amount/100}₽")
+            if settings.REFERRAL_INVITER_BONUS_KOPEKS > 0:
+                await add_user_balance(
+                    db, referrer, settings.REFERRAL_INVITER_BONUS_KOPEKS,
+                    f"Бонус за первое пополнение реферала {user.full_name}",
+                    bot=bot
+                )
+                
+                await create_referral_earning(
+                    db=db,
+                    user_id=referrer.id,
+                    referral_id=user.id, 
+                    amount_kopeks=settings.REFERRAL_INVITER_BONUS_KOPEKS,
+                    reason="referral_first_topup"
+                )
+                logger.info(f"💰 Реферер {referrer.telegram_id} получил бонус {settings.REFERRAL_INVITER_BONUS_KOPEKS/100}₽")
+                
+                if bot:
+                    inviter_bonus_notification = (
+                        f"💰 <b>Реферальная награда!</b>\n\n"
+                        f"Ваш реферал <b>{user.full_name}</b> сделал первое пополнение!\n\n"
+                        f"🎁 Вы получили награду: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}\n\n"
+                        f"📈 Теперь с каждого его пополнения вы будете получать {settings.REFERRAL_COMMISSION_PERCENT}% комиссии."
+                    )
+                    await send_referral_notification(bot, referrer.telegram_id, inviter_bonus_notification)
+        
+        else:
+            if settings.REFERRAL_COMMISSION_PERCENT > 0:
+                commission_amount = int(topup_amount_kopeks * settings.REFERRAL_COMMISSION_PERCENT / 100)
+                
+                if commission_amount > 0:
+                    await add_user_balance(
+                        db, referrer, commission_amount,
+                        f"Комиссия {settings.REFERRAL_COMMISSION_PERCENT}% с пополнения {user.full_name}",
+                        bot=bot
+                    )
+                    
+                    await create_referral_earning(
+                        db=db,
+                        user_id=referrer.id,
+                        referral_id=user.id,
+                        amount_kopeks=commission_amount,
+                        reason="referral_commission_topup"
+                    )
+                    
+                    logger.info(f"💰 Комиссия с пополнения: {referrer.telegram_id} получил {commission_amount/100}₽")
+                    
+                    if bot:
+                        commission_notification = (
+                            f"💰 <b>Реферальная комиссия!</b>\n\n"
+                            f"Ваш реферал <b>{user.full_name}</b> пополнил баланс на "
+                            f"{settings.format_price(topup_amount_kopeks)}\n\n"
+                            f"🎁 Ваша комиссия ({settings.REFERRAL_COMMISSION_PERCENT}%): "
+                            f"{settings.format_price(commission_amount)}\n\n"
+                            f"💎 Средства зачислены на ваш баланс."
+                        )
+                        await send_referral_notification(bot, referrer.telegram_id, commission_notification)
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка обработки пополнения реферала: {e}")
+        return False
+
+
+async def process_referral_purchase(
+    db: AsyncSession,
+    user_id: int,
+    purchase_amount_kopeks: int,
+    transaction_id: int = None,
+    bot: Bot = None
+):
+    try:
+        user = await get_user_by_id(db, user_id)
+        if not user or not user.referred_by_id:
+            return True
+        
+        referrer = await get_user_by_id(db, user.referred_by_id)
+        if not referrer:
+            logger.error(f"Реферер {user.referred_by_id} не найден")
+            return False
         
         if not (0 <= settings.REFERRAL_COMMISSION_PERCENT <= 100):
-            logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: REFERRAL_COMMISSION_PERCENT = {settings.REFERRAL_COMMISSION_PERCENT} некорректный! Должен быть от 0 до 100")
+            logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: REFERRAL_COMMISSION_PERCENT = {settings.REFERRAL_COMMISSION_PERCENT} некорректный!")
             commission_percent = 10 
         else:
             commission_percent = settings.REFERRAL_COMMISSION_PERCENT
@@ -115,19 +223,31 @@ async def process_referral_purchase(
         if commission_amount > 0:
             await add_user_balance(
                 db, referrer, commission_amount,
-                f"Комиссия {commission_percent}% с покупки {user.full_name}"
+                f"Комиссия {commission_percent}% с покупки {user.full_name}",
+                bot=bot
             )
             
             await create_referral_earning(
                 db=db,
                 user_id=referrer.id,
-                referral_id=user_id,
+                referral_id=user.id, 
                 amount_kopeks=commission_amount,
                 reason="referral_commission",
                 referral_transaction_id=transaction_id
             )
             
             logger.info(f"💰 Комиссия с покупки: {referrer.telegram_id} получил {commission_amount/100}₽")
+            
+            if bot:
+                purchase_commission_notification = (
+                    f"💰 <b>Комиссия с покупки!</b>\n\n"
+                    f"Ваш реферал <b>{user.full_name}</b> совершил покупку на "
+                    f"{settings.format_price(purchase_amount_kopeks)}\n\n"
+                    f"🎁 Ваша комиссия ({commission_percent}%): "
+                    f"{settings.format_price(commission_amount)}\n\n"
+                    f"💎 Средства зачислены на ваш баланс."
+                )
+                await send_referral_notification(bot, referrer.telegram_id, purchase_commission_notification)
         
         if not user.has_had_paid_subscription:
             user.has_had_paid_subscription = True
@@ -141,46 +261,3 @@ async def process_referral_purchase(
         import traceback
         logger.error(f"Полный traceback: {traceback.format_exc()}")
         return False
-
-
-async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
-    
-    try:
-        from app.database.crud.referral import get_referral_earnings_sum
-        from sqlalchemy import select, func
-        from app.database.models import User
-        
-        invited_count_result = await db.execute(
-            select(func.count(User.id)).where(User.referred_by_id == user_id)
-        )
-        invited_count = invited_count_result.scalar() or 0
-        
-        paid_referrals_result = await db.execute(
-            select(func.count(User.id)).where(
-                User.referred_by_id == user_id,
-                User.has_had_paid_subscription == True
-            )
-        )
-        paid_referrals_count = paid_referrals_result.scalar() or 0
-        
-        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) or 0
-        
-        return {
-            "invited_count": invited_count,
-            "paid_referrals_count": paid_referrals_count,
-            "total_earned_kopeks": total_earned,
-            "month_earned_kopeks": month_earned
-        }
-        
-    except Exception as e:
-        logger.error(f"Ошибка получения статистики рефералов: {e}")
-        return {
-            "invited_count": 0,
-            "paid_referrals_count": 0,
-            "total_earned_kopeks": 0,
-            "month_earned_kopeks": 0
-        }

app/services/remnawave_service.py

@@ -200,7 +200,7 @@ class RemnaWaveService:
                     return result
                 
             except RemnaWaveAPIError as e:
-                logger.error(f"Ошибка RemnaWave API при получении статистики: {e}")
+                logger.error(f"Ошибка Remnawave API при получении статистики: {e}")
                 return {"error": str(e)}
             except Exception as e:
                 logger.error(f"Общая ошибка получения системной статистики: {e}")
@@ -271,11 +271,11 @@ class RemnaWaveService:
                         'traffic_limit_bytes': node.traffic_limit_bytes
                     })
                 
-                logger.info(f"✅ Получено {len(result)} нод из RemnaWave")
+                logger.info(f"✅ Получено {len(result)} нод из Remnawave")
                 return result
                 
         except Exception as e:
-            logger.error(f"Ошибка получения нод из RemnaWave: {e}")
+            logger.error(f"Ошибка получения нод из Remnawave: {e}")
             return []
 
     async def test_connection(self) -> bool:
@@ -283,11 +283,11 @@ class RemnaWaveService:
         try:
             async with self.api as api:
                 stats = await api.get_system_stats()
-                logger.info("✅ Соединение с RemnaWave API работает")
+                logger.info("✅ Соединение с Remnawave API работает")
                 return True
                 
         except Exception as e:
-            logger.error(f"❌ Ошибка соединения с RemnaWave API: {e}")
+            logger.error(f"❌ Ошибка соединения с Remnawave API: {e}")
             return False
     
     async def get_node_details(self, node_uuid: str) -> Optional[Dict[str, Any]]:
@@ -378,11 +378,11 @@ class RemnaWaveService:
                         'inbounds': squad.inbounds
                     })
                 
-                logger.info(f"✅ Получено {len(result)} сквадов из RemnaWave")
+                logger.info(f"✅ Получено {len(result)} сквадов из Remnawave")
                 return result
                 
         except Exception as e:
-            logger.error(f"Ошибка получения сквадов из RemnaWave: {e}")
+            logger.error(f"Ошибка получения сквадов из Remnawave: {e}")
             return []
     
     async def create_squad(self, name: str, inbounds: List[str]) -> Optional[str]:
@@ -1119,9 +1119,6 @@ class RemnaWaveService:
             return False
 
     async def cleanup_orphaned_subscriptions(self, db: AsyncSession) -> Dict[str, int]:
-        """
-        Усиленная версия очистки с полным удалением данных
-        """
         try:
             stats = {"deactivated": 0, "errors": 0, "checked": 0}
         
@@ -1286,10 +1283,10 @@ class RemnaWaveService:
                                     if rw_user:
                                         subscription.remnawave_short_uuid = rw_user.short_uuid
                                         subscription.subscription_url = rw_user.subscription_url
-                                        logger.info(f"🔧 Восстановлены данные RemnaWave для {user.telegram_id}")
+                                        logger.info(f"🔧 Восстановлены данные Remnawave для {user.telegram_id}")
                                         issues_fixed += 1
                             except Exception as rw_error:
-                                logger.warning(f"⚠️ Не удалось получить данные RemnaWave для {user.telegram_id}: {rw_error}")
+                                logger.warning(f"⚠️ Не удалось получить данные Remnawave для {user.telegram_id}: {rw_error}")
                     
                         if subscription.traffic_limit_gb < 0:
                             subscription.traffic_limit_gb = 0
@@ -1356,7 +1353,7 @@ class RemnaWaveService:
                 recommendations["should_sync"] = True
                 recommendations["sync_type"] = "all"
                 recommendations["priority"] = "high"
-                recommendations["reasons"].append(f"Найдено {users_without_uuid} пользователей без связи с RemnaWave")
+                recommendations["reasons"].append(f"Найдено {users_without_uuid} пользователей без связи с Remnawave")
                 recommendations["estimated_time"] = "3-5 минут"
         
             if active_expired > 5:
@@ -1382,3 +1379,211 @@ class RemnaWaveService:
                 "priority": "medium",
                 "estimated_time": "3-5 минут"
             }
+
+    async def monitor_panel_status(self, bot) -> Dict[str, Any]:
+        try:
+            from app.utils.cache import cache
+            previous_status = await cache.get("remnawave_panel_status") or "unknown"
+                
+            status_result = await self.check_panel_health()
+            current_status = status_result.get("status", "offline")
+                
+            if current_status != previous_status and previous_status != "unknown":
+                await self._send_status_change_notification(
+                    bot, 
+                    previous_status, 
+                    current_status, 
+                    status_result
+                )
+                
+            await cache.set("remnawave_panel_status", current_status, expire=300)
+                
+            return status_result
+                
+        except Exception as e:
+            logger.error(f"Ошибка мониторинга статуса панели Remnawave: {e}")
+            return {"status": "error", "error": str(e)}
+        
+
+        
+    async def _send_status_change_notification(
+        self, 
+        bot, 
+        old_status: str, 
+        new_status: str, 
+        status_data: Dict[str, Any]
+    ):
+        try:
+            from app.services.admin_notification_service import AdminNotificationService
+                
+            notification_service = AdminNotificationService(bot)
+                
+            details = {
+                "api_url": status_data.get("api_url"),
+                "response_time": status_data.get("response_time"),
+                "last_check": status_data.get("last_check"),
+                "users_online": status_data.get("users_online"),
+                "nodes_online": status_data.get("nodes_online"),
+                "total_nodes": status_data.get("total_nodes"),
+                "old_status": old_status
+            }
+                
+            if new_status == "offline":
+                details["error"] = status_data.get("api_error")
+            elif new_status == "degraded":
+                issues = []
+                if status_data.get("response_time", 0) > 10:
+                    issues.append(f"Медленный отклик API ({status_data.get('response_time')}с)")
+                if status_data.get("nodes_health") == "unhealthy":
+                    issues.append(f"Проблемы с нодами ({status_data.get('nodes_online')}/{status_data.get('total_nodes')} онлайн)")
+                details["issues"] = issues
+                
+            await notification_service.send_remnawave_panel_status_notification(
+                new_status, 
+                details
+            )
+                
+            logger.info(f"Отправлено уведомление об изменении статуса панели: {old_status} -> {new_status}")
+                
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об изменении статуса: {e}")
+        
+
+        
+    async def send_manual_status_notification(self, bot, status: str, message: str = ""):
+        try:
+            from app.services.admin_notification_service import AdminNotificationService
+                
+            notification_service = AdminNotificationService(bot)
+                
+            details = {
+                "api_url": settings.REMNAWAVE_API_URL,
+                "last_check": datetime.utcnow(),
+                "manual_message": message
+            }
+                
+            if status == "maintenance":
+                details["maintenance_reason"] = message or "Плановое обслуживание"
+                
+            await notification_service.send_remnawave_panel_status_notification(status, details)
+                
+            logger.info(f"Отправлено ручное уведомление о статусе панели: {status}")
+            return True
+                
+        except Exception as e:
+            logger.error(f"Ошибка отправки ручного уведомления: {e}")
+            return False
+
+    async def get_panel_status_summary(self) -> Dict[str, Any]:
+        try:
+            status_data = await self.check_panel_health()
+                
+            status_descriptions = {
+                "online": "🟢 Панель работает нормально",
+                "offline": "🔴 Панель недоступна",
+                "degraded": "🟡 Панель работает со сбоями",
+                "maintenance": "🔧 Панель на обслуживании"
+            }
+                
+            status = status_data.get("status", "offline")
+                
+            summary = {
+                "status": status,
+                "description": status_descriptions.get(status, "❓ Статус неизвестен"),
+                "response_time": status_data.get("response_time", 0),
+                "api_available": status_data.get("api_available", False),
+                "nodes_status": f"{status_data.get('nodes_online', 0)}/{status_data.get('total_nodes', 0)} нод онлайн",
+                "users_online": status_data.get("users_online", 0),
+                "last_check": status_data.get("last_check"),
+                "has_issues": status in ["offline", "degraded"]
+            }
+                
+            if status == "offline":
+                summary["recommendation"] = "Проверьте подключение к серверу и работоспособность панели"
+            elif status == "degraded":
+                summary["recommendation"] = "Рекомендуется проверить состояние нод и производительность сервера"
+            else:
+                summary["recommendation"] = "Все системы работают нормально"
+                
+            return summary
+                
+        except Exception as e:
+            logger.error(f"Ошибка получения сводки статуса панели: {e}")
+            return {
+                "status": "error",
+                "description": "❌ Ошибка проверки статуса",
+                "response_time": 0,
+                "api_available": False,
+                "nodes_status": "неизвестно",
+                "users_online": 0,
+                "last_check": datetime.utcnow(),
+                "has_issues": True,
+                "recommendation": "Обратитесь к системному администратору",
+                "error": str(e)
+            }
+        
+    async def check_panel_health(self) -> Dict[str, Any]:
+        try:
+            start_time = datetime.utcnow()
+                
+            async with self.api as api:
+                try:
+                    system_stats = await api.get_system_stats()
+                    api_available = True
+                    api_error = None
+                except Exception as e:
+                    api_available = False
+                    api_error = str(e)
+                    system_stats = {}
+                    
+                try:
+                    nodes = await api.get_all_nodes()
+                    nodes_online = sum(1 for node in nodes if node.is_connected and node.is_node_online)
+                    total_nodes = len(nodes)
+                    nodes_health = "healthy" if nodes_online > 0 else "unhealthy"
+                except Exception:
+                    nodes_online = 0
+                    total_nodes = 0
+                    nodes_health = "unknown"
+                    
+                end_time = datetime.utcnow()
+                response_time = (end_time - start_time).total_seconds()
+                    
+                if not api_available:
+                    status = "offline"
+                elif response_time > 10: 
+                    status = "degraded"
+                elif nodes_health == "unhealthy":
+                    status = "degraded"
+                else:
+                    status = "online"
+                    
+                return {
+                    "status": status,
+                    "api_available": api_available,
+                    "api_error": api_error,
+                    "response_time": round(response_time, 2),
+                    "nodes_online": nodes_online,
+                    "total_nodes": total_nodes,
+                    "nodes_health": nodes_health,
+                    "users_online": system_stats.get('onlineStats', {}).get('onlineNow', 0),
+                    "total_users": system_stats.get('users', {}).get('totalUsers', 0),
+                    "last_check": end_time,
+                    "api_url": settings.REMNAWAVE_API_URL
+                }
+                
+        except Exception as e:
+            logger.error(f"Ошибка проверки здоровья панели: {e}")
+            return {
+                "status": "offline",
+                "api_available": False,
+                "api_error": str(e),
+                "response_time": 0,
+                "nodes_online": 0,
+                "total_nodes": 0,
+                "nodes_health": "unknown",
+                "last_check": datetime.utcnow(),
+                "api_url": settings.REMNAWAVE_API_URL
+            }
+        
+

app/services/tribute_service.py

@@ -1,6 +1,4 @@
 import logging
-import hashlib
-import hmac
 import json
 from typing import Optional, Dict, Any
 from datetime import datetime
@@ -56,15 +54,9 @@ class TributeService:
     
     async def process_webhook(
         self,
-        payload: str,
-        signature: Optional[str] = None
+        payload: str
     ) -> Dict[str, Any]:
         
-        if signature and settings.TRIBUTE_WEBHOOK_SECRET:
-            if not self.tribute_api.verify_webhook_signature(payload, signature):
-                logger.warning("Неверная подпись Tribute webhook")
-                return {"status": "error", "reason": "invalid_signature"}
-        
         try:
             webhook_data = json.loads(payload)
         except json.JSONDecodeError:
@@ -90,37 +82,38 @@ class TributeService:
         return {"status": "ok", "event": event_type}
     
     async def _handle_successful_payment(self, payment_data: Dict[str, Any]):
-        """Обработка успешного платежа - ПОЛНОСТЬЮ ПЕРЕРАБОТАННАЯ ВЕРСИЯ"""
-        
         try:
-            user_id = payment_data["user_id"]
+            user_telegram_id = payment_data["user_id"] 
             amount_kopeks = payment_data["amount_kopeks"]
             payment_id = payment_data["payment_id"]
             
-            logger.info(f"Обрабатываем успешный Tribute платеж: user_id={user_id}, amount={amount_kopeks}, payment_id={payment_id}")
+            logger.info(f"Обрабатываем успешный Tribute платеж: user_telegram_id={user_telegram_id}, amount={amount_kopeks}, payment_id={payment_id}")
             
             async for session in get_db():
-                from app.database.crud.transaction import check_tribute_payment_duplicate, create_unique_tribute_transaction
-                
-                duplicate_transaction = await check_tribute_payment_duplicate(
-                    session, payment_id, amount_kopeks, user_id
-                )
-                
-                if duplicate_transaction:
-                    logger.warning(f"Найден дубликат платежа:")
-                    logger.warning(f"   Transaction ID: {duplicate_transaction.id}")
-                    logger.warning(f"   Amount: {duplicate_transaction.amount_kopeks} коп")
-                    logger.warning(f"   Created: {duplicate_transaction.created_at}")
-                    logger.warning(f"Платеж игнорирован")
-                    return
-                
-                user = await get_user_by_telegram_id(session, user_id)
+                user = await get_user_by_telegram_id(session, user_telegram_id)
                 if not user:
-                    logger.error(f"Пользователь {user_id} не найден")
+                    logger.error(f"Пользователь {user_telegram_id} не найден")
                     return
                 
                 logger.info(f"Найден пользователь {user.telegram_id}, текущий баланс: {user.balance_kopeks} коп")
                 
+                from app.database.crud.transaction import check_tribute_payment_duplicate
+                
+                duplicate_transaction = await check_tribute_payment_duplicate(
+                    session, payment_id, amount_kopeks, user_telegram_id
+                )
+                
+                if duplicate_transaction:
+                    logger.warning(f"Найден дубликат платежа в течение 24ч:")
+                    logger.warning(f"   Transaction ID: {duplicate_transaction.id}")
+                    logger.warning(f"   Amount: {duplicate_transaction.amount_kopeks} коп")
+                    logger.warning(f"   Created: {duplicate_transaction.created_at}")
+                    logger.warning(f"   External ID: {duplicate_transaction.external_id}")
+                    logger.warning(f"Платеж игнорирован - это дубликат свежего платежа")
+                    return
+                
+                from app.database.crud.transaction import create_unique_tribute_transaction
+                
                 transaction = await create_unique_tribute_transaction(
                     db=session,
                     user_id=user.id,
@@ -135,18 +128,38 @@ class TributeService:
                 
                 await session.commit()
                 
-                logger.info(f"Баланс пользователя {user_id} обновлен: {old_balance} -> {user.balance_kopeks} коп (+{amount_kopeks})")
+                logger.info(f"✅ Баланс пользователя {user_telegram_id} обновлен: {old_balance} -> {user.balance_kopeks} коп (+{amount_kopeks})")
+                logger.info(f"✅ Создана транзакция ID: {transaction.id}")
                 
-                await self._send_success_notification(user_id, amount_kopeks)
+                try:
+                    from app.services.referral_service import process_referral_topup
+                    await process_referral_topup(session, user.id, amount_kopeks, self.bot)
+                except Exception as e:
+                    logger.error(f"Ошибка обработки реферального пополнения Tribute: {e}")
+                    
+                if not user.has_made_first_topup:
+                    user.has_made_first_topup = True
+                    logger.info(f"Отмечен первый топап для пользователя {user_telegram_id}")
                 
-                logger.info(f"Успешно обработан Tribute платеж: {amount_kopeks/100}₽ для пользователя {user_id}")
+                
+                try:
+                    from app.services.admin_notification_service import AdminNotificationService
+                    notification_service = AdminNotificationService(self.bot)
+                    await notification_service.send_balance_topup_notification(
+                        session, user, transaction, old_balance
+                    )
+                except Exception as e:
+                    logger.error(f"Ошибка отправки уведомления о Tribute пополнении: {e}")
+                
+                await self._send_success_notification(user_telegram_id, amount_kopeks)
+                
+                logger.info(f"🎉 Успешно обработан Tribute платеж: {amount_kopeks/100}₽ для пользователя {user_telegram_id}")
                 break
                 
         except Exception as e:
-            logger.error(f"Ошибка обработки успешного Tribute платежа: {e}", exc_info=True)
+            logger.error(f"⌘ Ошибка обработки успешного Tribute платежа: {e}", exc_info=True)
     
     async def _handle_failed_payment(self, payment_data: Dict[str, Any]):
-        """Обработка неудачного платежа"""
         
         try:
             user_id = payment_data["user_id"]
@@ -170,7 +183,6 @@ class TributeService:
             logger.error(f"Ошибка обработки неудачного Tribute платежа: {e}")
     
     async def _handle_refund(self, refund_data: Dict[str, Any]):
-        """Обработка возврата"""
         
         try:
             user_id = refund_data["user_id"]
@@ -203,7 +215,6 @@ class TributeService:
             logger.error(f"Ошибка обработки возврата Tribute: {e}")
     
     async def _send_success_notification(self, user_id: int, amount_kopeks: int):
-        """Отправка уведомления об успешном платеже"""
         
         try:
             amount_rubles = amount_kopeks / 100
@@ -232,11 +243,10 @@ class TributeService:
             logger.error(f"Ошибка отправки уведомления об успешном платеже: {e}")
     
     async def _send_failure_notification(self, user_id: int):
-        """Отправка уведомления о неудачном платеже"""
         
         try:
             text = (
-                "❌ **Платеж не прошел**\n\n"
+                "⌘ **Платеж не прошел**\n\n"
                 "К сожалению, ваш платеж через Tribute был отклонен.\n\n"
                 "Возможные причины:\n"
                 "• Недостаточно средств на карте\n"
@@ -261,7 +271,6 @@ class TributeService:
             logger.error(f"Ошибка отправки уведомления о неудачном платеже: {e}")
     
     async def _send_refund_notification(self, user_id: int, amount_kopeks: int):
-        """Отправка уведомления о возврате"""
         
         try:
             amount_rubles = amount_kopeks / 100
@@ -296,7 +305,6 @@ class TributeService:
         amount_kopeks: int,
         description: str = "Принудительная обработка Tribute платежа"
     ) -> bool:
-        """Принудительная обработка платежа (для отладки)"""
         
         try:
             logger.info(f"🔧 ПРИНУДИТЕЛЬНАЯ ОБРАБОТКА: payment_id={payment_id}, user_id={user_id}, amount={amount_kopeks}")
@@ -304,7 +312,7 @@ class TributeService:
             async for session in get_db():
                 user = await get_user_by_telegram_id(session, user_id)
                 if not user:
-                    logger.error(f"❌ Пользователь {user_id} не найден")
+                    logger.error(f"⌘ Пользователь {user_id} не найден")
                     return False
                 
                 external_id = f"force_donation_{payment_id}_{int(datetime.utcnow().timestamp())}"
@@ -334,7 +342,7 @@ class TributeService:
                 return True
                 
         except Exception as e:
-            logger.error(f"❌ Ошибка принудительной обработки: {e}", exc_info=True)
+            logger.error(f"⌘ Ошибка принудительной обработки: {e}", exc_info=True)
             return False
     
     async def get_payment_status(self, payment_id: str) -> Optional[Dict[str, Any]]:

app/services/user_service.py

@@ -242,9 +242,9 @@ class UserService:
                     from app.services.subscription_service import SubscriptionService
                     subscription_service = SubscriptionService()
                     await subscription_service.disable_remnawave_user(user.remnawave_uuid)
-                    logger.info(f"   ✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован")
+                    logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован")
                 except Exception as e:
-                    logger.warning(f"   ⚠️ Ошибка деактивации RemnaWave: {e}")
+                    logger.warning(f"⚠️ Ошибка деактивации RemnaWave: {e}")
             
             try:
                 from app.database.models import YooKassaPayment
@@ -256,14 +256,14 @@ class UserService:
                 yookassa_payments = yookassa_result.scalars().all()
                 
                 if yookassa_payments:
-                    logger.info(f"   🔄 Удаляем {len(yookassa_payments)} YooKassa платежей")
+                    logger.info(f"🔄 Удаляем {len(yookassa_payments)} YooKassa платежей")
                     await db.execute(
                         delete(YooKassaPayment).where(YooKassaPayment.user_id == user_id)
                     )
                     await db.flush()
-                    logger.info(f"   ✅ YooKassa платежи удалены")
+                    logger.info(f"✅ YooKassa платежи удалены")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка удаления YooKassa платежей: {e}")
+                logger.error(f"❌ Ошибка удаления YooKassa платежей: {e}")
             
             try:
                 transactions_result = await db.execute(
@@ -272,41 +272,41 @@ class UserService:
                 transactions = transactions_result.scalars().all()
                 
                 if transactions:
-                    logger.info(f"   🔄 Удаляем {len(transactions)} транзакций")
+                    logger.info(f"🔄 Удаляем {len(transactions)} транзакций")
                     await db.execute(
                         delete(Transaction).where(Transaction.user_id == user_id)
                     )
                     await db.flush()
-                    logger.info(f"   ✅ Транзакции удалены")
+                    logger.info(f"✅ Транзакции удалены")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка удаления транзакций: {e}")
+                logger.error(f"❌ Ошибка удаления транзакций: {e}")
             
             try:
                 await db.execute(
                     delete(PromoCodeUse).where(PromoCodeUse.user_id == user_id)
                 )
                 await db.flush()
-                logger.info(f"   🗑️ Удалены использования промокодов пользователя {user_id}")
+                logger.info(f"🗑️ Удалены использования промокодов пользователя {user_id}")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка удаления использований промокодов: {e}")
+                logger.error(f"❌ Ошибка удаления использований промокодов: {e}")
             
             try:
                 await db.execute(
                     delete(ReferralEarning).where(ReferralEarning.user_id == user_id)
                 )
                 await db.flush()
-                logger.info(f"   🗑️ Удалены реферальные доходы пользователя {user_id}")
+                logger.info(f"🗑️ Удалены реферальные доходы пользователя {user_id}")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка удаления реферальных доходов: {e}")
+                logger.error(f"❌ Ошибка удаления реферальных доходов: {e}")
             
             try:
                 await db.execute(
                     delete(ReferralEarning).where(ReferralEarning.referral_id == user_id)
                 )
                 await db.flush()
-                logger.info(f"   🗑️ Удалены реферальные записи о пользователе {user_id}")
+                logger.info(f"🗑️ Удалены реферальные записи о пользователе {user_id}")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка удаления реферальных записей: {e}")
+                logger.error(f"❌ Ошибка удаления реферальных записей: {e}")
             
             try:
                 from app.database.models import BroadcastHistory
@@ -314,9 +314,26 @@ class UserService:
                     delete(BroadcastHistory).where(BroadcastHistory.admin_id == user_id)
                 )
                 await db.flush()
-                logger.info(f"   🗑️ Удалена история рассылок админа {user_id}")
+                logger.info(f"🗑️ Удалена история рассылок админа {user_id}")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка удаления истории рассылок: {e}")
+                logger.error(f"❌ Ошибка удаления истории рассылок: {e}")
+            
+            try:
+                from app.database.models import SubscriptionConversion
+                conversions_result = await db.execute(
+                    select(SubscriptionConversion).where(SubscriptionConversion.user_id == user_id)
+                )
+                conversions = conversions_result.scalars().all()
+                
+                if conversions:
+                    logger.info(f"🔄 Удаляем {len(conversions)} записей конверсий")
+                    await db.execute(
+                        delete(SubscriptionConversion).where(SubscriptionConversion.user_id == user_id)
+                    )
+                    await db.flush()
+                    logger.info(f"✅ Записи конверсий удалены")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления записей конверсий: {e}")
             
             if user.subscription:
                 try:
@@ -326,9 +343,9 @@ class UserService:
                         )
                     )
                     await db.flush()
-                    logger.info(f"   🗑️ Удалены записи SubscriptionServer для подписки {user.subscription.id}")
+                    logger.info(f"🗑️ Удалены записи SubscriptionServer для подписки {user.subscription.id}")
                 except Exception as e:
-                    logger.error(f"   ❌ Ошибка удаления SubscriptionServer: {e}")
+                    logger.error(f"❌ Ошибка удаления SubscriptionServer: {e}")
             
             if user.subscription:
                 try:
@@ -337,9 +354,9 @@ class UserService:
                         delete(Subscription).where(Subscription.user_id == user_id)
                     )
                     await db.flush()
-                    logger.info(f"   🗑️ Удалена подписка пользователя {user_id}")
+                    logger.info(f"🗑️ Удалена подписка пользователя {user_id}")
                 except Exception as e:
-                    logger.error(f"   ❌ Ошибка удаления подписки: {e}")
+                    logger.error(f"❌ Ошибка удаления подписки: {e}")
             
             try:
                 from sqlalchemy import update
@@ -349,19 +366,19 @@ class UserService:
                     .values(referred_by_id=None)
                 )
                 if referrals_result.rowcount > 0:
-                    logger.info(f"   🔗 Очищены реферальные ссылки у {referrals_result.rowcount} рефералов")
+                    logger.info(f"🔗 Очищены реферальные ссылки у {referrals_result.rowcount} рефералов")
                 await db.flush()
             except Exception as e:
-                logger.error(f"   ❌ Ошибка очистки реферальных ссылок: {e}")
+                logger.error(f"❌ Ошибка очистки реферальных ссылок: {e}")
             
             try:
                 await db.execute(
                     delete(User).where(User.id == user_id)
                 )
                 await db.commit()
-                logger.info(f"   ✅ Пользователь {user_id} окончательно удален из базы")
+                logger.info(f"✅ Пользователь {user_id} окончательно удален из базы")
             except Exception as e:
-                logger.error(f"   ❌ Ошибка финального удаления пользователя: {e}")
+                logger.error(f"❌ Ошибка финального удаления пользователя: {e}")
                 await db.rollback()
                 return False
             

app/utils/user_utils.py

@@ -1,76 +1,298 @@
 import logging
-import random
+import secrets
 import string
-from datetime import datetime
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List
+from sqlalchemy import select, func, and_
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from app.database.models import User
+from sqlalchemy.orm import selectinload
+
+from app.database.models import User, ReferralEarning, Transaction, TransactionType
 
 logger = logging.getLogger(__name__)
 
 
-async def mark_user_as_had_paid_subscription(
-    db: AsyncSession,
-    user: User
-) -> None:
-    if not user.has_had_paid_subscription:
-        user.has_had_paid_subscription = True
-        user.updated_at = datetime.utcnow()
-        await db.commit()
-        logger.info(f"🎯 Пользователь {user.telegram_id} отмечен как имевший платную подписку")
-
-
 async def generate_unique_referral_code(db: AsyncSession, telegram_id: int) -> str:
+    max_attempts = 10
     
-    base_code = str(telegram_id)[-6:]
-    
-    for attempt in range(10):
-        if attempt == 0:
-            referral_code = base_code
-        else:
-            suffix = ''.join(random.choices(string.ascii_lowercase + string.digits, k=2))
-            referral_code = base_code + suffix
+    for _ in range(max_attempts):
+        code = f"ref{''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(8))}"
         
         result = await db.execute(
-            select(User.id).where(User.referral_code == referral_code)
+            select(User).where(User.referral_code == code)
+        )
+        if not result.scalar_one_or_none():
+            return code
+    
+    timestamp = str(int(datetime.utcnow().timestamp()))[-6:]
+    return f"ref{timestamp}"
+
+
+async def mark_user_as_had_paid_subscription(db: AsyncSession, user_id: int) -> bool:
+    try:
+        from app.database.crud.user import get_user_by_id
+        
+        user = await get_user_by_id(db, user_id)
+        if not user:
+            logger.error(f"Пользователь {user_id} не найден")
+            return False
+        
+        if not user.has_had_paid_subscription:
+            user.has_had_paid_subscription = True
+            user.updated_at = datetime.utcnow()
+            await db.commit()
+            logger.info(f"✅ Пользователь {user_id} отмечен как имевший платную подписку")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка отметки пользователя {user_id} как имевшего платную подписку: {e}")
+        return False
+
+
+async def get_user_referral_summary(db: AsyncSession, user_id: int) -> Dict:
+    try:
+        invited_count_result = await db.execute(
+            select(func.count(User.id)).where(User.referred_by_id == user_id)
+        )
+        invited_count = invited_count_result.scalar() or 0
+        
+        referrals_result = await db.execute(
+            select(User).where(User.referred_by_id == user_id)
+        )
+        referrals = referrals_result.scalars().all()
+        
+        paid_referrals_count = sum(1 for ref in referrals if ref.has_made_first_topup)
+        
+        total_earnings_result = await db.execute(
+            select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+            .where(ReferralEarning.user_id == user_id)
+        )
+        total_earned_kopeks = total_earnings_result.scalar() or 0
+        
+        month_ago = datetime.utcnow() - timedelta(days=30)
+        month_earnings_result = await db.execute(
+            select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+            .where(
+                and_(
+                    ReferralEarning.user_id == user_id,
+                    ReferralEarning.created_at >= month_ago
+                )
+            )
+        )
+        month_earned_kopeks = month_earnings_result.scalar() or 0
+        
+        recent_earnings_result = await db.execute(
+            select(ReferralEarning)
+            .options(selectinload(ReferralEarning.referral))
+            .where(ReferralEarning.user_id == user_id)
+            .order_by(ReferralEarning.created_at.desc())
+            .limit(5)
+        )
+        recent_earnings_raw = recent_earnings_result.scalars().all()
+        
+        recent_earnings = []
+        for earning in recent_earnings_raw:
+            if earning.referral:
+                recent_earnings.append({
+                    'amount_kopeks': earning.amount_kopeks,
+                    'reason': earning.reason,
+                    'referral_name': earning.referral.full_name,
+                    'created_at': earning.created_at
+                })
+        
+        earnings_by_type = {}
+        earnings_by_type_result = await db.execute(
+            select(
+                ReferralEarning.reason,
+                func.count(ReferralEarning.id).label('count'),
+                func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0).label('total_amount')
+            )
+            .where(ReferralEarning.user_id == user_id)
+            .group_by(ReferralEarning.reason)
         )
         
-        if not result.scalar():
-            return referral_code
-    
-    import uuid
-    return str(uuid.uuid4())[:8]
-
-
-async def get_user_referral_summary(db: AsyncSession, user_id: int) -> dict:
-    
-    try:
-        from app.services.referral_service import get_referral_stats_for_user
-        from app.database.crud.referral import get_referral_earnings_by_user
+        for row in earnings_by_type_result:
+            earnings_by_type[row.reason] = {
+                'count': row.count,
+                'total_amount_kopeks': row.total_amount
+            }
         
-        stats = await get_referral_stats_for_user(db, user_id)
-        
-        recent_earnings = await get_referral_earnings_by_user(db, user_id, limit=5)
+        active_referrals_count = 0
+        for referral in referrals:
+            if referral.last_activity and referral.last_activity >= month_ago:
+                active_referrals_count += 1
         
         return {
-            **stats,
-            "recent_earnings": [
-                {
-                    "amount_kopeks": earning.amount_kopeks,
-                    "reason": earning.reason,
-                    "created_at": earning.created_at,
-                    "referral_name": earning.referral.full_name if earning.referral else "Неизвестно"
-                }
-                for earning in recent_earnings
-            ]
+            'invited_count': invited_count,
+            'paid_referrals_count': paid_referrals_count,
+            'active_referrals_count': active_referrals_count,
+            'total_earned_kopeks': total_earned_kopeks,
+            'month_earned_kopeks': month_earned_kopeks,
+            'recent_earnings': recent_earnings,
+            'earnings_by_type': earnings_by_type,
+            'conversion_rate': round((paid_referrals_count / invited_count * 100) if invited_count > 0 else 0, 1)
         }
         
     except Exception as e:
-        logger.error(f"Ошибка получения сводки рефералов: {e}")
+        logger.error(f"Ошибка получения статистики рефералов для пользователя {user_id}: {e}")
         return {
-            "invited_count": 0,
-            "paid_referrals_count": 0,
-            "total_earned_kopeks": 0,
-            "month_earned_kopeks": 0,
-            "recent_earnings": []
-        }
+            'invited_count': 0,
+            'paid_referrals_count': 0,
+            'active_referrals_count': 0,
+            'total_earned_kopeks': 0,
+            'month_earned_kopeks': 0,
+            'recent_earnings': [],
+            'earnings_by_type': {},
+            'conversion_rate': 0.0
+        }
+
+
+async def get_detailed_referral_list(db: AsyncSession, user_id: int, limit: int = 20, offset: int = 0) -> Dict:
+    try:
+        referrals_result = await db.execute(
+            select(User)
+            .where(User.referred_by_id == user_id)
+            .order_by(User.created_at.desc())
+            .offset(offset)
+            .limit(limit)
+        )
+        referrals = referrals_result.scalars().all()
+        
+        total_count_result = await db.execute(
+            select(func.count(User.id)).where(User.referred_by_id == user_id)
+        )
+        total_count = total_count_result.scalar() or 0
+        
+        detailed_referrals = []
+        for referral in referrals:
+            earnings_result = await db.execute(
+                select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+                .where(
+                    and_(
+                        ReferralEarning.user_id == user_id,
+                        ReferralEarning.referral_id == referral.id
+                    )
+                )
+            )
+            total_earned_from_referral = earnings_result.scalar() or 0
+            
+            topups_result = await db.execute(
+                select(func.count(Transaction.id))
+                .where(
+                    and_(
+                        Transaction.user_id == referral.id,
+                        Transaction.type == TransactionType.DEPOSIT.value,
+                        Transaction.is_completed == True
+                    )
+                )
+            )
+            topups_count = topups_result.scalar() or 0
+            
+            days_since_registration = (datetime.utcnow() - referral.created_at).days
+            
+            days_since_activity = None
+            if referral.last_activity:
+                days_since_activity = (datetime.utcnow() - referral.last_activity).days
+            
+            detailed_referrals.append({
+                'id': referral.id,
+                'telegram_id': referral.telegram_id,
+                'full_name': referral.full_name,
+                'username': referral.username,
+                'created_at': referral.created_at,
+                'last_activity': referral.last_activity,
+                'has_made_first_topup': referral.has_made_first_topup,
+                'balance_kopeks': referral.balance_kopeks,
+                'total_earned_kopeks': total_earned_from_referral,
+                'topups_count': topups_count,
+                'days_since_registration': days_since_registration,
+                'days_since_activity': days_since_activity,
+                'status': 'active' if days_since_activity is not None and days_since_activity <= 30 else 'inactive'
+            })
+        
+        return {
+            'referrals': detailed_referrals,
+            'total_count': total_count,
+            'has_next': offset + limit < total_count,
+            'has_prev': offset > 0,
+            'current_page': (offset // limit) + 1,
+            'total_pages': (total_count + limit - 1) // limit
+        }
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения списка рефералов для пользователя {user_id}: {e}")
+        return {
+            'referrals': [],
+            'total_count': 0,
+            'has_next': False,
+            'has_prev': False,
+            'current_page': 1,
+            'total_pages': 1
+        }
+
+
+async def get_referral_analytics(db: AsyncSession, user_id: int) -> Dict:
+    try:
+        now = datetime.utcnow()
+        periods = {
+            'today': now.replace(hour=0, minute=0, second=0, microsecond=0),
+            'week': now - timedelta(days=7),
+            'month': now - timedelta(days=30),
+            'quarter': now - timedelta(days=90)
+        }
+        
+        earnings_by_period = {}
+        for period_name, start_date in periods.items():
+            result = await db.execute(
+                select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+                .where(
+                    and_(
+                        ReferralEarning.user_id == user_id,
+                        ReferralEarning.created_at >= start_date
+                    )
+                )
+            )
+            earnings_by_period[period_name] = result.scalar() or 0
+        
+        top_referrals_result = await db.execute(
+            select(
+                ReferralEarning.referral_id,
+                func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0).label('total_earned'),
+                func.count(ReferralEarning.id).label('earnings_count')
+            )
+            .where(ReferralEarning.user_id == user_id)
+            .group_by(ReferralEarning.referral_id)
+            .order_by(func.sum(ReferralEarning.amount_kopeks).desc())
+            .limit(5)
+        )
+        
+        top_referrals = []
+        for row in top_referrals_result:
+            referral_result = await db.execute(
+                select(User).where(User.id == row.referral_id)
+            )
+            referral = referral_result.scalar_one_or_none()
+            if referral:
+                top_referrals.append({
+                    'referral_name': referral.full_name,
+                    'total_earned_kopeks': row.total_earned,
+                    'earnings_count': row.earnings_count
+                })
+        
+        return {
+            'earnings_by_period': earnings_by_period,
+            'top_referrals': top_referrals
+        }
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения аналитики рефералов для пользователя {user_id}: {e}")
+        return {
+            'earnings_by_period': {
+                'today': 0,
+                'week': 0,
+                'month': 0,
+                'quarter': 0
+            },
+            'top_referrals': []
+        }

app/utils/validators.py

@@ -1,7 +1,19 @@
 import re
 from typing import Optional, Union
 from datetime import datetime
+import html
 
+ALLOWED_HTML_TAGS = {
+    'b', 'strong',           
+    'i', 'em',              
+    'u', 'ins',             
+    's', 'strike', 'del',  
+    'code',                 
+    'pre',                
+    'a',                  
+    'blockquote',           
+    'spoiler', 'tg-spoiler' 
+}
 
 def validate_email(email: str) -> bool:
     pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
@@ -105,13 +117,24 @@ def validate_subscription_period(days: Union[str, int]) -> Optional[int]:
 
 
 def sanitize_html(text: str) -> str:
-    allowed_tags = ['b', 'strong', 'i', 'em', 'u', 'ins', 's', 'strike', 'del', 'code', 'pre']
+    if not text:
+        return text
     
-    for tag in allowed_tags:
-        text = re.sub(f'<{tag}>', f'<{tag}>', text, flags=re.IGNORECASE)
-        text = re.sub(f'</{tag}>', f'</{tag}>', text, flags=re.IGNORECASE)
+    text = html.escape(text)
     
-    text = re.sub(r'<(?!/?(?:' + '|'.join(allowed_tags) + r')\b)[^>]*>', '', text)
+    for tag in ALLOWED_HTML_TAGS:
+        text = re.sub(
+            f'&lt;{tag}(&gt;|\\s[^&]*&gt;)', 
+            lambda m: m.group(0).replace('&lt;', '<').replace('&gt;', '>'),
+            text, 
+            flags=re.IGNORECASE
+        )
+        text = re.sub(
+            f'&lt;/{tag}&gt;', 
+            f'</{tag}>', 
+            text, 
+            flags=re.IGNORECASE
+        )
     
     return text
 
@@ -134,4 +157,52 @@ def validate_referral_code(code: str) -> bool:
         user_id_part = code[3:]
         return user_id_part.isdigit()
     
-    return validate_promocode(code)
+    return validate_promocode(code)
+
+def validate_html_tags(text: str) -> tuple[bool, str]:
+    if not text:
+        return True, ""
+    
+    tag_pattern = r'<(/?)([a-zA-Z][a-zA-Z0-9-]*)[^>]*>'
+    tags = re.findall(tag_pattern, text)
+    
+    for is_closing, tag_name in tags:
+        tag_name_lower = tag_name.lower()
+        
+        if tag_name_lower not in ALLOWED_HTML_TAGS:
+            return False, f"Неподдерживаемый тег: <{tag_name}>"
+    
+    tag_stack = []
+    for is_closing, tag_name in tags:
+        tag_name_lower = tag_name.lower()
+        
+        if not is_closing: 
+            tag_stack.append(tag_name_lower)
+        else:  
+            if not tag_stack:
+                return False, f"Закрывающий тег без открывающего: </{tag_name}>"
+            
+            last_tag = tag_stack.pop()
+            if last_tag != tag_name_lower:
+                return False, f"Неправильная вложенность тегов: ожидался </{last_tag}>, найден </{tag_name}>"
+    
+    if tag_stack:
+        return False, f"Незакрытый тег: <{tag_stack[-1]}>"
+    
+    return True, ""
+
+
+def get_html_help_text() -> str:
+    return """<b>Поддерживаемые HTML теги:</b>
+
+- <code>&lt;b&gt;жирный&lt;/b&gt;</code> или <code>&lt;strong&gt;жирный&lt;/strong&gt;</code>
+- <code>&lt;i&gt;курсив&lt;/i&gt;</code> или <code>&lt;em&gt;курсив&lt;/em&gt;</code>  
+- <code>&lt;u&gt;подчеркнутый&lt;/u&gt;</code>
+- <code>&lt;s&gt;зачеркнутый&lt;/s&gt;</code>
+- <code>&lt;code&gt;моноширинный&lt;/code&gt;</code>
+- <code>&lt;pre&gt;блок кода&lt;/pre&gt;</code>
+- <code>&lt;a href="url"&gt;ссылка&lt;/a&gt;</code>
+- <code>&lt;blockquote&gt;цитата&lt;/blockquote&gt;</code>
+- <code>&lt;spoiler&gt;спойлер&lt;/spoiler&gt;</code>
+
+<b>Неподдерживаемые теги:</b> &lt;br&gt;, &lt;p&gt;, &lt;div&gt;, &lt;span&gt; и другие"""

docker-compose.yml

@@ -35,7 +35,9 @@ services:
       retries: 3
 
   bot:
-    image: fr1ngg/remnawave-bedolaga-telegram-bot:latest
+    build:
+      context: .   # директория где лежит Dockerfile
+      dockerfile: Dockerfile
     container_name: remnawave_bot
     restart: unless-stopped
     depends_on:
@@ -58,12 +60,6 @@ services:
       - "${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: