Update Dockerfile

Рассылка промопредложений + выдача сквадов(серверов) на время

.github/workflows/docker-hub.yml

@@ -36,15 +36,15 @@ jobs:
           TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:latest,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
           echo "🏷️ Собираем релизную версию: $VERSION"
         elif [[ $GITHUB_REF == refs/heads/main ]]; then
-          VERSION="v2.4.3-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.4-$(git rev-parse --short HEAD)"
           TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:latest,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
           echo "🚀 Собираем версию из main: $VERSION"
         elif [[ $GITHUB_REF == refs/heads/dev ]]; then
-          VERSION="v2.4.3-dev-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.4-dev-$(git rev-parse --short HEAD)"
           TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:dev,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
           echo "🧪 Собираем dev версию: $VERSION"
         else
-          VERSION="v2.4.3-pr-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.4-pr-$(git rev-parse --short HEAD)"
           TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:pr-$(git rev-parse --short HEAD)"
           echo "🔀 Собираем PR версию: $VERSION"
         fi

.github/workflows/docker-registry.yml

@@ -49,13 +49,13 @@ jobs:
             VERSION=${GITHUB_REF#refs/tags/}
             echo "🏷️ Building release version: $VERSION"
           elif [[ $GITHUB_REF == refs/heads/main ]]; then
-            VERSION="v2.4.3-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.4-$(git rev-parse --short HEAD)"
             echo "🚀 Building main version: $VERSION"
           elif [[ $GITHUB_REF == refs/heads/dev ]]; then
-            VERSION="v2.4.3-dev-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.4-dev-$(git rev-parse --short HEAD)"
             echo "🧪 Building dev version: $VERSION"
           else
-            VERSION="v2.4.3-pr-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.4-pr-$(git rev-parse --short HEAD)"
             echo "🔀 Building PR version: $VERSION"
           fi
           echo "version=$VERSION" >> $GITHUB_OUTPUT

Dockerfile

@@ -14,7 +14,7 @@ RUN pip install --no-cache-dir --upgrade pip && \
 
 FROM python:3.13-slim
 
-ARG VERSION="v2.4.3"
+ARG VERSION="v2.4.4"
 ARG BUILD_DATE
 ARG VCS_REF
 

README.md

@@ -155,7 +155,7 @@ docker compose logs
 2. Убедитесь, что входящий трафик на **80/tcp и 443/tcp** открыт (брандмауэр, облачный фаервол).
 3. В `.env` пропишите корректные URL, чтобы бот формировал ссылки с HTTPS-доменами:
    ```env
-   WEBHOOK_URL=https://hooks.example.com/webhook
+   WEBHOOK_URL=https://hooks.example.com
    WEB_API_ENABLED=true
    WEB_API_ALLOWED_ORIGINS=https://miniapp.example.com
    MINIAPP_CUSTOM_URL=https://miniapp.example.com

app/bot.py

@@ -33,6 +33,7 @@ from app.handlers.admin import (
     maintenance as admin_maintenance,
     promo_groups as admin_promo_groups,
     campaigns as admin_campaigns,
+    promo_offers as admin_promo_offers,
     user_messages as admin_user_messages,
     updates as admin_updates,
     backup as admin_backup,
@@ -137,6 +138,7 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     admin_statistics.register_handlers(dp)
     admin_promo_groups.register_handlers(dp)
     admin_campaigns.register_handlers(dp)
+    admin_promo_offers.register_handlers(dp)
     admin_maintenance.register_handlers(dp)
     admin_user_messages.register_handlers(dp)
     admin_updates.register_handlers(dp)

app/database/crud/discount_offer.py

@@ -1,11 +1,17 @@
+from __future__ import annotations
+
+import logging
 from datetime import datetime, timedelta
 from typing import Optional
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.database.crud.promo_offer_log import log_promo_offer_action
 from app.database.models import DiscountOffer
 
+logger = logging.getLogger(__name__)
+
 
 async def upsert_discount_offer(
     db: AsyncSession,
@@ -16,6 +22,8 @@ async def upsert_discount_offer(
     discount_percent: int,
     bonus_amount_kopeks: int,
     valid_hours: int,
+    effect_type: str = "percent_discount",
+    extra_data: Optional[dict] = None,
 ) -> DiscountOffer:
     """Create or refresh a discount offer for a user."""
 
@@ -37,6 +45,8 @@ async def upsert_discount_offer(
         offer.bonus_amount_kopeks = bonus_amount_kopeks
         offer.expires_at = expires_at
         offer.subscription_id = subscription_id
+        offer.effect_type = effect_type
+        offer.extra_data = extra_data
     else:
         offer = DiscountOffer(
             user_id=user_id,
@@ -46,6 +56,8 @@ async def upsert_discount_offer(
             bonus_amount_kopeks=bonus_amount_kopeks,
             expires_at=expires_at,
             is_active=True,
+            effect_type=effect_type,
+            extra_data=extra_data,
         )
         db.add(offer)
 
@@ -61,11 +73,42 @@ async def get_offer_by_id(db: AsyncSession, offer_id: int) -> Optional[DiscountO
     return result.scalar_one_or_none()
 
 
-async def mark_offer_claimed(db: AsyncSession, offer: DiscountOffer) -> DiscountOffer:
+async def mark_offer_claimed(
+    db: AsyncSession,
+    offer: DiscountOffer,
+    *,
+    details: Optional[dict] = None,
+) -> DiscountOffer:
     offer.claimed_at = datetime.utcnow()
     offer.is_active = False
     await db.commit()
     await db.refresh(offer)
+
+    try:
+        await log_promo_offer_action(
+            db,
+            user_id=offer.user_id,
+            offer_id=offer.id,
+            action="claimed",
+            source=offer.notification_type,
+            percent=offer.discount_percent,
+            effect_type=offer.effect_type,
+            details=details,
+        )
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.warning(
+            "Failed to record promo offer claim log for offer %s: %s",
+            offer.id,
+            exc,
+        )
+        try:
+            await db.rollback()
+        except Exception as rollback_error:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to rollback session after promo offer claim log failure: %s",
+                rollback_error,
+            )
+
     return offer
 
 
@@ -82,9 +125,69 @@ async def deactivate_expired_offers(db: AsyncSession) -> int:
         return 0
 
     count = 0
+    log_payloads = []
     for offer in offers:
         offer.is_active = False
         count += 1
+        log_payloads.append(
+            {
+                "user_id": offer.user_id,
+                "offer_id": offer.id,
+                "source": offer.notification_type,
+                "percent": offer.discount_percent,
+                "effect_type": offer.effect_type,
+            }
+        )
 
     await db.commit()
+
+    for payload in log_payloads:
+        if not payload.get("user_id"):
+            continue
+        try:
+            await log_promo_offer_action(
+                db,
+                user_id=payload["user_id"],
+                offer_id=payload["offer_id"],
+                action="disabled",
+                source=payload.get("source"),
+                percent=payload.get("percent"),
+                effect_type=payload.get("effect_type"),
+                details={"reason": "offer_expired"},
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to record promo offer disable log for offer %s: %s",
+                payload.get("offer_id"),
+                exc,
+            )
+            try:
+                await db.rollback()
+            except Exception as rollback_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to rollback session after promo offer disable log failure: %s",
+                    rollback_error,
+                )
+
     return count
+
+
+async def get_latest_claimed_offer_for_user(
+    db: AsyncSession,
+    user_id: int,
+    source: Optional[str] = None,
+) -> Optional[DiscountOffer]:
+    stmt = (
+        select(DiscountOffer)
+        .where(
+            DiscountOffer.user_id == user_id,
+            DiscountOffer.claimed_at.isnot(None),
+        )
+        .order_by(DiscountOffer.claimed_at.desc())
+    )
+
+    if source:
+        stmt = stmt.where(DiscountOffer.notification_type == source)
+
+    result = await db.execute(stmt)
+    return result.scalars().first()

app/database/crud/promo_offer_log.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import logging
+from typing import Dict, List, Optional, Tuple
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import PromoOfferLog
+
+logger = logging.getLogger(__name__)
+
+
+async def log_promo_offer_action(
+    db: AsyncSession,
+    *,
+    user_id: Optional[int],
+    offer_id: Optional[int],
+    action: str,
+    source: Optional[str] = None,
+    percent: Optional[int] = None,
+    effect_type: Optional[str] = None,
+    details: Optional[Dict[str, object]] = None,
+    commit: bool = True,
+) -> PromoOfferLog:
+    """Persist a promo offer log entry."""
+
+    entry = PromoOfferLog(
+        user_id=user_id,
+        offer_id=offer_id,
+        action=action,
+        source=source,
+        percent=percent,
+        effect_type=effect_type,
+        details=(details or {}).copy(),
+    )
+    db.add(entry)
+
+    if commit:
+        try:
+            await db.commit()
+            await db.refresh(entry)
+        except Exception:
+            logger.exception("Failed to commit promo offer log entry")
+            raise
+
+    return entry
+
+
+async def list_promo_offer_logs(
+    db: AsyncSession,
+    offset: int = 0,
+    limit: int = 20,
+) -> Tuple[List[PromoOfferLog], int]:
+    stmt = (
+        select(PromoOfferLog)
+        .options(
+            selectinload(PromoOfferLog.user),
+            selectinload(PromoOfferLog.offer),
+        )
+        .order_by(PromoOfferLog.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+    result = await db.execute(stmt)
+    logs = result.scalars().all()
+
+    count_stmt = select(func.count(PromoOfferLog.id))
+    total = (await db.execute(count_stmt)).scalar() or 0
+
+    return logs, total

app/database/crud/promo_offer_template.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, List, Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import PromoOfferTemplate
+
+
+UPDATED_TEMPLATE_MESSAGES = {
+    "extend_discount": (
+        "💎 Экономия {discount_percent}% при продлении\n\n"
+        "Скидка суммируется с промогруппой и действует один раз.\n"
+        "Срок действия предложения — {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+    "purchase_discount": (
+        "🎯 Вернитесь со скидкой {discount_percent}%\n\n"
+        "Скидка суммируется с промогруппой и действует один раз.\n"
+        "Предложение действует {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+}
+
+
+LEGACY_TEMPLATE_MESSAGES = {
+    "extend_discount": (
+        "💎 <b>Экономия {discount_percent}% при продлении</b>\n\n"
+        "Активируйте предложение и получите дополнительную скидку на оплату продления. "
+        "Она суммируется с вашими промогрупповыми скидками и действует один раз.\n"
+        "Срок действия предложения — {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+    "purchase_discount": (
+        "🎯 <b>Вернитесь со скидкой {discount_percent}%</b>\n\n"
+        "После активации мы применим дополнительную скидку к вашей следующей оплате подписки. "
+        "Скидка суммируется с промогруппой и действует один раз.\n"
+        "Предложение действует {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+}
+
+
+DEFAULT_TEMPLATES: tuple[dict, ...] = (
+    {
+        "offer_type": "test_access",
+        "name": "Тестовые сервера",
+        "message_text": (
+            "🔥 <b>Испытайте новые сервера</b>\n\n"
+            "Активируйте предложение и получите временный доступ к дополнительным сквадам на {test_duration_hours} ч.\n"
+            "Предложение действительно {valid_hours} ч."
+        ),
+        "button_text": "🚀 Попробовать серверы",
+        "valid_hours": 24,
+        "discount_percent": 0,
+        "bonus_amount_kopeks": 0,
+        "active_discount_hours": None,
+        "test_duration_hours": 24,
+        "test_squad_uuids": [],
+    },
+    {
+        "offer_type": "extend_discount",
+        "name": "Скидка на продление",
+        "message_text": UPDATED_TEMPLATE_MESSAGES["extend_discount"],
+        "button_text": "🎁 Получить скидку",
+        "valid_hours": 24,
+        "discount_percent": 20,
+        "bonus_amount_kopeks": 0,
+        "active_discount_hours": 24,
+        "test_duration_hours": None,
+        "test_squad_uuids": [],
+    },
+    {
+        "offer_type": "purchase_discount",
+        "name": "Скидка на покупку",
+        "message_text": UPDATED_TEMPLATE_MESSAGES["purchase_discount"],
+        "button_text": "🎁 Забрать скидку",
+        "valid_hours": 48,
+        "discount_percent": 25,
+        "bonus_amount_kopeks": 0,
+        "active_discount_hours": 48,
+        "test_duration_hours": None,
+        "test_squad_uuids": [],
+    },
+)
+
+
+def _format_template_fields(payload: dict) -> dict:
+    data = dict(payload)
+    data.setdefault("valid_hours", 24)
+    data.setdefault("discount_percent", 0)
+    data.setdefault("bonus_amount_kopeks", 0)
+    data.setdefault("active_discount_hours", None)
+    data.setdefault("test_duration_hours", None)
+    data.setdefault("test_squad_uuids", [])
+    return data
+
+
+async def ensure_default_templates(db: AsyncSession, *, created_by: Optional[int] = None) -> List[PromoOfferTemplate]:
+    templates: List[PromoOfferTemplate] = []
+
+    for template_data in DEFAULT_TEMPLATES:
+        result = await db.execute(
+            select(PromoOfferTemplate).where(PromoOfferTemplate.offer_type == template_data["offer_type"])
+        )
+        existing = result.scalars().first()
+        if existing:
+            new_message = UPDATED_TEMPLATE_MESSAGES.get(template_data["offer_type"])
+            legacy_message = LEGACY_TEMPLATE_MESSAGES.get(template_data["offer_type"])
+            should_update = False
+
+            if new_message and legacy_message and existing.message_text == legacy_message:
+                should_update = True
+            elif new_message and (
+                "{bonus_amount" in existing.message_text or "Мы начислим" in existing.message_text
+            ):
+                should_update = True
+
+            if should_update and new_message:
+                existing.message_text = new_message
+                existing.updated_at = datetime.utcnow()
+                await db.flush()
+
+            target_active_hours = template_data.get("active_discount_hours")
+            if (
+                target_active_hours is not None
+                and target_active_hours > 0
+                and not existing.active_discount_hours
+            ):
+                existing.active_discount_hours = target_active_hours
+                existing.updated_at = datetime.utcnow()
+                await db.flush()
+            templates.append(existing)
+            continue
+
+        payload = _format_template_fields(template_data)
+        template = PromoOfferTemplate(
+            name=payload["name"],
+            offer_type=payload["offer_type"],
+            message_text=payload["message_text"],
+            button_text=payload["button_text"],
+            valid_hours=payload["valid_hours"],
+            discount_percent=payload["discount_percent"],
+            bonus_amount_kopeks=payload["bonus_amount_kopeks"],
+            active_discount_hours=payload["active_discount_hours"],
+            test_duration_hours=payload["test_duration_hours"],
+            test_squad_uuids=payload["test_squad_uuids"],
+            is_active=True,
+            created_by=created_by,
+        )
+        db.add(template)
+        await db.flush()
+        templates.append(template)
+
+    await db.commit()
+
+    return templates
+
+
+async def list_promo_offer_templates(db: AsyncSession) -> List[PromoOfferTemplate]:
+    result = await db.execute(
+        select(PromoOfferTemplate).order_by(PromoOfferTemplate.offer_type, PromoOfferTemplate.id)
+    )
+    return result.scalars().all()
+
+
+async def get_promo_offer_template_by_id(db: AsyncSession, template_id: int) -> Optional[PromoOfferTemplate]:
+    result = await db.execute(
+        select(PromoOfferTemplate).where(PromoOfferTemplate.id == template_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_promo_offer_template_by_type(db: AsyncSession, offer_type: str) -> Optional[PromoOfferTemplate]:
+    result = await db.execute(
+        select(PromoOfferTemplate).where(PromoOfferTemplate.offer_type == offer_type)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_promo_offer_template(
+    db: AsyncSession,
+    template: PromoOfferTemplate,
+    *,
+    name: Optional[str] = None,
+    message_text: Optional[str] = None,
+    button_text: Optional[str] = None,
+    valid_hours: Optional[int] = None,
+    discount_percent: Optional[int] = None,
+    bonus_amount_kopeks: Optional[int] = None,
+    active_discount_hours: Optional[int] = None,
+    test_duration_hours: Optional[int] = None,
+    test_squad_uuids: Optional[Iterable[str]] = None,
+    is_active: Optional[bool] = None,
+) -> PromoOfferTemplate:
+    if name is not None:
+        template.name = name
+    if message_text is not None:
+        template.message_text = message_text
+    if button_text is not None:
+        template.button_text = button_text
+    if valid_hours is not None:
+        template.valid_hours = valid_hours
+    if discount_percent is not None:
+        template.discount_percent = discount_percent
+    if bonus_amount_kopeks is not None:
+        template.bonus_amount_kopeks = bonus_amount_kopeks
+    if active_discount_hours is not None:
+        template.active_discount_hours = active_discount_hours
+    if test_duration_hours is not None:
+        template.test_duration_hours = test_duration_hours
+    if test_squad_uuids is not None:
+        template.test_squad_uuids = list(test_squad_uuids)
+    if is_active is not None:
+        template.is_active = is_active
+
+    template.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(template)
+    return template

app/database/crud/user.py

@@ -12,6 +12,7 @@ from app.database.models import (
     User,
     UserStatus,
     Subscription,
+    SubscriptionStatus,
     Transaction,
     PromoGroup,
     PaymentMethod,
@@ -19,6 +20,8 @@ from app.database.models import (
 )
 from app.config import settings
 from app.database.crud.promo_group import get_default_promo_group
+from app.database.crud.discount_offer import get_latest_claimed_offer_for_user
+from app.database.crud.promo_offer_log import log_promo_offer_action
 from app.utils.validators import sanitize_telegram_name
 
 logger = logging.getLogger(__name__)
@@ -272,6 +275,8 @@ async def subtract_user_balance(
     description: str,
     create_transaction: bool = False,
     payment_method: Optional[PaymentMethod] = None,
+    *,
+    consume_promo_offer: bool = False,
 ) -> bool:
     logger.error(f"💸 ОТЛАДКА subtract_user_balance:")
     logger.error(f"   👤 User ID: {user.id} (TG: {user.telegram_id})")
@@ -279,15 +284,57 @@ async def subtract_user_balance(
     logger.error(f"   💸 Сумма к списанию: {amount_kopeks} копеек")
     logger.error(f"   📝 Описание: {description}")
     
+    log_context: Optional[Dict[str, object]] = None
+    if consume_promo_offer:
+        try:
+            current_percent = int(getattr(user, "promo_offer_discount_percent", 0) or 0)
+        except (TypeError, ValueError):
+            current_percent = 0
+
+        if current_percent > 0:
+            source = getattr(user, "promo_offer_discount_source", None)
+            log_context = {
+                "offer_id": None,
+                "percent": current_percent,
+                "source": source,
+                "effect_type": None,
+                "details": {
+                    "reason": "manual_charge",
+                    "description": description,
+                    "amount_kopeks": amount_kopeks,
+                },
+            }
+            try:
+                offer = await get_latest_claimed_offer_for_user(db, user.id, source)
+            except Exception as lookup_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to fetch latest claimed promo offer for user %s: %s",
+                    user.id,
+                    lookup_error,
+                )
+                offer = None
+
+            if offer:
+                log_context["offer_id"] = offer.id
+                log_context["effect_type"] = offer.effect_type
+                if not log_context["percent"] and offer.discount_percent:
+                    log_context["percent"] = offer.discount_percent
+
     if user.balance_kopeks < amount_kopeks:
         logger.error(f"   ❌ НЕДОСТАТОЧНО СРЕДСТВ!")
         return False
-    
+
     try:
         old_balance = user.balance_kopeks
         user.balance_kopeks -= amount_kopeks
+
+        if consume_promo_offer and getattr(user, "promo_offer_discount_percent", 0):
+            user.promo_offer_discount_percent = 0
+            user.promo_offer_discount_source = None
+            user.promo_offer_discount_expires_at = None
+
         user.updated_at = datetime.utcnow()
-        
+
         await db.commit()
         await db.refresh(user)
 
@@ -305,6 +352,32 @@ async def subtract_user_balance(
                 payment_method=payment_method,
             )
 
+        if consume_promo_offer and log_context:
+            try:
+                await log_promo_offer_action(
+                    db,
+                    user_id=user.id,
+                    offer_id=log_context.get("offer_id"),
+                    action="consumed",
+                    source=log_context.get("source"),
+                    percent=log_context.get("percent"),
+                    effect_type=log_context.get("effect_type"),
+                    details=log_context.get("details"),
+                )
+            except Exception as log_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to record promo offer consumption log for user %s: %s",
+                    user.id,
+                    log_error,
+                )
+                try:
+                    await db.rollback()
+                except Exception as rollback_error:  # pragma: no cover - defensive logging
+                    logger.warning(
+                        "Failed to rollback session after promo offer consumption log failure: %s",
+                        rollback_error,
+                    )
+
         logger.error(f"   ✅ Средства списаны: {old_balance} → {user.balance_kopeks}")
         return True
         
@@ -314,6 +387,97 @@ async def subtract_user_balance(
         return False
 
 
+async def cleanup_expired_promo_offer_discounts(db: AsyncSession) -> int:
+    now = datetime.utcnow()
+    result = await db.execute(
+        select(User).where(
+            User.promo_offer_discount_percent > 0,
+            User.promo_offer_discount_expires_at.isnot(None),
+            User.promo_offer_discount_expires_at <= now,
+        )
+    )
+    users = result.scalars().all()
+    if not users:
+        return 0
+
+    log_payloads: List[Dict[str, object]] = []
+
+    for user in users:
+        try:
+            percent = int(getattr(user, "promo_offer_discount_percent", 0) or 0)
+        except (TypeError, ValueError):
+            percent = 0
+
+        source = getattr(user, "promo_offer_discount_source", None)
+        offer_id = None
+        effect_type = None
+
+        if source:
+            try:
+                offer = await get_latest_claimed_offer_for_user(db, user.id, source)
+            except Exception as lookup_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to fetch latest claimed promo offer for user %s during expiration cleanup: %s",
+                    user.id,
+                    lookup_error,
+                )
+                offer = None
+
+            if offer:
+                offer_id = offer.id
+                effect_type = offer.effect_type
+                if not percent and offer.discount_percent:
+                    percent = offer.discount_percent
+
+        log_payloads.append(
+            {
+                "user_id": user.id,
+                "offer_id": offer_id,
+                "source": source,
+                "percent": percent,
+                "effect_type": effect_type,
+            }
+        )
+
+        user.promo_offer_discount_percent = 0
+        user.promo_offer_discount_source = None
+        user.promo_offer_discount_expires_at = None
+        user.updated_at = now
+
+    await db.commit()
+
+    for payload in log_payloads:
+        user_id = payload.get("user_id")
+        if not user_id:
+            continue
+        try:
+            await log_promo_offer_action(
+                db,
+                user_id=user_id,
+                offer_id=payload.get("offer_id"),
+                action="disabled",
+                source=payload.get("source"),
+                percent=payload.get("percent"),
+                effect_type=payload.get("effect_type"),
+                details={"reason": "offer_expired"},
+            )
+        except Exception as log_error:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to log promo offer expiration for user %s: %s",
+                user_id,
+                log_error,
+            )
+            try:
+                await db.rollback()
+            except Exception as rollback_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to rollback session after promo offer expiration log failure: %s",
+                    rollback_error,
+                )
+
+    return len(users)
+
+
 async def get_users_list(
     db: AsyncSession,
     offset: int = 0,
@@ -515,6 +679,59 @@ async def get_referrals(db: AsyncSession, user_id: int) -> List[User]:
     return result.scalars().all()
 
 
+async def get_users_for_promo_segment(db: AsyncSession, segment: str) -> List[User]:
+    now = datetime.utcnow()
+
+    base_query = (
+        select(User)
+        .options(selectinload(User.subscription))
+        .where(User.status == UserStatus.ACTIVE.value)
+    )
+
+    if segment == "no_subscription":
+        query = (
+            base_query.outerjoin(Subscription, Subscription.user_id == User.id)
+            .where(Subscription.id.is_(None))
+        )
+    else:
+        query = base_query.join(Subscription)
+
+        if segment == "paid_active":
+            query = query.where(
+                Subscription.is_trial == False,  # noqa: E712
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date > now,
+            )
+        elif segment == "paid_expired":
+            query = query.where(
+                Subscription.is_trial == False,  # noqa: E712
+                or_(
+                    Subscription.status == SubscriptionStatus.EXPIRED.value,
+                    Subscription.end_date <= now,
+                ),
+            )
+        elif segment == "trial_active":
+            query = query.where(
+                Subscription.is_trial == True,  # noqa: E712
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date > now,
+            )
+        elif segment == "trial_expired":
+            query = query.where(
+                Subscription.is_trial == True,  # noqa: E712
+                or_(
+                    Subscription.status == SubscriptionStatus.EXPIRED.value,
+                    Subscription.end_date <= now,
+                ),
+            )
+        else:
+            logger.warning("Неизвестный сегмент для промо: %s", segment)
+            return []
+
+    result = await db.execute(query.order_by(User.id))
+    return result.scalars().unique().all()
+
+
 async def get_inactive_users(db: AsyncSession, months: int = 3) -> List[User]:
     threshold_date = datetime.utcnow() - timedelta(days=months * 30)
     

app/database/models.py

@@ -386,9 +386,13 @@ class User(Base):
     transactions = relationship("Transaction", back_populates="user")
     referral_earnings = relationship("ReferralEarning", foreign_keys="ReferralEarning.user_id", back_populates="user")
     discount_offers = relationship("DiscountOffer", back_populates="user")
+    promo_offer_logs = relationship("PromoOfferLog", back_populates="user")
     lifetime_used_traffic_bytes = Column(BigInteger, default=0)
     auto_promo_group_assigned = Column(Boolean, nullable=False, default=False)
     auto_promo_group_threshold_kopeks = Column(BigInteger, nullable=False, default=0)
+    promo_offer_discount_percent = Column(Integer, nullable=False, default=0)
+    promo_offer_discount_source = Column(String(100), nullable=True)
+    promo_offer_discount_expires_at = Column(DateTime, nullable=True)
     last_remnawave_sync = Column(DateTime, nullable=True)
     trojan_password = Column(String(255), nullable=True)
     vless_uuid = Column(String(255), nullable=True)
@@ -453,6 +457,7 @@ class Subscription(Base):
 
     user = relationship("User", back_populates="subscription")
     discount_offers = relationship("DiscountOffer", back_populates="subscription")
+    temporary_accesses = relationship("SubscriptionTemporaryAccess", back_populates="subscription")
     
     @property
     def is_active(self) -> bool:
@@ -811,11 +816,73 @@ class DiscountOffer(Base):
     expires_at = Column(DateTime, nullable=False)
     claimed_at = Column(DateTime, nullable=True)
     is_active = Column(Boolean, default=True, nullable=False)
+    effect_type = Column(String(50), nullable=False, default="percent_discount")
+    extra_data = Column(JSON, nullable=True)
     created_at = Column(DateTime, default=func.now())
     updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
 
     user = relationship("User", back_populates="discount_offers")
     subscription = relationship("Subscription", back_populates="discount_offers")
+    logs = relationship("PromoOfferLog", back_populates="offer")
+
+
+class PromoOfferTemplate(Base):
+    __tablename__ = "promo_offer_templates"
+    __table_args__ = (
+        Index("ix_promo_offer_templates_type", "offer_type"),
+    )
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255), nullable=False)
+    offer_type = Column(String(50), nullable=False)
+    message_text = Column(Text, nullable=False)
+    button_text = Column(String(255), nullable=False)
+    valid_hours = Column(Integer, nullable=False, default=24)
+    discount_percent = Column(Integer, nullable=False, default=0)
+    bonus_amount_kopeks = Column(Integer, nullable=False, default=0)
+    active_discount_hours = Column(Integer, nullable=True)
+    test_duration_hours = Column(Integer, nullable=True)
+    test_squad_uuids = Column(JSON, default=list)
+    is_active = Column(Boolean, default=True, nullable=False)
+    created_by = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    creator = relationship("User")
+
+
+class SubscriptionTemporaryAccess(Base):
+    __tablename__ = "subscription_temporary_access"
+
+    id = Column(Integer, primary_key=True, index=True)
+    subscription_id = Column(Integer, ForeignKey("subscriptions.id", ondelete="CASCADE"), nullable=False)
+    offer_id = Column(Integer, ForeignKey("discount_offers.id", ondelete="CASCADE"), nullable=False)
+    squad_uuid = Column(String(255), nullable=False)
+    expires_at = Column(DateTime, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    deactivated_at = Column(DateTime, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    was_already_connected = Column(Boolean, default=False, nullable=False)
+
+    subscription = relationship("Subscription", back_populates="temporary_accesses")
+    offer = relationship("DiscountOffer")
+
+
+class PromoOfferLog(Base):
+    __tablename__ = "promo_offer_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True, index=True)
+    offer_id = Column(Integer, ForeignKey("discount_offers.id", ondelete="SET NULL"), nullable=True, index=True)
+    action = Column(String(50), nullable=False)
+    source = Column(String(100), nullable=True)
+    percent = Column(Integer, nullable=True)
+    effect_type = Column(String(50), nullable=True)
+    details = Column(JSON, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+
+    user = relationship("User", back_populates="promo_offer_logs")
+    offer = relationship("DiscountOffer", back_populates="logs")
 
 class BroadcastHistory(Base):
     __tablename__ = "broadcast_history"

app/database/universal_migration.py

@@ -728,6 +728,8 @@ async def create_discount_offers_table():
                         expires_at DATETIME NOT NULL,
                         claimed_at DATETIME NULL,
                         is_active BOOLEAN NOT NULL DEFAULT 1,
+                        effect_type VARCHAR(50) NOT NULL DEFAULT 'percent_discount',
+                        extra_data TEXT NULL,
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                         FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
@@ -751,6 +753,8 @@ async def create_discount_offers_table():
                         expires_at TIMESTAMP NOT NULL,
                         claimed_at TIMESTAMP NULL,
                         is_active BOOLEAN NOT NULL DEFAULT TRUE,
+                        effect_type VARCHAR(50) NOT NULL DEFAULT 'percent_discount',
+                        extra_data JSON NULL,
                         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                     )
@@ -772,6 +776,8 @@ async def create_discount_offers_table():
                         expires_at DATETIME NOT NULL,
                         claimed_at DATETIME NULL,
                         is_active BOOLEAN NOT NULL DEFAULT TRUE,
+                        effect_type VARCHAR(50) NOT NULL DEFAULT 'percent_discount',
+                        extra_data JSON NULL,
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                         CONSTRAINT fk_discount_offers_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
@@ -793,6 +799,422 @@ async def create_discount_offers_table():
         logger.error(f"Ошибка создания таблицы discount_offers: {e}")
         return False
 
+
+async def ensure_discount_offer_columns():
+    try:
+        effect_exists = await check_column_exists('discount_offers', 'effect_type')
+        extra_exists = await check_column_exists('discount_offers', 'extra_data')
+
+        if effect_exists and extra_exists:
+            return True
+
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+
+            if not effect_exists:
+                if db_type == 'sqlite':
+                    await conn.execute(text(
+                        "ALTER TABLE discount_offers ADD COLUMN effect_type VARCHAR(50) NOT NULL DEFAULT 'percent_discount'"
+                    ))
+                elif db_type == 'postgresql':
+                    await conn.execute(text(
+                        "ALTER TABLE discount_offers ADD COLUMN effect_type VARCHAR(50) NOT NULL DEFAULT 'percent_discount'"
+                    ))
+                elif db_type == 'mysql':
+                    await conn.execute(text(
+                        "ALTER TABLE discount_offers ADD COLUMN effect_type VARCHAR(50) NOT NULL DEFAULT 'percent_discount'"
+                    ))
+                else:
+                    raise ValueError(f"Unsupported database type: {db_type}")
+
+            if not extra_exists:
+                if db_type == 'sqlite':
+                    await conn.execute(text(
+                        "ALTER TABLE discount_offers ADD COLUMN extra_data TEXT NULL"
+                    ))
+                elif db_type == 'postgresql':
+                    await conn.execute(text(
+                        "ALTER TABLE discount_offers ADD COLUMN extra_data JSON NULL"
+                    ))
+                elif db_type == 'mysql':
+                    await conn.execute(text(
+                        "ALTER TABLE discount_offers ADD COLUMN extra_data JSON NULL"
+                    ))
+                else:
+                    raise ValueError(f"Unsupported database type: {db_type}")
+
+        logger.info("✅ Колонки effect_type и extra_data для discount_offers проверены")
+        return True
+
+    except Exception as e:
+        logger.error(f"Ошибка обновления колонок discount_offers: {e}")
+        return False
+
+
+async def ensure_user_promo_offer_discount_columns():
+    try:
+        percent_exists = await check_column_exists('users', 'promo_offer_discount_percent')
+        source_exists = await check_column_exists('users', 'promo_offer_discount_source')
+        expires_exists = await check_column_exists('users', 'promo_offer_discount_expires_at')
+
+        if percent_exists and source_exists and expires_exists:
+            return True
+
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+
+            if not percent_exists:
+                column_def = 'INTEGER NOT NULL DEFAULT 0'
+                if db_type == 'mysql':
+                    column_def = 'INT NOT NULL DEFAULT 0'
+                await conn.execute(text(
+                    f"ALTER TABLE users ADD COLUMN promo_offer_discount_percent {column_def}"
+                ))
+
+            if not source_exists:
+                if db_type == 'sqlite':
+                    column_def = 'TEXT NULL'
+                elif db_type == 'postgresql':
+                    column_def = 'VARCHAR(100) NULL'
+                elif db_type == 'mysql':
+                    column_def = 'VARCHAR(100) NULL'
+                else:
+                    raise ValueError(f"Unsupported database type: {db_type}")
+
+                await conn.execute(text(
+                    f"ALTER TABLE users ADD COLUMN promo_offer_discount_source {column_def}"
+                ))
+
+            if not expires_exists:
+                if db_type == 'sqlite':
+                    column_def = 'DATETIME NULL'
+                elif db_type == 'postgresql':
+                    column_def = 'TIMESTAMP NULL'
+                elif db_type == 'mysql':
+                    column_def = 'DATETIME NULL'
+                else:
+                    raise ValueError(f"Unsupported database type: {db_type}")
+
+                await conn.execute(text(
+                    f"ALTER TABLE users ADD COLUMN promo_offer_discount_expires_at {column_def}"
+                ))
+
+        logger.info("✅ Колонки promo_offer_discount_* для users проверены")
+        return True
+    except Exception as e:
+        logger.error(f"Ошибка обновления колонок promo_offer_discount_*: {e}")
+        return False
+
+
+async def ensure_promo_offer_template_active_duration_column() -> bool:
+    try:
+        column_exists = await check_column_exists('promo_offer_templates', 'active_discount_hours')
+
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+
+            if not column_exists:
+                if db_type == 'sqlite':
+                    column_def = 'INTEGER NULL'
+                elif db_type == 'postgresql':
+                    column_def = 'INTEGER NULL'
+                elif db_type == 'mysql':
+                    column_def = 'INT NULL'
+                else:
+                    raise ValueError(f"Unsupported database type: {db_type}")
+
+                await conn.execute(text(
+                    f"ALTER TABLE promo_offer_templates ADD COLUMN active_discount_hours {column_def}"
+                ))
+
+            await conn.execute(text(
+                "UPDATE promo_offer_templates "
+                "SET active_discount_hours = valid_hours "
+                "WHERE offer_type IN ('extend_discount', 'purchase_discount') "
+                "AND (active_discount_hours IS NULL OR active_discount_hours <= 0)"
+            ))
+
+        logger.info("✅ Колонка active_discount_hours в promo_offer_templates актуальна")
+        return True
+    except Exception as e:
+        logger.error(f"Ошибка обновления active_discount_hours в promo_offer_templates: {e}")
+        return False
+
+
+async def migrate_discount_offer_effect_types():
+    try:
+        async with engine.begin() as conn:
+            await conn.execute(text(
+                "UPDATE discount_offers SET effect_type = 'percent_discount' "
+                "WHERE effect_type = 'balance_bonus'"
+            ))
+        logger.info("✅ Типы эффектов discount_offers обновлены на percent_discount")
+        return True
+    except Exception as e:
+        logger.error(f"Ошибка обновления типов эффектов discount_offers: {e}")
+        return False
+
+
+async def reset_discount_offer_bonuses():
+    try:
+        async with engine.begin() as conn:
+            await conn.execute(text(
+                "UPDATE discount_offers SET bonus_amount_kopeks = 0 WHERE bonus_amount_kopeks <> 0"
+            ))
+            await conn.execute(text(
+                "UPDATE promo_offer_templates SET bonus_amount_kopeks = 0 WHERE bonus_amount_kopeks <> 0"
+            ))
+        logger.info("✅ Бонусы промо-предложений сброшены до нуля")
+        return True
+    except Exception as e:
+        logger.error(f"Ошибка обнуления бонусов промо-предложений: {e}")
+        return False
+
+
+async def create_promo_offer_templates_table():
+    table_exists = await check_table_exists('promo_offer_templates')
+    if table_exists:
+        logger.info("Таблица promo_offer_templates уже существует")
+        return True
+
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+
+            if db_type == 'sqlite':
+                create_sql = """
+                CREATE TABLE promo_offer_templates (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name VARCHAR(255) NOT NULL,
+                    offer_type VARCHAR(50) NOT NULL,
+                    message_text TEXT NOT NULL,
+                    button_text VARCHAR(255) NOT NULL,
+                    valid_hours INTEGER NOT NULL DEFAULT 24,
+                    discount_percent INTEGER NOT NULL DEFAULT 0,
+                    bonus_amount_kopeks INTEGER NOT NULL DEFAULT 0,
+                    active_discount_hours INTEGER NULL,
+                    test_duration_hours INTEGER NULL,
+                    test_squad_uuids TEXT NULL,
+                    is_active BOOLEAN NOT NULL DEFAULT 1,
+                    created_by INTEGER NULL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY(created_by) REFERENCES users(id) ON DELETE SET NULL
+                );
+
+                CREATE INDEX ix_promo_offer_templates_type ON promo_offer_templates(offer_type);
+                """
+            elif db_type == 'postgresql':
+                create_sql = """
+                CREATE TABLE IF NOT EXISTS promo_offer_templates (
+                    id SERIAL PRIMARY KEY,
+                    name VARCHAR(255) NOT NULL,
+                    offer_type VARCHAR(50) NOT NULL,
+                    message_text TEXT NOT NULL,
+                    button_text VARCHAR(255) NOT NULL,
+                    valid_hours INTEGER NOT NULL DEFAULT 24,
+                    discount_percent INTEGER NOT NULL DEFAULT 0,
+                    bonus_amount_kopeks INTEGER NOT NULL DEFAULT 0,
+                    active_discount_hours INTEGER NULL,
+                    test_duration_hours INTEGER NULL,
+                    test_squad_uuids JSON NULL,
+                    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+                    created_by INTEGER NULL REFERENCES users(id) ON DELETE SET NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                CREATE INDEX IF NOT EXISTS ix_promo_offer_templates_type ON promo_offer_templates(offer_type);
+                """
+            elif db_type == 'mysql':
+                create_sql = """
+                CREATE TABLE IF NOT EXISTS promo_offer_templates (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    name VARCHAR(255) NOT NULL,
+                    offer_type VARCHAR(50) NOT NULL,
+                    message_text TEXT NOT NULL,
+                    button_text VARCHAR(255) NOT NULL,
+                    valid_hours INT NOT NULL DEFAULT 24,
+                    discount_percent INT NOT NULL DEFAULT 0,
+                    bonus_amount_kopeks INT NOT NULL DEFAULT 0,
+                    active_discount_hours INT NULL,
+                    test_duration_hours INT NULL,
+                    test_squad_uuids JSON NULL,
+                    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+                    created_by INT NULL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                    FOREIGN KEY(created_by) REFERENCES users(id) ON DELETE SET NULL
+                );
+
+                CREATE INDEX ix_promo_offer_templates_type ON promo_offer_templates(offer_type);
+                """
+            else:
+                raise ValueError(f"Unsupported database type: {db_type}")
+
+            await conn.execute(text(create_sql))
+
+        logger.info("✅ Таблица promo_offer_templates успешно создана")
+        return True
+
+    except Exception as e:
+        logger.error(f"Ошибка создания таблицы promo_offer_templates: {e}")
+        return False
+
+
+async def create_promo_offer_logs_table() -> bool:
+    table_exists = await check_table_exists('promo_offer_logs')
+    if table_exists:
+        logger.info("Таблица promo_offer_logs уже существует")
+        return True
+
+    try:
+        db_type = await get_database_type()
+        async with engine.begin() as conn:
+            if db_type == 'sqlite':
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS promo_offer_logs (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        user_id INTEGER NULL REFERENCES users(id) ON DELETE SET NULL,
+                        offer_id INTEGER NULL REFERENCES discount_offers(id) ON DELETE SET NULL,
+                        action VARCHAR(50) NOT NULL,
+                        source VARCHAR(100) NULL,
+                        percent INTEGER NULL,
+                        effect_type VARCHAR(50) NULL,
+                        details JSON NULL,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                    );
+
+                    CREATE INDEX IF NOT EXISTS ix_promo_offer_logs_created_at ON promo_offer_logs(created_at DESC);
+                    CREATE INDEX IF NOT EXISTS ix_promo_offer_logs_user_id ON promo_offer_logs(user_id);
+                """))
+            elif db_type == 'postgresql':
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS promo_offer_logs (
+                        id SERIAL PRIMARY KEY,
+                        user_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
+                        offer_id INTEGER REFERENCES discount_offers(id) ON DELETE SET NULL,
+                        action VARCHAR(50) NOT NULL,
+                        source VARCHAR(100),
+                        percent INTEGER,
+                        effect_type VARCHAR(50),
+                        details JSONB,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    );
+
+                    CREATE INDEX IF NOT EXISTS ix_promo_offer_logs_created_at ON promo_offer_logs(created_at DESC);
+                    CREATE INDEX IF NOT EXISTS ix_promo_offer_logs_user_id ON promo_offer_logs(user_id);
+                """))
+            elif db_type == 'mysql':
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS promo_offer_logs (
+                        id INT AUTO_INCREMENT PRIMARY KEY,
+                        user_id INT NULL,
+                        offer_id INT NULL,
+                        action VARCHAR(50) NOT NULL,
+                        source VARCHAR(100) NULL,
+                        percent INT NULL,
+                        effect_type VARCHAR(50) NULL,
+                        details JSON NULL,
+                        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                        CONSTRAINT fk_promo_offer_logs_users FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE SET NULL,
+                        CONSTRAINT fk_promo_offer_logs_offers FOREIGN KEY (offer_id) REFERENCES discount_offers(id) ON DELETE SET NULL
+                    );
+
+                    CREATE INDEX ix_promo_offer_logs_created_at ON promo_offer_logs(created_at DESC);
+                    CREATE INDEX ix_promo_offer_logs_user_id ON promo_offer_logs(user_id);
+                """))
+            else:
+                logger.warning("Неизвестный тип БД для создания promo_offer_logs: %s", db_type)
+                return False
+
+        logger.info("✅ Таблица promo_offer_logs успешно создана")
+        return True
+    except Exception as e:
+        logger.error(f"Ошибка создания таблицы promo_offer_logs: {e}")
+        return False
+
+
+async def create_subscription_temporary_access_table():
+    table_exists = await check_table_exists('subscription_temporary_access')
+    if table_exists:
+        logger.info("Таблица subscription_temporary_access уже существует")
+        return True
+
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+
+            if db_type == 'sqlite':
+                create_sql = """
+                CREATE TABLE subscription_temporary_access (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    subscription_id INTEGER NOT NULL,
+                    offer_id INTEGER NOT NULL,
+                    squad_uuid VARCHAR(255) NOT NULL,
+                    expires_at DATETIME NOT NULL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    deactivated_at DATETIME NULL,
+                    is_active BOOLEAN NOT NULL DEFAULT 1,
+                    was_already_connected BOOLEAN NOT NULL DEFAULT 0,
+                    FOREIGN KEY(subscription_id) REFERENCES subscriptions(id) ON DELETE CASCADE,
+                    FOREIGN KEY(offer_id) REFERENCES discount_offers(id) ON DELETE CASCADE
+                );
+
+                CREATE INDEX ix_temp_access_subscription ON subscription_temporary_access(subscription_id);
+                CREATE INDEX ix_temp_access_offer ON subscription_temporary_access(offer_id);
+                CREATE INDEX ix_temp_access_active ON subscription_temporary_access(is_active, expires_at);
+                """
+            elif db_type == 'postgresql':
+                create_sql = """
+                CREATE TABLE IF NOT EXISTS subscription_temporary_access (
+                    id SERIAL PRIMARY KEY,
+                    subscription_id INTEGER NOT NULL REFERENCES subscriptions(id) ON DELETE CASCADE,
+                    offer_id INTEGER NOT NULL REFERENCES discount_offers(id) ON DELETE CASCADE,
+                    squad_uuid VARCHAR(255) NOT NULL,
+                    expires_at TIMESTAMP NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    deactivated_at TIMESTAMP NULL,
+                    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+                    was_already_connected BOOLEAN NOT NULL DEFAULT FALSE
+                );
+
+                CREATE INDEX IF NOT EXISTS ix_temp_access_subscription ON subscription_temporary_access(subscription_id);
+                CREATE INDEX IF NOT EXISTS ix_temp_access_offer ON subscription_temporary_access(offer_id);
+                CREATE INDEX IF NOT EXISTS ix_temp_access_active ON subscription_temporary_access(is_active, expires_at);
+                """
+            elif db_type == 'mysql':
+                create_sql = """
+                CREATE TABLE IF NOT EXISTS subscription_temporary_access (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    subscription_id INT NOT NULL,
+                    offer_id INT NOT NULL,
+                    squad_uuid VARCHAR(255) NOT NULL,
+                    expires_at DATETIME NOT NULL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    deactivated_at DATETIME NULL,
+                    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+                    was_already_connected BOOLEAN NOT NULL DEFAULT FALSE,
+                    FOREIGN KEY(subscription_id) REFERENCES subscriptions(id) ON DELETE CASCADE,
+                    FOREIGN KEY(offer_id) REFERENCES discount_offers(id) ON DELETE CASCADE
+                );
+
+                CREATE INDEX ix_temp_access_subscription ON subscription_temporary_access(subscription_id);
+                CREATE INDEX ix_temp_access_offer ON subscription_temporary_access(offer_id);
+                CREATE INDEX ix_temp_access_active ON subscription_temporary_access(is_active, expires_at);
+                """
+            else:
+                raise ValueError(f"Unsupported database type: {db_type}")
+
+            await conn.execute(text(create_sql))
+
+        logger.info("✅ Таблица subscription_temporary_access успешно создана")
+        return True
+
+    except Exception as e:
+        logger.error(f"Ошибка создания таблицы subscription_temporary_access: {e}")
+        return False
+
 async def create_user_messages_table():
     table_exists = await check_table_exists('user_messages')
     if table_exists:
@@ -2201,6 +2623,57 @@ async def run_universal_migration():
         else:
             logger.warning("⚠️ Проблемы с таблицей discount_offers")
 
+        discount_columns_ready = await ensure_discount_offer_columns()
+        if discount_columns_ready:
+            logger.info("✅ Колонки discount_offers в актуальном состоянии")
+        else:
+            logger.warning("⚠️ Не удалось обновить колонки discount_offers")
+
+        user_discount_columns_ready = await ensure_user_promo_offer_discount_columns()
+        if user_discount_columns_ready:
+            logger.info("✅ Колонки пользовательских промо-скидок готовы")
+        else:
+            logger.warning("⚠️ Не удалось обновить пользовательские промо-скидки")
+
+        effect_types_updated = await migrate_discount_offer_effect_types()
+        if effect_types_updated:
+            logger.info("✅ Типы эффектов промо-предложений обновлены")
+        else:
+            logger.warning("⚠️ Не удалось обновить типы эффектов промо-предложений")
+
+        bonuses_reset = await reset_discount_offer_bonuses()
+        if bonuses_reset:
+            logger.info("✅ Бонусные начисления промо-предложений отключены")
+        else:
+            logger.warning("⚠️ Не удалось обнулить бонусы промо-предложений")
+
+        logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ PROMO_OFFER_TEMPLATES ===")
+        promo_templates_created = await create_promo_offer_templates_table()
+        if promo_templates_created:
+            logger.info("✅ Таблица promo_offer_templates готова")
+        else:
+            logger.warning("⚠️ Проблемы с таблицей promo_offer_templates")
+
+        template_columns_ready = await ensure_promo_offer_template_active_duration_column()
+        if template_columns_ready:
+            logger.info("✅ Колонка active_discount_hours промо-предложений готова")
+        else:
+            logger.warning("⚠️ Не удалось обновить колонку active_discount_hours промо-предложений")
+
+        logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ PROMO_OFFER_LOGS ===")
+        promo_logs_created = await create_promo_offer_logs_table()
+        if promo_logs_created:
+            logger.info("✅ Таблица promo_offer_logs готова")
+        else:
+            logger.warning("⚠️ Проблемы с таблицей promo_offer_logs")
+
+        logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ SUBSCRIPTION_TEMPORARY_ACCESS ===")
+        temp_access_created = await create_subscription_temporary_access_table()
+        if temp_access_created:
+            logger.info("✅ Таблица subscription_temporary_access готова")
+        else:
+            logger.warning("⚠️ Проблемы с таблицей subscription_temporary_access")
+
         logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ USER_MESSAGES ===")
         user_messages_created = await create_user_messages_table()
         if user_messages_created:
@@ -2401,7 +2874,17 @@ async def check_migration_status():
             "promo_groups_addon_discount_column": False,
             "users_auto_promo_group_assigned_column": False,
             "users_auto_promo_group_threshold_column": False,
+            "users_promo_offer_discount_percent_column": False,
+            "users_promo_offer_discount_source_column": False,
+            "users_promo_offer_discount_expires_column": False,
             "subscription_crypto_link_column": False,
+            "discount_offers_table": False,
+            "discount_offers_effect_column": False,
+            "discount_offers_extra_column": False,
+            "promo_offer_templates_table": False,
+            "promo_offer_templates_active_discount_column": False,
+            "promo_offer_logs_table": False,
+            "subscription_temporary_access_table": False,
         }
         
         status["has_made_first_topup_column"] = await check_column_exists('users', 'has_made_first_topup')
@@ -2413,6 +2896,14 @@ async def check_migration_status():
         status["promo_groups_table"] = await check_table_exists('promo_groups')
         status["server_promo_groups_table"] = await check_table_exists('server_squad_promo_groups')
 
+        status["discount_offers_table"] = await check_table_exists('discount_offers')
+        status["discount_offers_effect_column"] = await check_column_exists('discount_offers', 'effect_type')
+        status["discount_offers_extra_column"] = await check_column_exists('discount_offers', 'extra_data')
+        status["promo_offer_templates_table"] = await check_table_exists('promo_offer_templates')
+        status["promo_offer_templates_active_discount_column"] = await check_column_exists('promo_offer_templates', 'active_discount_hours')
+        status["promo_offer_logs_table"] = await check_table_exists('promo_offer_logs')
+        status["subscription_temporary_access_table"] = await check_table_exists('subscription_temporary_access')
+
         status["welcome_texts_is_enabled_column"] = await check_column_exists('welcome_texts', 'is_enabled')
         status["users_promo_group_column"] = await check_column_exists('users', 'promo_group_id')
         status["promo_groups_period_discounts_column"] = await check_column_exists('promo_groups', 'period_discounts')
@@ -2420,6 +2911,9 @@ async def check_migration_status():
         status["promo_groups_addon_discount_column"] = await check_column_exists('promo_groups', 'apply_discounts_to_addons')
         status["users_auto_promo_group_assigned_column"] = await check_column_exists('users', 'auto_promo_group_assigned')
         status["users_auto_promo_group_threshold_column"] = await check_column_exists('users', 'auto_promo_group_threshold_kopeks')
+        status["users_promo_offer_discount_percent_column"] = await check_column_exists('users', 'promo_offer_discount_percent')
+        status["users_promo_offer_discount_source_column"] = await check_column_exists('users', 'promo_offer_discount_source')
+        status["users_promo_offer_discount_expires_column"] = await check_column_exists('users', 'promo_offer_discount_expires_at')
         status["subscription_crypto_link_column"] = await check_column_exists('subscriptions', 'subscription_crypto_link')
         
         media_fields_exist = (
@@ -2459,7 +2953,17 @@ async def check_migration_status():
             "promo_groups_addon_discount_column": "Колонка apply_discounts_to_addons у промо-групп",
             "users_auto_promo_group_assigned_column": "Флаг автоназначения промогруппы у пользователей",
             "users_auto_promo_group_threshold_column": "Порог последней авто-промогруппы у пользователей",
+            "users_promo_offer_discount_percent_column": "Колонка процента промо-скидки у пользователей",
+            "users_promo_offer_discount_source_column": "Колонка источника промо-скидки у пользователей",
+            "users_promo_offer_discount_expires_column": "Колонка срока действия промо-скидки у пользователей",
             "subscription_crypto_link_column": "Колонка subscription_crypto_link в subscriptions",
+            "discount_offers_table": "Таблица discount_offers",
+            "discount_offers_effect_column": "Колонка effect_type в discount_offers",
+            "discount_offers_extra_column": "Колонка extra_data в discount_offers",
+            "promo_offer_templates_table": "Таблица promo_offer_templates",
+            "promo_offer_templates_active_discount_column": "Колонка active_discount_hours в promo_offer_templates",
+            "promo_offer_logs_table": "Таблица promo_offer_logs",
+            "subscription_temporary_access_table": "Таблица subscription_temporary_access",
         }
         
         for check_key, check_status in status.items():

app/external/webhook_server.py

@@ -133,20 +133,23 @@ class WebhookServer:
 
             payment_service = PaymentService(self.bot)
 
-            async for db in get_db():
-                try:
-                    success = await payment_service.process_mulenpay_callback(db, payload)
-                    if success:
-                        return web.json_response({"status": "ok"}, status=200)
-                    return web.json_response({"status": "error", "reason": "processing_failed"}, status=400)
-                except Exception as error:
-                    logger.error(f"Ошибка обработки Mulen Pay webhook: {error}", exc_info=True)
-                    return web.json_response({"status": "error", "reason": "internal_error"}, status=500)
-                finally:
-                    break
+            # Получаем соединение с БД
+            db_generator = get_db()
+            db = await db_generator.__anext__()
             
-            # Если не удалось получить соединение с БД
-            return web.json_response({"status": "error", "reason": "database_error"}, status=500)
+            try:
+                success = await payment_service.process_mulenpay_callback(db, payload)
+                if success:
+                    return web.json_response({"status": "ok"}, status=200)
+                return web.json_response({"status": "error", "reason": "processing_failed"}, status=400)
+            except Exception as error:
+                logger.error(f"Ошибка обработки Mulen Pay webhook: {error}", exc_info=True)
+                return web.json_response({"status": "error", "reason": "internal_error"}, status=500)
+            finally:
+                try:
+                    await db_generator.__anext__()
+                except StopAsyncIteration:
+                    pass
 
         except Exception as error:
             logger.error(f"Критическая ошибка Mulen Pay webhook: {error}", exc_info=True)

app/handlers/admin/monitoring.py

@@ -226,18 +226,16 @@ def _build_notification_preview_message(language: str, notification_type: str):
     elif notification_type == "expired_2d":
         percent = NotificationSettingsService.get_second_wave_discount_percent()
         valid_hours = NotificationSettingsService.get_second_wave_valid_hours()
-        bonus_amount = settings.PRICE_30_DAYS * percent // 100
         template = texts.get(
             "SUBSCRIPTION_EXPIRED_SECOND_WAVE",
             (
                 "🔥 <b>Скидка {percent}% на продление</b>\n\n"
-                "Нажмите «Получить скидку», и мы начислим {bonus} на баланс. "
-                "Предложение действует до {expires_at}."
+                "Активируйте предложение, чтобы получить дополнительную скидку. "
+                "Она суммируется с вашей промогруппой и действует до {expires_at}."
             ),
         )
         message = template.format(
             percent=percent,
-            bonus=settings.format_price(bonus_amount),
             expires_at=(now + timedelta(hours=valid_hours)).strftime("%d.%m.%Y %H:%M"),
             trigger_days=3,
         )
@@ -273,18 +271,16 @@ def _build_notification_preview_message(language: str, notification_type: str):
         percent = NotificationSettingsService.get_third_wave_discount_percent()
         valid_hours = NotificationSettingsService.get_third_wave_valid_hours()
         trigger_days = NotificationSettingsService.get_third_wave_trigger_days()
-        bonus_amount = settings.PRICE_30_DAYS * percent // 100
         template = texts.get(
             "SUBSCRIPTION_EXPIRED_THIRD_WAVE",
             (
                 "🎁 <b>Индивидуальная скидка {percent}%</b>\n\n"
-                "Прошло {trigger_days} дней без подписки — возвращайтесь, и мы добавим {bonus} на баланс. "
-                "Скидка действует до {expires_at}."
+                "Прошло {trigger_days} дней без подписки — возвращайтесь и активируйте дополнительную скидку. "
+                "Она суммируется с промогруппой и действует до {expires_at}."
             ),
         )
         message = template.format(
             percent=percent,
-            bonus=settings.format_price(bonus_amount),
             trigger_days=trigger_days,
             expires_at=(now + timedelta(hours=valid_hours)).strftime("%d.%m.%Y %H:%M"),
         )

app/handlers/menu.py

@@ -17,6 +17,10 @@ from app.services.subscription_checkout_service import (
 )
 from app.utils.photo_message import edit_or_answer_photo
 from app.services.support_settings_service import SupportSettingsService
+from app.utils.promo_offer import (
+    build_promo_offer_hint,
+    build_test_access_hint,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -300,9 +304,38 @@ async def get_main_menu_text(user, texts, db: AsyncSession):
         user_name=user.full_name,
         subscription_status=_get_subscription_status(user, texts)
     )
-    
+
     action_prompt = texts.t("MAIN_MENU_ACTION_PROMPT", "Выберите действие:")
 
+    info_sections: list[str] = []
+
+    try:
+        promo_hint = await build_promo_offer_hint(db, user, texts)
+        if promo_hint:
+            info_sections.append(promo_hint.strip())
+    except Exception as hint_error:
+        logger.debug(
+            "Не удалось построить подсказку промо-предложения для пользователя %s: %s",
+            getattr(user, "id", None),
+            hint_error,
+        )
+
+    try:
+        test_access_hint = await build_test_access_hint(db, user, texts)
+        if test_access_hint:
+            info_sections.append(test_access_hint.strip())
+    except Exception as test_error:
+        logger.debug(
+            "Не удалось построить подсказку тестового доступа для пользователя %s: %s",
+            getattr(user, "id", None),
+            test_error,
+        )
+
+    if info_sections:
+        extra_block = "\n\n".join(section for section in info_sections if section)
+        if extra_block:
+            base_text = _insert_random_message(base_text, extra_block, action_prompt)
+
     try:
         random_message = await get_random_active_message(db)
         if random_message:

app/handlers/start.py

@@ -32,6 +32,10 @@ from app.services.admin_notification_service import AdminNotificationService
 from app.services.subscription_service import SubscriptionService
 from app.services.support_settings_service import SupportSettingsService
 from app.utils.user_utils import generate_unique_referral_code
+from app.utils.promo_offer import (
+    build_promo_offer_hint,
+    build_test_access_hint,
+)
 from app.database.crud.user_message import get_random_active_message
 
 
@@ -1279,6 +1283,35 @@ async def get_main_menu_text(user, texts, db: AsyncSession):
 
     action_prompt = texts.t("MAIN_MENU_ACTION_PROMPT", "Выберите действие:")
 
+    info_sections: list[str] = []
+
+    try:
+        promo_hint = await build_promo_offer_hint(db, user, texts)
+        if promo_hint:
+            info_sections.append(promo_hint.strip())
+    except Exception as hint_error:
+        logger.debug(
+            "Не удалось построить подсказку промо-предложения для пользователя %s: %s",
+            getattr(user, "id", None),
+            hint_error,
+        )
+
+    try:
+        test_access_hint = await build_test_access_hint(db, user, texts)
+        if test_access_hint:
+            info_sections.append(test_access_hint.strip())
+    except Exception as test_error:
+        logger.debug(
+            "Не удалось построить подсказку тестового доступа для пользователя %s: %s",
+            getattr(user, "id", None),
+            test_error,
+        )
+
+    if info_sections:
+        extra_block = "\n\n".join(section for section in info_sections if section)
+        if extra_block:
+            base_text = _insert_random_message(base_text, extra_block, action_prompt)
+
     try:
         random_message = await get_random_active_message(db)
         if random_message:

app/handlers/subscription.py

@@ -9,14 +9,18 @@ from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings, PERIOD_PRICES, get_traffic_prices
-from app.database.crud.discount_offer import get_offer_by_id, mark_offer_claimed
+from app.database.crud.discount_offer import (
+    get_offer_by_id,
+    mark_offer_claimed,
+)
+from app.database.crud.promo_offer_template import get_promo_offer_template_by_id
 from app.database.crud.subscription import (
     create_trial_subscription,
     create_paid_subscription, add_subscription_traffic, add_subscription_devices,
     update_subscription_autopay
 )
 from app.database.crud.transaction import create_transaction
-from app.database.crud.user import subtract_user_balance, add_user_balance
+from app.database.crud.user import subtract_user_balance
 from app.database.models import (
     User, TransactionType, SubscriptionStatus,
     Subscription
@@ -52,6 +56,7 @@ from app.services.subscription_checkout_service import (
     should_offer_checkout_resume,
 )
 from app.services.subscription_service import SubscriptionService
+from app.services.promo_offer_service import promo_offer_service
 from app.states import SubscriptionStates
 from app.utils.pagination import paginate_list
 from app.utils.pricing_utils import (
@@ -67,6 +72,10 @@ from app.utils.subscription_utils import (
     get_happ_cryptolink_redirect_link,
     convert_subscription_link_to_happ_scheme,
 )
+from app.utils.promo_offer import (
+    build_promo_offer_hint,
+    get_user_active_promo_discount_percent,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -110,6 +119,29 @@ def _apply_addon_discount(
     }
 
 
+def _get_promo_offer_discount_percent(user: Optional[User]) -> int:
+    return get_user_active_promo_discount_percent(user)
+
+
+def _apply_promo_offer_discount(user: Optional[User], amount: int) -> Dict[str, int]:
+    percent = _get_promo_offer_discount_percent(user)
+
+    if amount <= 0 or percent <= 0:
+        return {"discounted": amount, "discount": 0, "percent": 0}
+
+    discounted, discount_value = apply_percentage_discount(amount, percent)
+    return {"discounted": discounted, "discount": discount_value, "percent": percent}
+
+
+async def _get_promo_offer_hint(
+        db: AsyncSession,
+        db_user: User,
+        texts,
+        percent: Optional[int] = None,
+) -> Optional[str]:
+    return await build_promo_offer_hint(db, db_user, texts, percent)
+
+
 def _get_period_hint_from_subscription(subscription: Optional[Subscription]) -> Optional[int]:
     if not subscription:
         return None
@@ -245,7 +277,20 @@ async def _prepare_subscription_summary(
     if not is_valid:
         raise ValueError("Subscription price calculation validation failed")
 
+    original_total_price = total_price
+    promo_offer_component = _apply_promo_offer_discount(db_user, total_price)
+    if promo_offer_component["discount"] > 0:
+        total_price = promo_offer_component["discounted"]
+
     summary_data['total_price'] = total_price
+    if promo_offer_component["discount"] > 0:
+        summary_data['promo_offer_discount_percent'] = promo_offer_component["percent"]
+        summary_data['promo_offer_discount_value'] = promo_offer_component["discount"]
+        summary_data['total_price_before_promo_offer'] = original_total_price
+    else:
+        summary_data.pop('promo_offer_discount_percent', None)
+        summary_data.pop('promo_offer_discount_value', None)
+        summary_data.pop('total_price_before_promo_offer', None)
     summary_data['server_prices_for_period'] = selected_server_prices
     summary_data['months_in_period'] = months_in_period
     summary_data['base_price'] = base_price
@@ -329,6 +374,17 @@ async def _prepare_subscription_summary(
             )
         details_lines.append(devices_line)
 
+    if promo_offer_component["discount"] > 0:
+        details_lines.append(
+            texts.t(
+                "SUBSCRIPTION_SUMMARY_PROMO_DISCOUNT",
+                "- Промо-предложение: -{amount} ({percent}% дополнительно)",
+            ).format(
+                amount=texts.format_price(promo_offer_component["discount"]),
+                percent=promo_offer_component["percent"],
+            )
+        )
+
     details_text = "\n".join(details_lines)
 
     summary_text = (
@@ -426,19 +482,29 @@ def _build_promo_group_discount_text(
     return "\n".join(lines)
 
 
-def _build_subscription_period_prompt(db_user: User, texts) -> str:
+async def _build_subscription_period_prompt(
+        db_user: User,
+        texts,
+        db: AsyncSession,
+) -> str:
     base_text = texts.BUY_SUBSCRIPTION_START.rstrip()
 
+    lines: List[str] = [base_text]
+
+    promo_offer_hint = await _get_promo_offer_hint(db, db_user, texts)
+    if promo_offer_hint:
+        lines.extend(["", promo_offer_hint])
+
     promo_text = _build_promo_group_discount_text(
         db_user,
         settings.get_available_subscription_periods(),
         texts=texts,
     )
 
-    if not promo_text:
-        return f"{base_text}\n"
+    if promo_text:
+        lines.extend(["", promo_text])
 
-    return f"{base_text}\n\n{promo_text}\n"
+    return "\n".join(lines) + "\n"
 
 
 async def show_subscription_info(
@@ -760,8 +826,6 @@ async def get_subscription_cost(subscription, db: AsyncSession) -> int:
             except AttributeError:
                 period_discount_percent = 0
 
-        from app.utils.pricing_utils import apply_percentage_discount
-
         base_cost, _ = apply_percentage_discount(
             base_cost_original,
             period_discount_percent,
@@ -1032,13 +1096,15 @@ async def activate_trial(
 async def start_subscription_purchase(
         callback: types.CallbackQuery,
         state: FSMContext,
-        db_user: User
+        db_user: User,
+        db: AsyncSession,
 ):
     texts = get_texts(db_user.language)
 
     await callback.message.edit_text(
-        _build_subscription_period_prompt(db_user, texts),
-        reply_markup=get_subscription_period_keyboard(db_user.language)
+        await _build_subscription_period_prompt(db_user, texts, db),
+        reply_markup=get_subscription_period_keyboard(db_user.language),
+        parse_mode="HTML",
     )
 
     subscription = getattr(db_user, 'subscription', None)
@@ -2373,14 +2439,13 @@ async def handle_extend_subscription(
 
     available_periods = settings.get_available_renewal_periods()
     renewal_prices = {}
+    promo_offer_percent = _get_promo_offer_discount_percent(db_user)
 
     for days in available_periods:
         try:
             months_in_period = calculate_months_from_days(days)
 
             from app.config import PERIOD_PRICES
-            from app.utils.pricing_utils import apply_percentage_discount
-
             base_price_original = PERIOD_PRICES.get(days, 0)
             period_discount_percent = db_user.get_promo_discount("period", days)
             base_price, _ = apply_percentage_discount(
@@ -2418,7 +2483,8 @@ async def handle_extend_subscription(
             total_traffic_price = (traffic_price_per_month - traffic_discount_per_month) * months_in_period
 
             price = base_price + total_servers_price + total_devices_price + total_traffic_price
-            renewal_prices[days] = price
+            promo_component = _apply_promo_offer_discount(db_user, price)
+            renewal_prices[days] = promo_component["discounted"]
 
         except Exception as e:
             logger.error(f"Ошибка расчета цены для периода {days}: {e}")
@@ -2455,6 +2521,15 @@ async def handle_extend_subscription(
     if promo_discounts_text:
         message_text += f"{promo_discounts_text}\n\n"
 
+    promo_offer_hint = await _get_promo_offer_hint(
+        db,
+        db_user,
+        texts,
+        promo_offer_percent,
+    )
+    if promo_offer_hint:
+        message_text += f"{promo_offer_hint}\n\n"
+
     message_text += "💡 <i>Цена включает все ваши текущие серверы и настройки</i>"
 
     await callback.message.edit_text(
@@ -2666,7 +2741,6 @@ async def confirm_extend_subscription(
 
     try:
         from app.config import PERIOD_PRICES
-        from app.utils.pricing_utils import apply_percentage_discount
 
         base_price_original = PERIOD_PRICES.get(days, 0)
         period_discount_percent = db_user.get_promo_discount("period", days)
@@ -2719,13 +2793,17 @@ async def confirm_extend_subscription(
         total_traffic_price = discounted_traffic_price_per_month * months_in_period
 
         price = base_price + total_servers_price + total_devices_price + total_traffic_price
+        original_price = price
+        promo_component = _apply_promo_offer_discount(db_user, price)
+        if promo_component["discount"] > 0:
+            price = promo_component["discounted"]
 
         monthly_additions = (
                 discounted_servers_price_per_month
                 + discounted_devices_price_per_month
                 + discounted_traffic_price_per_month
         )
-        is_valid = validate_pricing_calculation(base_price, monthly_additions, months_in_period, price)
+        is_valid = validate_pricing_calculation(base_price, monthly_additions, months_in_period, original_price)
 
         if not is_valid:
             logger.error(f"Ошибка в расчете цены продления для пользователя {db_user.telegram_id}")
@@ -2773,6 +2851,12 @@ async def confirm_extend_subscription(
                     else ""
                 )
             )
+        if promo_component["discount"] > 0:
+            logger.info(
+                "   🎯 Промо-предложение: -%s₽ (%s%%)",
+                promo_component["discount"] / 100,
+                promo_component["percent"],
+            )
         logger.info(f"   💎 ИТОГО: {price / 100}₽")
 
     except Exception as e:
@@ -2811,8 +2895,11 @@ async def confirm_extend_subscription(
 
     try:
         success = await subtract_user_balance(
-            db, db_user, price,
-            f"Продление подписки на {days} дней"
+            db,
+            db_user,
+            price,
+            f"Продление подписки на {days} дней",
+            consume_promo_offer=promo_component["discount"] > 0,
         )
 
         if not success:
@@ -2903,6 +2990,12 @@ async def confirm_extend_subscription(
             f"💰 Списано: {texts.format_price(price)}"
         )
 
+        if promo_component["discount"] > 0:
+            success_message += (
+                f" (включая доп. скидку {promo_component['percent']}%:"
+                f" -{texts.format_price(promo_component['discount'])})"
+            )
+
         await callback.message.edit_text(
             success_message,
             reply_markup=get_back_keyboard(db_user.language)
@@ -3463,8 +3556,6 @@ async def confirm_purchase(
         discounted_servers_price_per_month = 0
         server_prices = []
 
-        from app.utils.pricing_utils import apply_percentage_discount
-
         for server_price_per_month in per_month_prices:
             discounted_per_month, discount_per_month = apply_percentage_discount(
                 server_price_per_month,
@@ -3504,8 +3595,6 @@ async def confirm_purchase(
             "devices",
             data['period_days'],
         )
-        from app.utils.pricing_utils import apply_percentage_discount
-
         discounted_devices_price_per_month, discount_per_month = apply_percentage_discount(
             devices_price_per_month,
             devices_discount_percent,
@@ -3538,8 +3627,6 @@ async def confirm_purchase(
             "traffic",
             data['period_days'],
         )
-        from app.utils.pricing_utils import apply_percentage_discount
-
         discounted_traffic_price_per_month, discount_per_month = apply_percentage_discount(
             traffic_price_per_month,
             traffic_discount_percent,
@@ -3549,7 +3636,26 @@ async def confirm_purchase(
 
     total_servers_price = data.get('total_servers_price', total_countries_price)
 
-    final_price = data['total_price']
+    cached_total_price = data['total_price']
+    cached_promo_discount_value = data.get('promo_offer_discount_value', 0)
+
+    validation_total_price = data.get('total_price_before_promo_offer')
+    if validation_total_price is None and cached_promo_discount_value > 0:
+        validation_total_price = cached_total_price + cached_promo_discount_value
+    if validation_total_price is None:
+        validation_total_price = cached_total_price
+
+    current_promo_offer_percent = _get_promo_offer_discount_percent(db_user)
+    if current_promo_offer_percent > 0:
+        final_price, promo_offer_discount_value = apply_percentage_discount(
+            validation_total_price,
+            current_promo_offer_percent,
+        )
+        promo_offer_discount_percent = current_promo_offer_percent
+    else:
+        final_price = validation_total_price
+        promo_offer_discount_value = 0
+        promo_offer_discount_percent = 0
 
     discounted_monthly_additions = data.get(
         'discounted_monthly_additions',
@@ -3562,7 +3668,7 @@ async def confirm_purchase(
         base_price,
         discounted_monthly_additions,
         months_in_period,
-        final_price,
+        validation_total_price,
     )
 
     if not is_valid:
@@ -3611,6 +3717,12 @@ async def confirm_purchase(
                 f" -{devices_discount_total / 100}₽)"
             )
         logger.info(message)
+    if promo_offer_discount_value > 0:
+        logger.info(
+            "   🎯 Промо-предложение: -%s₽ (%s%%)",
+            promo_offer_discount_value / 100,
+            promo_offer_discount_percent,
+        )
     logger.info(f"   ИТОГО: {final_price / 100}₽")
 
     if db_user.balance_kopeks < final_price:
@@ -3646,8 +3758,11 @@ async def confirm_purchase(
 
     try:
         success = await subtract_user_balance(
-            db, db_user, final_price,
-            f"Покупка подписки на {data['period_days']} дней"
+            db,
+            db_user,
+            final_price,
+            f"Покупка подписки на {data['period_days']} дней",
+            consume_promo_offer=promo_offer_discount_value > 0,
         )
 
         if not success:
@@ -3810,6 +3925,16 @@ async def confirm_purchase(
         subscription_link = get_display_subscription_link(subscription)
         hide_subscription_link = settings.should_hide_subscription_link()
 
+        discount_note = ""
+        if promo_offer_discount_value > 0:
+            discount_note = texts.t(
+                "SUBSCRIPTION_PROMO_DISCOUNT_NOTE",
+                "⚡ Доп. скидка {percent}%: -{amount}",
+            ).format(
+                percent=promo_offer_discount_percent,
+                amount=texts.format_price(promo_offer_discount_value),
+            )
+
         if remnawave_user and subscription_link:
             if settings.is_happ_cryptolink_mode():
                 success_text = (
@@ -3849,6 +3974,9 @@ async def confirm_purchase(
                     f"{texts.t('SUBSCRIPTION_IMPORT_INSTRUCTION_PROMPT', '📱 Нажмите кнопку ниже, чтобы получить инструкцию по настройке VPN на вашем устройстве')}"
                 )
 
+            if discount_note:
+                success_text = f"{success_text}\n\n{discount_note}"
+
             connect_mode = settings.CONNECT_BUTTON_MODE
 
             if connect_mode == "miniapp_subscription":
@@ -3922,11 +4050,14 @@ async def confirm_purchase(
                 parse_mode="HTML"
             )
         else:
+            purchase_text = texts.SUBSCRIPTION_PURCHASED
+            if discount_note:
+                purchase_text = f"{purchase_text}\n\n{discount_note}"
             await callback.message.edit_text(
                 texts.t(
                     "SUBSCRIPTION_LINK_GENERATING_NOTICE",
                     "{purchase_text}\n\nСсылка генерируется, перейдите в раздел 'Моя подписка' через несколько секунд.",
-                ).format(purchase_text=texts.SUBSCRIPTION_PURCHASED),
+                ).format(purchase_text=purchase_text),
                 reply_markup=get_back_keyboard(db_user.language)
             )
 
@@ -4314,8 +4445,9 @@ async def handle_subscription_config_back(
 
     if current_state == SubscriptionStates.selecting_traffic.state:
         await callback.message.edit_text(
-            _build_subscription_period_prompt(db_user, texts),
-            reply_markup=get_subscription_period_keyboard(db_user.language)
+            await _build_subscription_period_prompt(db_user, texts, db),
+            reply_markup=get_subscription_period_keyboard(db_user.language),
+            parse_mode="HTML",
         )
         await state.set_state(SubscriptionStates.selecting_period)
 
@@ -4328,8 +4460,9 @@ async def handle_subscription_config_back(
             await state.set_state(SubscriptionStates.selecting_traffic)
         else:
             await callback.message.edit_text(
-                _build_subscription_period_prompt(db_user, texts),
-                reply_markup=get_subscription_period_keyboard(db_user.language)
+                await _build_subscription_period_prompt(db_user, texts, db),
+                reply_markup=get_subscription_period_keyboard(db_user.language),
+                parse_mode="HTML",
             )
             await state.set_state(SubscriptionStates.selecting_period)
 
@@ -4352,8 +4485,9 @@ async def handle_subscription_config_back(
             await state.set_state(SubscriptionStates.selecting_traffic)
         else:
             await callback.message.edit_text(
-                _build_subscription_period_prompt(db_user, texts),
-                reply_markup=get_subscription_period_keyboard(db_user.language)
+                await _build_subscription_period_prompt(db_user, texts, db),
+                reply_markup=get_subscription_period_keyboard(db_user.language),
+                parse_mode="HTML",
             )
             await state.set_state(SubscriptionStates.selecting_period)
 
@@ -5052,33 +5186,184 @@ async def claim_discount_offer(
         )
         return
 
-    bonus_amount = offer.bonus_amount_kopeks or 0
-    if bonus_amount > 0:
-        success = await add_user_balance(
+    effect_type = (offer.effect_type or "percent_discount").lower()
+    if effect_type == "balance_bonus":
+        effect_type = "percent_discount"
+
+    if effect_type == "test_access":
+        success, newly_added, expires_at, error_code = await promo_offer_service.grant_test_access(
             db,
             db_user,
-            bonus_amount,
-            texts.get("DISCOUNT_BONUS_DESCRIPTION", "Скидка за продление подписки"),
+            offer,
         )
+
         if not success:
-            await callback.answer(
-                texts.get("DISCOUNT_CLAIM_ERROR", "❌ Не удалось начислить скидку. Попробуйте позже."),
-                show_alert=True,
-            )
+            if error_code == "subscription_missing":
+                error_message = texts.get(
+                    "TEST_ACCESS_NO_SUBSCRIPTION",
+                    "❌ Для активации предложения необходима действующая подписка.",
+                )
+            elif error_code == "squads_missing":
+                error_message = texts.get(
+                    "TEST_ACCESS_NO_SQUADS",
+                    "❌ Не удалось определить список серверов для теста. Обратитесь к администратору.",
+                )
+            elif error_code == "already_connected":
+                error_message = texts.get(
+                    "TEST_ACCESS_ALREADY_CONNECTED",
+                    "ℹ️ Этот сервер уже подключен к вашей подписке.",
+                )
+            elif error_code == "remnawave_sync_failed":
+                error_message = texts.get(
+                    "TEST_ACCESS_REMNAWAVE_ERROR",
+                    "❌ Не удалось подключить серверы. Попробуйте позже или обратитесь в поддержку.",
+                )
+            else:
+                error_message = texts.get(
+                    "TEST_ACCESS_UNKNOWN_ERROR",
+                    "❌ Не удалось активировать предложение. Попробуйте позже.",
+                )
+            await callback.answer(error_message, show_alert=True)
             return
 
-    await mark_offer_claimed(db, offer)
+        await mark_offer_claimed(
+            db,
+            offer,
+            details={
+                "context": "test_access_claim",
+                "new_squads": newly_added,
+                "expires_at": expires_at.isoformat() if expires_at else None,
+            },
+        )
+
+        expires_text = expires_at.strftime("%d.%m.%Y %H:%M") if expires_at else ""
+        success_message = texts.get(
+            "TEST_ACCESS_ACTIVATED_MESSAGE",
+            "🎉 Тестовые сервера подключены! Доступ активен до {expires_at}.",
+        ).format(expires_at=expires_text)
+
+        popup_text = texts.get("TEST_ACCESS_ACTIVATED_POPUP", "✅ Доступ выдан!")
+        await callback.answer(popup_text, show_alert=True)
+        back_keyboard = InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(
+                        text=texts.get("BACK_TO_MENU", "🏠 В главное меню"),
+                        callback_data="back_to_menu",
+                    )
+                ]
+            ]
+        )
+        await callback.message.answer(success_message, reply_markup=back_keyboard)
+        return
+
+    discount_percent = int(offer.discount_percent or 0)
+    if discount_percent <= 0:
+        await callback.answer(
+            texts.get("DISCOUNT_CLAIM_ERROR", "❌ Не удалось активировать скидку. Попробуйте позже."),
+            show_alert=True,
+        )
+        return
+
+    db_user.promo_offer_discount_percent = discount_percent
+    db_user.promo_offer_discount_source = offer.notification_type
+    db_user.updated_at = now
+
+    extra_data = offer.extra_data or {}
+    raw_duration = extra_data.get("active_discount_hours")
+    template_id = extra_data.get("template_id")
+
+    if raw_duration in (None, "") and template_id:
+        try:
+            template = await get_promo_offer_template_by_id(db, int(template_id))
+        except (ValueError, TypeError):
+            template = None
+        if template and template.active_discount_hours:
+            raw_duration = template.active_discount_hours
+
+    try:
+        duration_hours = int(raw_duration) if raw_duration is not None else None
+    except (TypeError, ValueError):
+        duration_hours = None
+
+    if duration_hours and duration_hours > 0:
+        discount_expires_at = now + timedelta(hours=duration_hours)
+    else:
+        discount_expires_at = None
+
+    db_user.promo_offer_discount_expires_at = discount_expires_at
+
+    await mark_offer_claimed(
+        db,
+        offer,
+        details={
+            "context": "discount_claim",
+            "discount_percent": discount_percent,
+            "discount_expires_at": discount_expires_at.isoformat() if discount_expires_at else None,
+        },
+    )
+    await db.refresh(db_user)
 
     success_message = texts.get(
         "DISCOUNT_CLAIM_SUCCESS",
-        "🎉 Скидка {percent}% активирована! На баланс начислено {amount}.",
-    ).format(
-        percent=offer.discount_percent,
-        amount=settings.format_price(bonus_amount),
-    )
+        "🎉 Скидка {percent}% активирована! Она автоматически применится при следующей оплате.",
+    ).format(percent=discount_percent)
 
     await callback.answer("✅ Скидка активирована!", show_alert=True)
-    await callback.message.answer(success_message)
+
+    offer_type = None
+    if isinstance(extra_data, dict):
+        offer_type = extra_data.get("offer_type")
+
+    subscription = getattr(db_user, "subscription", None)
+
+    if offer_type == "purchase_discount":
+        button_text = texts.get("MENU_BUY_SUBSCRIPTION", "💎 Купить подписку")
+        button_callback = "subscription_upgrade"
+    elif offer_type == "extend_discount":
+        button_text = texts.get("SUBSCRIPTION_EXTEND", "💎 Продлить подписку")
+        button_callback = "subscription_extend"
+    else:
+        has_active_paid_subscription = bool(
+            subscription
+            and getattr(subscription, "is_active", False)
+            and not getattr(subscription, "is_trial", False)
+        )
+
+        if has_active_paid_subscription:
+            button_text = texts.get("SUBSCRIPTION_EXTEND", "💎 Продлить подписку")
+            button_callback = "subscription_extend"
+        else:
+            button_text = texts.get("MENU_BUY_SUBSCRIPTION", "💎 Купить подписку")
+            button_callback = "subscription_upgrade"
+
+    buy_keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text=button_text,
+                    callback_data=button_callback,
+                )
+            ]
+        ]
+    )
+    await callback.message.answer(success_message, reply_markup=buy_keyboard)
+
+
+async def handle_promo_offer_close(
+        callback: types.CallbackQuery,
+        db_user: User,
+        db: AsyncSession,
+):
+    try:
+        await callback.message.delete()
+    except Exception:
+        try:
+            await callback.message.edit_reply_markup()
+        except Exception:
+            pass
+
+    await callback.answer()
 
 
 async def handle_device_guide(
@@ -6124,6 +6409,11 @@ def register_handlers(dp: Dispatcher):
         F.data.startswith("claim_discount_")
     )
 
+    dp.callback_query.register(
+        handle_promo_offer_close,
+        F.data == "promo_offer_close",
+    )
+
     dp.callback_query.register(
         handle_happ_download_request,
         F.data == "subscription_happ_download"

app/keyboards/admin.py

@@ -101,6 +101,12 @@ def get_admin_communications_submenu_keyboard(language: str = "ru") -> InlineKey
         [
             InlineKeyboardButton(text=texts.ADMIN_MESSAGES, callback_data="admin_messages")
         ],
+        [
+            InlineKeyboardButton(
+                text=_t(texts, "ADMIN_COMMUNICATIONS_PROMO_OFFERS", "🎯 Промо-предложения"),
+                callback_data="admin_promo_offers"
+            )
+        ],
         [
             InlineKeyboardButton(
                 text=_t(texts, "ADMIN_COMMUNICATIONS_WELCOME_TEXT", "👋 Приветственный текст"),

app/localization/locales/en.json

@@ -75,6 +75,8 @@
   "LOADING": "⏳ Loading...",
   "MAIN_MENU": "👤 <b>{user_name}</b>\n\n📱 <b>Subscription:</b> {subscription_status}\n\nChoose an option:\n",
   "MAIN_MENU_ACTION_PROMPT": "Choose an option:",
+  "MAIN_MENU_TEST_ACCESS_HEADER": "🧪 Test servers active: {servers}",
+  "MAIN_MENU_TEST_ACCESS_TIMER": "⏳ Access active for {time_left}\n<code>{bar}</code>",
   "MAIN_MENU_BUTTON": "🏠 Main menu",
   "MANAGE_DEVICES_BUTTON": "🔧 Manage devices",
   "DEVICE_UUID_NOT_FOUND": "❌ User UUID not found",
@@ -275,6 +277,7 @@
   "CHANGE_DEVICES_SUCCESS_INCREASE": "\n✅ Device limit increased!\n\n📱 Was: {old_count} → Now: {new_count}\n💰 Charged: {amount}\n",
   "CHANGE_DEVICES_TITLE": "📱 Change device limit",
   "CONTACT_SUPPORT": "💬 Contact support",
+  "PRIVACY_RESTRICTED_BUTTON_HINT": "⚠️ <b>Telegram blocked the contact request button because of your privacy settings.</b>\n\nAllow sharing your contact details in Telegram settings or send the required information manually in the chat.",
   "CREATE_INVITE": "📝 Create invite",
   "DEVICES_INSUFFICIENT_BALANCE": "⚠️ Insufficient balance!\nRequired: {required} (for {months} mo)\nYou have: {balance}",
   "DEVICES_LIMIT_EXCEEDED": "⚠️ Maximum device limit exceeded ({limit})",
@@ -522,6 +525,16 @@
   "ADMIN_PROMO_GROUP_INVALID_AUTO_ASSIGN": "Enter a non-negative amount in rubles or 0 to disable.",
   "ADMIN_PROMO_GROUP_INVALID_PERIOD_DISCOUNTS": "Enter period:discount pairs separated by commas, e.g. 30:10, 90:15, or 0.",
   "ADMIN_PROMO_GROUP_PERIOD_DISCOUNTS_HEADER": "⏳ Period discounts:",
+  "ADMIN_PROMO_OFFER_TEST_DURATION": "Access: {hours} h",
+  "ADMIN_PROMO_OFFER_TEST_SQUAD_NAME": "Server: {name}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS": "Squads: {squads}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS_EMPTY": "Squads: not specified",
+  "ADMIN_PROMO_OFFER_RESULT": "📬 Broadcast finished\nSent: {sent}\nFailed: {failed}",
+  "ADMIN_PROMO_OFFER_SKIPPED": "Skipped: {skipped} (already have access)",
+  "ADMIN_PROMO_OFFER_CTA_BUY": "Buy subscription",
+  "ADMIN_PROMO_OFFER_CTA_EXTEND": "Extend subscription",
+  "ADMIN_PROMO_OFFER_BACK_TO_TEMPLATE": "↩️ Back to offer",
+  "ADMIN_PROMO_OFFER_BACK_TO_LIST": "⬅️ Back to promo offers",
   "ADMIN_REPORTS": "📊 Reports",
   "ADMIN_TICKETS_TITLE": "🎫 All support tickets:",
   "ADMIN_TICKETS_TITLE_CLOSED": "🎫 Closed support tickets:",
@@ -548,11 +561,17 @@
   "CREATE_TICKET_BUTTON": "🎫 Create ticket",
   "DELETE_MESSAGE": "🗑 Delete",
   "DISCOUNT_BONUS_DESCRIPTION": "Renewal discount bonus",
+  "SUBSCRIPTION_SUMMARY_PROMO_DISCOUNT": "- Promo offer: -{amount} ({percent}% extra)",
+  "SUBSCRIPTION_PROMO_DISCOUNT_NOTE": "⚡ Extra discount {percent}%: -{amount}",
+  "SUBSCRIPTION_PROMO_DISCOUNT_HINT": "⚡ Extra {percent}% discount is active and will apply automatically. It stacks with other discounts.",
+  "SUBSCRIPTION_PROMO_DISCOUNT_TIMER": "⏳ Discount active for {time_left}\n<code>{bar}</code>",
   "DISCOUNT_CLAIM_ALREADY": "ℹ️ This discount has already been activated.",
-  "DISCOUNT_CLAIM_ERROR": "❌ Failed to credit the discount. Please try again later.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Failed to activate the discount. Please try again later.",
+  "PROMO_OFFER_CLOSE": "❌ Close",
   "DISCOUNT_CLAIM_EXPIRED": "⚠️ The offer has expired.",
   "DISCOUNT_CLAIM_NOT_FOUND": "❌ Offer not found.",
-  "DISCOUNT_CLAIM_SUCCESS": "🎉 Discount of {percent}% activated! {amount} credited to your balance.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 Discount of {percent}% activated! It will be applied automatically to your next payment.",
+  "TEST_ACCESS_ALREADY_CONNECTED": "ℹ️ This server is already connected to your subscription.",
   "ENTER_BLOCK_MINUTES": "Enter the number of minutes to block the user (e.g., 15):",
   "LANGUAGE_SELECTION_DISABLED": "⚙️ Language selection is temporarily unavailable. Using the default language.",
   "MARK_AS_ANSWERED": "✅ Mark as answered",
@@ -592,8 +611,8 @@
   "REPORT_CLOSE_ERROR": "❌ Failed to close the report.",
   "SENDING_ATTACHMENTS": "📎 Sending attachments...",
   "SUBSCRIPTION_EXPIRED_1D": "⛔ <b>Your subscription expired</b>\n\nAccess was disabled on {end_date}. Renew to return to the service.\n\n💎 Renewal price: {price}",
-  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>{percent}% discount on renewal</b>\n\nTap “Get discount” and we'll add {bonus} to your balance. The offer is valid until {expires_at}.",
-  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Personal {percent}% discount</b>\n\nIt's been {trigger_days} days without a subscription. Come back — tap “Get discount” and {bonus} will be credited. Offer valid until {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>{percent}% discount on renewal</b>\n\nActivate the offer to get an additional discount. It stacks with your promo group and is valid until {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Personal {percent}% discount</b>\n\nIt's been {trigger_days} days without a subscription. Come back and activate the extra discount — it stacks with your promo group and is valid until {expires_at}.",
   "SUBSCRIPTION_EXTEND": "💎 Extend subscription",
   "SUBSCRIPTION_HAPP_CRYPTOLINK_BLOCK": "<blockquote expandable><code>{crypto_link}</code></blockquote>",
   "SUBSCRIPTION_HAPP_LINK_PROMPT": "🔒 Subscription link is ready. Tap the \"Connect\" button below to open it in Happ.",

app/localization/locales/ru.json

@@ -158,6 +158,7 @@
   "HAPP_DOWNLOAD_OPEN_LINK": "🔗 Открыть ссылку",
   "CONTACT_SUPPORT": "💬 Написать в поддержку",
   "CONTINUE": "➡️ Продолжить",
+  "PRIVACY_RESTRICTED_BUTTON_HINT": "⚠️ <b>Telegram не позволяет боту запросить контакт из-за ваших настроек приватности.</b>\n\nРазрешите отправку контакта в настройках Telegram или поделитесь данными вручную в ответ на сообщение.",
   "CONTINUE_BUTTON": "✅ Продолжить",
   "COPY_SUBSCRIPTION_LINK": "📋 Скопировать ссылку подписки",
   "CREATE_INVITE": "📝 Создать приглашение",
@@ -202,6 +203,8 @@
   "MAINTENANCE_MODE_API_ERROR": "\n🔧 Технические работы!\n\nСервис временно недоступен из-за проблем с подключением к серверам.\n\n⏰ Мы работаем над восстановлением. Попробуйте через несколько минут.\n\n🔄 Последняя проверка: {last_check}\n",
   "MAIN_MENU": "👤 <b>{user_name}</b>\n    \n📱 <b>Подписка:</b> {subscription_status}\n\nВыберите действие:\n",
   "MAIN_MENU_ACTION_PROMPT": "Выберите действие:",
+  "MAIN_MENU_TEST_ACCESS_HEADER": "🧪 Тестовые сервера активны: {servers}",
+  "MAIN_MENU_TEST_ACCESS_TIMER": "⏳ Доступ действует ещё: {time_left}\n<code>{bar}</code>",
   "MAIN_MENU_BUTTON": "🏠 Главное меню",
   "MANAGE_DEVICES_BUTTON": "🔧 Управление устройствами",
   "DEVICE_UUID_NOT_FOUND": "❌ UUID пользователя не найден",
@@ -524,6 +527,16 @@
   "ADMIN_PROMO_GROUP_INVALID_AUTO_ASSIGN": "Введите неотрицательное число в рублях или 0 для отключения.",
   "ADMIN_PROMO_GROUP_INVALID_PERIOD_DISCOUNTS": "Введите пары период:скидка через запятую, например 30:10, 90:15, или 0.",
   "ADMIN_PROMO_GROUP_PERIOD_DISCOUNTS_HEADER": "⏳ Скидки по периодам:",
+  "ADMIN_PROMO_OFFER_TEST_DURATION": "Доступ: {hours} ч",
+  "ADMIN_PROMO_OFFER_TEST_SQUAD_NAME": "Сервер: {name}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS": "Сквады: {squads}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS_EMPTY": "Сквады: не указаны",
+  "ADMIN_PROMO_OFFER_RESULT": "📬 Рассылка завершена\nОтправлено: {sent}\nОшибок: {failed}",
+  "ADMIN_PROMO_OFFER_SKIPPED": "Пропущено: {skipped} (уже есть доступ)",
+  "ADMIN_PROMO_OFFER_CTA_BUY": "Купить подписку",
+  "ADMIN_PROMO_OFFER_CTA_EXTEND": "Продлить подписку",
+  "ADMIN_PROMO_OFFER_BACK_TO_TEMPLATE": "↩️ К предложению",
+  "ADMIN_PROMO_OFFER_BACK_TO_LIST": "⬅️ К промопредложениям",
   "ADMIN_REPORTS": "📊 Отчеты",
   "ADMIN_TICKETS_TITLE": "🎫 Все тикеты поддержки:",
   "ADMIN_TICKET_REPLY_INPUT": "Введите ответ от поддержки:",
@@ -548,11 +561,17 @@
   "CREATE_TICKET_BUTTON": "🎫 Создать тикет",
   "DELETE_MESSAGE": "🗑 Удалить",
   "DISCOUNT_BONUS_DESCRIPTION": "Скидка за продление подписки",
+  "SUBSCRIPTION_SUMMARY_PROMO_DISCOUNT": "- Промо-предложение: -{amount} ({percent}% дополнительно)",
+  "SUBSCRIPTION_PROMO_DISCOUNT_NOTE": "⚡ Доп. скидка {percent}%: -{amount}",
+  "SUBSCRIPTION_PROMO_DISCOUNT_HINT": "⚡ Активирована доп. скидка {percent}%. \n\nСуммируется с другими скидками!",
+  "SUBSCRIPTION_PROMO_DISCOUNT_TIMER": "⏳ Скидка действует ещё: {time_left}\n<code>{bar}</code>",
   "DISCOUNT_CLAIM_ALREADY": "ℹ️ Скидка уже была активирована ранее.",
-  "DISCOUNT_CLAIM_ERROR": "❌ Не удалось начислить скидку. Попробуйте позже.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Не удалось активировать скидку. Попробуйте позже.",
+  "PROMO_OFFER_CLOSE": "❌ Закрыть",
   "DISCOUNT_CLAIM_EXPIRED": "⚠️ Время действия предложения истекло.",
   "DISCOUNT_CLAIM_NOT_FOUND": "❌ Предложение не найдено.",
-  "DISCOUNT_CLAIM_SUCCESS": "🎉 Скидка {percent}% активирована! На баланс начислено {amount}.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 <b>Скидка {percent}% активирована!</b> \n\nОна суммируется с другими скидками и автоматически применится при следующей оплате.",
+  "TEST_ACCESS_ALREADY_CONNECTED": "ℹ️ Этот сервер уже подключен к вашей подписке.",
   "ENTER_BLOCK_MINUTES": "Введите количество минут для блокировки пользователя (например, 15):",
   "LANGUAGE_SELECTION_DISABLED": "⚙️ Выбор языка временно недоступен. Используем язык по умолчанию.",
   "MARK_AS_ANSWERED": "✅ Отметить как отвеченный",
@@ -592,8 +611,8 @@
   "REPORT_CLOSE_ERROR": "❌ Не удалось закрыть отчет.",
   "SENDING_ATTACHMENTS": "📎 Отправляю вложения...",
   "SUBSCRIPTION_EXPIRED_1D": "⛔ <b>Подписка закончилась</b>\n\nДоступ был отключён {end_date}. Продлите подписку, чтобы вернуть полный доступ.\n\n💎 Стоимость продления: {price}",
-  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>Скидка {percent}% на продление</b>\n\nНажмите «Получить скидку», и мы начислим {bonus} на ваш баланс. Предложение действительно до {expires_at}.",
-  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Индивидуальная скидка {percent}%</b>\n\nПрошло {trigger_days} дней без подписки. Вернитесь — нажмите «Получить скидку», и {bonus} поступит на баланс. Предложение действительно до {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>Скидка {percent}% на продление</b>\n\nАктивируйте предложение, чтобы получить дополнительную скидку. Она суммируется с вашей промогруппой и действует до {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Индивидуальная скидка {percent}%</b>\n\nПрошло {trigger_days} дней без подписки. Вернитесь и активируйте дополнительную скидку — она суммируется с промогруппой и действует до {expires_at}.",
   "SUBSCRIPTION_EXTEND": "💎 Продлить подписку",
   "SUBSCRIPTION_HAPP_CRYPTOLINK_BLOCK": "<blockquote expandable><code>{crypto_link}</code></blockquote>",
   "SUBSCRIPTION_HAPP_LINK_PROMPT": "🔒 Ссылка на подписку создана. Нажмите кнопку \"Подключиться\" ниже, чтобы открыть её в Happ.",

app/services/monitoring_service.py

@@ -15,8 +15,10 @@ from app.config import settings
 from app.database.database import get_db
 from app.database.crud.discount_offer import (
     deactivate_expired_offers,
+    get_latest_claimed_offer_for_user,
     upsert_discount_offer,
 )
+from app.database.crud.promo_offer_log import log_promo_offer_action
 from app.database.crud.notification import (
     clear_notification_by_type,
     notification_sent,
@@ -34,12 +36,15 @@ from app.database.crud.user import (
     get_inactive_users,
     get_user_by_id,
     subtract_user_balance,
+    cleanup_expired_promo_offer_discounts,
 )
 from app.database.models import MonitoringLog, SubscriptionStatus, Subscription, User, Ticket, TicketStatus
 from app.localization.texts import get_texts
 from app.services.notification_settings_service import NotificationSettingsService
 from app.services.payment_service import PaymentService
 from app.services.subscription_service import SubscriptionService
+from app.services.promo_offer_service import promo_offer_service
+from app.utils.pricing_utils import apply_percentage_discount
 
 from app.external.remnawave_api import (
     RemnaWaveAPIError,
@@ -179,6 +184,17 @@ class MonitoringService:
                 if expired_offers:
                     logger.info(f"🧹 Деактивировано {expired_offers} просроченных скидочных предложений")
 
+                expired_active_discounts = await cleanup_expired_promo_offer_discounts(db)
+                if expired_active_discounts:
+                    logger.info(
+                        "🧹 Сброшено %s активных скидок промо-предложений с истекшим сроком",
+                        expired_active_discounts,
+                    )
+
+                cleaned_test_access = await promo_offer_service.cleanup_expired_test_access(db)
+                if cleaned_test_access:
+                    logger.info(f"🧹 Отозвано {cleaned_test_access} истекших тестовых доступов к сквадам")
+
                 await self._check_expired_subscriptions(db)
                 await self._check_expiring_subscriptions(db)
                 await self._check_trial_expiring_soon(db)
@@ -676,15 +692,15 @@ class MonitoringService:
                     if not await notification_sent(db, user.id, subscription.id, "expired_discount_wave2"):
                         percent = NotificationSettingsService.get_second_wave_discount_percent()
                         valid_hours = NotificationSettingsService.get_second_wave_valid_hours()
-                        bonus_amount = settings.PRICE_30_DAYS * percent // 100
                         offer = await upsert_discount_offer(
                             db,
                             user_id=user.id,
                             subscription_id=subscription.id,
                             notification_type="expired_discount_wave2",
                             discount_percent=percent,
-                            bonus_amount_kopeks=bonus_amount,
+                            bonus_amount_kopeks=0,
                             valid_hours=valid_hours,
+                            effect_type="percent_discount",
                         )
                         success = await self._send_expired_discount_notification(
                             user,
@@ -693,7 +709,6 @@ class MonitoringService:
                             offer.expires_at,
                             offer.id,
                             "second",
-                            bonus_amount,
                         )
                         if success:
                             await record_notification(db, user.id, subscription.id, "expired_discount_wave2")
@@ -706,15 +721,15 @@ class MonitoringService:
                         if not await notification_sent(db, user.id, subscription.id, "expired_discount_wave3"):
                             percent = NotificationSettingsService.get_third_wave_discount_percent()
                             valid_hours = NotificationSettingsService.get_third_wave_valid_hours()
-                            bonus_amount = settings.PRICE_30_DAYS * percent // 100
                             offer = await upsert_discount_offer(
                                 db,
                                 user_id=user.id,
                                 subscription_id=subscription.id,
                                 notification_type="expired_discount_wave3",
                                 discount_percent=percent,
-                                bonus_amount_kopeks=bonus_amount,
+                                bonus_amount_kopeks=0,
                                 valid_hours=valid_hours,
+                                effect_type="percent_discount",
                             )
                             success = await self._send_expired_discount_notification(
                                 user,
@@ -723,7 +738,6 @@ class MonitoringService:
                                 offer.expires_at,
                                 offer.id,
                                 "third",
-                                bonus_amount,
                                 trigger_days=trigger_days,
                             )
                             if success:
@@ -777,6 +791,85 @@ class MonitoringService:
         
         return subscriptions
     
+    @staticmethod
+    def _get_user_promo_offer_discount_percent(user: Optional[User]) -> int:
+        if not user:
+            return 0
+
+        try:
+            percent = int(getattr(user, "promo_offer_discount_percent", 0) or 0)
+        except (TypeError, ValueError):
+            return 0
+
+        expires_at = getattr(user, "promo_offer_discount_expires_at", None)
+        if expires_at and expires_at <= datetime.utcnow():
+            return 0
+
+        return max(0, min(100, percent))
+
+    @staticmethod
+    async def _consume_user_promo_offer_discount(db: AsyncSession, user: User) -> None:
+        percent = MonitoringService._get_user_promo_offer_discount_percent(user)
+        if percent <= 0:
+            return
+
+        source = getattr(user, "promo_offer_discount_source", None)
+        log_payload = {
+            "offer_id": None,
+            "percent": percent,
+            "source": source,
+            "effect_type": None,
+        }
+
+        try:
+            offer = await get_latest_claimed_offer_for_user(db, user.id, source)
+        except Exception as lookup_error:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to resolve latest claimed promo offer for user %s: %s",
+                user.id,
+                lookup_error,
+            )
+            offer = None
+
+        if offer:
+            log_payload["offer_id"] = offer.id
+            log_payload["effect_type"] = offer.effect_type
+            if not log_payload["percent"] and offer.discount_percent:
+                log_payload["percent"] = offer.discount_percent
+
+        user.promo_offer_discount_percent = 0
+        user.promo_offer_discount_source = None
+        user.promo_offer_discount_expires_at = None
+        user.updated_at = datetime.utcnow()
+
+        await db.commit()
+        await db.refresh(user)
+
+        try:
+            await log_promo_offer_action(
+                db,
+                user_id=user.id,
+                offer_id=log_payload.get("offer_id"),
+                action="consumed",
+                source=log_payload.get("source"),
+                percent=log_payload.get("percent"),
+                effect_type=log_payload.get("effect_type"),
+                details={"reason": "autopay_consumed"},
+            )
+        except Exception as log_error:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to record promo offer autopay log for user %s: %s",
+                user.id,
+                log_error,
+            )
+            try:
+                await db.rollback()
+            except Exception as rollback_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to rollback session after promo offer autopay log failure: %s",
+                    rollback_error,
+                )
+
     async def _process_autopayments(self, db: AsyncSession):
         try:
             current_time = datetime.utcnow()
@@ -809,17 +902,26 @@ class MonitoringService:
                     continue
                 
                 renewal_cost = settings.PRICE_30_DAYS
-                
+                promo_discount_percent = self._get_user_promo_offer_discount_percent(user)
+                charge_amount = renewal_cost
+                promo_discount_value = 0
+
+                if renewal_cost > 0 and promo_discount_percent > 0:
+                    charge_amount, promo_discount_value = apply_percentage_discount(
+                        renewal_cost,
+                        promo_discount_percent,
+                    )
+
                 autopay_key = f"autopay_{user.telegram_id}_{subscription.id}"
                 if autopay_key in self._notified_users:
                     continue
-                
-                if user.balance_kopeks >= renewal_cost:
+
+                if user.balance_kopeks >= charge_amount:
                     success = await subtract_user_balance(
-                        db, user, renewal_cost,
+                        db, user, charge_amount,
                         "Автопродление подписки"
                     )
-                    
+
                     if success:
                         await extend_subscription(db, subscription, 30)
                         await self.subscription_service.update_remnawave_user(
@@ -828,22 +930,30 @@ class MonitoringService:
                             reset_traffic=settings.RESET_TRAFFIC_ON_PAYMENT,
                             reset_reason="автопродление подписки",
                         )
-                        
+
+                        if promo_discount_value > 0:
+                            await self._consume_user_promo_offer_discount(db, user)
+
                         if self.bot:
-                            await self._send_autopay_success_notification(user, renewal_cost, 30)
-                        
+                            await self._send_autopay_success_notification(user, charge_amount, 30)
+
                         processed_count += 1
                         self._notified_users.add(autopay_key)
-                        logger.info(f"💳 Автопродление подписки пользователя {user.telegram_id} успешно")
+                        logger.info(
+                            "💳 Автопродление подписки пользователя %s успешно (списано %s, скидка %s%%)",
+                            user.telegram_id,
+                            charge_amount,
+                            promo_discount_percent,
+                        )
                     else:
                         failed_count += 1
                         if self.bot:
-                            await self._send_autopay_failed_notification(user, user.balance_kopeks, renewal_cost)
+                            await self._send_autopay_failed_notification(user, user.balance_kopeks, charge_amount)
                         logger.warning(f"💳 Ошибка списания средств для автопродления пользователя {user.telegram_id}")
                 else:
                     failed_count += 1
                     if self.bot:
-                        await self._send_autopay_failed_notification(user, user.balance_kopeks, renewal_cost)
+                        await self._send_autopay_failed_notification(user, user.balance_kopeks, charge_amount)
                     logger.warning(f"💳 Недостаточно средств для автопродления у пользователя {user.telegram_id}")
             
             if processed_count > 0 or failed_count > 0:
@@ -1186,7 +1296,6 @@ class MonitoringService:
         expires_at: datetime,
         offer_id: int,
         wave: str,
-        bonus_amount: int,
         trigger_days: int = None,
     ) -> bool:
         try:
@@ -1197,8 +1306,8 @@ class MonitoringService:
                     "SUBSCRIPTION_EXPIRED_SECOND_WAVE",
                     (
                         "🔥 <b>Скидка {percent}% на продление</b>\n\n"
-                        "Нажмите «Получить скидку», и мы начислим {bonus} на баланс. "
-                        "Предложение действует до {expires_at}."
+                        "Активируйте предложение, чтобы получить дополнительную скидку. "
+                        "Она суммируется с вашей промогруппой и действует до {expires_at}."
                     ),
                 )
             else:
@@ -1206,14 +1315,13 @@ class MonitoringService:
                     "SUBSCRIPTION_EXPIRED_THIRD_WAVE",
                     (
                         "🎁 <b>Индивидуальная скидка {percent}%</b>\n\n"
-                        "Прошло {trigger_days} дней без подписки — возвращайтесь, и мы добавим {bonus} на баланс. "
-                        "Скидка действует до {expires_at}."
+                        "Прошло {trigger_days} дней без подписки — возвращайтесь и активируйте дополнительную скидку. "
+                        "Она суммируется с промогруппой и действует до {expires_at}."
                     ),
                 )
 
             message = template.format(
                 percent=percent,
-                bonus=settings.format_price(bonus_amount),
                 expires_at=expires_at.strftime("%d.%m.%Y %H:%M"),
                 trigger_days=trigger_days or "",
             )

app/services/promo_offer_service.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import (
+    DiscountOffer,
+    Subscription,
+    SubscriptionTemporaryAccess,
+    User,
+)
+from app.services.subscription_service import SubscriptionService
+from app.database.crud.promo_offer_log import log_promo_offer_action
+
+logger = logging.getLogger(__name__)
+
+
+class PromoOfferService:
+    def __init__(self) -> None:
+        self.subscription_service = SubscriptionService()
+
+    async def grant_test_access(
+        self,
+        db: AsyncSession,
+        user: User,
+        offer: DiscountOffer,
+    ) -> Tuple[bool, Optional[List[str]], Optional[datetime], str]:
+        subscription = getattr(user, "subscription", None)
+        if not subscription:
+            return False, None, None, "subscription_missing"
+
+        payload = offer.extra_data or {}
+        raw_squads = payload.get("test_squad_uuids") or payload.get("squads") or []
+        if isinstance(raw_squads, str):
+            candidates = [raw_squads]
+        else:
+            try:
+                candidates = list(raw_squads)
+            except TypeError:
+                candidates = []
+
+        squad_uuids: Sequence[str] = [str(item) for item in candidates if item]
+        if not squad_uuids:
+            return False, None, None, "squads_missing"
+
+        squad_uuids = list(dict.fromkeys(squad_uuids))
+
+        connected = {str(item) for item in subscription.connected_squads or []}
+        if squad_uuids and set(squad_uuids).issubset(connected):
+            return False, None, None, "already_connected"
+
+        try:
+            duration_hours = int(payload.get("test_duration_hours") or payload.get("duration_hours") or 24)
+        except (TypeError, ValueError):
+            duration_hours = 24
+
+        if duration_hours <= 0:
+            duration_hours = 24
+
+        now = datetime.utcnow()
+        expires_at = now + timedelta(hours=duration_hours)
+
+        original_connected = set(connected)
+        newly_added: List[str] = []
+        changes_made = False
+
+        for squad_uuid in squad_uuids:
+            normalized_uuid = str(squad_uuid)
+            existing_result = await db.execute(
+                select(SubscriptionTemporaryAccess)
+                .where(
+                    SubscriptionTemporaryAccess.offer_id == offer.id,
+                    SubscriptionTemporaryAccess.squad_uuid == normalized_uuid,
+                )
+                .order_by(SubscriptionTemporaryAccess.id.desc())
+            )
+            existing_access = existing_result.scalars().first()
+            if existing_access and existing_access.is_active:
+                if existing_access.expires_at < expires_at:
+                    existing_access.expires_at = expires_at
+                    changes_made = True
+                continue
+
+            was_already_connected = normalized_uuid in connected
+            if not was_already_connected:
+                connected.add(normalized_uuid)
+                newly_added.append(normalized_uuid)
+                changes_made = True
+
+            access_entry = SubscriptionTemporaryAccess(
+                subscription_id=subscription.id,
+                offer_id=offer.id,
+                squad_uuid=normalized_uuid,
+                expires_at=expires_at,
+                is_active=True,
+                was_already_connected=was_already_connected,
+            )
+            db.add(access_entry)
+            changes_made = True
+
+        connected_changed = connected != original_connected
+
+        if newly_added:
+            subscription.connected_squads = list(connected)
+            subscription.updated_at = now
+            changes_made = True
+
+        if connected_changed:
+            remnawave_user = await self.subscription_service.update_remnawave_user(
+                db,
+                subscription,
+            )
+            if remnawave_user is None:
+                await db.rollback()
+                await db.refresh(subscription)
+                logger.error(
+                    "Не удалось синхронизировать временный доступ подписки %s с RemnaWave",
+                    subscription.id,
+                )
+                return False, None, None, "remnawave_sync_failed"
+
+            await db.refresh(subscription)
+        elif changes_made:
+            await db.commit()
+            await db.refresh(subscription)
+
+        return True, newly_added, expires_at, "ok"
+
+    async def cleanup_expired_test_access(self, db: AsyncSession) -> int:
+        now = datetime.utcnow()
+        result = await db.execute(
+            select(SubscriptionTemporaryAccess)
+            .options(
+                selectinload(SubscriptionTemporaryAccess.subscription),
+                selectinload(SubscriptionTemporaryAccess.offer),
+            )
+            .where(
+                SubscriptionTemporaryAccess.is_active == True,  # noqa: E712
+                SubscriptionTemporaryAccess.expires_at <= now,
+            )
+        )
+        entries = result.scalars().all()
+        if not entries:
+            return 0
+
+        subscriptions_updates: dict[int, Tuple[Subscription, set[str]]] = {}
+        log_payloads: List[Dict[str, object]] = []
+
+        for entry in entries:
+            entry.is_active = False
+            entry.deactivated_at = now
+            subscription = entry.subscription
+            if not subscription:
+                continue
+
+            bucket = subscriptions_updates.setdefault(subscription.id, (subscription, set()))
+            if not entry.was_already_connected:
+                bucket[1].add(entry.squad_uuid)
+
+            user_id = subscription.user_id
+            if user_id:
+                offer = entry.offer
+                log_payloads.append(
+                    {
+                        "user_id": user_id,
+                        "offer_id": entry.offer_id,
+                        "source": getattr(offer, "notification_type", None),
+                        "percent": getattr(offer, "discount_percent", None),
+                        "effect_type": getattr(offer, "effect_type", "test_access"),
+                        "details": {
+                            "reason": "test_access_expired",
+                            "squad_uuid": entry.squad_uuid,
+                        },
+                    }
+                )
+
+        for subscription, squads_to_remove in subscriptions_updates.values():
+            if not squads_to_remove:
+                continue
+            current = set(subscription.connected_squads or [])
+            updated = current.difference(squads_to_remove)
+            if updated != current:
+                subscription.connected_squads = list(updated)
+                subscription.updated_at = now
+                try:
+                    await self.subscription_service.update_remnawave_user(db, subscription)
+                except Exception as exc:  # pragma: no cover - defensive logging
+                    logger.error(
+                        "Ошибка обновления Remnawave при отзыве тестового доступа подписки %s: %s",
+                        subscription.id,
+                        exc,
+                    )
+
+        await db.commit()
+        for payload in log_payloads:
+            try:
+                await log_promo_offer_action(
+                    db,
+                    user_id=payload["user_id"],
+                    offer_id=payload.get("offer_id"),
+                    action="disabled",
+                    source=payload.get("source"),
+                    percent=payload.get("percent"),
+                    effect_type=payload.get("effect_type"),
+                    details=payload.get("details"),
+                )
+            except Exception as exc:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to record promo offer test access disable log for user %s: %s",
+                    payload.get("user_id"),
+                    exc,
+                )
+                try:
+                    await db.rollback()
+                except Exception as rollback_error:  # pragma: no cover - defensive logging
+                    logger.warning(
+                        "Failed to rollback session after promo offer test access log failure: %s",
+                        rollback_error,
+                    )
+        return len(entries)
+
+
+promo_offer_service = PromoOfferService()

app/services/subscription_service.py

@@ -78,31 +78,56 @@ def get_traffic_reset_strategy():
 class SubscriptionService:
 
     def __init__(self):
+        self._config_error: Optional[str] = None
+        self.api: Optional[RemnaWaveAPI] = None
+        self._last_config_signature: Optional[Tuple[str, ...]] = None
+
+        self._refresh_configuration()
+
+    def _refresh_configuration(self) -> None:
         auth_params = settings.get_remnawave_auth_params()
         base_url = (auth_params.get("base_url") or "").strip()
         api_key = (auth_params.get("api_key") or "").strip()
+        secret_key = (auth_params.get("secret_key") or "").strip() or None
+        username = (auth_params.get("username") or "").strip() or None
+        password = (auth_params.get("password") or "").strip() or None
+        auth_type = (auth_params.get("auth_type") or "").strip() or None
 
-        self._config_error: Optional[str] = None
+        config_signature = (
+            base_url,
+            api_key,
+            secret_key or "",
+            username or "",
+            password or "",
+            auth_type or "",
+        )
+
+        if config_signature == self._last_config_signature:
+            return
 
         if not base_url:
             self._config_error = "REMNAWAVE_API_URL не настроен"
+            self.api = None
         elif not api_key:
             self._config_error = "REMNAWAVE_API_KEY не настроен"
+            self.api = None
+        else:
+            self._config_error = None
+            self.api = RemnaWaveAPI(
+                base_url=base_url,
+                api_key=api_key,
+                secret_key=secret_key,
+                username=username,
+                password=password,
+            )
 
         if self._config_error:
             logger.warning(
                 "RemnaWave API недоступен: %s. Подписочный сервис будет работать в оффлайн-режиме.",
                 self._config_error
             )
-            self.api = None
-        else:
-            self.api = RemnaWaveAPI(
-                base_url=base_url,
-                api_key=api_key,
-                secret_key=auth_params.get("secret_key"),
-                username=auth_params.get("username"),
-                password=auth_params.get("password")
-            )
+
+        self._last_config_signature = config_signature
 
     @property
     def is_configured(self) -> bool:
@@ -113,6 +138,7 @@ class SubscriptionService:
         return self._config_error
 
     def _ensure_configured(self) -> None:
+        self._refresh_configuration()
         if not self.api or not self.is_configured:
             raise RemnaWaveAPIError(
                 self._config_error or "RemnaWave API не настроен"

app/states.py

@@ -97,14 +97,22 @@ class AdminStates(StatesGroup):
     editing_server_limit = State()
     editing_server_description = State()
     editing_server_promo_groups = State()
-    
+
     creating_server_uuid = State()
     creating_server_name = State()
     creating_server_price = State()
     creating_server_country = State()
-    
+
     editing_welcome_text = State()
     waiting_for_message_buttons = "waiting_for_message_buttons"
+
+    editing_promo_offer_message = State()
+    editing_promo_offer_button = State()
+    editing_promo_offer_valid_hours = State()
+    editing_promo_offer_active_duration = State()
+    editing_promo_offer_discount = State()
+    editing_promo_offer_test_duration = State()
+    editing_promo_offer_squads = State()
     
     # Состояния для отслеживания источника перехода
     viewing_user_from_balance_list = State()

app/utils/message_patch.py

@@ -1,10 +1,14 @@
 from pathlib import Path
-from aiogram.types import Message, FSInputFile, InputMediaPhoto
+from typing import Any, Dict
+
 from aiogram.exceptions import TelegramBadRequest
+from aiogram.types import FSInputFile, InputMediaPhoto, Message
 
 from app.config import settings
+from app.localization.texts import get_texts
 
 LOGO_PATH = Path(settings.LOGO_FILE)
+_PRIVACY_RESTRICTED_CODE = "BUTTON_USER_PRIVACY_RESTRICTED"
 
 
 def is_qr_message(message: Message) -> bool:
@@ -15,6 +19,65 @@ _original_answer = Message.answer
 _original_edit_text = Message.edit_text
 
 
+def _get_language(message: Message) -> str | None:
+    try:
+        user = message.from_user
+        if user and getattr(user, "language_code", None):
+            return user.language_code
+    except AttributeError:
+        pass
+    return None
+
+
+def _default_privacy_hint(language: str | None) -> str:
+    if language and language.lower().startswith("en"):
+        return (
+            "⚠️ Telegram blocked the contact request button because of your privacy settings. "
+            "Please allow sharing your contact information or send the required details manually."
+        )
+    return (
+        "⚠️ Telegram запретил кнопку запроса контакта из-за настроек приватности. "
+        "Разрешите отправку контакта в настройках Telegram или отправьте данные вручную."
+    )
+
+
+def append_privacy_hint(text: str | None, language: str | None) -> str:
+    base_text = text or ""
+    try:
+        hint = get_texts(language).t(
+            "PRIVACY_RESTRICTED_BUTTON_HINT",
+            default=_default_privacy_hint(language),
+        )
+    except Exception:
+        hint = _default_privacy_hint(language)
+
+    hint = hint.strip()
+    if not hint:
+        return base_text
+
+    if hint in base_text:
+        return base_text
+
+    if base_text:
+        return f"{base_text}\n\n{hint}"
+    return hint
+
+
+def prepare_privacy_safe_kwargs(kwargs: Dict[str, Any] | None = None) -> Dict[str, Any]:
+    safe_kwargs: Dict[str, Any] = dict(kwargs or {})
+    safe_kwargs.pop("reply_markup", None)
+    return safe_kwargs
+
+
+def is_privacy_restricted_error(error: Exception) -> bool:
+    if not isinstance(error, TelegramBadRequest):
+        return False
+
+    message = getattr(error, "message", "") or ""
+    description = str(error)
+    return _PRIVACY_RESTRICTED_CODE in message or _PRIVACY_RESTRICTED_CODE in description
+
+
 async def _answer_with_photo(self: Message, text: str = None, **kwargs):
     # Уважаем флаг в рантайме: если логотип выключен — не подменяем ответ
     if not settings.ENABLE_LOGO_MODE:
@@ -25,12 +88,20 @@ async def _answer_with_photo(self: Message, text: str = None, **kwargs):
             return await _original_answer(self, text, **kwargs)
     except Exception:
         pass
+    language = _get_language(self)
+
     if LOGO_PATH.exists():
         try:
             # Отправляем caption как есть; при ошибке парсинга ниже сработает фоллбек
             return await self.answer_photo(FSInputFile(LOGO_PATH), caption=text, **kwargs)
+        except TelegramBadRequest as error:
+            if is_privacy_restricted_error(error):
+                fallback_text = append_privacy_hint(text, language)
+                safe_kwargs = prepare_privacy_safe_kwargs(kwargs)
+                return await _original_answer(self, fallback_text, **safe_kwargs)
+            # Фоллбек, если Telegram ругается на caption или другое ограничение: отправим как текст
+            return await _original_answer(self, text, **kwargs)
         except Exception:
-            # Фоллбек, если Telegram ругается на caption: отправим как текст
             return await _original_answer(self, text, **kwargs)
     return await _original_answer(self, text, **kwargs)
 
@@ -40,6 +111,7 @@ async def _edit_with_photo(self: Message, text: str, **kwargs):
     if not settings.ENABLE_LOGO_MODE:
         return await _original_edit_text(self, text, **kwargs)
     if self.photo:
+        language = _get_language(self)
         # Если caption потенциально слишком длинный — отправим как текст вместо caption
         try:
             if text is not None and len(text) > 900:
@@ -59,14 +131,23 @@ async def _edit_with_photo(self: Message, text: str, **kwargs):
         else:
             media = self.photo[-1].file_id
         media_kwargs = {"media": media, "caption": text}
-        if "parse_mode" in kwargs:
-            _pm = kwargs.pop("parse_mode")
+        edit_kwargs = dict(kwargs)
+        if "parse_mode" in edit_kwargs:
+            _pm = edit_kwargs.pop("parse_mode")
             media_kwargs["parse_mode"] = _pm if _pm is not None else "HTML"
         else:
             media_kwargs["parse_mode"] = "HTML"
         try:
-            return await self.edit_media(InputMediaPhoto(**media_kwargs), **kwargs)
-        except TelegramBadRequest:
+            return await self.edit_media(InputMediaPhoto(**media_kwargs), **edit_kwargs)
+        except TelegramBadRequest as error:
+            if is_privacy_restricted_error(error):
+                fallback_text = append_privacy_hint(text, language)
+                safe_kwargs = prepare_privacy_safe_kwargs(kwargs)
+                try:
+                    await self.delete()
+                except Exception:
+                    pass
+                return await _original_answer(self, fallback_text, **safe_kwargs)
             # Фоллбек: удалим и отправим обычный текст без фото
             try:
                 await self.delete()

app/utils/photo_message.py

@@ -3,7 +3,13 @@ from aiogram.exceptions import TelegramBadRequest
 from aiogram.types import FSInputFile, InputMediaPhoto
 
 from app.config import settings
-from .message_patch import LOGO_PATH, is_qr_message
+from .message_patch import (
+    LOGO_PATH,
+    append_privacy_hint,
+    is_privacy_restricted_error,
+    is_qr_message,
+    prepare_privacy_safe_kwargs,
+)
 
 
 def _resolve_media(message: types.Message):
@@ -17,35 +23,69 @@ def _resolve_media(message: types.Message):
     return FSInputFile(LOGO_PATH)
 
 
+def _get_language(callback: types.CallbackQuery) -> str | None:
+    try:
+        user = callback.from_user
+        if user and getattr(user, "language_code", None):
+            return user.language_code
+    except AttributeError:
+        pass
+    return None
+
+
+def _build_base_kwargs(keyboard: types.InlineKeyboardMarkup | None, parse_mode: str | None):
+    kwargs: dict[str, object] = {}
+    if parse_mode is not None:
+        kwargs["parse_mode"] = parse_mode
+    if keyboard is not None:
+        kwargs["reply_markup"] = keyboard
+    return kwargs
+
+
+async def _answer_text(
+    callback: types.CallbackQuery,
+    caption: str,
+    keyboard: types.InlineKeyboardMarkup | None,
+    parse_mode: str | None,
+    error: TelegramBadRequest | None = None,
+) -> None:
+    language = _get_language(callback)
+    kwargs = _build_base_kwargs(keyboard, parse_mode)
+
+    if error and is_privacy_restricted_error(error):
+        caption = append_privacy_hint(caption, language)
+        kwargs = prepare_privacy_safe_kwargs(kwargs)
+
+    kwargs.setdefault("parse_mode", parse_mode or "HTML")
+
+    await callback.message.answer(
+        caption,
+        **kwargs,
+    )
+
+
 async def edit_or_answer_photo(
     callback: types.CallbackQuery,
     caption: str,
     keyboard: types.InlineKeyboardMarkup,
     parse_mode: str | None = "HTML",
 ) -> None:
+    resolved_parse_mode = parse_mode or "HTML"
     # Если режим логотипа выключен — работаем текстом
     if not settings.ENABLE_LOGO_MODE:
         try:
             if callback.message.photo:
                 await callback.message.delete()
-                await callback.message.answer(
-                    caption,
-                    reply_markup=keyboard,
-                    parse_mode=parse_mode,
-                )
+                await _answer_text(callback, caption, keyboard, resolved_parse_mode)
             else:
                 await callback.message.edit_text(
                     caption,
                     reply_markup=keyboard,
-                    parse_mode=parse_mode,
+                    parse_mode=resolved_parse_mode,
                 )
-        except TelegramBadRequest:
+        except TelegramBadRequest as error:
             await callback.message.delete()
-            await callback.message.answer(
-                caption,
-                reply_markup=keyboard,
-                parse_mode=parse_mode,
-            )
+            await _answer_text(callback, caption, keyboard, resolved_parse_mode, error)
         return
 
     # Если текст слишком длинный для caption — отправим как текст
@@ -53,13 +93,9 @@ async def edit_or_answer_photo(
         try:
             if callback.message.photo:
                 await callback.message.delete()
-            await callback.message.answer(
-                caption,
-                reply_markup=keyboard,
-                parse_mode=parse_mode,
-            )
-        except TelegramBadRequest:
-            pass
+            await _answer_text(callback, caption, keyboard, resolved_parse_mode)
+        except TelegramBadRequest as error:
+            await _answer_text(callback, caption, keyboard, resolved_parse_mode, error)
         return
 
     media = _resolve_media(callback.message)
@@ -68,7 +104,14 @@ async def edit_or_answer_photo(
             InputMediaPhoto(media=media, caption=caption, parse_mode=(parse_mode or "HTML")),
             reply_markup=keyboard,
         )
-    except TelegramBadRequest:
+    except TelegramBadRequest as error:
+        if is_privacy_restricted_error(error):
+            try:
+                await callback.message.delete()
+            except Exception:
+                pass
+            await _answer_text(callback, caption, keyboard, resolved_parse_mode, error)
+            return
         # Фоллбек: если не удалось обновить фото — отправим текст, чтобы не упасть на лимите caption
         try:
             await callback.message.delete()
@@ -80,12 +123,10 @@ async def edit_or_answer_photo(
                 photo=media if isinstance(media, FSInputFile) else FSInputFile(LOGO_PATH),
                 caption=caption,
                 reply_markup=keyboard,
-                parse_mode=(parse_mode or "HTML"),
+                parse_mode=resolved_parse_mode,
             )
+        except TelegramBadRequest as photo_error:
+            await _answer_text(callback, caption, keyboard, resolved_parse_mode, photo_error)
         except Exception:
             # Последний фоллбек — обычный текст
-            await callback.message.answer(
-                caption,
-                reply_markup=keyboard,
-                parse_mode=(parse_mode or "HTML"),
-            )
+            await _answer_text(callback, caption, keyboard, resolved_parse_mode)

app/utils/promo_offer.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import html
+import math
+from datetime import datetime
+from typing import Optional, Sequence
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.crud.discount_offer import get_latest_claimed_offer_for_user
+from app.database.models import ServerSquad, SubscriptionTemporaryAccess, User
+
+
+def _escape_format_braces(text: str) -> str:
+    """Escape braces so str.format treats them as literals."""
+
+    return text.replace("{", "{{").replace("}", "}}")
+
+
+def get_user_active_promo_discount_percent(user: Optional[User]) -> int:
+    if not user:
+        return 0
+
+    try:
+        percent = int(getattr(user, "promo_offer_discount_percent", 0) or 0)
+    except (TypeError, ValueError):
+        return 0
+
+    expires_at = getattr(user, "promo_offer_discount_expires_at", None)
+    if expires_at and expires_at <= datetime.utcnow():
+        return 0
+
+    return max(0, min(100, percent))
+
+
+def _format_time_left(seconds_left: int, language: str) -> str:
+    total_minutes = max(1, math.ceil(seconds_left / 60))
+    days, remainder_minutes = divmod(total_minutes, 60 * 24)
+    hours, minutes = divmod(remainder_minutes, 60)
+
+    language_code = (language or "ru").split("-")[0].lower()
+    if language_code == "en":
+        day_label, hour_label, minute_label = "d", "h", "m"
+    else:
+        day_label, hour_label, minute_label = "д", "ч", "м"
+
+    parts: list[str] = []
+    if days:
+        parts.append(f"{days}{day_label}")
+    if hours or days:
+        parts.append(f"{hours}{hour_label}")
+    parts.append(f"{minutes}{minute_label}")
+    return " ".join(parts)
+
+
+def _build_progress_bar(seconds_left: int, total_seconds: int) -> str:
+    if total_seconds <= 0:
+        total_seconds = seconds_left or 1
+
+    ratio = max(0.0, min(1.0, seconds_left / total_seconds))
+    bar_length = 10
+    filled_segments = int(round(ratio * bar_length))
+    filled_segments = max(0, min(bar_length, filled_segments))
+    if filled_segments == 0 and seconds_left > 0:
+        filled_segments = 1
+
+    return f"[{'█' * filled_segments}{'░' * (bar_length - filled_segments)}]"
+
+
+async def build_promo_offer_timer_line(
+    db: AsyncSession,
+    user: User,
+    texts,
+) -> Optional[str]:
+    expires_at = getattr(user, "promo_offer_discount_expires_at", None)
+    if not expires_at:
+        return None
+
+    now = datetime.utcnow()
+    if expires_at <= now:
+        return None
+
+    seconds_left = int((expires_at - now).total_seconds())
+    if seconds_left <= 0:
+        return None
+
+    total_seconds: Optional[int] = None
+    source = getattr(user, "promo_offer_discount_source", None)
+
+    try:
+        offer = await get_latest_claimed_offer_for_user(db, user.id, source)
+    except Exception:
+        offer = None
+
+    if offer and getattr(offer, "claimed_at", None):
+        total_seconds = int((expires_at - offer.claimed_at).total_seconds())
+        if total_seconds <= 0:
+            total_seconds = None
+
+    if total_seconds is None and offer:
+        extra_data = getattr(offer, "extra_data", None)
+        if isinstance(extra_data, dict):
+            raw_duration = (
+                extra_data.get("active_discount_hours")
+                or extra_data.get("duration_hours")
+            )
+        else:
+            raw_duration = None
+        try:
+            if raw_duration:
+                total_seconds = int(float(raw_duration) * 3600)
+        except (TypeError, ValueError):
+            total_seconds = None
+
+    if total_seconds is None or total_seconds <= 0:
+        total_seconds = seconds_left
+
+    bar = _build_progress_bar(seconds_left, total_seconds)
+    time_left_text = _format_time_left(seconds_left, getattr(texts, "language", "ru"))
+
+    template = texts.t(
+        "SUBSCRIPTION_PROMO_DISCOUNT_TIMER",
+        "⏳ Discount active for {time_left}\n<code>{bar}</code>",
+    )
+    return template.format(bar=bar, time_left=time_left_text)
+
+
+async def build_promo_offer_hint(
+    db: AsyncSession,
+    user: User,
+    texts,
+    percent: Optional[int] = None,
+) -> Optional[str]:
+    if percent is None:
+        percent = get_user_active_promo_discount_percent(user)
+
+    if percent <= 0:
+        return None
+
+    base_hint = texts.t(
+        "SUBSCRIPTION_PROMO_DISCOUNT_HINT",
+        "⚡ Extra {percent}% discount is active and will apply automatically. It stacks with other discounts.",
+    ).format(percent=percent)
+
+    timer_line = await build_promo_offer_timer_line(db, user, texts)
+    if timer_line:
+        return f"{base_hint}\n{timer_line}"
+
+    return base_hint
+
+
+async def build_test_access_hint(
+    db: AsyncSession,
+    user: User,
+    texts,
+) -> Optional[str]:
+    subscription = getattr(user, "subscription", None)
+    if not subscription:
+        return None
+
+    subscription_id = getattr(subscription, "id", None)
+    if not subscription_id:
+        return None
+
+    now = datetime.utcnow()
+
+    result = await db.execute(
+        select(SubscriptionTemporaryAccess)
+        .options(selectinload(SubscriptionTemporaryAccess.offer))
+        .where(
+            SubscriptionTemporaryAccess.subscription_id == subscription_id,
+            SubscriptionTemporaryAccess.is_active == True,  # noqa: E712
+            SubscriptionTemporaryAccess.expires_at > now,
+        )
+        .order_by(SubscriptionTemporaryAccess.expires_at.desc())
+    )
+    entries: Sequence[SubscriptionTemporaryAccess] = result.scalars().all()
+
+    active_entries = [
+        entry for entry in entries if entry.expires_at and entry.expires_at > now
+    ]
+    if not active_entries:
+        return None
+
+    latest_expiry = max(entry.expires_at for entry in active_entries)
+    seconds_left = int((latest_expiry - now).total_seconds())
+    if seconds_left <= 0:
+        return None
+
+    total_seconds: Optional[int] = None
+    for entry in active_entries:
+        offer = entry.offer
+        claimed_at = getattr(offer, "claimed_at", None) if offer else None
+        if claimed_at:
+            total = int((entry.expires_at - claimed_at).total_seconds())
+            if total > 0 and (total_seconds is None or total > total_seconds):
+                total_seconds = total
+
+    if total_seconds is None or total_seconds <= 0:
+        total_seconds = seconds_left
+
+    bar = _build_progress_bar(seconds_left, total_seconds)
+    time_left_text = _format_time_left(seconds_left, getattr(texts, "language", "ru"))
+
+    unique_squad_uuids: list[str] = []
+    seen_squads: set[str] = set()
+    for entry in active_entries:
+        squad_uuid = getattr(entry, "squad_uuid", None)
+        if squad_uuid and squad_uuid not in seen_squads:
+            seen_squads.add(squad_uuid)
+            unique_squad_uuids.append(squad_uuid)
+
+    squad_display_names: list[str] = []
+    if unique_squad_uuids:
+        squads_result = await db.execute(
+            select(ServerSquad.squad_uuid, ServerSquad.display_name).where(
+                ServerSquad.squad_uuid.in_(unique_squad_uuids)
+            )
+        )
+        names_map = {
+            squad_uuid: html.escape(display_name)
+            for squad_uuid, display_name in squads_result.all()
+            if display_name
+        }
+        for squad_uuid in unique_squad_uuids:
+            if squad_uuid in names_map:
+                squad_display_names.append(names_map[squad_uuid])
+            else:
+                squad_display_names.append(html.escape(squad_uuid))
+
+    if squad_display_names:
+        servers_display = ", ".join(squad_display_names)
+    elif unique_squad_uuids:
+        servers_display = ", ".join(
+            html.escape(squad_uuid) for squad_uuid in unique_squad_uuids
+        )
+    else:
+        servers_display = str(len(active_entries))
+
+    header_template = texts.t(
+        "MAIN_MENU_TEST_ACCESS_HEADER",
+        "🧪 Test servers active: {servers}",
+    )
+    timer_template = texts.t(
+        "MAIN_MENU_TEST_ACCESS_TIMER",
+        "⏳ Access active for {time_left}\n<code>{bar}</code>",
+    )
+
+    header = header_template.format(
+        servers=_escape_format_braces(servers_display)
+    )
+    timer_line = timer_template.format(time_left=time_left_text, bar=bar)
+
+    return f"{header}\n{timer_line}"

locales/en.json

@@ -55,6 +55,8 @@
   "LOADING": "⏳ Loading...",
   "MAIN_MENU": "👤 <b>{user_name}</b>\n\n📱 <b>Subscription:</b> {subscription_status}\n\nChoose an option:\n",
   "MAIN_MENU_ACTION_PROMPT": "Choose an option:",
+  "MAIN_MENU_TEST_ACCESS_HEADER": "🧪 Test servers active: {servers}",
+  "MAIN_MENU_TEST_ACCESS_TIMER": "⏳ Access active for {time_left}\n<code>{bar}</code>",
   "MAIN_MENU_BUTTON": "🏠 Main menu",
   "MANAGE_DEVICES_BUTTON": "🔧 Manage devices",
   "MENU_BALANCE": "💰 Balance",
@@ -527,14 +529,26 @@
   "TRIAL_INACTIVE_1H": "⏳ <b>An hour has passed and we haven't seen any traffic yet</b>\n\nOpen the connection guide and follow the steps. We're always ready to help!",
   "TRIAL_INACTIVE_24H": "⏳ <b>A full day passed without activity</b>\n\nWe still don't see traffic from your test subscription. Use the guide or message support and we'll help you connect!",
   "SUBSCRIPTION_EXPIRED_1D": "⛔ <b>Your subscription expired</b>\n\nAccess was disabled on {end_date}. Renew to return to the service.\n\n💎 Renewal price: {price}",
-  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>{percent}% discount on renewal</b>\n\nTap “Get discount” and we'll add {bonus} to your balance. The offer is valid until {expires_at}.",
-  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Personal {percent}% discount</b>\n\nIt's been {trigger_days} days without a subscription. Come back — tap “Get discount” and {bonus} will be credited. Offer valid until {expires_at}.",
-  "DISCOUNT_CLAIM_SUCCESS": "🎉 Discount of {percent}% activated! {amount} credited to your balance.",
+  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>{percent}% discount on renewal</b>\n\nActivate the offer to get an additional discount. It stacks with your promo group and is valid until {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Personal {percent}% discount</b>\n\nIt's been {trigger_days} days without a subscription. Come back and activate the extra discount — it stacks with your promo group and is valid until {expires_at}.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 Discount of {percent}% activated! It stacks with other discounts and will apply automatically to your next payment.",
   "DISCOUNT_CLAIM_ALREADY": "ℹ️ This discount has already been activated.",
   "DISCOUNT_CLAIM_EXPIRED": "⚠️ The offer has expired.",
   "DISCOUNT_CLAIM_NOT_FOUND": "❌ Offer not found.",
-  "DISCOUNT_CLAIM_ERROR": "❌ Failed to credit the discount. Please try again later.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Failed to activate the discount. Please try again later.",
+  "PROMO_OFFER_CLOSE": "❌ Close",
+  "TEST_ACCESS_NO_SUBSCRIPTION": "❌ You need an active subscription to use this offer.",
+  "TEST_ACCESS_NO_SQUADS": "❌ Unable to determine servers for the test access. Please contact support.",
+  "TEST_ACCESS_REMNAWAVE_ERROR": "❌ Failed to connect the servers. Please try again later or contact support.",
+  "TEST_ACCESS_UNKNOWN_ERROR": "❌ Failed to activate the offer. Please try again later.",
+  "TEST_ACCESS_ALREADY_CONNECTED": "ℹ️ This server is already connected to your subscription.",
+  "TEST_ACCESS_ACTIVATED_MESSAGE": "🎉 Test servers are connected! Access is active until {expires_at}.",
+  "TEST_ACCESS_ACTIVATED_POPUP": "✅ Access granted!",
   "DISCOUNT_BONUS_DESCRIPTION": "Renewal discount bonus",
+  "SUBSCRIPTION_SUMMARY_PROMO_DISCOUNT": "- Promo offer: -{amount} ({percent}% extra)",
+  "SUBSCRIPTION_PROMO_DISCOUNT_NOTE": "⚡ Extra discount {percent}%: -{amount}",
+  "SUBSCRIPTION_PROMO_DISCOUNT_HINT": "⚡ Extra {percent}% discount is active and will apply automatically. It stacks with other discounts.",
+  "SUBSCRIPTION_PROMO_DISCOUNT_TIMER": "⏳ Discount active for {time_left}\n<code>{bar}</code>",
   "NOTIFICATION_VALUE_INVALID": "❌ Invalid value, please enter a number.",
   "NOTIFICATION_VALUE_UPDATED": "✅ Settings updated.",
   "NOTIFY_PROMPT_SECOND_PERCENT": "Enter a new discount percentage for the 2-3 day reminder (0-100):",
@@ -557,6 +571,70 @@
   "ADMIN_SUBMENU_SELECT_SECTION": "Choose a section:",
   "ADMIN_COMMUNICATIONS_WELCOME_TEXT": "👋 Welcome message",
   "ADMIN_COMMUNICATIONS_MENU_MESSAGES": "📢 Menu messages",
+  "ADMIN_COMMUNICATIONS_PROMO_OFFERS": "🎯 Promo offers",
+  "ADMIN_PROMO_OFFERS_TITLE": "🎯 <b>Promo offers</b>\n\nSelect a template to configure:",
+  "ADMIN_PROMO_OFFER_TEST_ACCESS": "Test servers",
+  "ADMIN_PROMO_OFFER_EXTEND": "Renewal discount",
+  "ADMIN_PROMO_OFFER_PURCHASE": "Purchase discount",
+  "ADMIN_PROMO_OFFER_TYPE": "Type: {label}",
+  "ADMIN_PROMO_OFFER_VALID": "Validity: {hours} h",
+  "ADMIN_PROMO_OFFER_DISCOUNT": "Extra discount: {percent}% (stacks with other discounts)",
+  "ADMIN_PROMO_OFFER_STACKABLE_NOTE": "The discount applies once and stacks with the promo group.",
+  "ADMIN_PROMO_OFFER_ACTIVE_DURATION": "After activation the discount lasts for {hours} h.",
+  "ADMIN_PROMO_OFFER_TEST_DURATION": "Access: {hours} h",
+  "ADMIN_PROMO_OFFER_TEST_SQUAD_NAME": "Server: {name}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS": "Squads: {squads}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS_EMPTY": "Squads: not specified",
+  "ADMIN_PROMO_OFFER_ALLOWED": "Available segments:",
+  "ADMIN_PROMO_OFFER_PREVIEW": "Preview:",
+  "ADMIN_PROMO_OFFER_PROMPT_MESSAGE": "Enter the new offer text:",
+  "ADMIN_PROMO_OFFER_PROMPT_BUTTON": "Enter the button label:",
+  "ADMIN_PROMO_OFFER_PROMPT_VALID": "Enter validity (hours):",
+  "ADMIN_PROMO_OFFER_PROMPT_DISCOUNT": "Enter discount percentage:",
+  "ADMIN_PROMO_OFFER_PROMPT_ACTIVE_DURATION": "Enter how long the activated discount should remain valid (hours):",
+  "ADMIN_PROMO_OFFER_PROMPT_DURATION": "Enter test access duration (hours):",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_TITLE": "🌍 <b>Select a squad</b>",
+  "ADMIN_PROMO_OFFER_SELECTED_SQUAD": "Current squad: {name}",
+  "ADMIN_PROMO_OFFER_SELECTED_SQUAD_UUID": "Current squad: {uuid}",
+  "ADMIN_PROMO_OFFER_SELECTED_SQUAD_EMPTY": "Current squad: not selected",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_HINT": "Pick a server to grant temporary access from the list below.",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_PAGE": "Page {page}/{total}",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_CLEAR": "🗑 Clear",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_BACK": "↩️ Back",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_UPDATED": "✅ Squad updated",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_CLEARED": "✅ Squad cleared",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_NOT_FOUND": "❌ Server not found",
+  "ADMIN_PROMO_OFFER_NO_SQUADS_AVAILABLE": "❌ No servers available.",
+  "ADMIN_PROMO_OFFER_SENDING": "Starting broadcast...",
+  "ADMIN_PROMO_OFFER_NO_USERS": "No matching users found.",
+  "ADMIN_PROMO_OFFER_RESULT": "📬 Broadcast finished\nSent: {sent}\nFailed: {failed}",
+  "ADMIN_PROMO_OFFER_SKIPPED": "Skipped: {skipped} (already have access)",
+  "ADMIN_PROMO_OFFER_CTA_BUY": "Buy subscription",
+  "ADMIN_PROMO_OFFER_CTA_EXTEND": "Extend subscription",
+  "ADMIN_PROMO_OFFER_BACK_TO_TEMPLATE": "↩️ Back to offer",
+  "ADMIN_PROMO_OFFER_BACK_TO_LIST": "⬅️ Back to promo offers",
+  "ADMIN_PROMO_OFFER_LOGS": "📜 Activity log",
+  "ADMIN_PROMO_OFFER_LOGS_TITLE": "📜 <b>Promo offer activity log</b>",
+  "ADMIN_PROMO_OFFER_LOGS_PAGINATION": "Page {page}/{total}",
+  "ADMIN_PROMO_OFFER_LOGS_EMPTY_BODY": "No activity yet.",
+  "ADMIN_PROMO_OFFER_LOGS_UNKNOWN_USER": "Unknown user",
+  "ADMIN_PROMO_OFFER_LOGS_USER": "👤 {user}",
+  "ADMIN_PROMO_OFFER_LOGS_PERCENT": "📉 Discount: {percent}%",
+  "ADMIN_PROMO_OFFER_LOGS_EFFECT_TEST": "🧪 Test access",
+  "ADMIN_PROMO_OFFER_LOGS_EFFECT_DISCOUNT": "💸 Discount",
+  "ADMIN_PROMO_OFFER_LOGS_SOURCE": "🏷 Source: {source}",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_GENERIC": "ℹ️ Action: {reason}",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_MANUAL": "💳 Applied during manual payment",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_AUTOPAY": "🤖 Used in autopay renewal",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_EXPIRED": "⏳ Offer expired",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_TEST_EXPIRED": "⏳ Test access removed",
+  "ADMIN_PROMO_OFFER_LOGS_DESCRIPTION": "📝 {description}",
+  "ADMIN_PROMO_OFFER_LOGS_AMOUNT": "💰 Amount: {amount}",
+  "ADMIN_PROMO_OFFER_LOGS_SQUAD": "🌍 Squad: {squad}",
+  "ADMIN_PROMO_OFFER_LOGS_NEW_SQUADS": "🌍 New squads: {squads}",
+  "ADMIN_PROMO_OFFER_LOGS_ACTION_CLAIMED": "Claimed",
+  "ADMIN_PROMO_OFFER_LOGS_ACTION_CONSUMED": "Used",
+  "ADMIN_PROMO_OFFER_LOGS_ACTION_DISABLED": "Disabled",
   "ADMIN_SUPPORT_TICKETS": "🎫 Support tickets",
   "ADMIN_SUPPORT_AUDIT": "🧾 Moderator audit",
   "ADMIN_SUPPORT_SETTINGS": "🛟 Support settings",

locales/ru.json

@@ -235,6 +235,8 @@
   "MAINTENANCE_MODE_API_ERROR": "\n🔧 Технические работы!\n\nСервис временно недоступен из-за проблем с подключением к серверам.\n\n⏰ Мы работаем над восстановлением. Попробуйте через несколько минут.\n\n🔄 Последняя проверка: {last_check}\n",
   "MAIN_MENU": "👤 <b>{user_name}</b>\n    \n📱 <b>Подписка:</b> {subscription_status}\n\nВыберите действие:\n",
   "MAIN_MENU_ACTION_PROMPT": "Выберите действие:",
+  "MAIN_MENU_TEST_ACCESS_HEADER": "🧪 Тестовые сервера активны: {servers}",
+  "MAIN_MENU_TEST_ACCESS_TIMER": "⏳ Доступ действует ещё: {time_left}\n<code>{bar}</code>",
   "MAIN_MENU_BUTTON": "🏠 Главное меню",
   "MANAGE_DEVICES_BUTTON": "🔧 Управление устройствами",
   "MENU_ADMIN": "⚙️ Админ-панель",
@@ -527,14 +529,26 @@
   "TRIAL_INACTIVE_1H": "⏳ <b>Прошёл час, а подключение не выполнено</b>\n\nЕсли возникли сложности — откройте инструкцию и следуйте шагам. Мы всегда готовы помочь!",
   "TRIAL_INACTIVE_24H": "⏳ <b>Прошли сутки с начала теста</b>\n\nМы не видим трафика по вашей подписке. Загляните в инструкцию или напишите в поддержку — поможем подключиться!",
   "SUBSCRIPTION_EXPIRED_1D": "⛔ <b>Подписка закончилась</b>\n\nДоступ был отключён {end_date}. Продлите подписку, чтобы вернуть полный доступ.\n\n💎 Стоимость продления: {price}",
-  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>Скидка {percent}% на продление</b>\n\nНажмите «Получить скидку», и мы начислим {bonus} на ваш баланс. Предложение действительно до {expires_at}.",
-  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Индивидуальная скидка {percent}%</b>\n\nПрошло {trigger_days} дней без подписки. Вернитесь — нажмите «Получить скидку», и {bonus} поступит на баланс. Предложение действительно до {expires_at}.",
-  "DISCOUNT_CLAIM_SUCCESS": "🎉 Скидка {percent}% активирована! На баланс начислено {amount}.",
+  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>Скидка {percent}% на продление</b>\n\nАктивируйте предложение, чтобы получить дополнительную скидку. Она суммируется с вашей промогруппой и действует до {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Индивидуальная скидка {percent}%</b>\n\nПрошло {trigger_days} дней без подписки. Вернитесь и активируйте дополнительную скидку — она суммируется с промогруппой и действует до {expires_at}.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 <b>Скидка {percent}% активирована!</b> \n\nОна суммируется с другими скидками и автоматически применится при следующей оплате.",
   "DISCOUNT_CLAIM_ALREADY": "ℹ️ Скидка уже была активирована ранее.",
   "DISCOUNT_CLAIM_EXPIRED": "⚠️ Время действия предложения истекло.",
   "DISCOUNT_CLAIM_NOT_FOUND": "❌ Предложение не найдено.",
-  "DISCOUNT_CLAIM_ERROR": "❌ Не удалось начислить скидку. Попробуйте позже.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Не удалось активировать скидку. Попробуйте позже.",
+  "PROMO_OFFER_CLOSE": "❌ Закрыть",
+  "TEST_ACCESS_NO_SUBSCRIPTION": "❌ Для активации предложения необходима действующая подписка.",
+  "TEST_ACCESS_NO_SQUADS": "❌ Не удалось определить список серверов для теста. Обратитесь к администратору.",
+  "TEST_ACCESS_REMNAWAVE_ERROR": "❌ Не удалось подключить серверы. Попробуйте позже или обратитесь в поддержку.",
+  "TEST_ACCESS_UNKNOWN_ERROR": "❌ Не удалось активировать предложение. Попробуйте позже.",
+  "TEST_ACCESS_ALREADY_CONNECTED": "ℹ️ Этот сервер уже подключен к вашей подписке.",
+  "TEST_ACCESS_ACTIVATED_MESSAGE": "🎉 Тестовые сервера подключены! Доступ активен до {expires_at}.",
+  "TEST_ACCESS_ACTIVATED_POPUP": "✅ Доступ выдан!",
   "DISCOUNT_BONUS_DESCRIPTION": "Скидка за продление подписки",
+  "SUBSCRIPTION_SUMMARY_PROMO_DISCOUNT": "- Промо-предложение: -{amount} ({percent}% дополнительно)",
+  "SUBSCRIPTION_PROMO_DISCOUNT_NOTE": "⚡ Доп. скидка {percent}%: -{amount}",
+  "SUBSCRIPTION_PROMO_DISCOUNT_HINT": "⚡ Активирована доп. скидка {percent}%. \n\nСуммируется с другими скидками!",
+  "SUBSCRIPTION_PROMO_DISCOUNT_TIMER": "⏳ Скидка действует ещё: {time_left}\n<code>{bar}</code>",
   "NOTIFICATION_VALUE_INVALID": "❌ Некорректное значение, укажите число.",
   "NOTIFICATION_VALUE_UPDATED": "✅ Настройки обновлены.",
   "NOTIFY_PROMPT_SECOND_PERCENT": "Введите новый процент скидки для уведомления через 2-3 дня (0-100):",
@@ -557,6 +571,70 @@
   "ADMIN_SUBMENU_SELECT_SECTION": "Выберите нужный раздел:",
   "ADMIN_COMMUNICATIONS_WELCOME_TEXT": "👋 Приветственный текст",
   "ADMIN_COMMUNICATIONS_MENU_MESSAGES": "📢 Сообщения в меню",
+  "ADMIN_COMMUNICATIONS_PROMO_OFFERS": "🎯 Промо-предложения",
+  "ADMIN_PROMO_OFFERS_TITLE": "🎯 <b>Промо-предложения</b>\n\nВыберите предложение для настройки:",
+  "ADMIN_PROMO_OFFER_TEST_ACCESS": "Тестовые сервера",
+  "ADMIN_PROMO_OFFER_EXTEND": "Скидка на продление",
+  "ADMIN_PROMO_OFFER_PURCHASE": "Скидка на покупку",
+  "ADMIN_PROMO_OFFER_TYPE": "Тип: {label}",
+  "ADMIN_PROMO_OFFER_VALID": "Срок действия: {hours} ч",
+  "ADMIN_PROMO_OFFER_DISCOUNT": "Доп. скидка: {percent}% (суммируется с другими скидками)",
+  "ADMIN_PROMO_OFFER_STACKABLE_NOTE": "Скидка применяется один раз и добавляется к промогруппе.",
+  "ADMIN_PROMO_OFFER_ACTIVE_DURATION": "Скидка после активации действует {hours} ч.",
+  "ADMIN_PROMO_OFFER_TEST_DURATION": "Доступ: {hours} ч",
+  "ADMIN_PROMO_OFFER_TEST_SQUAD_NAME": "Сервер: {name}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS": "Сквады: {squads}",
+  "ADMIN_PROMO_OFFER_TEST_SQUADS_EMPTY": "Сквады: не указаны",
+  "ADMIN_PROMO_OFFER_ALLOWED": "Доступные категории:",
+  "ADMIN_PROMO_OFFER_PREVIEW": "Предпросмотр:",
+  "ADMIN_PROMO_OFFER_PROMPT_MESSAGE": "Введите новый текст предложения:",
+  "ADMIN_PROMO_OFFER_PROMPT_BUTTON": "Введите новый текст кнопки:",
+  "ADMIN_PROMO_OFFER_PROMPT_VALID": "Укажите срок действия (в часах):",
+  "ADMIN_PROMO_OFFER_PROMPT_DISCOUNT": "Введите размер скидки в процентах:",
+  "ADMIN_PROMO_OFFER_PROMPT_ACTIVE_DURATION": "Укажите срок действия активированной скидки (в часах):",
+  "ADMIN_PROMO_OFFER_PROMPT_DURATION": "Введите длительность тестового доступа (в часах):",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_TITLE": "🌍 <b>Выберите сквад</b>",
+  "ADMIN_PROMO_OFFER_SELECTED_SQUAD": "Текущий сквад: {name}",
+  "ADMIN_PROMO_OFFER_SELECTED_SQUAD_UUID": "Текущий сквад: {uuid}",
+  "ADMIN_PROMO_OFFER_SELECTED_SQUAD_EMPTY": "Текущий сквад: не выбран",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_HINT": "Выберите сервер для тестового доступа из списка ниже.",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_PAGE": "Страница {page}/{total}",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_CLEAR": "🗑 Очистить",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_BACK": "↩️ Назад",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_UPDATED": "✅ Сквад обновлён",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_CLEARED": "✅ Сквад очищен",
+  "ADMIN_PROMO_OFFER_SELECT_SQUAD_NOT_FOUND": "❌ Сервер не найден",
+  "ADMIN_PROMO_OFFER_NO_SQUADS_AVAILABLE": "❌ Доступные серверы не найдены.",
+  "ADMIN_PROMO_OFFER_SENDING": "Начинаем рассылку...",
+  "ADMIN_PROMO_OFFER_NO_USERS": "Подходящих пользователей не найдено.",
+  "ADMIN_PROMO_OFFER_RESULT": "📬 Рассылка завершена\nОтправлено: {sent}\nОшибок: {failed}",
+  "ADMIN_PROMO_OFFER_SKIPPED": "Пропущено: {skipped} (уже есть доступ)",
+  "ADMIN_PROMO_OFFER_CTA_BUY": "Купить подписку",
+  "ADMIN_PROMO_OFFER_CTA_EXTEND": "Продлить подписку",
+  "ADMIN_PROMO_OFFER_BACK_TO_TEMPLATE": "↩️ К предложению",
+  "ADMIN_PROMO_OFFER_BACK_TO_LIST": "⬅️ К промопредложениям",
+  "ADMIN_PROMO_OFFER_LOGS": "📜 Лог операций",
+  "ADMIN_PROMO_OFFER_LOGS_TITLE": "📜 <b>Лог операций промо-предложений</b>",
+  "ADMIN_PROMO_OFFER_LOGS_PAGINATION": "Страница {page}/{total}",
+  "ADMIN_PROMO_OFFER_LOGS_EMPTY_BODY": "Записей пока нет.",
+  "ADMIN_PROMO_OFFER_LOGS_UNKNOWN_USER": "Неизвестный пользователь",
+  "ADMIN_PROMO_OFFER_LOGS_USER": "👤 {user}",
+  "ADMIN_PROMO_OFFER_LOGS_PERCENT": "📉 Скидка: {percent}%",
+  "ADMIN_PROMO_OFFER_LOGS_EFFECT_TEST": "🧪 Тестовый доступ",
+  "ADMIN_PROMO_OFFER_LOGS_EFFECT_DISCOUNT": "💸 Скидка",
+  "ADMIN_PROMO_OFFER_LOGS_SOURCE": "🏷 Источник: {source}",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_GENERIC": "ℹ️ Действие: {reason}",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_MANUAL": "💳 Списано при ручной оплате",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_AUTOPAY": "🤖 Применено при автопродлении",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_EXPIRED": "⏳ Предложение истекло",
+  "ADMIN_PROMO_OFFER_LOGS_REASON_TEST_EXPIRED": "⏳ Тестовый доступ отключён",
+  "ADMIN_PROMO_OFFER_LOGS_DESCRIPTION": "📝 {description}",
+  "ADMIN_PROMO_OFFER_LOGS_AMOUNT": "💰 Сумма: {amount}",
+  "ADMIN_PROMO_OFFER_LOGS_SQUAD": "🌍 Сквад: {squad}",
+  "ADMIN_PROMO_OFFER_LOGS_NEW_SQUADS": "🌍 Новые сквады: {squads}",
+  "ADMIN_PROMO_OFFER_LOGS_ACTION_CLAIMED": "Принято",
+  "ADMIN_PROMO_OFFER_LOGS_ACTION_CONSUMED": "Использовано",
+  "ADMIN_PROMO_OFFER_LOGS_ACTION_DISABLED": "Отключено",
   "ADMIN_SUPPORT_TICKETS": "🎫 Тикеты поддержки",
   "ADMIN_SUPPORT_AUDIT": "🧾 Аудит модераторов",
   "ADMIN_SUPPORT_SETTINGS": "🛟 Настройки поддержки",