Update Dockerfile

Update docker-registry.yml
2025-10-01 07:05:17 +03:00 · 2025-10-01 07:05:02 +03:00 · 2025-10-01 07:04:44 +03:00 · 2025-10-01 07:04:31 +03:00 · 2025-10-01 06:43:37 +03:00 · 2025-10-01 06:32:56 +03:00
134 changed files with 29358 additions and 3087 deletions
@@ -14,6 +14,11 @@ ADMIN_NOTIFICATIONS_ENABLED=true
 ADMIN_NOTIFICATIONS_CHAT_ID=-1001234567890   # Замени на ID твоего канала (-100) - ПРЕФИКС ЗАКРЫТОГО КАНАЛА! ВСТАВИТЬ СВОЙ ID СРАЗУ ПОСЛЕ (-100) БЕЗ ПРОБЕЛОВ!
 ADMIN_NOTIFICATIONS_TOPIC_ID=123             # Опционально: ID топика
 ADMIN_NOTIFICATIONS_TICKET_TOPIC_ID=126      # Опционально: ID топика для тикетов
+# Автоматические отчеты
+ADMIN_REPORTS_ENABLED=false
+ADMIN_REPORTS_CHAT_ID=                        # Опционально: чат для отчетов (по умолчанию ADMIN_NOTIFICATIONS_CHAT_ID)
+ADMIN_REPORTS_TOPIC_ID=                      # ID топика для отчетов
+ADMIN_REPORTS_SEND_TIME=10:00                # Время отправки (по МСК) ежедневного отчета
 # Обязательная подписка на канал
 CHANNEL_SUB_ID= # Опционально ID твоего канала (-100)
 CHANNEL_IS_REQUIRED_SUB=false # Обязательна ли подписка на канал
@@ -84,8 +89,13 @@ MAX_DEVICES_LIMIT=15
 # Дефолт параметры для подписок выданных через админку
 DEFAULT_TRAFFIC_LIMIT_GB=100

+# Плюсовать дни триала при покупке платной подписке 
+TRIAL_ADD_REMAINING_DAYS_TO_PAID=false
+
 # ===== ГЛОБАЛЬНЫЙ ПАРАМЕТР ДЛЯ ВСЕХ ПОДПИСОК =====
 DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+# Сбрасывать трафик при каждой оплате подписки
+RESET_TRAFFIC_ON_PAYMENT=false

 # ===== НАСТРОЙКИ ТРАФИКА =====
 # Режим выбора трафика:
@@ -221,7 +231,7 @@ PAYMENT_BALANCE_TEMPLATE={service_name} - {description}
 PAYMENT_SUBSCRIPTION_TEMPLATE={service_name} - {description}

 # CRYPTOBOT
-CRYPTOBOT_ENABLED=true
+CRYPTOBOT_ENABLED=false
 CRYPTOBOT_API_TOKEN=123456789:AAzQcZWQqQAbsfgPnOLr4FHC8Doa4L7KryC
 CRYPTOBOT_WEBHOOK_SECRET=your_webhook_secret_here
 CRYPTOBOT_BASE_URL=https://pay.crypt.bot
@@ -232,6 +242,35 @@ CRYPTOBOT_DEFAULT_ASSET=USDT
 CRYPTOBOT_ASSETS=USDT,TON,BTC,ETH,LTC,BNB,TRX,USDC
 CRYPTOBOT_INVOICE_EXPIRES_HOURS=24

+# MULENPAY
+MULENPAY_ENABLED=false
+MULENPAY_API_KEY=
+MULENPAY_SECRET_KEY=
+MULENPAY_SHOP_ID=<ID магазина>
+# необязательно, есть дефолтные значения
+MULENPAY_BASE_URL=https://mulenpay.ru/api
+MULENPAY_WEBHOOK_PATH=/mulenpay-webhook
+MULENPAY_DESCRIPTION="Пополнение баланса"
+MULENPAY_LANGUAGE=ru
+MULENPAY_VAT_CODE=0
+MULENPAY_PAYMENT_SUBJECT=4
+MULENPAY_PAYMENT_MODE=4
+MULENPAY_MIN_AMOUNT_KOPEKS=10000
+MULENPAY_MAX_AMOUNT_KOPEKS=10000000
+
+# PAYPALYCH / PAL24
+PAL24_ENABLED=false
+PAL24_API_TOKEN=
+PAL24_SHOP_ID=
+PAL24_SIGNATURE_TOKEN=
+PAL24_BASE_URL=https://pal24.pro/api/v1/
+PAL24_WEBHOOK_PATH=/pal24-webhook
+PAL24_WEBHOOK_PORT=8084
+PAL24_PAYMENT_DESCRIPTION="Пополнение баланса"
+PAL24_MIN_AMOUNT_KOPEKS=10000
+PAL24_MAX_AMOUNT_KOPEKS=100000000
+PAL24_REQUEST_TIMEOUT=30
+
 # ===== ИНТЕРФЕЙС И UX =====

 # Включить логотип для всех сообщений (true - с изображением, false - только текст)
@@ -246,10 +285,24 @@ HIDE_SUBSCRIPTION_LINK=false
 # miniapp_subscription - открывает ссылку подписки в мини-приложении (режим 2)
 # miniapp_custom - открывает заданную ссылку в мини-приложении (режим 3)
 # link - Открывает ссылку напрямую в браузере (режим 4)
+# happ_cryptolink - Вывод cryptoLink ссылки на подписку Happ (режим 5)
 CONNECT_BUTTON_MODE=guide

 # URL для режима miniapp_custom (обязателен при CONNECT_BUTTON_MODE=miniapp_custom)
 MINIAPP_CUSTOM_URL=
+MINIAPP_SERVICE_NAME_EN=Bedolaga VPN
+MINIAPP_SERVICE_NAME_RU=Bedolaga VPN
+MINIAPP_SERVICE_DESCRIPTION_EN=Secure & Fast Connection
+MINIAPP_SERVICE_DESCRIPTION_RU=Безопасное и быстрое подключение
+
+# Параметры режима happ_cryptolink
+CONNECT_BUTTON_HAPP_DOWNLOAD_ENABLED=false
+HAPP_DOWNLOAD_LINK_IOS=
+HAPP_DOWNLOAD_LINK_ANDROID=
+HAPP_DOWNLOAD_LINK_MACOS=
+HAPP_DOWNLOAD_LINK_WINDOWS=
+# Кнопка (Подключится) с редиректом (тк ссылки с happ:// тг не поддерживает) - Без установленной ссылки на редирект кнопки (подключится) не будет! Пример: https://sub.domain.sub/redirect-page/?redirect_to=
+HAPP_CRYPTOLINK_REDIRECT_TEMPLATE=

 # Пропустить принятие правил использования бота
 SKIP_RULES_ACCEPT=false
@@ -268,9 +321,9 @@ MONITORING_LOGS_RETENTION_DAYS=30
 NOTIFICATION_CACHE_HOURS=24

 # ===== СТАТУС СЕРВЕРОВ =====
-# Режимы: disabled, external_link, xray
+# Режимы: disabled, external_link, external_link_miniapp, xray
 SERVER_STATUS_MODE=disabled
-# Ссылка на внешний мониторинг (для режима external_link)
+# Ссылка на внешний мониторинг (для режимов external_link и external_link_miniapp)
 SERVER_STATUS_EXTERNAL_URL=
 # URL метрик XrayChecker (для режима xray)
 SERVER_STATUS_METRICS_URL=
@@ -294,6 +347,8 @@ MAINTENANCE_MESSAGE=Ведутся технические работы. Серв
 # Укажите язык из AVAILABLE_LANGUAGES. При некорректном значении используется ru.
 DEFAULT_LANGUAGE=ru
 AVAILABLE_LANGUAGES=ru,en
+# Включить выбор языка при старте и отображение кнопки в меню
+LANGUAGE_SELECTION_ENABLED=true

 # ===== ДОПОЛНИТЕЛЬНЫЕ НАСТРОЙКИ =====
 # Конфигурация приложений для гайда подключения
@@ -330,4 +385,4 @@ LOG_FILE=logs/bot.log
 # ===== РАЗРАБОТКА =====
 DEBUG=false
 WEBHOOK_URL=
-WEBHOOK_PATH=/webhook
+WEBHOOK_PATH=/webhook
@@ -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.3.8-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.2-$(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.3.8-dev-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.2-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.3.8-pr-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.2-pr-$(git rev-parse --short HEAD)"
          TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:pr-$(git rev-parse --short HEAD)"
          echo "🔀 Собираем PR версию: $VERSION"
        fi
@@ -49,13 +49,13 @@ jobs:
            VERSION=${GITHUB_REF#refs/tags/}
            echo "🏷️ Building release version: $VERSION"
          elif [[ $GITHUB_REF == refs/heads/main ]]; then
-            VERSION="v2.3.8-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.2-$(git rev-parse --short HEAD)"
            echo "🚀 Building main version: $VERSION"
          elif [[ $GITHUB_REF == refs/heads/dev ]]; then
-            VERSION="v2.3.8-dev-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.2-dev-$(git rev-parse --short HEAD)"
            echo "🧪 Building dev version: $VERSION"
          else
-            VERSION="v2.3.8-pr-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.2-pr-$(git rev-parse --short HEAD)"
            echo "🔀 Building PR version: $VERSION"
          fi
          echo "version=$VERSION" >> $GITHUB_OUTPUT
@@ -8,6 +8,8 @@
 !app-config.json
 !main.py
 !requirements.txt
+!docs/
+!docs/**

 # Разрешаем папку app/ и все её содержимое рекурсивно
 !app/
@@ -14,7 +14,7 @@ RUN pip install --no-cache-dir --upgrade pip && \

 FROM python:3.13-slim

-ARG VERSION="v2.3.8"
+ARG VERSION="v2.4.2"
 ARG BUILD_DATE
 ARG VCS_REF

@@ -45,7 +45,7 @@ ENV PYTHONPATH=/app \
    BUILD_DATE=${BUILD_DATE} \
    VCS_REF=${VCS_REF}

-EXPOSE 8081 8082 8083
+EXPOSE 8080 8081 8082 

 LABEL org.opencontainers.image.title="Bedolaga RemnaWave Bot" \
      org.opencontainers.image.description="Telegram bot for RemnaWave VPN service" \
@@ -35,7 +35,7 @@

 ### ⚡ **Полная автоматизация VPN бизнеса**
 - 🎯 **Готовое решение** - разверни за 5 минут, начни продавать сегодня
- 💰 **Многоканальные платежи** - Telegram Stars + Tribute + CryptoBot + ЮKassa + P2P
+- 💰 **Многоканальные платежи** - Telegram Stars + Tribute + CryptoBot + ЮKassa + MulenPay + PayPalych + P2P
 - 🔄 **Автоматизация 99%** - от регистрации до продления подписок
 - 📊 **Детальная аналитика** - полная картина вашего бизнеса
 - 💬 **Уведомления в топики** об: Активация триала 💎 Покупка подписки 🔄 Конверсия из триала в платную ⏰ Продление подписки 💰 Пополнение баланса 🚧 Включении тех работ ♻️ Появлении новой версии бота
@@ -108,12 +108,20 @@ docker compose logs
 | 🛡️ **REMNAWAVE_SECRET_KEY** | Ключ защиты панели | `secret_name:secret_value` |
 | 👑 **ADMIN_IDS** | Твой Telegram ID | `123456789,987654321` |

+### 🌐 Интеграция веб-админки
+
+Подробное пошаговое руководство по запуску административного веб-API и подключению внешней панели находится в [docs/web-admin-integration.md](docs/web-admin-integration.md).
+
+### 📱 Telegram Mini App с подпиской
+
+Инструкция по развёртыванию мини-приложения, публикации статической страницы и настройке reverse-proxy доступна в [docs/miniapp-setup.md](docs/miniapp-setup.md).
+
 ### 📊 Статус серверов в главном меню

 | Переменная | Описание | Пример |
 |------------|----------|--------|
-| `SERVER_STATUS_MODE` | Режим работы кнопки: `disabled`, `external_link` (просто ссылка) или `xray` (интеграция с XrayChecker). | `xray` |
-| `SERVER_STATUS_EXTERNAL_URL` | Прямая ссылка на внешний мониторинг (используется в режиме `external_link`). | `https://status.example.com` |
+| `SERVER_STATUS_MODE` | Режим работы кнопки: `disabled`, `external_link` (открывает ссылку в браузере), `external_link_miniapp` (открывает ссылку во встроенном мини-приложении Telegram) или `xray` (интеграция с XrayChecker). | `xray` |
+| `SERVER_STATUS_EXTERNAL_URL` | Прямая ссылка на внешний мониторинг (используется в режимах `external_link` и `external_link_miniapp`). | `https://status.example.com` |
 | `SERVER_STATUS_METRICS_URL` | URL страницы метрик XrayChecker (Prometheus формат). | `https://sub.example.com/metrics` |
 | `SERVER_STATUS_METRICS_USERNAME` / `SERVER_STATUS_METRICS_PASSWORD` | Данные Basic Auth, если страница метрик защищена паролем. | `status` / `secret` |
 | `SERVER_STATUS_ITEMS_PER_PAGE` | Количество серверов, показываемых на одной странице в режиме интеграции. | `10` |
@@ -248,11 +256,17 @@ ADMIN_IDS=
 # Ссылка на поддержку: Telegram username (например, @support) или полный URL
 SUPPORT_USERNAME=@support

+
 # Уведомления администраторов
 ADMIN_NOTIFICATIONS_ENABLED=true
 ADMIN_NOTIFICATIONS_CHAT_ID=-1001234567890   # Замени на ID твоего канала (-100) - ПРЕФИКС ЗАКРЫТОГО КАНАЛА! ВСТАВИТЬ СВОЙ ID СРАЗУ ПОСЛЕ (-100) БЕЗ ПРОБЕЛОВ!
 ADMIN_NOTIFICATIONS_TOPIC_ID=123             # Опционально: ID топика
-
+ADMIN_NOTIFICATIONS_TICKET_TOPIC_ID=126      # Опционально: ID топика для тикетов
+# Автоматические отчеты
+ADMIN_REPORTS_ENABLED=false
+ADMIN_REPORTS_CHAT_ID=                        # Опционально: чат для отчетов (по умолчанию ADMIN_NOTIFICATIONS_CHAT_ID)
+ADMIN_REPORTS_TOPIC_ID=                      # ID топика для отчетов
+ADMIN_REPORTS_SEND_TIME=10:00                # Время отправки (по МСК) ежедневного отчета
 # Обязательная подписка на канал
 CHANNEL_SUB_ID= # Опционально ID твоего канала (-100)
 CHANNEL_IS_REQUIRED_SUB=false # Обязательна ли подписка на канал
@@ -274,6 +288,7 @@ POSTGRES_PASSWORD=secure_password_123

 # SQLite настройки (для локального запуска)
 SQLITE_PATH=./data/bot.db
+LOCALES_PATH=./locales

 # Redis
 REDIS_URL=redis://redis:6379/0
@@ -300,6 +315,11 @@ REMNAWAVE_SECRET_KEY=
 #   {telegram_id}       — ID Telegram
 REMNAWAVE_USER_DESCRIPTION_TEMPLATE="Bot user: {full_name} {username}"

+# Режим удаления пользователей из панели RemnaWave
+# delete - полностью удалить пользователя из панели
+# disable - только деактивировать пользователя
+REMNAWAVE_USER_DELETE_MODE=delete
+
 # ========= ПОДПИСКИ =========
 # ===== ТРИАЛ ПОДПИСКА =====
 TRIAL_DURATION_DAYS=3
@@ -319,6 +339,8 @@ DEFAULT_TRAFFIC_LIMIT_GB=100

 # ===== ГЛОБАЛЬНЫЙ ПАРАМЕТР ДЛЯ ВСЕХ ПОДПИСОК =====
 DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+# Сбрасывать трафик при каждой оплате подписки
+RESET_TRAFFIC_ON_PAYMENT=false

 # ===== НАСТРОЙКИ ТРАФИКА =====
 # Режим выбора трафика:
@@ -437,6 +459,13 @@ YOOKASSA_WEBHOOK_PATH=/yookassa-webhook
 YOOKASSA_WEBHOOK_PORT=8082
 YOOKASSA_WEBHOOK_SECRET=your_webhook_secret

+# Лимиты сумм пополнения через YooKassa (в копейках)
+YOOKASSA_MIN_AMOUNT_KOPEKS=5000
+YOOKASSA_MAX_AMOUNT_KOPEKS=1000000
+
+# Быстрый выбор суммы пополнения через YooKassa
+YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED=true
+
 # ===== НАСТРОЙКИ ОПИСАНИЙ ПЛАТЕЖЕЙ =====
 # Эти настройки позволяют изменить описания платежей, 
 # чтобы избежать блокировок платежных систем
@@ -447,7 +476,7 @@ PAYMENT_BALANCE_TEMPLATE={service_name} - {description}
 PAYMENT_SUBSCRIPTION_TEMPLATE={service_name} - {description}

 # CRYPTOBOT
-CRYPTOBOT_ENABLED=true
+CRYPTOBOT_ENABLED=false
 CRYPTOBOT_API_TOKEN=123456789:AAzQcZWQqQAbsfgPnOLr4FHC8Doa4L7KryC
 CRYPTOBOT_WEBHOOK_SECRET=your_webhook_secret_here
 CRYPTOBOT_BASE_URL=https://pay.crypt.bot
@@ -458,6 +487,35 @@ CRYPTOBOT_DEFAULT_ASSET=USDT
 CRYPTOBOT_ASSETS=USDT,TON,BTC,ETH,LTC,BNB,TRX,USDC
 CRYPTOBOT_INVOICE_EXPIRES_HOURS=24

+# MULENPAY
+MULENPAY_ENABLED=false
+MULENPAY_API_KEY=
+MULENPAY_SECRET_KEY=
+MULENPAY_SHOP_ID=<ID магазина>
+# необязательно, есть дефолтные значения
+MULENPAY_BASE_URL=https://mulenpay.ru/api
+MULENPAY_WEBHOOK_PATH=/mulenpay-webhook
+MULENPAY_DESCRIPTION="Пополнение баланса"
+MULENPAY_LANGUAGE=ru
+MULENPAY_VAT_CODE=0
+MULENPAY_PAYMENT_SUBJECT=4
+MULENPAY_PAYMENT_MODE=4
+MULENPAY_MIN_AMOUNT_KOPEKS=10000
+MULENPAY_MAX_AMOUNT_KOPEKS=10000000
+
+# PAYPALYCH / PAL24
+PAL24_ENABLED=false
+PAL24_API_TOKEN=
+PAL24_SHOP_ID=
+PAL24_SIGNATURE_TOKEN=
+PAL24_BASE_URL=https://pal24.pro/api/v1/
+PAL24_WEBHOOK_PATH=/pal24-webhook
+PAL24_WEBHOOK_PORT=8084
+PAL24_PAYMENT_DESCRIPTION="Пополнение баланса"
+PAL24_MIN_AMOUNT_KOPEKS=10000
+PAL24_MAX_AMOUNT_KOPEKS=100000000
+PAL24_REQUEST_TIMEOUT=30
+
 # ===== ИНТЕРФЕЙС И UX =====

 # Включить логотип для всех сообщений (true - с изображением, false - только текст)
@@ -472,10 +530,24 @@ HIDE_SUBSCRIPTION_LINK=false
 # miniapp_subscription - открывает ссылку подписки в мини-приложении (режим 2)
 # miniapp_custom - открывает заданную ссылку в мини-приложении (режим 3)
 # link - Открывает ссылку напрямую в браузере (режим 4)
+# happ_cryptolink - Вывод cryptoLink ссылки на подписку Happ (режим 5)
 CONNECT_BUTTON_MODE=guide

 # URL для режима miniapp_custom (обязателен при CONNECT_BUTTON_MODE=miniapp_custom)
 MINIAPP_CUSTOM_URL=
+MINIAPP_SERVICE_NAME_EN=Bedolaga VPN
+MINIAPP_SERVICE_NAME_RU=Bedolaga VPN
+MINIAPP_SERVICE_DESCRIPTION_EN=Secure & Fast Connection
+MINIAPP_SERVICE_DESCRIPTION_RU=Безопасное и быстрое подключение
+
+# Параметры режима happ_cryptolink
+CONNECT_BUTTON_HAPP_DOWNLOAD_ENABLED=false
+HAPP_DOWNLOAD_LINK_IOS=
+HAPP_DOWNLOAD_LINK_ANDROID=
+HAPP_DOWNLOAD_LINK_MACOS=
+HAPP_DOWNLOAD_LINK_WINDOWS=
+# Кнопка (Подключится) с редиректом (тк ссылки с happ:// тг не поддерживает) - Без установленной ссылки на редирект кнопки (подключится) не будет! Пример: https://sub.domain.sub/redirect-page/?redirect_to=
+HAPP_CRYPTOLINK_REDIRECT_TEMPLATE=

 # Пропустить принятие правил использования бота
 SKIP_RULES_ACCEPT=false
@@ -493,6 +565,23 @@ NOTIFICATION_RETRY_ATTEMPTS=3
 MONITORING_LOGS_RETENTION_DAYS=30
 NOTIFICATION_CACHE_HOURS=24

+# ===== СТАТУС СЕРВЕРОВ =====
+# Режимы: disabled, external_link, external_link_miniapp, xray
+SERVER_STATUS_MODE=disabled
+# Ссылка на внешний мониторинг (для режимов external_link и external_link_miniapp)
+SERVER_STATUS_EXTERNAL_URL=
+# URL метрик XrayChecker (для режима xray)
+SERVER_STATUS_METRICS_URL=
+# Данные Basic Auth (опционально)
+SERVER_STATUS_METRICS_USERNAME=
+SERVER_STATUS_METRICS_PASSWORD=
+# Проверять SSL сертификат при запросе метрик
+SERVER_STATUS_METRICS_VERIFY_SSL=true
+# Таймаут запроса к метрикам (в секундах)
+SERVER_STATUS_REQUEST_TIMEOUT=10
+# Количество серверов на странице в режиме интеграции
+SERVER_STATUS_ITEMS_PER_PAGE=10
+
 # ===== РЕЖИМ ТЕХНИЧЕСКИХ РАБОТ =====
 MAINTENANCE_MODE=false
 MAINTENANCE_CHECK_INTERVAL=30
@@ -503,6 +592,8 @@ MAINTENANCE_MESSAGE=Ведутся технические работы. Серв
 # Укажите язык из AVAILABLE_LANGUAGES. При некорректном значении используется ru.
 DEFAULT_LANGUAGE=ru
 AVAILABLE_LANGUAGES=ru,en
+# Включить выбор языка при старте и отображение кнопки в меню
+LANGUAGE_SELECTION_ENABLED=true

 # ===== ДОПОЛНИТЕЛЬНЫЕ НАСТРОЙКИ =====
 # Конфигурация приложений для гайда подключения
@@ -540,8 +631,6 @@ LOG_FILE=logs/bot.log
 DEBUG=false
 WEBHOOK_URL=
 WEBHOOK_PATH=/webhook
-
-
 ```

 </details>
@@ -573,6 +662,8 @@ WEBHOOK_PATH=/webhook
 - ⭐ Telegram Stars
 - 💳 Tribute
 - 💳 YooKassa (включая СБП и онлайн-чек)
+- 💳 MulenPay
+- 💳 PayPalych (Pal24)
 - 💰 CryptoBot (мультивалюта и срок жизни инвойсов)
 - 🎁 Реферальные и промо-бонусы
 - Детальная история транзакций и чеков
@@ -598,7 +689,7 @@ WEBHOOK_PATH=/webhook

 📊 **Мощная аналитика**
 - 👥 Детальная статистика пользователей и подписок
- 💰 Анализ платежей по источникам (Stars, YooKassa, Tribute, CryptoBot)
+- 💰 Анализ платежей по источникам (Stars, YooKassa, Tribute, MulenPay, PayPalych, CryptoBot)
 - 🖥️ Мониторинг серверов Remnawave и статуса сквадов
 - 📈 Финансовые отчеты, конверсии и эффективность рекламных кампаний

@@ -891,6 +982,7 @@ docker compose down -v --remove-orphans
   - **Telegram Stars**: Работает автоматически
   - **Tribute**: Настрой webhook на `https://your-domain.com/tribute-webhook`
   - **YooKassa**: Настрой webhook на `https://your-domain.com/yookassa-webhook`
+   - **PayPalych**: Укажи Result URL `https://your-domain.com/pal24-webhook` в кабинете Pal24


 ### 🛠️ Настройка Уведомлений в топик группы
@@ -1103,7 +1195,7 @@ docker system prune
 |----------|-------------|---------|
 | **Бот не отвечает** | `docker logs remnawave_bot` | Проверь `BOT_TOKEN` и интернет |
 | **Ошибки БД** | `docker compose ps postgres` | Проверь статус PostgreSQL |
-| **Webhook не работает** | Проверь порты 8081/8082 | Настрой прокси-сервер правильно |
+| **Webhook не работает** | Проверь порты 8081/8082/8084 | Настрой прокси-сервер правильно |
 | **API недоступен** | Проверь логи бота | Проверь `REMNAWAVE_API_URL` и ключ |
 | **Мониторинг не работает** | Админ панель → Мониторинг | Проверь `MAINTENANCE_AUTO_ENABLE` |
 | **Платежи не проходят** | Проверь webhook'и | Настрой URL в платежных системах |
@@ -1124,20 +1216,41 @@ server {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
-
+    
    # CryptoBot webhook endpoint
-    handle /cryptobot-webhook* {
-        reverse_proxy localhost:8081 {
-            header_up Host {host}
-            header_up X-Real-IP {remote_host}
-        }
+    location /cryptobot-webhook {
+        proxy_pass http://127.0.0.1:8081;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
    }
    
+    # MulenPay webhook endpoint
+    location /mulenpay-webhook {
+        proxy_pass http://127.0.0.1:8081;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # PayPalych webhook endpoint
+    location /pal24-webhook {
+        proxy_pass http://127.0.0.1:8084;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
    # Для YooKassa
    location /yookassa-webhook {
        proxy_pass http://127.0.0.1:8082;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
    }
    
    # Health check
@@ -1153,21 +1266,48 @@ your-domain.com {
    handle /tribute-webhook* {
        reverse_proxy localhost:8081
    }
-
+    
    handle /cryptobot-webhook* {
        reverse_proxy localhost:8081
    }
    
+    handle /mulenpay-webhook* {
+        reverse_proxy localhost:8081
+    }
+
+    handle /pal24-webhook* {
+        reverse_proxy localhost:8084
+    }
+
    handle /yookassa-webhook* {
        reverse_proxy localhost:8082
    }
-    
+
    handle /health {
        reverse_proxy localhost:8081/health
    }
 }
 ```

+#### 🧪 Проверка PayPalych postback
+
+```bash
+# Генерируем подпись: md5("100.00:test-order-1:${PAL24_SIGNATURE_TOKEN}")
+SIGNATURE=$(python - <<'PY'
+import hashlib, os
+token = os.environ.get('PAL24_SIGNATURE_TOKEN', 'test_token')
+payload = f"100.00:test-order-1:{token}".encode()
+print(hashlib.md5(payload).hexdigest().upper())
+PY
+)
+
+curl -X POST https://your-domain.com/pal24-webhook \
+  -H "Content-Type: application/json" \
+  -d '{"InvId": "test-order-1", "OutSum": "100.00", "Status": "SUCCESS", "SignatureValue": "'$SIGNATURE'"}'
+```
+
+Ответ `{"status": "ok"}` подтверждает корректную обработку вебхука.
+
 ---

 ## 💡 Использование
@@ -1,163 +1,233 @@
 {
-  "ios": [
-    {
-      "id": "happ",
-      "name": "Happ",
-      "isFeatured": true,
-      "urlScheme": "happ://add/",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215",
-            "buttonText": {
-              "en": "App Store [EU]",
-              "ru": "App Store [EU]"
-            }
-          },
-          {
-            "buttonLink": "https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973",
-            "buttonText": {
-              "en": "App Store [RU]",
-              "ru": "App Store [RU]"
+  "config": {},
+  "platforms": {
+    "ios": [
+      {
+        "id": "happ",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215",
+              "buttonText": {
+                "en": "App Store [EU]",
+                "fa": "App Store [EU]",
+                "ru": "App Store [EU]",
+                "zh": "App Store [EU]"
+              }
+            },
+            {
+              "buttonLink": "https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973",
+              "buttonText": {
+                "en": "App Store [RU]",
+                "fa": "App Store [RU]",
+                "ru": "App Store [RU]",
+                "zh": "App Store [RU]"
+              }
            }
+          ],
+          "description": {
+            "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
+            "fa": "صفحه را در App Store باز کنید و برنامه را نصب کنید. آن را اجرا کنید، در پنجره مجوز پیکربندی VPN روی Allow کلیک کنید و رمز عبور خود را وارد کنید.",
+            "ru": "Откройте страницу в App Store и установите приложение. Запустите его, в окне разрешения VPN-конфигурации нажмите Allow и введите свой пароль.",
+            "zh": "在 App Store 中打开页面并安装应用。启动应用后，在 VPN 配置权限窗口中点击\"允许\"并输入您的密码。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below — the app will open and the subscription will be added automatically",
+            "fa": "برای افزودن خودکار اشتراک روی دکمه زیر کلیک کنید - برنامه باز خواهد شد",
+            "ru": "Нажмите кнопку ниже — приложение откроется, и подписка добавится автоматически.",
+            "zh": "点击下方按钮 — 应用将打开并自动添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
          }
-        ],
-        "description": {
-          "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
-          "ru": "Откройте страницу в App Store и установите приложение. Вернись на страницу с подпиской"
-        }
-      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below — the app will open and the subscription will be added automatically",
-          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
-          "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов."
        }
      }
-    }
-  ],
-  "android": [
-    {
-      "id": "happ",
-      "name": "Happ",
-      "isFeatured": true,
-      "urlScheme": "happ://add/",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://play.google.com/store/apps/details?id=com.happproxy",
-            "buttonText": {
-              "en": "Google Play",
-              "ru": "Google Play"
-            }
-          },
-          {
-            "buttonLink": "https://github.com/Happ-proxy/happ-android/releases/latest/download/Happ.apk",
-            "buttonText": {
-              "en": "Download APK",
-              "ru": "Скачать APK"
+    ],
+    "android": [
+      {
+        "id": "happ",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://play.google.com/store/apps/details?id=com.happproxy",
+              "buttonText": {
+                "en": "Google Play",
+                "fa": "Google Play",
+                "ru": "Google Play",
+                "zh": "Google Play"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/Happ-proxy/happ-android/releases/latest/download/Happ.apk",
+              "buttonText": {
+                "en": "Download APK",
+                "fa": "دانلود APK",
+                "ru": "Скачать APK",
+                "zh": "下载 APK"
+              }
            }
+          ],
+          "description": {
+            "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+            "fa": "صفحه را در Google Play باز کنید و برنامه را نصب کنید. یا برنامه را مستقیماً از فایل APK نصب کنید، اگر Google Play کار نمی کند.",
+            "ru": "Откройте страницу в Google Play и установите приложение. Или установите приложение из APK файла напрямую, если Google Play не работает.",
+            "zh": "在 Google Play 中打开页面并安装应用。如果 Google Play 无法使用，也可以直接从 APK 文件安装应用。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "fa": "برای افزودن اشتراک روی دکمه زیر کلیک کنید",
+            "ru": "Нажмите кнопку ниже, чтобы добавить подписку",
+            "zh": "点击下方按钮添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "Open the app and connect to the server",
+            "fa": "برنامه را باز کنید و به سرور متصل شوید",
+            "ru": "Откройте приложение и подключитесь к серверу",
+            "zh": "打开应用并连接到服务器"
          }
-        ],
-        "description": {
-          "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
-          "ru": "Откройте страницу в Google Play и установите приложение. Или установите приложение из APK файла напрямую, если Google Play не работает."
-        }
-      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below to add subscription",
-          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "Open the app and connect to the server",
-          "ru": "Откройте приложение и подключитесь к серверу"
        }
      }
-    }
-  ],
-  "pc": [
-    {
-      "id": "happ",
-      "name": "Happ",
-      "isFeatured": false,
-      "urlScheme": "happ://add/",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215?l=ru",
-            "buttonText": {
-              "en": "Mac Os",
-              "ru": "Mac Os"
-            }
-          },
-          {
-            "buttonLink": "https://github.com/Happ-proxy/happ-desktop/releases/latest/download/setup-Happ.x86.exe",
-            "buttonText": {
-              "en": "Windows",
-              "ru": "Windows"
+    ],
+    "macos": [
+      {
+        "id": "happ",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215",
+              "buttonText": {
+                "en": "App Store [EU]",
+                "fa": "App Store [EU]",
+                "ru": "App Store [EU]",
+                "zh": "App Store [EU]"
+              }
+            },
+            {
+              "buttonLink": "https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973",
+              "buttonText": {
+                "en": "App Store [RU]",
+                "fa": "App Store [RU]",
+                "ru": "App Store [RU]",
+                "zh": "App Store [RU]"
+              }
            }
+          ],
+          "description": {
+            "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
+            "fa": "صفحه را در App Store باز کنید و برنامه را نصب کنید. آن را اجرا کنید، در پنجره مجوز پیکربندی VPN روی Allow کلیک کنید و رمز عبور خود را وارد کنید.",
+            "ru": "Откройте страницу в App Store и установите приложение. Запустите его, в окне разрешения VPN-конфигурации нажмите Allow и введите свой пароль.",
+            "zh": "在 App Store 中打开页面并安装应用。启动应用后，在 VPN 配置权限窗口中点击\"允许\"并输入您的密码。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below — the app will open and the subscription will be added automatically",
+            "fa": "برای افزودن خودکار اشتراک روی دکمه زیر کلیک کنید - برنامه باز خواهد شد",
+            "ru": "Нажмите кнопку ниже — приложение откроется, и подписка добавится автоматически.",
+            "zh": "点击下方按钮 — 应用将打开并自动添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
          }
-        ],
-        "description": {
-          "en": "Choose the version for your device, click the button below and install the app.",
-          "ru": "Выберите подходящую версию для вашего устройства, нажмите на кнопку ниже и установите приложение"
-        }
-      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below to add subscription",
-          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "You can select a server",
-          "ru": "Выберете локацию, включить VPN"
        }
      }
-    }
-  ],
-  "tv": [
-    {
-      "id": "vpn4tv",
-      "name": "VPN4TV",
-      "isFeatured": true,
-      "urlScheme": "",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://play.google.com/store/apps/details?id=com.vpn4tv.hiddify",
-            "buttonText": {
-              "en": "Google Play",
-              "ru": "Google Play"
+    ],
+    "windows": [
+      {
+        "id": "happ",
+        "name": "Happ",
+        "isFeatured": false,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://github.com/Happ-proxy/happ-desktop/releases/latest/download/setup-Happ.x86.exe",
+              "buttonText": {
+                "en": "Download",
+                "ru": "Скачать"
+              }
            }
+          ],
+          "description": {
+            "en": "Download and install Happ.",
+            "ru": "Скачайте и установите Happ"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "You can select a server",
+            "ru": "Выберете локацию, включить VPN"
          }
-        ],
-        "description": {
-          "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
-          "ru": "Откройте страницу в Google Play и установите приложение"
-        }
-      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below to add subscription",
-          "ru": "Нажмите кнопку выше — (Скопировать ссылку подписки) ты скопируешь свою подписку, далее на телевизоре открой VPN4TV, следуя инструкция передай telegram боту ссылку, которую ты скопировал"
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "Open the app and connect to the server",
-          "ru": "Приложение автоматически обновится и загрузит нужные конфиги на твой телевизор, подключай VPN"
        }
      }
-    }
-  ]
-}
+    ],
+    "androidTV": [
+      {
+        "id": "vpn4tv",
+        "name": "VPN4TV",
+        "isFeatured": true,
+        "urlScheme": "",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://play.google.com/store/apps/details?id=com.vpn4tv.hiddify",
+              "buttonText": {
+                "en": "Google Play",
+                "ru": "Google Play"
+              }
+            }
+          ],
+          "description": {
+            "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+            "ru": "Откройте страницу в Google Play и установите приложение"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "ru": "Нажмите кнопку выше — (Скопировать ссылку подписки) ты скопируешь свою подписку, далее на телевизоре открой VPN4TV, следуя инструкция передай telegram боту ссылку, которую ты скопировал"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "Open the app and connect to the server",
+            "ru": "Приложение автоматически обновится и загрузит нужные конфиги на твой телевизор, подключай VPN"
+          }
+        }
+      }
+    ],
+    "linux": [],
+    "appleTV": []
+  }
+}
@@ -36,8 +36,11 @@ from app.handlers.admin import (
    user_messages as admin_user_messages,
    updates as admin_updates,
    backup as admin_backup,
+    system_logs as admin_system_logs,
    welcome_text as admin_welcome_text,
    tickets as admin_tickets,
+    reports as admin_reports,
+    bot_configuration as admin_bot_configuration,
 )
 from app.handlers.stars_payments import register_stars_handlers

@@ -137,8 +140,11 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    admin_user_messages.register_handlers(dp)
    admin_updates.register_handlers(dp)
    admin_backup.register_handlers(dp)
+    admin_system_logs.register_handlers(dp)
    admin_welcome_text.register_welcome_text_handlers(dp)
    admin_tickets.register_handlers(dp)
+    admin_reports.register_handlers(dp)
+    admin_bot_configuration.register_handlers(dp)
    common.register_handlers(dp)
    register_stars_handlers(dp)
    logger.info("⭐ Зарегистрированы обработчики Telegram Stars платежей")
@@ -1,7 +1,9 @@
+import logging
 import os
 import re
 import html
 from collections import defaultdict
+from datetime import time
 from typing import List, Optional, Union, Dict
 from pydantic_settings import BaseSettings
 from pydantic import field_validator, Field
@@ -16,12 +18,22 @@ class Settings(BaseSettings):
    SUPPORT_MENU_ENABLED: bool = True
    SUPPORT_SYSTEM_MODE: str = "both"  # one of: tickets, contact, both
    SUPPORT_MENU_ENABLED: bool = True
+    # SLA for support tickets
+    SUPPORT_TICKET_SLA_ENABLED: bool = True
+    SUPPORT_TICKET_SLA_MINUTES: int = 5
+    SUPPORT_TICKET_SLA_CHECK_INTERVAL_SECONDS: int = 60
+    SUPPORT_TICKET_SLA_REMINDER_COOLDOWN_MINUTES: int = 15

    ADMIN_NOTIFICATIONS_ENABLED: bool = False
    ADMIN_NOTIFICATIONS_CHAT_ID: Optional[str] = None
    ADMIN_NOTIFICATIONS_TOPIC_ID: Optional[int] = None
    ADMIN_NOTIFICATIONS_TICKET_TOPIC_ID: Optional[int] = None

+    ADMIN_REPORTS_ENABLED: bool = False
+    ADMIN_REPORTS_CHAT_ID: Optional[str] = None
+    ADMIN_REPORTS_TOPIC_ID: Optional[int] = None
+    ADMIN_REPORTS_SEND_TIME: Optional[str] = None
+
    CHANNEL_SUB_ID: Optional[str] = None
    CHANNEL_LINK: Optional[str] = None
    CHANNEL_IS_REQUIRED_SUB: bool = False
@@ -41,8 +53,8 @@ class Settings(BaseSettings):
    
    REDIS_URL: str = "redis://localhost:6379/0"
    
-    REMNAWAVE_API_URL: str
-    REMNAWAVE_API_KEY: str
+    REMNAWAVE_API_URL: str = ""
+    REMNAWAVE_API_KEY: str = ""
    REMNAWAVE_SECRET_KEY: Optional[str] = None

    REMNAWAVE_USERNAME: Optional[str] = None
@@ -54,10 +66,12 @@ class Settings(BaseSettings):
    TRIAL_DURATION_DAYS: int = 3
    TRIAL_TRAFFIC_LIMIT_GB: int = 10
    TRIAL_DEVICE_LIMIT: int = 2
+    TRIAL_ADD_REMAINING_DAYS_TO_PAID: bool = False
    DEFAULT_TRAFFIC_LIMIT_GB: int = 100
    DEFAULT_DEVICE_LIMIT: int = 1
-    TRIAL_SQUAD_UUID: str
+    TRIAL_SQUAD_UUID: str = ""
    DEFAULT_TRAFFIC_RESET_STRATEGY: str = "MONTH"
+    RESET_TRAFFIC_ON_PAYMENT: bool = False
    MAX_DEVICES_LIMIT: int = 20
    
    TRIAL_WARNING_HOURS: int = 2 
@@ -169,8 +183,48 @@ class Settings(BaseSettings):
    CRYPTOBOT_ASSETS: str = "USDT,TON,BTC,ETH"
    CRYPTOBOT_INVOICE_EXPIRES_HOURS: int = 24

+    MULENPAY_ENABLED: bool = False
+    MULENPAY_API_KEY: Optional[str] = None
+    MULENPAY_SECRET_KEY: Optional[str] = None
+    MULENPAY_SHOP_ID: Optional[int] = None
+    MULENPAY_BASE_URL: str = "https://mulenpay.ru/api"
+    MULENPAY_WEBHOOK_PATH: str = "/mulenpay-webhook"
+    MULENPAY_DESCRIPTION: str = "Пополнение баланса"
+    MULENPAY_LANGUAGE: str = "ru"
+    MULENPAY_VAT_CODE: int = 0
+    MULENPAY_PAYMENT_SUBJECT: int = 4
+    MULENPAY_PAYMENT_MODE: int = 4
+    MULENPAY_MIN_AMOUNT_KOPEKS: int = 10000
+    MULENPAY_MAX_AMOUNT_KOPEKS: int = 10000000
+
+    PAL24_ENABLED: bool = False
+    PAL24_API_TOKEN: Optional[str] = None
+    PAL24_SHOP_ID: Optional[str] = None
+    PAL24_SIGNATURE_TOKEN: Optional[str] = None
+    PAL24_BASE_URL: str = "https://pal24.pro/api/v1/"
+    PAL24_WEBHOOK_PATH: str = "/pal24-webhook"
+    PAL24_WEBHOOK_PORT: int = 8084
+    PAL24_PAYMENT_DESCRIPTION: str = "Пополнение баланса"
+    PAL24_MIN_AMOUNT_KOPEKS: int = 10000
+    PAL24_MAX_AMOUNT_KOPEKS: int = 100000000
+    PAL24_REQUEST_TIMEOUT: int = 30
+    PAL24_SBP_BUTTON_TEXT: Optional[str] = None
+    PAL24_CARD_BUTTON_TEXT: Optional[str] = None
+
    CONNECT_BUTTON_MODE: str = "guide"
    MINIAPP_CUSTOM_URL: str = ""
+    MINIAPP_PURCHASE_URL: str = ""
+    MINIAPP_SERVICE_NAME_EN: str = "Bedolaga VPN"
+    MINIAPP_SERVICE_NAME_RU: str = "Bedolaga VPN"
+    MINIAPP_SERVICE_DESCRIPTION_EN: str = "Secure & Fast Connection"
+    MINIAPP_SERVICE_DESCRIPTION_RU: str = "Безопасное и быстрое подключение"
+    CONNECT_BUTTON_HAPP_DOWNLOAD_ENABLED: bool = False
+    HAPP_CRYPTOLINK_REDIRECT_TEMPLATE: Optional[str] = None
+    HAPP_DOWNLOAD_LINK_IOS: Optional[str] = None
+    HAPP_DOWNLOAD_LINK_ANDROID: Optional[str] = None
+    HAPP_DOWNLOAD_LINK_MACOS: Optional[str] = None
+    HAPP_DOWNLOAD_LINK_WINDOWS: Optional[str] = None
+    HAPP_DOWNLOAD_LINK_PC: Optional[str] = None
    HIDE_SUBSCRIPTION_LINK: bool = False
    ENABLE_LOGO_MODE: bool = True
    LOGO_FILE: str = "vpn_logo.png"
@@ -179,6 +233,7 @@ class Settings(BaseSettings):

    DEFAULT_LANGUAGE: str = "ru"
    AVAILABLE_LANGUAGES: str = "ru,en"
+    LANGUAGE_SELECTION_ENABLED: bool = True
    
    LOG_LEVEL: str = "INFO"
    LOG_FILE: str = "logs/bot.log"
@@ -186,6 +241,19 @@ class Settings(BaseSettings):
    DEBUG: bool = False
    WEBHOOK_URL: Optional[str] = None
    WEBHOOK_PATH: str = "/webhook"
+
+    WEB_API_ENABLED: bool = False
+    WEB_API_HOST: str = "0.0.0.0"
+    WEB_API_PORT: int = 8080
+    WEB_API_WORKERS: int = 1
+    WEB_API_ALLOWED_ORIGINS: str = "*"
+    WEB_API_DOCS_ENABLED: bool = False
+    WEB_API_TITLE: str = "Remnawave Bot Admin API"
+    WEB_API_VERSION: str = "1.0.0"
+    WEB_API_DEFAULT_TOKEN: Optional[str] = None
+    WEB_API_DEFAULT_TOKEN_NAME: str = "Bootstrap Token"
+    WEB_API_TOKEN_HASH_ALGORITHM: str = "sha256"
+    WEB_API_REQUEST_LOGGING: bool = True
    
    APP_CONFIG_PATH: str = "app-config.json"
    ENABLE_DEEP_LINKS: bool = True
@@ -221,6 +289,13 @@ class Settings(BaseSettings):
            "link": "external_link",
            "url": "external_link",
            "external_link": "external_link",
+            "miniapp": "external_link_miniapp",
+            "mini_app": "external_link_miniapp",
+            "mini-app": "external_link_miniapp",
+            "webapp": "external_link_miniapp",
+            "web_app": "external_link_miniapp",
+            "web-app": "external_link_miniapp",
+            "external_link_miniapp": "external_link_miniapp",
            "xray": "xray",
            "xraychecker": "xray",
            "xray_metrics": "xray",
@@ -228,8 +303,10 @@ class Settings(BaseSettings):
        }

        mode = aliases.get(normalized, normalized)
-        if mode not in {"disabled", "external_link", "xray"}:
-            raise ValueError("SERVER_STATUS_MODE must be one of: disabled, external_link, xray")
+        if mode not in {"disabled", "external_link", "external_link_miniapp", "xray"}:
+            raise ValueError(
+                "SERVER_STATUS_MODE must be one of: disabled, external_link, external_link_miniapp, xray"
+            )
        return mode

    @field_validator('SERVER_STATUS_ITEMS_PER_PAGE', mode='before')
@@ -329,6 +406,14 @@ class Settings(BaseSettings):
            "password": self.REMNAWAVE_PASSWORD,
            "auth_type": self.REMNAWAVE_AUTH_TYPE
        }
+
+    def get_pal24_sbp_button_text(self, fallback: str) -> str:
+        value = (self.PAL24_SBP_BUTTON_TEXT or "").strip()
+        return value or fallback
+
+    def get_pal24_card_button_text(self, fallback: str) -> str:
+        value = (self.PAL24_CARD_BUTTON_TEXT or "").strip()
+        return value or fallback
    
    def get_remnawave_user_delete_mode(self) -> str:
        """Возвращает режим удаления пользователей: 'delete' или 'disable'"""
@@ -383,10 +468,39 @@ class Settings(BaseSettings):
            return ["ru", "en"]
        except AttributeError:
            return ["ru", "en"]
-    
+
+    def is_language_selection_enabled(self) -> bool:
+        return bool(getattr(self, "LANGUAGE_SELECTION_ENABLED", True))
+
    def format_price(self, price_kopeks: int) -> str:
        rubles = price_kopeks // 100
        return f"{rubles} ₽"
+
+    def get_reports_chat_id(self) -> Optional[str]:
+        if self.ADMIN_REPORTS_CHAT_ID:
+            return self.ADMIN_REPORTS_CHAT_ID
+        return self.ADMIN_NOTIFICATIONS_CHAT_ID
+
+    def get_reports_topic_id(self) -> Optional[int]:
+        return self.ADMIN_REPORTS_TOPIC_ID or None
+
+    def get_reports_send_time(self) -> Optional[time]:
+        value = self.ADMIN_REPORTS_SEND_TIME
+        if not value:
+            return None
+
+        try:
+            hours_str, minutes_str = value.strip().split(":", 1)
+            hours = int(hours_str)
+            minutes = int(minutes_str)
+            if not (0 <= hours <= 23 and 0 <= minutes <= 59):
+                raise ValueError
+            return time(hour=hours, minute=minutes)
+        except (ValueError, AttributeError):
+            logging.getLogger(__name__).warning(
+                "Некорректное значение ADMIN_REPORTS_SEND_TIME: %s", value
+            )
+            return None
    
    def kopeks_to_rubles(self, kopeks: int) -> float:
        return kopeks / 100
@@ -409,6 +523,34 @@ class Settings(BaseSettings):
    
    def is_deep_links_enabled(self) -> bool:
        return self.ENABLE_DEEP_LINKS
+
+    def get_miniapp_branding(self) -> Dict[str, Dict[str, Optional[str]]]:
+        def _clean(value: Optional[str]) -> Optional[str]:
+            if value is None:
+                return None
+            value_str = str(value).strip()
+            return value_str or None
+
+        name_en = _clean(self.MINIAPP_SERVICE_NAME_EN)
+        name_ru = _clean(self.MINIAPP_SERVICE_NAME_RU)
+        desc_en = _clean(self.MINIAPP_SERVICE_DESCRIPTION_EN)
+        desc_ru = _clean(self.MINIAPP_SERVICE_DESCRIPTION_RU)
+
+        default_name = name_en or name_ru or "RemnaWave VPN"
+        default_description = desc_en or desc_ru or "Secure & Fast Connection"
+
+        return {
+            "service_name": {
+                "default": default_name,
+                "en": name_en,
+                "ru": name_ru,
+            },
+            "service_description": {
+                "default": default_description,
+                "en": desc_en,
+                "ru": desc_ru,
+            },
+        }
    
    def get_app_config_cache_ttl(self) -> int:
        return self.APP_CONFIG_CACHE_TTL
@@ -435,9 +577,24 @@ class Settings(BaseSettings):
        return "https://t.me/"

    def is_cryptobot_enabled(self) -> bool:
-        return (self.CRYPTOBOT_ENABLED and 
+        return (self.CRYPTOBOT_ENABLED and
                self.CRYPTOBOT_API_TOKEN is not None)
-    
+
+    def is_mulenpay_enabled(self) -> bool:
+        return (
+            self.MULENPAY_ENABLED
+            and self.MULENPAY_API_KEY is not None
+            and self.MULENPAY_SECRET_KEY is not None
+            and self.MULENPAY_SHOP_ID is not None
+        )
+
+    def is_pal24_enabled(self) -> bool:
+        return (
+            self.PAL24_ENABLED
+            and self.PAL24_API_TOKEN is not None
+            and self.PAL24_SHOP_ID is not None
+        )
+
    def get_cryptobot_base_url(self) -> str:
        if self.CRYPTOBOT_TESTNET:
            return "https://testnet-pay.crypt.bot"
@@ -455,6 +612,41 @@ class Settings(BaseSettings):
    def get_cryptobot_invoice_expires_seconds(self) -> int:
        return self.CRYPTOBOT_INVOICE_EXPIRES_HOURS * 3600

+    def is_happ_cryptolink_mode(self) -> bool:
+        return self.CONNECT_BUTTON_MODE == "happ_cryptolink"
+
+    def is_happ_download_button_enabled(self) -> bool:
+        return self.is_happ_cryptolink_mode() and self.CONNECT_BUTTON_HAPP_DOWNLOAD_ENABLED
+
+    def should_hide_subscription_link(self) -> bool:
+        """Returns True when subscription links must be hidden from the interface."""
+
+        if self.is_happ_cryptolink_mode():
+            return False
+        return self.HIDE_SUBSCRIPTION_LINK
+
+    def get_happ_cryptolink_redirect_template(self) -> Optional[str]:
+        template = (self.HAPP_CRYPTOLINK_REDIRECT_TEMPLATE or "").strip()
+        return template or None
+
+    def get_happ_download_link(self, platform: str) -> Optional[str]:
+        platform_key = platform.lower()
+
+        if platform_key == "pc":
+            platform_key = "windows"
+
+        links = {
+            "ios": (self.HAPP_DOWNLOAD_LINK_IOS or "").strip(),
+            "android": (self.HAPP_DOWNLOAD_LINK_ANDROID or "").strip(),
+            "macos": (self.HAPP_DOWNLOAD_LINK_MACOS or "").strip(),
+            "windows": (
+                (self.HAPP_DOWNLOAD_LINK_WINDOWS or "").strip()
+                or (self.HAPP_DOWNLOAD_LINK_PC or "").strip()
+            ),
+        }
+        link = links.get(platform_key)
+        return link if link else None
+
    def is_maintenance_mode(self) -> bool:
        return self.MAINTENANCE_MODE
    
@@ -831,7 +1023,25 @@ class Settings(BaseSettings):

    def get_server_status_request_timeout(self) -> int:
        return max(1, self.SERVER_STATUS_REQUEST_TIMEOUT)
-    
+
+    def is_web_api_enabled(self) -> bool:
+        return bool(self.WEB_API_ENABLED)
+
+    def get_web_api_allowed_origins(self) -> list[str]:
+        raw = (self.WEB_API_ALLOWED_ORIGINS or "").split(",")
+        origins = [origin.strip() for origin in raw if origin.strip()]
+        return origins or ["*"]
+
+    def get_web_api_docs_config(self) -> Dict[str, Optional[str]]:
+        if self.WEB_API_DOCS_ENABLED:
+            return {
+                "docs_url": "/docs",
+                "redoc_url": "/redoc",
+                "openapi_url": "/openapi.json",
+            }
+
+        return {"docs_url": None, "redoc_url": None, "openapi_url": None}
+
    def get_support_system_mode(self) -> str:
        mode = (self.SUPPORT_SYSTEM_MODE or "both").strip().lower()
        return mode if mode in {"tickets", "contact", "both"} else "both"
@@ -841,32 +1051,6 @@ class Settings(BaseSettings):
    
    def is_support_contact_enabled(self) -> bool:
        return self.get_support_system_mode() in {"contact", "both"}
-        
-        enabled_packages = [pkg for pkg in packages if pkg["enabled"]]
-        if not enabled_packages:
-            return 0
-        
-        unlimited_package = next((pkg for pkg in enabled_packages if pkg["gb"] == 0), None)
-        
-        finite_packages = [pkg for pkg in enabled_packages if pkg["gb"] > 0]
-        if finite_packages:
-            max_package = max(finite_packages, key=lambda x: x["gb"])
-            
-            if gb > max_package["gb"]:
-                if unlimited_package:
-                    return unlimited_package["price"]
-                else:
-                    return max_package["price"]
-            
-            suitable_packages = [pkg for pkg in finite_packages if pkg["gb"] >= gb]
-            if suitable_packages:
-                nearest_package = min(suitable_packages, key=lambda x: x["gb"])
-                return nearest_package["price"]
-        
-        if unlimited_package:
-            return unlimited_package["price"]
-        
-        return 0
    
    model_config = {
        "env_file": ".env",
@@ -32,6 +32,7 @@ async def create_campaign(
    subscription_traffic_gb: Optional[int] = None,
    subscription_device_limit: Optional[int] = None,
    subscription_squads: Optional[List[str]] = None,
+    is_active: bool = True,
 ) -> AdvertisingCampaign:
    campaign = AdvertisingCampaign(
        name=name,
@@ -43,7 +44,7 @@ async def create_campaign(
        subscription_device_limit=subscription_device_limit,
        subscription_squads=subscription_squads or [],
        created_by=created_by,
-        is_active=True,
+        is_active=is_active,
    )

    db.add(campaign)
@@ -135,7 +136,10 @@ async def update_campaign(
        "is_active",
    }

-    update_data = {key: value for key, value in kwargs.items() if key in allowed_fields}
+    update_data = {}
+    for key, value in kwargs.items():
+        if key in allowed_fields and value is not None:
+            update_data[key] = value

    if not update_data:
        return campaign
@@ -0,0 +1,90 @@
+from datetime import datetime, timedelta
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import DiscountOffer
+
+
+async def upsert_discount_offer(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    subscription_id: Optional[int],
+    notification_type: str,
+    discount_percent: int,
+    bonus_amount_kopeks: int,
+    valid_hours: int,
+) -> DiscountOffer:
+    """Create or refresh a discount offer for a user."""
+
+    expires_at = datetime.utcnow() + timedelta(hours=valid_hours)
+
+    result = await db.execute(
+        select(DiscountOffer)
+        .where(
+            DiscountOffer.user_id == user_id,
+            DiscountOffer.notification_type == notification_type,
+            DiscountOffer.is_active == True,  # noqa: E712
+        )
+        .order_by(DiscountOffer.created_at.desc())
+    )
+    offer = result.scalars().first()
+
+    if offer and offer.claimed_at is None:
+        offer.discount_percent = discount_percent
+        offer.bonus_amount_kopeks = bonus_amount_kopeks
+        offer.expires_at = expires_at
+        offer.subscription_id = subscription_id
+    else:
+        offer = DiscountOffer(
+            user_id=user_id,
+            subscription_id=subscription_id,
+            notification_type=notification_type,
+            discount_percent=discount_percent,
+            bonus_amount_kopeks=bonus_amount_kopeks,
+            expires_at=expires_at,
+            is_active=True,
+        )
+        db.add(offer)
+
+    await db.commit()
+    await db.refresh(offer)
+    return offer
+
+
+async def get_offer_by_id(db: AsyncSession, offer_id: int) -> Optional[DiscountOffer]:
+    result = await db.execute(
+        select(DiscountOffer).where(DiscountOffer.id == offer_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def mark_offer_claimed(db: AsyncSession, offer: DiscountOffer) -> DiscountOffer:
+    offer.claimed_at = datetime.utcnow()
+    offer.is_active = False
+    await db.commit()
+    await db.refresh(offer)
+    return offer
+
+
+async def deactivate_expired_offers(db: AsyncSession) -> int:
+    now = datetime.utcnow()
+    result = await db.execute(
+        select(DiscountOffer).where(
+            DiscountOffer.is_active == True,  # noqa: E712
+            DiscountOffer.expires_at < now,
+        )
+    )
+    offers = result.scalars().all()
+    if not offers:
+        return 0
+
+    count = 0
+    for offer in offers:
+        offer.is_active = False
+        count += 1
+
+    await db.commit()
+    return count
@@ -0,0 +1,118 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import MulenPayPayment
+
+logger = logging.getLogger(__name__)
+
+
+async def create_mulenpay_payment(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    amount_kopeks: int,
+    uuid: str,
+    description: str,
+    payment_url: Optional[str],
+    mulen_payment_id: Optional[int],
+    currency: str,
+    status: str,
+    metadata: Optional[dict] = None,
+) -> MulenPayPayment:
+    payment = MulenPayPayment(
+        user_id=user_id,
+        amount_kopeks=amount_kopeks,
+        uuid=uuid,
+        description=description,
+        payment_url=payment_url,
+        mulen_payment_id=mulen_payment_id,
+        currency=currency,
+        status=status,
+        metadata_json=metadata or {},
+    )
+
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Создан MulenPay платеж #%s (uuid=%s) на сумму %s копеек для пользователя %s",
+        payment.mulen_payment_id,
+        uuid,
+        amount_kopeks,
+        user_id,
+    )
+
+    return payment
+
+
+async def get_mulenpay_payment_by_local_id(
+    db: AsyncSession, payment_id: int
+) -> Optional[MulenPayPayment]:
+    result = await db.execute(
+        select(MulenPayPayment).where(MulenPayPayment.id == payment_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_mulenpay_payment_by_uuid(
+    db: AsyncSession, uuid: str
+) -> Optional[MulenPayPayment]:
+    result = await db.execute(
+        select(MulenPayPayment).where(MulenPayPayment.uuid == uuid)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_mulenpay_payment_by_mulen_id(
+    db: AsyncSession, mulen_payment_id: int
+) -> Optional[MulenPayPayment]:
+    result = await db.execute(
+        select(MulenPayPayment).where(
+            MulenPayPayment.mulen_payment_id == mulen_payment_id
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_mulenpay_payment_status(
+    db: AsyncSession,
+    *,
+    payment: MulenPayPayment,
+    status: str,
+    is_paid: Optional[bool] = None,
+    paid_at: Optional[datetime] = None,
+    callback_payload: Optional[dict] = None,
+    mulen_payment_id: Optional[int] = None,
+) -> MulenPayPayment:
+    payment.status = status
+    if is_paid is not None:
+        payment.is_paid = is_paid
+    if paid_at:
+        payment.paid_at = paid_at
+    if callback_payload is not None:
+        payment.callback_payload = callback_payload
+    if mulen_payment_id is not None and not payment.mulen_payment_id:
+        payment.mulen_payment_id = mulen_payment_id
+
+    payment.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(payment)
+    return payment
+
+
+async def link_mulenpay_payment_to_transaction(
+    db: AsyncSession,
+    *,
+    payment: MulenPayPayment,
+    transaction_id: int,
+) -> MulenPayPayment:
+    payment.transaction_id = transaction_id
+    payment.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(payment)
+    return payment
@@ -50,3 +50,17 @@ async def clear_notifications(db: AsyncSession, subscription_id: int) -> None:
        )
    )
    await db.commit()
+
+
+async def clear_notification_by_type(
+    db: AsyncSession,
+    subscription_id: int,
+    notification_type: str,
+) -> None:
+    await db.execute(
+        delete(SentNotification).where(
+            SentNotification.subscription_id == subscription_id,
+            SentNotification.notification_type == notification_type,
+        )
+    )
+    await db.commit()
@@ -0,0 +1,160 @@
+"""CRUD helpers for PayPalych (Pal24) payments."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import Pal24Payment
+
+logger = logging.getLogger(__name__)
+
+
+async def create_pal24_payment(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    bill_id: str,
+    amount_kopeks: int,
+    description: Optional[str],
+    status: str,
+    type_: str,
+    currency: str,
+    link_url: Optional[str],
+    link_page_url: Optional[str],
+    order_id: Optional[str] = None,
+    ttl: Optional[int] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> Pal24Payment:
+    payment = Pal24Payment(
+        user_id=user_id,
+        bill_id=bill_id,
+        order_id=order_id,
+        amount_kopeks=amount_kopeks,
+        currency=currency,
+        description=description,
+        status=status,
+        type=type_,
+        link_url=link_url,
+        link_page_url=link_page_url,
+        metadata_json=metadata or {},
+        ttl=ttl,
+    )
+
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Создан Pal24 платеж #%s для пользователя %s: %s копеек (статус %s)",
+        payment.id,
+        user_id,
+        amount_kopeks,
+        status,
+    )
+
+    return payment
+
+
+async def get_pal24_payment_by_id(db: AsyncSession, payment_id: int) -> Optional[Pal24Payment]:
+    result = await db.execute(
+        select(Pal24Payment).where(Pal24Payment.id == payment_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_pal24_payment_by_bill_id(db: AsyncSession, bill_id: str) -> Optional[Pal24Payment]:
+    result = await db.execute(
+        select(Pal24Payment).where(Pal24Payment.bill_id == bill_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_pal24_payment_by_order_id(db: AsyncSession, order_id: str) -> Optional[Pal24Payment]:
+    result = await db.execute(
+        select(Pal24Payment).where(Pal24Payment.order_id == order_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_pal24_payment_status(
+    db: AsyncSession,
+    payment: Pal24Payment,
+    *,
+    status: str,
+    is_active: Optional[bool] = None,
+    is_paid: Optional[bool] = None,
+    payment_id: Optional[str] = None,
+    payment_status: Optional[str] = None,
+    payment_method: Optional[str] = None,
+    balance_amount: Optional[str] = None,
+    balance_currency: Optional[str] = None,
+    payer_account: Optional[str] = None,
+    callback_payload: Optional[Dict[str, Any]] = None,
+) -> Pal24Payment:
+    update_values: Dict[str, Any] = {
+        "status": status,
+    }
+
+    if is_active is not None:
+        update_values["is_active"] = is_active
+    if is_paid is not None:
+        update_values["is_paid"] = is_paid
+    if payment_id is not None:
+        update_values["payment_id"] = payment_id
+    if payment_status is not None:
+        update_values["payment_status"] = payment_status
+    if payment_method is not None:
+        update_values["payment_method"] = payment_method
+    if balance_amount is not None:
+        update_values["balance_amount"] = balance_amount
+    if balance_currency is not None:
+        update_values["balance_currency"] = balance_currency
+    if payer_account is not None:
+        update_values["payer_account"] = payer_account
+    if callback_payload is not None:
+        update_values["callback_payload"] = callback_payload
+
+    update_values["last_status"] = status
+
+    await db.execute(
+        update(Pal24Payment)
+        .where(Pal24Payment.id == payment.id)
+        .values(**update_values)
+    )
+
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Обновлен Pal24 платеж %s: статус=%s, is_paid=%s",
+        payment.bill_id,
+        payment.status,
+        payment.is_paid,
+    )
+
+    return payment
+
+
+async def link_pal24_payment_to_transaction(
+    db: AsyncSession,
+    payment: Pal24Payment,
+    transaction_id: int,
+) -> Pal24Payment:
+    await db.execute(
+        update(Pal24Payment)
+        .where(Pal24Payment.id == payment.id)
+        .values(transaction_id=transaction_id)
+    )
+    await db.commit()
+    await db.refresh(payment)
+    logger.info(
+        "Pal24 платеж %s привязан к транзакции %s",
+        payment.bill_id,
+        transaction_id,
+    )
+    return payment
+
@@ -1,5 +1,5 @@
 import logging
-from typing import List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple

 from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -7,18 +7,46 @@ from sqlalchemy.orm import selectinload

 from app.database.models import PromoGroup, User

+
+def _normalize_period_discounts(period_discounts: Optional[Dict[int, int]]) -> Dict[int, int]:
+    if not period_discounts:
+        return {}
+
+    normalized: Dict[int, int] = {}
+
+    for key, value in period_discounts.items():
+        try:
+            period = int(key)
+            percent = int(value)
+        except (TypeError, ValueError):
+            continue
+
+        normalized[period] = max(0, min(100, percent))
+
+    return normalized
+
 logger = logging.getLogger(__name__)


 async def get_promo_groups_with_counts(
    db: AsyncSession,
+    *,
+    offset: int = 0,
+    limit: Optional[int] = None,
 ) -> List[Tuple[PromoGroup, int]]:
-    result = await db.execute(
+    query = (
        select(PromoGroup, func.count(User.id))
        .outerjoin(User, User.promo_group_id == PromoGroup.id)
        .group_by(PromoGroup.id)
        .order_by(PromoGroup.is_default.desc(), PromoGroup.name)
    )
+
+    if offset:
+        query = query.offset(offset)
+    if limit is not None:
+        query = query.limit(limit)
+
+    result = await db.execute(query)
    return result.all()


@@ -26,6 +54,11 @@ async def get_promo_group_by_id(db: AsyncSession, group_id: int) -> Optional[Pro
    return await db.get(PromoGroup, group_id)


+async def count_promo_groups(db: AsyncSession) -> int:
+    result = await db.execute(select(func.count(PromoGroup.id)))
+    return int(result.scalar_one())
+
+
 async def get_default_promo_group(db: AsyncSession) -> Optional[PromoGroup]:
    result = await db.execute(
        select(PromoGroup).where(PromoGroup.is_default.is_(True))
@@ -40,25 +73,56 @@ async def create_promo_group(
    server_discount_percent: int,
    traffic_discount_percent: int,
    device_discount_percent: int,
+    period_discounts: Optional[Dict[int, int]] = None,
+    auto_assign_total_spent_kopeks: Optional[int] = None,
+    apply_discounts_to_addons: bool = True,
+    is_default: bool = False,
 ) -> PromoGroup:
+    normalized_period_discounts = _normalize_period_discounts(period_discounts)
+
+    auto_assign_total_spent_kopeks = (
+        max(0, auto_assign_total_spent_kopeks)
+        if auto_assign_total_spent_kopeks is not None
+        else None
+    )
+
+    existing_default = await get_default_promo_group(db)
+    should_be_default = existing_default is None or is_default
+
    promo_group = PromoGroup(
        name=name.strip(),
        server_discount_percent=max(0, min(100, server_discount_percent)),
        traffic_discount_percent=max(0, min(100, traffic_discount_percent)),
        device_discount_percent=max(0, min(100, device_discount_percent)),
-        is_default=False,
+        period_discounts=normalized_period_discounts or None,
+        auto_assign_total_spent_kopeks=auto_assign_total_spent_kopeks,
+        apply_discounts_to_addons=bool(apply_discounts_to_addons),
+        is_default=should_be_default,
    )

    db.add(promo_group)
+    await db.flush()
+
+    if should_be_default and existing_default and existing_default.id != promo_group.id:
+        await db.execute(
+            update(PromoGroup)
+            .where(PromoGroup.id != promo_group.id)
+            .values(is_default=False)
+        )
+
    await db.commit()
    await db.refresh(promo_group)

    logger.info(
-        "Создана промогруппа '%s' с скидками (servers=%s%%, traffic=%s%%, devices=%s%%)",
+        "Создана промогруппа '%s' (default=%s) с скидками (servers=%s%%, traffic=%s%%, devices=%s%%, periods=%s) и порогом автоприсвоения %s₽, скидки на доп. услуги: %s",
        promo_group.name,
+        promo_group.is_default,
        promo_group.server_discount_percent,
        promo_group.traffic_discount_percent,
        promo_group.device_discount_percent,
+        normalized_period_discounts,
+        (auto_assign_total_spent_kopeks or 0) / 100,
+        "on" if promo_group.apply_discounts_to_addons else "off",
    )

    return promo_group
@@ -72,6 +136,10 @@ async def update_promo_group(
    server_discount_percent: Optional[int] = None,
    traffic_discount_percent: Optional[int] = None,
    device_discount_percent: Optional[int] = None,
+    period_discounts: Optional[Dict[int, int]] = None,
+    auto_assign_total_spent_kopeks: Optional[int] = None,
+    apply_discounts_to_addons: Optional[bool] = None,
+    is_default: Optional[bool] = None,
 ) -> PromoGroup:
    if name is not None:
        group.name = name.strip()
@@ -81,6 +149,43 @@ async def update_promo_group(
        group.traffic_discount_percent = max(0, min(100, traffic_discount_percent))
    if device_discount_percent is not None:
        group.device_discount_percent = max(0, min(100, device_discount_percent))
+    if period_discounts is not None:
+        normalized_period_discounts = _normalize_period_discounts(period_discounts)
+        group.period_discounts = normalized_period_discounts or None
+    if auto_assign_total_spent_kopeks is not None:
+        group.auto_assign_total_spent_kopeks = max(0, auto_assign_total_spent_kopeks)
+    if apply_discounts_to_addons is not None:
+        group.apply_discounts_to_addons = bool(apply_discounts_to_addons)
+
+    if is_default is not None:
+        if is_default:
+            group.is_default = True
+            await db.flush()
+            await db.execute(
+                update(PromoGroup)
+                .where(PromoGroup.id != group.id)
+                .values(is_default=False)
+            )
+        else:
+            if group.is_default:
+                group.is_default = False
+                await db.flush()
+                replacement = await db.execute(
+                    select(PromoGroup)
+                    .where(PromoGroup.id != group.id)
+                    .order_by(PromoGroup.id)
+                    .limit(1)
+                )
+                new_default = replacement.scalars().first()
+                if new_default:
+                    await db.execute(
+                        update(PromoGroup)
+                        .where(PromoGroup.id == new_default.id)
+                        .values(is_default=True)
+                    )
+                else:
+                    # Не допускаем состояния без базовой промогруппы
+                    group.is_default = True

    await db.commit()
    await db.refresh(group)
@@ -103,6 +208,7 @@ async def delete_promo_group(db: AsyncSession, group: PromoGroup) -> bool:
        logger.error("Не найдена базовая промогруппа для reassignment")
        return False

+
    await db.execute(
        update(User)
        .where(User.promo_group_id == group.id)
@@ -1,14 +1,33 @@
 import logging
-from typing import List, Optional, Tuple
-from sqlalchemy import select, and_, func, update, delete, text
+from datetime import datetime
+from typing import Iterable, List, Optional, Sequence, Tuple
+
+from sqlalchemy import (
+    select,
+    and_,
+    func,
+    update,
+    delete,
+    text,
+    or_,
+    cast,
+    String,
+)
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.database.models import ServerSquad, SubscriptionServer, Subscription
+from app.database.models import PromoGroup, ServerSquad, SubscriptionServer, Subscription, User

 logger = logging.getLogger(__name__)


+async def _get_default_promo_group_id(db: AsyncSession) -> Optional[int]:
+    result = await db.execute(
+        select(PromoGroup.id).where(PromoGroup.is_default.is_(True)).limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
 async def create_server_squad(
    db: AsyncSession,
    squad_uuid: str,
@@ -18,9 +37,30 @@ async def create_server_squad(
    price_kopeks: int = 0,
    description: str = None,
    max_users: int = None,
-    is_available: bool = True
+    is_available: bool = True,
+    promo_group_ids: Optional[Iterable[int]] = None,
 ) -> ServerSquad:
-    
+
+    normalized_group_ids: Sequence[int]
+    if promo_group_ids is None:
+        default_id = await _get_default_promo_group_id(db)
+        normalized_group_ids = [default_id] if default_id is not None else []
+    else:
+        normalized_group_ids = [int(pg_id) for pg_id in set(promo_group_ids)]
+
+    if not normalized_group_ids:
+        raise ValueError("Server squad must be linked to at least one promo group")
+
+    promo_groups_result = await db.execute(
+        select(PromoGroup).where(PromoGroup.id.in_(normalized_group_ids))
+    )
+    promo_groups = promo_groups_result.scalars().all()
+
+    if len(promo_groups) != len(normalized_group_ids):
+        logger.warning(
+            "Не все промогруппы найдены при создании сервера %s", display_name
+        )
+
    server_squad = ServerSquad(
        squad_uuid=squad_uuid,
        display_name=display_name,
@@ -29,9 +69,10 @@ async def create_server_squad(
        price_kopeks=price_kopeks,
        description=description,
        max_users=max_users,
-        is_available=is_available
+        is_available=is_available,
+        allowed_promo_groups=promo_groups,
    )
-    
+
    db.add(server_squad)
    await db.commit()
    await db.refresh(server_squad)
@@ -46,9 +87,11 @@ async def get_server_squad_by_uuid(
 ) -> Optional[ServerSquad]:
    
    result = await db.execute(
-        select(ServerSquad).where(ServerSquad.squad_uuid == squad_uuid)
+        select(ServerSquad)
+        .options(selectinload(ServerSquad.allowed_promo_groups))
+        .where(ServerSquad.squad_uuid == squad_uuid)
    )
-    return result.scalar_one_or_none()
+    return result.scalars().unique().one_or_none()


 async def get_server_squad_by_id(
@@ -57,9 +100,11 @@ async def get_server_squad_by_id(
 ) -> Optional[ServerSquad]:
    
    result = await db.execute(
-        select(ServerSquad).where(ServerSquad.id == server_id)
+        select(ServerSquad)
+        .options(selectinload(ServerSquad.allowed_promo_groups))
+        .where(ServerSquad.id == server_id)
    )
-    return result.scalar_one_or_none()
+    return result.scalars().unique().one_or_none()


 async def get_all_server_squads(
@@ -91,14 +136,59 @@ async def get_all_server_squads(
    return servers, total_count


-async def get_available_server_squads(db: AsyncSession) -> List[ServerSquad]:
-    
-    result = await db.execute(
+async def get_available_server_squads(
+    db: AsyncSession,
+    promo_group_id: Optional[int] = None,
+) -> List[ServerSquad]:
+
+    query = (
        select(ServerSquad)
-        .where(ServerSquad.is_available == True)
+        .options(selectinload(ServerSquad.allowed_promo_groups))
+        .where(ServerSquad.is_available.is_(True))
        .order_by(ServerSquad.sort_order, ServerSquad.display_name)
    )
-    return result.scalars().all()
+
+    if promo_group_id is not None:
+        query = query.join(ServerSquad.allowed_promo_groups).where(
+            PromoGroup.id == promo_group_id
+        )
+
+    result = await db.execute(query)
+    return result.scalars().unique().all()
+
+
+async def update_server_squad_promo_groups(
+    db: AsyncSession, server_id: int, promo_group_ids: Iterable[int]
+) -> Optional[ServerSquad]:
+    unique_ids = [int(pg_id) for pg_id in set(promo_group_ids)]
+
+    if not unique_ids:
+        raise ValueError("Нужно выбрать хотя бы одну промогруппу")
+
+    server = await get_server_squad_by_id(db, server_id)
+    if not server:
+        return None
+
+    result = await db.execute(
+        select(PromoGroup).where(PromoGroup.id.in_(unique_ids))
+    )
+    promo_groups = result.scalars().all()
+
+    if not promo_groups:
+        raise ValueError("Не найдены промогруппы для обновления сервера")
+
+    server.allowed_promo_groups = promo_groups
+    await db.commit()
+    await db.refresh(server)
+
+    logger.info(
+        "Обновлены промогруппы сервера %s (ID: %s): %s",
+        server.display_name,
+        server.id,
+        ", ".join(pg.name for pg in promo_groups),
+    )
+
+    return server


 async def update_server_squad(
@@ -153,10 +243,10 @@ async def sync_with_remnawave(
    db: AsyncSession,
    remnawave_squads: List[dict]
 ) -> Tuple[int, int, int]:
-    
+
    created = 0
    updated = 0
-    disabled = 0
+    removed = 0
    
    existing_servers = {}
    result = await db.execute(select(ServerSquad))
@@ -186,15 +276,121 @@ async def sync_with_remnawave(
            )
            created += 1
    
-    for uuid, server in existing_servers.items():
-        if uuid not in remnawave_uuids and server.is_available:
-            server.is_available = False
-            disabled += 1
-    
+    removed_servers = [
+        server for uuid, server in existing_servers.items()
+        if uuid not in remnawave_uuids
+    ]
+
+    if removed_servers:
+        removed_ids = [server.id for server in removed_servers]
+        removed_uuids = {server.squad_uuid for server in removed_servers}
+
+        subscription_ids_result = await db.execute(
+            select(SubscriptionServer.subscription_id)
+            .where(SubscriptionServer.server_squad_id.in_(removed_ids))
+        )
+        subscription_ids = {row[0] for row in subscription_ids_result.fetchall()}
+
+        for server in removed_servers:
+            logger.info(
+                "🗑️ Удаляется сервер %s (UUID: %s)",
+                server.display_name,
+                server.squad_uuid,
+            )
+
+        await db.execute(
+            delete(SubscriptionServer).where(SubscriptionServer.server_squad_id.in_(removed_ids))
+        )
+
+        subscriptions_to_update: dict[int, Subscription] = {}
+
+        if subscription_ids:
+            subscriptions_result = await db.execute(
+                select(Subscription).where(Subscription.id.in_(subscription_ids))
+            )
+            for subscription in subscriptions_result.scalars().unique().all():
+                subscriptions_to_update[subscription.id] = subscription
+
+        for squad_uuid in removed_uuids:
+            if not squad_uuid:
+                continue
+
+            extra_result = await db.execute(
+                select(Subscription).where(
+                    text("connected_squads::text LIKE :uuid_pattern")
+                ),
+                {"uuid_pattern": f'%"{squad_uuid}"%'}
+            )
+
+            for subscription in extra_result.scalars().unique().all():
+                subscriptions_to_update[subscription.id] = subscription
+
+        cleaned_subscriptions = 0
+
+        for subscription in subscriptions_to_update.values():
+            current_squads = list(subscription.connected_squads or [])
+            if not current_squads:
+                continue
+
+            filtered_squads = [
+                squad_uuid for squad_uuid in current_squads if squad_uuid not in removed_uuids
+            ]
+
+            if len(filtered_squads) != len(current_squads):
+                subscription.connected_squads = filtered_squads
+                subscription.updated_at = datetime.utcnow()
+                cleaned_subscriptions += 1
+
+        await db.execute(delete(ServerSquad).where(ServerSquad.id.in_(removed_ids)))
+        removed = len(removed_servers)
+
+        if cleaned_subscriptions:
+            logger.info(
+                "🧹 Обновлены подписки после удаления серверов: %s",
+                cleaned_subscriptions,
+            )
+
    await db.commit()
-    
-    logger.info(f"🔄 Синхронизация завершена: +{created} ~{updated} -{disabled}")
-    return created, updated, disabled
+
+    logger.info(f"🔄 Синхронизация завершена: +{created} ~{updated} -{removed}")
+    return created, updated, removed
+
+
+async def get_server_connected_users(
+    db: AsyncSession,
+    server_id: int
+) -> List[User]:
+
+    server_uuid_result = await db.execute(
+        select(ServerSquad.squad_uuid).where(ServerSquad.id == server_id)
+    )
+    server_uuid = server_uuid_result.scalar_one_or_none()
+
+    connection_filters = [SubscriptionServer.id.isnot(None)]
+
+    if server_uuid:
+        connection_filters.append(
+            cast(Subscription.connected_squads, String).like(
+                f'%"{server_uuid}"%'
+            )
+        )
+
+    result = await db.execute(
+        select(User)
+        .join(Subscription, Subscription.user_id == User.id)
+        .outerjoin(
+            SubscriptionServer,
+            and_(
+                SubscriptionServer.subscription_id == Subscription.id,
+                SubscriptionServer.server_squad_id == server_id,
+            ),
+        )
+        .where(or_(*connection_filters))
+        .options(selectinload(User.subscription))
+        .order_by(User.id)
+    )
+
+    return result.scalars().unique().all()


 def _generate_display_name(original_name: str) -> str:
@@ -116,13 +116,33 @@ async def extend_subscription(
    else:
        subscription.end_date = current_time + timedelta(days=days)
        logger.info(f"📅 Подписка истекла, устанавливаем новую дату окончания")
-    
+
+    if subscription.is_trial:
+        start_date = subscription.start_date or current_time
+        total_duration = subscription.end_date - start_date
+        max_trial_duration = timedelta(days=settings.TRIAL_DURATION_DAYS)
+
+        if total_duration > max_trial_duration:
+            subscription.is_trial = False
+            logger.info(
+                "🎯 Подписка %s автоматически переведена из триальной в платную после продления"
+                ", итоговая длительность: %s дней",
+                subscription.id,
+                total_duration.days,
+            )
+            if subscription.user:
+                subscription.user.has_had_paid_subscription = True
+
    if subscription.status == SubscriptionStatus.EXPIRED.value:
        subscription.status = SubscriptionStatus.ACTIVE.value
        logger.info(f"🔄 Статус изменён с EXPIRED на ACTIVE")
-    
+
+    if settings.RESET_TRAFFIC_ON_PAYMENT:
+        subscription.traffic_used_gb = 0.0
+        logger.info("🔄 Сбрасываем использованный трафик согласно настройке RESET_TRAFFIC_ON_PAYMENT")
+
    subscription.updated_at = current_time
-    
+
    await db.commit()
    await db.refresh(subscription)
    await clear_notifications(db, subscription.id)
@@ -531,7 +551,15 @@ async def calculate_subscription_total_cost(
    
    months_in_period = calculate_months_from_days(period_days)
    
-    base_price = PERIOD_PRICES.get(period_days, 0)
+    base_price_original = PERIOD_PRICES.get(period_days, 0)
+    period_discount_percent = _get_discount_percent(
+        user,
+        promo_group,
+        "period",
+        period_days=period_days,
+    )
+    base_discount_total = base_price_original * period_discount_percent // 100
+    base_price = base_price_original - base_discount_total
    
    promo_group = promo_group or (user.promo_group if user else None)

@@ -577,6 +605,9 @@ async def calculate_subscription_total_cost(

    details = {
        'base_price': base_price,
+        'base_price_original': base_price_original,
+        'base_discount_percent': period_discount_percent,
+        'base_discount_total': base_discount_total,
        'traffic_price_per_month': traffic_price_per_month,
        'traffic_discount_percent': traffic_discount_percent,
        'traffic_discount_total': total_traffic_discount,
@@ -954,7 +985,8 @@ async def create_subscription(
    device_limit: int = 1,
    connected_squads: list = None,
    remnawave_short_uuid: str = None,
-    subscription_url: str = ""
+    subscription_url: str = "",
+    subscription_crypto_link: str = ""
 ) -> Subscription:
    
    if end_date is None:
@@ -973,7 +1005,8 @@ async def create_subscription(
        device_limit=device_limit,
        connected_squads=connected_squads,
        remnawave_short_uuid=remnawave_short_uuid,
-        subscription_url=subscription_url
+        subscription_url=subscription_url,
+        subscription_crypto_link=subscription_crypto_link
    )
    
    db.add(subscription)
@@ -0,0 +1,40 @@
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import SystemSetting
+
+
+async def upsert_system_setting(
+    db: AsyncSession,
+    key: str,
+    value: Optional[str],
+    description: Optional[str] = None,
+) -> SystemSetting:
+    result = await db.execute(
+        select(SystemSetting).where(SystemSetting.key == key)
+    )
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = SystemSetting(key=key, value=value, description=description)
+        db.add(setting)
+    else:
+        setting.value = value
+        if description is not None:
+            setting.description = description
+
+    await db.flush()
+    return setting
+
+
+async def delete_system_setting(db: AsyncSession, key: str) -> None:
+    result = await db.execute(
+        select(SystemSetting).where(SystemSetting.key == key)
+    )
+    setting = result.scalar_one_or_none()
+    if setting is not None:
+        await db.delete(setting)
+        await db.flush()
+
@@ -4,7 +4,7 @@ from sqlalchemy import select, desc, and_, or_, update, func
 from sqlalchemy.orm import selectinload
 from datetime import datetime

-from app.database.models import Ticket, TicketMessage, TicketStatus, User
+from app.database.models import Ticket, TicketMessage, TicketStatus, User, SupportAuditLog


 class TicketCRUD:
@@ -87,6 +87,40 @@ class TicketCRUD:
        result = await db.execute(query)
        return result.scalars().all()

+    @staticmethod
+    async def count_user_tickets_by_statuses(
+        db: AsyncSession,
+        user_id: int,
+        statuses: List[str]
+    ) -> int:
+        """Подсчитать количество тикетов пользователя по списку статусов"""
+        query = select(func.count()).select_from(Ticket).where(Ticket.user_id == user_id)
+        if statuses:
+            query = query.where(Ticket.status.in_(statuses))
+        result = await db.execute(query)
+        return int(result.scalar() or 0)
+
+    @staticmethod
+    async def get_user_tickets_by_statuses(
+        db: AsyncSession,
+        user_id: int,
+        statuses: List[str],
+        limit: int = 20,
+        offset: int = 0
+    ) -> List[Ticket]:
+        """Получить тикеты пользователя по списку статусов с пагинацией"""
+        query = (
+            select(Ticket)
+            .where(Ticket.user_id == user_id)
+            .order_by(desc(Ticket.updated_at))
+            .offset(offset)
+            .limit(limit)
+        )
+        if statuses:
+            query = query.where(Ticket.status.in_(statuses))
+        result = await db.execute(query)
+        return result.scalars().all()
+
    @staticmethod
    async def user_has_active_ticket(
        db: AsyncSession,
@@ -239,6 +273,54 @@ class TicketCRUD:
        return await TicketCRUD.update_ticket_status(
            db, ticket_id, TicketStatus.CLOSED.value, datetime.utcnow()
        )
+
+    @staticmethod
+    async def add_support_audit(
+        db: AsyncSession,
+        *,
+        actor_user_id: Optional[int],
+        actor_telegram_id: int,
+        is_moderator: bool,
+        action: str,
+        ticket_id: Optional[int] = None,
+        target_user_id: Optional[int] = None,
+        details: Optional[dict] = None,
+    ) -> None:
+        try:
+            log = SupportAuditLog(
+                actor_user_id=actor_user_id,
+                actor_telegram_id=actor_telegram_id,
+                is_moderator=bool(is_moderator),
+                action=action,
+                ticket_id=ticket_id,
+                target_user_id=target_user_id,
+                details=details or {},
+            )
+            db.add(log)
+            await db.commit()
+        except Exception:
+            await db.rollback()
+            # не мешаем основной логике
+            pass
+
+    @staticmethod
+    async def list_support_audit(
+        db: AsyncSession,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> List[SupportAuditLog]:
+        from sqlalchemy import select, desc
+        result = await db.execute(
+            select(SupportAuditLog).order_by(desc(SupportAuditLog.created_at)).offset(offset).limit(limit)
+        )
+        return result.scalars().all()
+
+    @staticmethod
+    async def count_support_audit(db: AsyncSession) -> int:
+        from sqlalchemy import select, func
+        result = await db.execute(select(func.count()).select_from(SupportAuditLog))
+        return int(result.scalar() or 0)
    
    @staticmethod
    async def get_open_tickets_count(db: AsyncSession) -> int:
@@ -291,6 +373,14 @@ class TicketMessageCRUD:
            else:
                # Пользователь ответил - тикет открыт
                ticket.status = TicketStatus.OPEN.value
+                # Сбросить отметку последнего SLA-напоминания, чтобы снова напоминать от времени нового сообщения
+                try:
+                    from sqlalchemy import inspect as sa_inspect
+                    # если колонка существует в модели
+                    if hasattr(ticket, 'last_sla_reminder_at'):
+                        ticket.last_sla_reminder_at = None
+                except Exception:
+                    pass
            
            ticket.updated_at = datetime.utcnow()
        
@@ -37,6 +37,20 @@ async def create_transaction(
    await db.refresh(transaction)
    
    logger.info(f"💳 Создана транзакция: {type.value} на {amount_kopeks/100}₽ для пользователя {user_id}")
+
+    try:
+        from app.services.promo_group_assignment import (
+            maybe_assign_promo_group_by_total_spent,
+        )
+
+        await maybe_assign_promo_group_by_total_spent(db, user_id)
+    except Exception as exc:
+        logger.debug(
+            "Не удалось проверить автовыдачу промогруппы для пользователя %s: %s",
+            user_id,
+            exc,
+        )
+
    return transaction


@@ -98,15 +112,42 @@ async def get_user_transactions_count(
    return result.scalar()


+async def get_user_total_spent_kopeks(db: AsyncSession, user_id: int) -> int:
+    result = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            and_(
+                Transaction.user_id == user_id,
+                Transaction.is_completed.is_(True),
+                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+            )
+        )
+    )
+    return int(result.scalar_one())
+
+
 async def complete_transaction(db: AsyncSession, transaction: Transaction) -> Transaction:
-    
+
    transaction.is_completed = True
    transaction.completed_at = datetime.utcnow()
-    
+
    await db.commit()
    await db.refresh(transaction)
-    
+
    logger.info(f"✅ Транзакция {transaction.id} завершена")
+
+    try:
+        from app.services.promo_group_assignment import (
+            maybe_assign_promo_group_by_total_spent,
+        )
+
+        await maybe_assign_promo_group_by_total_spent(db, transaction.user_id)
+    except Exception as exc:
+        logger.debug(
+            "Не удалось проверить автовыдачу промогруппы для пользователя %s: %s",
+            transaction.user_id,
+            exc,
+        )
+
    return transaction


@@ -2,14 +2,23 @@ import logging
 import secrets
 import string
 from datetime import datetime, timedelta
-from typing import Optional, List
-from sqlalchemy import select, and_, or_, func
+from typing import Optional, List, Dict
+from sqlalchemy import select, and_, or_, func, case, nullslast
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.database.models import User, UserStatus, Subscription, Transaction, PromoGroup
+from app.database.models import (
+    User,
+    UserStatus,
+    Subscription,
+    Transaction,
+    PromoGroup,
+    PaymentMethod,
+    TransactionType,
+)
 from app.config import settings
 from app.database.crud.promo_group import get_default_promo_group
+from app.utils.validators import sanitize_telegram_name

 logger = logging.getLogger(__name__)

@@ -88,8 +97,7 @@ async def create_user(
 ) -> User:
    
    if not referral_code:
-        from app.utils.user_utils import generate_unique_referral_code
-        referral_code = await generate_unique_referral_code(db, telegram_id)
+        referral_code = await create_unique_referral_code(db)
    
    default_group = await get_default_promo_group(db)
    if not default_group:
@@ -105,11 +113,13 @@ async def create_user(

    promo_group_id = default_group.id

+    safe_first = sanitize_telegram_name(first_name)
+    safe_last = sanitize_telegram_name(last_name)
    user = User(
        telegram_id=telegram_id,
        username=username,
-        first_name=first_name,
-        last_name=last_name,
+        first_name=safe_first,
+        last_name=safe_last,
        language=language,
        referred_by_id=referred_by_id,
        referral_code=referral_code,
@@ -137,7 +147,10 @@ async def update_user(
    **kwargs
 ) -> User:
    
+    from app.utils.validators import sanitize_telegram_name
    for field, value in kwargs.items():
+        if field in ("first_name", "last_name"):
+            value = sanitize_telegram_name(value)
        if hasattr(user, field):
            setattr(user, field, value)
    
@@ -206,10 +219,12 @@ async def add_user_balance_by_id(


 async def subtract_user_balance(
-    db: AsyncSession, 
-    user: User, 
-    amount_kopeks: int, 
-    description: str
+    db: AsyncSession,
+    user: User,
+    amount_kopeks: int,
+    description: str,
+    create_transaction: bool = False,
+    payment_method: Optional[PaymentMethod] = None,
 ) -> bool:
    logger.error(f"💸 ОТЛАДКА subtract_user_balance:")
    logger.error(f"   👤 User ID: {user.id} (TG: {user.telegram_id})")
@@ -228,7 +243,21 @@ async def subtract_user_balance(
        
        await db.commit()
        await db.refresh(user)
-        
+
+        if create_transaction:
+            from app.database.crud.transaction import (
+                create_transaction as create_trans,
+            )
+
+            await create_trans(
+                db=db,
+                user_id=user.id,
+                type=TransactionType.WITHDRAWAL,
+                amount_kopeks=amount_kopeks,
+                description=description,
+                payment_method=payment_method,
+            )
+
        logger.error(f"   ✅ Средства списаны: {old_balance} → {user.balance_kopeks}")
        return True
        
@@ -244,7 +273,11 @@ async def get_users_list(
    limit: int = 50,
    search: Optional[str] = None,
    status: Optional[UserStatus] = None,
-    order_by_balance: bool = False
+    order_by_balance: bool = False,
+    order_by_traffic: bool = False,
+    order_by_last_activity: bool = False,
+    order_by_total_spent: bool = False,
+    order_by_purchase_count: bool = False
 ) -> List[User]:
    
    query = select(User).options(selectinload(User.subscription))
@@ -264,10 +297,71 @@ async def get_users_list(
            conditions.append(User.telegram_id == int(search))
        
        query = query.where(or_(*conditions))
-    
-    # Сортировка по балансу в порядке убывания, если order_by_balance=True
-    if order_by_balance:
-        query = query.order_by(User.balance_kopeks.desc())
+
+    sort_flags = [
+        order_by_balance,
+        order_by_traffic,
+        order_by_last_activity,
+        order_by_total_spent,
+        order_by_purchase_count,
+    ]
+    if sum(int(flag) for flag in sort_flags) > 1:
+        logger.debug(
+            "Выбрано несколько сортировок пользователей — применяется приоритет: трафик > траты > покупки > баланс > активность"
+        )
+
+    transactions_stats = None
+    if order_by_total_spent or order_by_purchase_count:
+        from app.database.models import Transaction
+
+        transactions_stats = (
+            select(
+                Transaction.user_id.label("user_id"),
+                func.coalesce(
+                    func.sum(
+                        case(
+                            (
+                                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                                Transaction.amount_kopeks,
+                            ),
+                            else_=0,
+                        )
+                    ),
+                    0,
+                ).label("total_spent"),
+                func.coalesce(
+                    func.sum(
+                        case(
+                            (
+                                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                                1,
+                            ),
+                            else_=0,
+                        )
+                    ),
+                    0,
+                ).label("purchase_count"),
+            )
+            .where(Transaction.is_completed.is_(True))
+            .group_by(Transaction.user_id)
+            .subquery()
+        )
+        query = query.outerjoin(transactions_stats, transactions_stats.c.user_id == User.id)
+
+    if order_by_traffic:
+        traffic_sort = func.coalesce(Subscription.traffic_used_gb, 0.0)
+        query = query.outerjoin(Subscription, Subscription.user_id == User.id)
+        query = query.order_by(traffic_sort.desc(), User.created_at.desc())
+    elif order_by_total_spent:
+        order_column = func.coalesce(transactions_stats.c.total_spent, 0)
+        query = query.order_by(order_column.desc(), User.created_at.desc())
+    elif order_by_purchase_count:
+        order_column = func.coalesce(transactions_stats.c.purchase_count, 0)
+        query = query.order_by(order_column.desc(), User.created_at.desc())
+    elif order_by_balance:
+        query = query.order_by(User.balance_kopeks.desc(), User.created_at.desc())
+    elif order_by_last_activity:
+        query = query.order_by(nullslast(User.last_activity.desc()), User.created_at.desc())
    else:
        query = query.order_by(User.created_at.desc())
    
@@ -305,6 +399,62 @@ async def get_users_count(
    return result.scalar()


+async def get_users_spending_stats(
+    db: AsyncSession,
+    user_ids: List[int]
+) -> Dict[int, Dict[str, int]]:
+    if not user_ids:
+        return {}
+
+    from app.database.models import Transaction
+
+    stats_query = (
+        select(
+            Transaction.user_id,
+            func.coalesce(
+                func.sum(
+                    case(
+                        (
+                            Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                            Transaction.amount_kopeks,
+                        ),
+                        else_=0,
+                    )
+                ),
+                0,
+            ).label("total_spent"),
+            func.coalesce(
+                func.sum(
+                    case(
+                        (
+                            Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                            1,
+                        ),
+                        else_=0,
+                    )
+                ),
+                0,
+            ).label("purchase_count"),
+        )
+        .where(
+            Transaction.user_id.in_(user_ids),
+            Transaction.is_completed.is_(True),
+        )
+        .group_by(Transaction.user_id)
+    )
+
+    result = await db.execute(stats_query)
+    rows = result.all()
+
+    return {
+        row.user_id: {
+            "total_spent": int(row.total_spent or 0),
+            "purchase_count": int(row.purchase_count or 0),
+        }
+        for row in rows
+    }
+
+
 async def get_referrals(db: AsyncSession, user_id: int) -> List[User]:
    result = await db.execute(
        select(User)
@@ -0,0 +1,106 @@
+"""CRUD операции для токенов административного веб-API."""
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, List, Optional
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import WebApiToken
+
+
+async def list_tokens(
+    db: AsyncSession,
+    *,
+    include_inactive: bool = False,
+) -> List[WebApiToken]:
+    query = select(WebApiToken)
+
+    if not include_inactive:
+        query = query.where(WebApiToken.is_active.is_(True))
+
+    query = query.order_by(WebApiToken.created_at.desc())
+
+    result = await db.execute(query)
+    return list(result.scalars().all())
+
+
+async def get_token_by_id(db: AsyncSession, token_id: int) -> Optional[WebApiToken]:
+    return await db.get(WebApiToken, token_id)
+
+
+async def get_token_by_hash(db: AsyncSession, token_hash: str) -> Optional[WebApiToken]:
+    query = select(WebApiToken).where(
+        WebApiToken.token_hash == token_hash
+    )
+    result = await db.execute(query)
+    return result.scalar_one_or_none()
+
+
+async def create_token(
+    db: AsyncSession,
+    *,
+    name: str,
+    token_hash: str,
+    token_prefix: str,
+    description: Optional[str] = None,
+    expires_at: Optional[datetime] = None,
+    created_by: Optional[str] = None,
+) -> WebApiToken:
+    token = WebApiToken(
+        name=name,
+        token_hash=token_hash,
+        token_prefix=token_prefix,
+        description=description,
+        expires_at=expires_at,
+        created_by=created_by,
+        is_active=True,
+    )
+
+    db.add(token)
+    await db.flush()
+    await db.refresh(token)
+    return token
+
+
+async def update_token(
+    db: AsyncSession,
+    token: WebApiToken,
+    **kwargs,
+) -> WebApiToken:
+    for key, value in kwargs.items():
+        if hasattr(token, key):
+            setattr(token, key, value)
+    token.updated_at = datetime.utcnow()
+    await db.flush()
+    await db.refresh(token)
+    return token
+
+
+async def set_tokens_active_status(
+    db: AsyncSession,
+    token_ids: Iterable[int],
+    *,
+    is_active: bool,
+) -> None:
+    await db.execute(
+        update(WebApiToken)
+        .where(WebApiToken.id.in_(list(token_ids)))
+        .values(is_active=is_active, updated_at=datetime.utcnow())
+    )
+
+
+async def delete_token(db: AsyncSession, token: WebApiToken) -> None:
+    await db.delete(token)
+
+
+__all__ = [
+    "list_tokens",
+    "get_token_by_id",
+    "get_token_by_hash",
+    "create_token",
+    "update_token",
+    "set_tokens_active_status",
+    "delete_token",
+]
@@ -10,7 +10,7 @@ from app.database.models import Base
 logger = logging.getLogger(__name__)

 engine = create_async_engine(
-    settings.DATABASE_URL,
+    settings.get_database_url(),
    poolclass=NullPool,
    echo=settings.DEBUG,
    future=True
@@ -48,4 +48,4 @@ async def init_db():

 async def close_db():
    await engine.dispose()
-    logger.info("✅ Подключение к базе данных закрыто")
+    logger.info("✅ Подключение к базе данных закрыто")
@@ -1,5 +1,5 @@
 from datetime import datetime, timedelta
-from typing import Optional, List
+from typing import Optional, List, Dict
 from enum import Enum

 from sqlalchemy import (
@@ -14,6 +14,8 @@ from sqlalchemy import (
    JSON,
    BigInteger,
    UniqueConstraint,
+    Index,
+    Table,
 )
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import relationship, Mapped, mapped_column
@@ -23,6 +25,24 @@ from sqlalchemy.sql import func
 Base = declarative_base()


+server_squad_promo_groups = Table(
+    "server_squad_promo_groups",
+    Base.metadata,
+    Column(
+        "server_squad_id",
+        Integer,
+        ForeignKey("server_squads.id", ondelete="CASCADE"),
+        primary_key=True,
+    ),
+    Column(
+        "promo_group_id",
+        Integer,
+        ForeignKey("promo_groups.id", ondelete="CASCADE"),
+        primary_key=True,
+    ),
+)
+
+
 class UserStatus(Enum):
    ACTIVE = "active"
    BLOCKED = "blocked"
@@ -53,9 +73,11 @@ class PromoCodeType(Enum):
 class PaymentMethod(Enum):
    TELEGRAM_STARS = "telegram_stars"
    TRIBUTE = "tribute"
-    YOOKASSA = "yookassa" 
+    YOOKASSA = "yookassa"
    CRYPTOBOT = "cryptobot"
-    MANUAL = "manual"  
+    MULENPAY = "mulenpay"
+    PAL24 = "pal24"
+    MANUAL = "manual"

 class YooKassaPayment(Base):
    __tablename__ = "yookassa_payments"
@@ -107,7 +129,7 @@ class YooKassaPayment(Base):

 class CryptoBotPayment(Base):
    __tablename__ = "cryptobot_payments"
-    
+
    id = Column(Integer, primary_key=True, index=True)
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
@@ -155,6 +177,111 @@ class CryptoBotPayment(Base):
        return f"<CryptoBotPayment(id={self.id}, invoice_id={self.invoice_id}, amount={self.amount} {self.asset}, status={self.status})>"


+class MulenPayPayment(Base):
+    __tablename__ = "mulenpay_payments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    mulen_payment_id = Column(Integer, nullable=True, index=True)
+    uuid = Column(String(255), unique=True, nullable=False, index=True)
+    amount_kopeks = Column(Integer, nullable=False)
+    currency = Column(String(10), nullable=False, default="RUB")
+    description = Column(Text, nullable=True)
+
+    status = Column(String(50), nullable=False, default="created")
+    is_paid = Column(Boolean, default=False)
+    paid_at = Column(DateTime, nullable=True)
+
+    payment_url = Column(Text, nullable=True)
+    metadata_json = Column(JSON, nullable=True)
+    callback_payload = Column(JSON, nullable=True)
+
+    transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    user = relationship("User", backref="mulenpay_payments")
+    transaction = relationship("Transaction", backref="mulenpay_payment")
+
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return (
+            "<MulenPayPayment(id={0}, mulen_id={1}, amount={2}₽, status={3})>".format(
+                self.id,
+                self.mulen_payment_id,
+                self.amount_rubles,
+                self.status,
+            )
+        )
+
+
+class Pal24Payment(Base):
+    __tablename__ = "pal24_payments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    bill_id = Column(String(255), unique=True, nullable=False, index=True)
+    order_id = Column(String(255), nullable=True, index=True)
+    amount_kopeks = Column(Integer, nullable=False)
+    currency = Column(String(10), nullable=False, default="RUB")
+    description = Column(Text, nullable=True)
+    type = Column(String(20), nullable=False, default="normal")
+
+    status = Column(String(50), nullable=False, default="NEW")
+    is_active = Column(Boolean, default=True)
+    is_paid = Column(Boolean, default=False)
+    paid_at = Column(DateTime, nullable=True)
+    last_status = Column(String(50), nullable=True)
+    last_status_checked_at = Column(DateTime, nullable=True)
+
+    link_url = Column(Text, nullable=True)
+    link_page_url = Column(Text, nullable=True)
+    metadata_json = Column(JSON, nullable=True)
+    callback_payload = Column(JSON, nullable=True)
+
+    payment_id = Column(String(255), nullable=True, index=True)
+    payment_status = Column(String(50), nullable=True)
+    payment_method = Column(String(50), nullable=True)
+    balance_amount = Column(String(50), nullable=True)
+    balance_currency = Column(String(10), nullable=True)
+    payer_account = Column(String(255), nullable=True)
+
+    ttl = Column(Integer, nullable=True)
+    expires_at = Column(DateTime, nullable=True)
+
+    transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    user = relationship("User", backref="pal24_payments")
+    transaction = relationship("Transaction", backref="pal24_payment")
+
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+
+    @property
+    def is_pending(self) -> bool:
+        return self.status in {"NEW", "PROCESS"}
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return (
+            "<Pal24Payment(id={0}, bill_id={1}, amount={2}₽, status={3})>".format(
+                self.id,
+                self.bill_id,
+                self.amount_rubles,
+                self.status,
+            )
+        )
+
+
 class PromoGroup(Base):
    __tablename__ = "promo_groups"

@@ -163,13 +290,67 @@ class PromoGroup(Base):
    server_discount_percent = Column(Integer, nullable=False, default=0)
    traffic_discount_percent = Column(Integer, nullable=False, default=0)
    device_discount_percent = Column(Integer, nullable=False, default=0)
+    period_discounts = Column(JSON, nullable=True, default=dict)
+    auto_assign_total_spent_kopeks = Column(Integer, nullable=True, default=None)
+    apply_discounts_to_addons = Column(Boolean, nullable=False, default=True)
    is_default = Column(Boolean, nullable=False, default=False)
    created_at = Column(DateTime, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())

    users = relationship("User", back_populates="promo_group")
+    server_squads = relationship(
+        "ServerSquad",
+        secondary=server_squad_promo_groups,
+        back_populates="allowed_promo_groups",
+        lazy="selectin",
+    )
+
+    def _get_period_discounts_map(self) -> Dict[int, int]:
+        raw_discounts = self.period_discounts or {}
+
+        if isinstance(raw_discounts, dict):
+            items = raw_discounts.items()
+        else:
+            items = []
+
+        normalized: Dict[int, int] = {}
+
+        for key, value in items:
+            try:
+                period = int(key)
+                percent = int(value)
+            except (TypeError, ValueError):
+                continue
+
+            normalized[period] = max(0, min(100, percent))
+
+        return normalized
+
+    def _get_period_discount(self, period_days: Optional[int]) -> int:
+        if not period_days:
+            return 0
+
+        discounts = self._get_period_discounts_map()
+
+        if period_days in discounts:
+            return discounts[period_days]
+
+        if self.is_default:
+            try:
+                from app.config import settings
+
+                if settings.is_base_promo_group_period_discount_enabled():
+                    config_discounts = settings.get_base_promo_group_period_discounts()
+                    return config_discounts.get(period_days, 0)
+            except Exception:
+                return 0
+
+        return 0

    def get_discount_percent(self, category: str, period_days: Optional[int] = None) -> int:
+        if category == "period":
+            return max(0, min(100, self._get_period_discount(period_days)))
+
        mapping = {
            "servers": self.server_discount_percent,
            "traffic": self.traffic_discount_percent,
@@ -177,24 +358,12 @@ class PromoGroup(Base):
        }
        percent = mapping.get(category, 0)

-        if self.is_default and period_days is not None:
-            try:
-                from app.config import settings
-
-                if settings.is_base_promo_group_period_discount_enabled():
-                    discounts = settings.get_base_promo_group_period_discounts()
-                    if period_days in discounts:
-                        period_discount = discounts[period_days]
-                        percent = period_discount
-            except Exception:
-                pass
-
        return max(0, min(100, percent))


 class User(Base):
    __tablename__ = "users"
-    
+
    id = Column(Integer, primary_key=True, index=True)
    telegram_id = Column(BigInteger, unique=True, index=True, nullable=False)
    username = Column(String(255), nullable=True)
@@ -216,7 +385,10 @@ class User(Base):
    subscription = relationship("Subscription", back_populates="user", uselist=False)
    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")
    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)
    last_remnawave_sync = Column(DateTime, nullable=True)
    trojan_password = Column(String(255), nullable=True)
    vless_uuid = Column(String(255), nullable=True)
@@ -265,7 +437,8 @@ class Subscription(Base):
    traffic_used_gb = Column(Float, default=0.0)

    subscription_url = Column(String, nullable=True)
-    
+    subscription_crypto_link = Column(String, nullable=True)
+
    device_limit = Column(Integer, default=1)
    
    connected_squads = Column(JSON, default=list)
@@ -277,8 +450,9 @@ class Subscription(Base):
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
    
    remnawave_short_uuid = Column(String(255), nullable=True)
-    
+
    user = relationship("User", back_populates="subscription")
+    discount_offers = relationship("DiscountOffer", back_populates="subscription")
    
    @property
    def is_active(self) -> bool:
@@ -397,8 +571,7 @@ class Subscription(Base):
        return 0.0
    
    def extend_subscription(self, days: int):
-        from datetime import timedelta, datetime
-    
+
        if self.end_date > datetime.utcnow():
            self.end_date = self.end_date + timedelta(days=days)
        else:
@@ -622,6 +795,28 @@ class SentNotification(Base):
    user = relationship("User", backref="sent_notifications")
    subscription = relationship("Subscription", backref="sent_notifications")

+
+class DiscountOffer(Base):
+    __tablename__ = "discount_offers"
+    __table_args__ = (
+        Index("ix_discount_offers_user_type", "user_id", "notification_type"),
+    )
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+    subscription_id = Column(Integer, ForeignKey("subscriptions.id", ondelete="SET NULL"), nullable=True)
+    notification_type = Column(String(50), nullable=False)
+    discount_percent = Column(Integer, nullable=False, default=0)
+    bonus_amount_kopeks = Column(Integer, nullable=False, default=0)
+    expires_at = Column(DateTime, nullable=False)
+    claimed_at = Column(DateTime, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    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")
+
 class BroadcastHistory(Base):
    __tablename__ = "broadcast_history"
    
@@ -644,9 +839,9 @@ class BroadcastHistory(Base):

 class ServerSquad(Base):
    __tablename__ = "server_squads"
-    
+
    id = Column(Integer, primary_key=True, index=True)
-    
+
    squad_uuid = Column(String(255), unique=True, nullable=False, index=True)
    
    display_name = Column(String(255), nullable=False)
@@ -664,10 +859,17 @@ class ServerSquad(Base):
    sort_order = Column(Integer, default=0)
    
    max_users = Column(Integer, nullable=True) 
-    current_users = Column(Integer, default=0) 
-    
+    current_users = Column(Integer, default=0)
+
    created_at = Column(DateTime, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    allowed_promo_groups = relationship(
+        "PromoGroup",
+        secondary=server_squad_promo_groups,
+        back_populates="server_squads",
+        lazy="selectin",
+    )
    
    @property
    def price_rubles(self) -> float:
@@ -703,6 +905,23 @@ class SubscriptionServer(Base):
    subscription = relationship("Subscription", backref="subscription_servers")
    server_squad = relationship("ServerSquad", backref="subscription_servers")

+
+class SupportAuditLog(Base):
+    __tablename__ = "support_audit_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    actor_user_id = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    actor_telegram_id = Column(BigInteger, nullable=False)
+    is_moderator = Column(Boolean, default=False)
+    action = Column(String(50), nullable=False)  # close_ticket, block_user_timed, block_user_perm, unblock_user
+    ticket_id = Column(Integer, ForeignKey("tickets.id", ondelete="SET NULL"), nullable=True)
+    target_user_id = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    details = Column(JSON, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+
+    actor = relationship("User", foreign_keys=[actor_user_id])
+    ticket = relationship("Ticket", foreign_keys=[ticket_id])
+
 class UserMessage(Base):
    __tablename__ = "user_messages"
    id = Column(Integer, primary_key=True, index=True)
@@ -810,6 +1029,8 @@ class Ticket(Base):
    created_at = Column(DateTime, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
    closed_at = Column(DateTime, nullable=True)
+    # SLA reminders
+    last_sla_reminder_at = Column(DateTime, nullable=True)
    
    # Связи
    user = relationship("User", backref="tickets")
@@ -869,7 +1090,7 @@ class Ticket(Base):

 class TicketMessage(Base):
    __tablename__ = "ticket_messages"
-    
+
    id = Column(Integer, primary_key=True, index=True)
    ticket_id = Column(Integer, ForeignKey("tickets.id", ondelete="CASCADE"), nullable=False)
    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
@@ -896,6 +1117,27 @@ class TicketMessage(Base):
    @property
    def is_admin_message(self) -> bool:
        return self.is_from_admin
-    
+
    def __repr__(self):
-        return f"<TicketMessage(id={self.id}, ticket_id={self.ticket_id}, is_admin={self.is_from_admin}, text='{self.message_text[:30]}...')>"
+        return f"<TicketMessage(id={self.id}, ticket_id={self.ticket_id}, is_admin={self.is_from_admin}, text='{self.message_text[:30]}...')>"
+
+
+class WebApiToken(Base):
+    __tablename__ = "web_api_tokens"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255), nullable=False)
+    token_hash = Column(String(128), nullable=False, unique=True, index=True)
+    token_prefix = Column(String(32), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    expires_at = Column(DateTime, nullable=True)
+    last_used_at = Column(DateTime, nullable=True)
+    last_used_ip = Column(String(64), nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    created_by = Column(String(255), nullable=True)
+
+    def __repr__(self) -> str:
+        status = "active" if self.is_active else "revoked"
+        return f"<WebApiToken id={self.id} name='{self.name}' status={status}>"
@@ -0,0 +1,216 @@
+"""Async client for PayPalych (Pal24) API."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import logging
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from typing import Any, Dict, Optional
+
+import aiohttp
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class Pal24APIError(Exception):
+    """Base error for Pal24 API operations."""
+
+
+@dataclass(slots=True)
+class Pal24Response:
+    """Wrapper for Pal24 API responses."""
+
+    success: bool
+    data: Dict[str, Any]
+    status: int
+
+    @classmethod
+    def from_payload(cls, payload: Dict[str, Any], status: int) -> "Pal24Response":
+        success = bool(payload.get("success", status < 400))
+        return cls(success=success, data=payload, status=status)
+
+    def raise_for_status(self, endpoint: str) -> None:
+        if not self.success:
+            detail = self.data.get("message") or self.data.get("error")
+            raise Pal24APIError(
+                f"Pal24 API error at {endpoint}: status={self.status}, detail={detail or self.data}"
+            )
+
+
+class Pal24Client:
+    """Async client implementing PayPalych API methods."""
+
+    def __init__(
+        self,
+        *,
+        api_token: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: Optional[int] = None,
+    ) -> None:
+        self.api_token = api_token or settings.PAL24_API_TOKEN
+        self.base_url = (base_url or settings.PAL24_BASE_URL or "").rstrip("/") + "/"
+        self.timeout = timeout or settings.PAL24_REQUEST_TIMEOUT
+
+        if not self.api_token:
+            logger.warning("Pal24Client initialized without API token")
+
+    @property
+    def is_configured(self) -> bool:
+        return bool(self.api_token and self.base_url)
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        json_payload: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Pal24Response:
+        if not self.is_configured:
+            raise Pal24APIError("Pal24 client is not configured")
+
+        url = f"{self.base_url}{endpoint.lstrip('/')}"
+        headers = {
+            "Authorization": f"Bearer {self.api_token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.request(
+                    method,
+                    url,
+                    headers=headers,
+                    json=json_payload,
+                    params=params,
+                ) as response:
+                    status = response.status
+                    try:
+                        payload = await response.json(content_type=None)
+                    except aiohttp.ContentTypeError:
+                        text_body = await response.text()
+                        logger.error(
+                            "Pal24 API returned non-JSON response for %s: %s",
+                            endpoint,
+                            text_body,
+                        )
+                        raise Pal24APIError(
+                            f"Pal24 API returned non-JSON response: {text_body}"
+                        ) from None
+
+                    result = Pal24Response.from_payload(payload, status)
+                    if status >= 400 or not result.success:
+                        logger.error(
+                            "Pal24 API error %s %s: %s",
+                            status,
+                            endpoint,
+                            payload,
+                        )
+                        result.raise_for_status(endpoint)
+
+                    return result
+
+        except asyncio.TimeoutError as error:
+            logger.error("Pal24 API request timeout for %s: %s", endpoint, error)
+            raise Pal24APIError(f"Pal24 API request timeout for {endpoint}") from error
+        except aiohttp.ClientError as error:
+            logger.error("Pal24 API client error for %s: %s", endpoint, error)
+            raise Pal24APIError(str(error)) from error
+
+    # API methods -----------------------------------------------------------------
+
+    async def create_bill(
+        self,
+        *,
+        amount: Decimal,
+        shop_id: str,
+        order_id: Optional[str] = None,
+        description: Optional[str] = None,
+        currency_in: str = "RUB",
+        type_: str = "normal",
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "amount": str(amount),
+            "shop_id": shop_id,
+            "currency_in": currency_in,
+            "type": type_,
+        }
+
+        if order_id:
+            payload["order_id"] = order_id
+        if description:
+            payload["description"] = description
+
+        payload.update({k: v for k, v in kwargs.items() if v is not None})
+
+        response = await self._request("POST", "bill/create", json_payload=payload)
+        return response.data
+
+    async def get_bill_status(self, bill_id: str) -> Dict[str, Any]:
+        response = await self._request("GET", "bill/status", params={"id": bill_id})
+        return response.data
+
+    async def toggle_bill_activity(self, bill_id: str, active: bool) -> Dict[str, Any]:
+        payload = {"id": bill_id, "active": 1 if active else 0}
+        response = await self._request("POST", "bill/toggle_activity", json_payload=payload)
+        return response.data
+
+    async def search_payments(self, **params: Any) -> Dict[str, Any]:
+        response = await self._request("GET", "payment/search", params=params)
+        return response.data
+
+    async def get_payment_status(self, payment_id: str) -> Dict[str, Any]:
+        response = await self._request("GET", "payment/status", params={"id": payment_id})
+        return response.data
+
+    async def get_balance(self) -> Dict[str, Any]:
+        response = await self._request("GET", "merchant/balance")
+        return response.data
+
+    async def search_bills(self, **params: Any) -> Dict[str, Any]:
+        response = await self._request("GET", "bill/search", params=params)
+        return response.data
+
+    async def get_bill_payments(self, bill_id: str) -> Dict[str, Any]:
+        response = await self._request("GET", "bill/payments", params={"id": bill_id})
+        return response.data
+
+    # Helpers ---------------------------------------------------------------------
+
+    @staticmethod
+    def calculate_signature(out_sum: str, inv_id: str, api_token: Optional[str] = None) -> str:
+        token = api_token or settings.PAL24_SIGNATURE_TOKEN or settings.PAL24_API_TOKEN
+        if not token:
+            raise Pal24APIError("Pal24 signature token is not configured")
+        raw = f"{out_sum}:{inv_id}:{token}".encode("utf-8")
+        return hashlib.md5(raw).hexdigest().upper()
+
+    @staticmethod
+    def verify_signature(
+        out_sum: str,
+        inv_id: str,
+        signature: str,
+        api_token: Optional[str] = None,
+    ) -> bool:
+        try:
+            expected = Pal24Client.calculate_signature(out_sum, inv_id, api_token)
+        except Pal24APIError:
+            logger.error("Pal24 signature verification failed: missing token")
+            return False
+        return expected == signature.upper()
+
+    @staticmethod
+    def normalize_amount(amount_kopeks: int) -> Decimal:
+        try:
+            return (Decimal(amount_kopeks) / Decimal("100")).quantize(Decimal("0.01"))
+        except (InvalidOperation, TypeError) as error:
+            raise Pal24APIError(f"Invalid amount: {amount_kopeks}") from error
+
@@ -0,0 +1,155 @@
+"""Flask webhook server for PayPalych postbacks."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import threading
+from asyncio import AbstractEventLoop
+from typing import Any, Dict, Optional
+
+from flask import Flask, jsonify, request
+from werkzeug.serving import make_server
+
+from app.config import settings
+from app.database.database import get_db
+from app.services.pal24_service import Pal24Service, Pal24APIError
+from app.services.payment_service import PaymentService
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_payload() -> Dict[str, str]:
+    if request.is_json:
+        payload = request.get_json(silent=True) or {}
+        if isinstance(payload, dict):
+            return {k: str(v) for k, v in payload.items()}
+        logger.warning("Pal24 webhook JSON payload не является объектом: %s", payload)
+        return {}
+
+    if request.form:
+        return {k: v for k, v in request.form.items()}
+
+    try:
+        raw_body = request.data.decode("utf-8")
+        if raw_body:
+            payload = json.loads(raw_body)
+            if isinstance(payload, dict):
+                return {k: str(v) for k, v in payload.items()}
+    except json.JSONDecodeError:
+        logger.debug("Pal24 webhook body не удалось распарсить как JSON")
+
+    return {}
+
+
+def create_pal24_flask_app(
+    payment_service: PaymentService,
+    loop: AbstractEventLoop,
+) -> Flask:
+    pal24_service = Pal24Service()
+    app = Flask(__name__)
+
+    @app.route(settings.PAL24_WEBHOOK_PATH, methods=["POST"])
+    def pal24_webhook() -> tuple:
+        if not pal24_service.is_configured:
+            logger.error("Pal24 webhook получен, но сервис не настроен")
+            return jsonify({"status": "error", "reason": "service_not_configured"}), 503
+
+        payload = _normalize_payload()
+        if not payload:
+            logger.warning("Пустой Pal24 webhook")
+            return jsonify({"status": "error", "reason": "empty_payload"}), 400
+
+        try:
+            parsed_payload = pal24_service.parse_postback(payload)
+        except Pal24APIError as error:
+            logger.error("Ошибка валидации Pal24 webhook: %s", error)
+            return jsonify({"status": "error", "reason": str(error)}), 400
+
+        async def process() -> bool:
+            async for db in get_db():
+                try:
+                    return await payment_service.process_pal24_postback(db, parsed_payload)
+                finally:
+                    await db.close()
+
+        try:
+            future = asyncio.run_coroutine_threadsafe(process(), loop)
+            processed = future.result()
+        except Exception as error:  # pragma: no cover - defensive
+            logger.exception("Критическая ошибка обработки Pal24 webhook: %s", error)
+            return jsonify({"status": "error", "reason": "internal_error"}), 500
+
+        if processed:
+            return jsonify({"status": "ok"}), 200
+        return jsonify({"status": "error", "reason": "not_processed"}), 400
+
+    @app.route(settings.PAL24_WEBHOOK_PATH, methods=["GET"])
+    def pal24_health() -> tuple:
+        return jsonify({
+            "status": "ok",
+            "service": "pal24_webhook",
+            "enabled": settings.is_pal24_enabled(),
+        }), 200
+
+    @app.route("/pal24/health", methods=["GET"])
+    def pal24_additional_health() -> tuple:
+        return jsonify({
+            "status": "ok",
+            "service": "pal24_webhook",
+            "path": settings.PAL24_WEBHOOK_PATH,
+        }), 200
+
+    return app
+
+
+class Pal24WebhookServer:
+    """Threaded Flask server for Pal24 postbacks."""
+
+    def __init__(self, payment_service: PaymentService, loop: AbstractEventLoop) -> None:
+        self.app = create_pal24_flask_app(payment_service, loop)
+        self._server: Optional[Any] = None
+        self._thread: Optional[threading.Thread] = None
+
+    def start(self) -> None:
+        if self._server:
+            logger.warning("Pal24 webhook server уже запущен")
+            return
+
+        self._server = make_server(
+            host="0.0.0.0",
+            port=settings.PAL24_WEBHOOK_PORT,
+            app=self.app,
+            threaded=True,
+        )
+
+        def _serve() -> None:
+            logger.info(
+                "Pal24 webhook сервер запущен на %s:%s%s",
+                "0.0.0.0",
+                settings.PAL24_WEBHOOK_PORT,
+                settings.PAL24_WEBHOOK_PATH,
+            )
+            self._server.serve_forever()
+
+        self._thread = threading.Thread(target=_serve, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        if self._server:
+            logger.info("Останавливаем Pal24 webhook сервер")
+            self._server.shutdown()
+            self._server = None
+
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5)
+            self._thread = None
+
+
+async def start_pal24_webhook_server(payment_service: PaymentService) -> Pal24WebhookServer:
+    loop = asyncio.get_running_loop()
+    server = Pal24WebhookServer(payment_service, loop)
+    await loop.run_in_executor(None, server.start)
+    return server
+
@@ -4,7 +4,6 @@ import ssl
 import base64 
 from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Union, Any
-from urllib.parse import urlparse
 import aiohttp
 import logging
 from dataclasses import dataclass
@@ -58,6 +57,8 @@ class RemnaWaveUser:
    ss_password: Optional[str] = None
    first_connected_at: Optional[datetime] = None
    last_triggered_threshold: int = 0
+    happ_link: Optional[str] = None
+    happ_crypto_link: Optional[str] = None


@dataclass
@@ -92,6 +93,8 @@ class SubscriptionInfo:
    ss_conf_links: Dict[str, str]
    subscription_url: str
    happ: Optional[Dict[str, str]]
+    happ_link: Optional[str] = None
+    happ_crypto_link: Optional[str] = None


 class RemnaWaveAPIError(Exception):
@@ -584,6 +587,10 @@ class RemnaWaveAPI:
    
    
    def _parse_user(self, user_data: Dict) -> RemnaWaveUser:
+        happ_data = user_data.get('happ') or {}
+        happ_link = happ_data.get('link') or happ_data.get('url')
+        happ_crypto_link = happ_data.get('cryptoLink') or happ_data.get('crypto_link')
+
        return RemnaWaveUser(
            uuid=user_data['uuid'],
            short_uuid=user_data['shortUuid'],
@@ -612,7 +619,9 @@ class RemnaWaveAPI:
            vless_uuid=user_data.get('vlessUuid'),
            ss_password=user_data.get('ssPassword'),
            first_connected_at=self._parse_optional_datetime(user_data.get('firstConnectedAt')),
-            last_triggered_threshold=user_data.get('lastTriggeredThreshold', 0)
+            last_triggered_threshold=user_data.get('lastTriggeredThreshold', 0),
+            happ_link=happ_link,
+            happ_crypto_link=happ_crypto_link
        )

    def _parse_optional_datetime(self, date_str: Optional[str]) -> Optional[datetime]:
@@ -645,13 +654,19 @@ class RemnaWaveAPI:
        )
    
    def _parse_subscription_info(self, data: Dict) -> SubscriptionInfo:
+        happ_data = data.get('happ') or {}
+        happ_link = happ_data.get('link') or happ_data.get('url')
+        happ_crypto_link = happ_data.get('cryptoLink') or happ_data.get('crypto_link')
+
        return SubscriptionInfo(
            is_found=data['isFound'],
            user=data.get('user'),
            links=data.get('links', []),
            ss_conf_links=data.get('ssConfLinks', {}),
            subscription_url=data.get('subscriptionUrl', ''),
-            happ=data.get('happ')
+            happ=data.get('happ'),
+            happ_link=happ_link,
+            happ_crypto_link=happ_crypto_link
        )


@@ -1,12 +1,17 @@
+import base64
+import hashlib
+import hmac
 import logging
 import json
-from typing import Optional
+from typing import Optional, Iterable

 from aiohttp import web
 from aiogram import Bot

 from app.config import settings
 from app.services.tribute_service import TributeService
+from app.services.payment_service import PaymentService
+from app.database.database import get_db

 logger = logging.getLogger(__name__)

@@ -25,18 +30,25 @@ class WebhookServer:
        self.app = web.Application()
        
        self.app.router.add_post(settings.TRIBUTE_WEBHOOK_PATH, self._tribute_webhook_handler)
-        
+
+        if settings.is_mulenpay_enabled():
+            self.app.router.add_post(settings.MULENPAY_WEBHOOK_PATH, self._mulenpay_webhook_handler)
+
        if settings.is_cryptobot_enabled():
            self.app.router.add_post(settings.CRYPTOBOT_WEBHOOK_PATH, self._cryptobot_webhook_handler)
        
        self.app.router.add_get('/health', self._health_check)
        
        self.app.router.add_options(settings.TRIBUTE_WEBHOOK_PATH, self._options_handler)
+        if settings.is_mulenpay_enabled():
+            self.app.router.add_options(settings.MULENPAY_WEBHOOK_PATH, self._options_handler)
        if settings.is_cryptobot_enabled():
            self.app.router.add_options(settings.CRYPTOBOT_WEBHOOK_PATH, self._options_handler)
        
        logger.info(f"Webhook сервер настроен:")
        logger.info(f"  - Tribute webhook: POST {settings.TRIBUTE_WEBHOOK_PATH}")
+        if settings.is_mulenpay_enabled():
+            logger.info(f"  - Mulen Pay webhook: POST {settings.MULENPAY_WEBHOOK_PATH}")
        if settings.is_cryptobot_enabled():
            logger.info(f"  - CryptoBot webhook: POST {settings.CRYPTOBOT_WEBHOOK_PATH}")
        logger.info(f"  - Health check: GET /health")
@@ -62,6 +74,10 @@ class WebhookServer:
            
            logger.info(f"Webhook сервер запущен на порту {settings.TRIBUTE_WEBHOOK_PORT}")
            logger.info(f"Tribute webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+            if settings.is_mulenpay_enabled():
+                logger.info(
+                    f"Mulen Pay webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.MULENPAY_WEBHOOK_PATH}"
+                )
            if settings.is_cryptobot_enabled():
                logger.info(f"CryptoBot webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.CRYPTOBOT_WEBHOOK_PATH}")
            
@@ -89,12 +105,139 @@ class WebhookServer:
            headers={
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
-                'Access-Control-Allow-Headers': 'Content-Type, trbt-signature, Crypto-Pay-API-Signature',
+                'Access-Control-Allow-Headers': 'Content-Type, trbt-signature, Crypto-Pay-API-Signature, X-MulenPay-Signature, Authorization',
            }
        )
-    
+
+    async def _mulenpay_webhook_handler(self, request: web.Request) -> web.Response:
+        try:
+            logger.info(f"Получен Mulen Pay webhook: {request.method} {request.path}")
+            raw_body = await request.read()
+
+            if not raw_body:
+                logger.warning("Пустой Mulen Pay webhook")
+                return web.json_response({"status": "error", "reason": "empty_body"}, status=400)
+
+            if not self._verify_mulenpay_signature(request, raw_body):
+                return web.json_response({"status": "error", "reason": "invalid_signature"}, status=401)
+
+            try:
+                payload = json.loads(raw_body.decode('utf-8'))
+            except json.JSONDecodeError as error:
+                logger.error(f"Ошибка парсинга Mulen Pay webhook: {error}")
+                return web.json_response({"status": "error", "reason": "invalid_json"}, status=400)
+
+            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
+
+        except Exception as error:
+            logger.error(f"Критическая ошибка Mulen Pay webhook: {error}", exc_info=True)
+            return web.json_response({"status": "error", "reason": "internal_error", "message": str(error)}, status=500)
+
+    @staticmethod
+    def _extract_mulenpay_header(request: web.Request, header_names: Iterable[str]) -> Optional[str]:
+        for header_name in header_names:
+            value = request.headers.get(header_name)
+            if value:
+                return value.strip()
+        return None
+
+    @staticmethod
+    def _verify_mulenpay_signature(request: web.Request, raw_body: bytes) -> bool:
+        secret_key = settings.MULENPAY_SECRET_KEY
+        if not secret_key:
+            logger.error("Mulen Pay secret key is not configured")
+            return False
+
+        signature = WebhookServer._extract_mulenpay_header(
+            request,
+            (
+                'X-MulenPay-Signature',
+                'X-Mulenpay-Signature',
+                'X-MULENPAY-SIGNATURE',
+                'X-MulenPay-Webhook-Signature',
+                'X-Mulenpay-Webhook-Signature',
+                'X-MULENPAY-WEBHOOK-SIGNATURE',
+                'X-Signature',
+                'Signature',
+            )
+        )
+        if signature:
+            normalized_signature = signature
+            if normalized_signature.lower().startswith('sha256='):
+                normalized_signature = normalized_signature.split('=', 1)[1].strip()
+
+            hmac_digest = hmac.new(
+                secret_key.encode('utf-8'),
+                raw_body,
+                hashlib.sha256,
+            ).digest()
+            expected_hex_signature = hmac_digest.hex()
+            expected_base64_signature = base64.b64encode(hmac_digest).decode('utf-8').strip()
+            expected_urlsafe_base64_signature = base64.urlsafe_b64encode(hmac_digest).decode('utf-8').strip()
+
+            normalized_signature_lower = normalized_signature.lower()
+            if hmac.compare_digest(normalized_signature_lower, expected_hex_signature.lower()):
+                return True
+
+            normalized_signature_no_padding = normalized_signature.rstrip('=')
+            if hmac.compare_digest(normalized_signature_no_padding, expected_base64_signature.rstrip('=')):
+                return True
+
+            if hmac.compare_digest(normalized_signature_no_padding, expected_urlsafe_base64_signature.rstrip('=')):
+                return True
+
+            logger.error("Неверная подпись Mulen Pay webhook")
+            return False
+
+        authorization_header = request.headers.get('Authorization')
+        if authorization_header:
+            scheme, _, value = authorization_header.partition(' ')
+            scheme_lower = scheme.lower()
+            token = value.strip() if value else scheme.strip()
+
+            if scheme_lower in ('bearer', 'token'):
+                if hmac.compare_digest(token, secret_key):
+                    return True
+
+                logger.error("Неверный %s токен Mulen Pay webhook", scheme)
+                return False
+
+            if not value and hmac.compare_digest(token, secret_key):
+                return True
+
+        fallback_token = WebhookServer._extract_mulenpay_header(
+            request,
+            (
+                'X-MulenPay-Token',
+                'X-Mulenpay-Token',
+                'X-Webhook-Token',
+            )
+        )
+        if fallback_token and hmac.compare_digest(fallback_token, secret_key):
+            return True
+
+        logger.debug(
+            "Mulen Pay webhook headers received: %s",
+            {key: value for key, value in request.headers.items() if 'authorization' not in key.lower()}
+        )
+
+        logger.error("Отсутствует подпись Mulen Pay webhook")
+        return False
+
    async def _tribute_webhook_handler(self, request: web.Request) -> web.Response:
-        
+
        try:
            logger.info(f"Получен Tribute webhook: {request.method} {request.path}")
            logger.info(f"Headers: {dict(request.headers)}")
@@ -10,14 +10,18 @@ from app.keyboards.admin import (
    get_admin_users_submenu_keyboard,
    get_admin_promo_submenu_keyboard,
    get_admin_communications_submenu_keyboard,
+    get_admin_support_submenu_keyboard,
    get_admin_settings_submenu_keyboard,
    get_admin_system_submenu_keyboard
 )
 from app.localization.texts import get_texts
 from app.handlers.admin import support_settings as support_settings_handlers
 from app.utils.decorators import admin_required, error_handler
+from app.services.support_settings_service import SupportSettingsService
 from app.database.crud.rules import clear_all_rules, get_rules_statistics
 from app.localization.texts import clear_rules_cache
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from app.database.crud.ticket import TicketCRUD

 logger = logging.getLogger(__name__)

@@ -67,10 +71,10 @@ async def show_users_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "👥 **Управление пользователями и подписками**\n\n"
-        "Выберите нужный раздел:",
+        texts.t("ADMIN_USERS_SUBMENU_TITLE", "👥 **Управление пользователями и подписками**\n\n") +
+        texts.t("ADMIN_SUBMENU_SELECT_SECTION", "Выберите нужный раздел:"),
        reply_markup=get_admin_users_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -85,10 +89,10 @@ async def show_promo_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "💰 **Промокоды и статистика**\n\n"
-        "Выберите нужный раздел:",
+        texts.t("ADMIN_PROMO_SUBMENU_TITLE", "💰 **Промокоды и статистика**\n\n") +
+        texts.t("ADMIN_SUBMENU_SELECT_SECTION", "Выберите нужный раздел:"),
        reply_markup=get_admin_promo_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -103,16 +107,135 @@ async def show_communications_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "📨 **Коммуникации**\n\n"
-        "Управление рассылками и текстами интерфейса:",
+        texts.t("ADMIN_COMMUNICATIONS_SUBMENU_TITLE", "📨 **Коммуникации**\n\n") +
+        texts.t("ADMIN_COMMUNICATIONS_SUBMENU_DESCRIPTION", "Управление рассылками и текстами интерфейса:"),
        reply_markup=get_admin_communications_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
    await callback.answer()


+@admin_required
+@error_handler
+async def show_support_submenu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    # Moderators have access only to tickets and not to settings
+    is_moderator_only = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
+    
+    kb = get_admin_support_submenu_keyboard(db_user.language)
+    if is_moderator_only:
+        # Rebuild keyboard to include only tickets and back to main menu
+        kb = InlineKeyboardMarkup(inline_keyboard=[
+            [InlineKeyboardButton(text=texts.t("ADMIN_SUPPORT_TICKETS", "🎫 Тикеты поддержки"), callback_data="admin_tickets")],
+            [InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")]
+        ])
+    await callback.message.edit_text(
+        texts.t("ADMIN_SUPPORT_SUBMENU_TITLE", "🛟 **Поддержка**\n\n") + (
+            texts.t("ADMIN_SUPPORT_SUBMENU_DESCRIPTION_MODERATOR", "Доступ к тикетам.")
+            if is_moderator_only
+            else texts.t("ADMIN_SUPPORT_SUBMENU_DESCRIPTION", "Управление тикетами и настройками поддержки:")
+        ),
+        reply_markup=kb,
+        parse_mode="Markdown"
+    )
+    await callback.answer()
+
+
+# Moderator panel entry (from main menu quick button)
+async def show_moderator_panel(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    kb = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text=texts.t("ADMIN_SUPPORT_TICKETS", "🎫 Тикеты поддержки"), callback_data="admin_tickets")],
+        [InlineKeyboardButton(text=texts.t("BACK_TO_MAIN_MENU_BUTTON", "⬅️ В главное меню"), callback_data="back_to_menu")]
+    ])
+    await callback.message.edit_text(
+        texts.t("ADMIN_SUPPORT_MODERATION_TITLE", "🧑‍⚖️ <b>Модерация поддержки</b>") + "\n\n" +
+        texts.t("ADMIN_SUPPORT_MODERATION_DESCRIPTION", "Доступ к тикетам поддержки."),
+        parse_mode="HTML",
+        reply_markup=kb
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_support_audit(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    # pagination
+    page = 1
+    if callback.data.startswith("admin_support_audit_page_"):
+        try:
+            page = int(callback.data.split("_")[-1])
+        except Exception:
+            page = 1
+    per_page = 10
+    total = await TicketCRUD.count_support_audit(db)
+    total_pages = max(1, (total + per_page - 1) // per_page)
+    if page < 1:
+        page = 1
+    if page > total_pages:
+        page = total_pages
+    offset = (page - 1) * per_page
+    logs = await TicketCRUD.list_support_audit(db, limit=per_page, offset=offset)
+
+    lines = [texts.t("ADMIN_SUPPORT_AUDIT_TITLE", "🧾 <b>Аудит модераторов</b>"), ""]
+    if not logs:
+        lines.append(texts.t("ADMIN_SUPPORT_AUDIT_EMPTY", "Пока пусто"))
+    else:
+        for log in logs:
+            role = (
+                texts.t("ADMIN_SUPPORT_AUDIT_ROLE_MODERATOR", "Модератор")
+                if getattr(log, 'is_moderator', False)
+                else texts.t("ADMIN_SUPPORT_AUDIT_ROLE_ADMIN", "Админ")
+            )
+            ts = log.created_at.strftime('%d.%m.%Y %H:%M') if getattr(log, 'created_at', None) else ''
+            action_map = {
+                'close_ticket': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_CLOSE_TICKET", "Закрытие тикета"),
+                'block_user_timed': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_TIMED", "Блокировка (время)"),
+                'block_user_perm': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_PERM", "Блокировка (навсегда)"),
+                'unblock_user': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_UNBLOCK", "Снятие блока"),
+            }
+            action_text = action_map.get(log.action, log.action)
+            ticket_part = f" тикет #{log.ticket_id}" if log.ticket_id else ""
+            details = log.details or {}
+            extra = ""
+            if log.action == 'block_user_timed' and 'minutes' in details:
+                extra = f" ({details['minutes']} мин)"
+            lines.append(f"{ts} • {role} <code>{log.actor_telegram_id}</code> — {action_text}{ticket_part}{extra}")
+
+    # keyboard with pagination
+    nav_row = []
+    if total_pages > 1:
+        if page > 1:
+            nav_row.append(InlineKeyboardButton(text="⬅️", callback_data=f"admin_support_audit_page_{page-1}"))
+        nav_row.append(InlineKeyboardButton(text=f"{page}/{total_pages}", callback_data="current_page"))
+        if page < total_pages:
+            nav_row.append(InlineKeyboardButton(text="➡️", callback_data=f"admin_support_audit_page_{page+1}"))
+
+    kb_rows = []
+    if nav_row:
+        kb_rows.append(nav_row)
+    kb_rows.append([InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_support")])
+    kb = InlineKeyboardMarkup(inline_keyboard=kb_rows)
+
+    await callback.message.edit_text("\n".join(lines), parse_mode="HTML", reply_markup=kb)
+    await callback.answer()
+
+
@admin_required
@error_handler
 async def show_settings_submenu(
@@ -121,10 +244,10 @@ async def show_settings_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "⚙️ **Настройки системы**\n\n"
-        "Управление Remnawave, мониторингом и другими настройками:",
+        texts.t("ADMIN_SETTINGS_SUBMENU_TITLE", "⚙️ **Настройки системы**\n\n") +
+        texts.t("ADMIN_SETTINGS_SUBMENU_DESCRIPTION", "Управление Remnawave, мониторингом и другими настройками:"),
        reply_markup=get_admin_settings_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -139,10 +262,10 @@ async def show_system_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "🛠️ **Системные функции**\n\n"
-        "Обновления, резервные копии и системные операции:",
+        texts.t("ADMIN_SYSTEM_SUBMENU_TITLE", "🛠️ **Системные функции**\n\n") +
+        texts.t("ADMIN_SYSTEM_SUBMENU_DESCRIPTION", "Отчеты, обновления, логи, резервные копии и системные операции:"),
        reply_markup=get_admin_system_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -285,6 +408,15 @@ def register_handlers(dp: Dispatcher):
        F.data == "admin_submenu_communications"
    )
    
+    dp.callback_query.register(
+        show_support_submenu,
+        F.data == "admin_submenu_support"
+    )
+    dp.callback_query.register(
+        show_support_audit,
+        F.data.in_(["admin_support_audit"]) | F.data.startswith("admin_support_audit_page_")
+    )
+    
    dp.callback_query.register(
        show_settings_submenu,
        F.data == "admin_submenu_settings"
@@ -294,6 +426,10 @@ def register_handlers(dp: Dispatcher):
        show_system_submenu,
        F.data == "admin_submenu_system"
    )
+    dp.callback_query.register(
+        show_moderator_panel,
+        F.data == "moderator_panel"
+    )
    # Support settings module
    support_settings_handlers.register_handlers(dp)
    
@@ -21,8 +21,8 @@ from app.keyboards.admin import (
    get_custom_criteria_keyboard, get_broadcast_history_keyboard,
    get_admin_pagination_keyboard, get_broadcast_media_keyboard,
    get_media_confirm_keyboard, get_updated_message_buttons_selector_keyboard_with_media,
-    BROADCAST_BUTTONS, BROADCAST_BUTTON_ROWS, DEFAULT_BROADCAST_BUTTONS,
-    BROADCAST_BUTTON_LABELS
+    BROADCAST_BUTTON_ROWS, DEFAULT_BROADCAST_BUTTONS,
+    get_broadcast_button_config, get_broadcast_button_labels
 )
 from app.localization.texts import get_texts
 from app.database.crud.user import get_users_list
@@ -31,10 +31,8 @@ from app.utils.decorators import admin_required, error_handler

 logger = logging.getLogger(__name__)

-BUTTON_CONFIG = BROADCAST_BUTTONS
 BUTTON_ROWS = BROADCAST_BUTTON_ROWS
 DEFAULT_SELECTED_BUTTONS = DEFAULT_BROADCAST_BUTTONS
-BUTTON_LABELS = BROADCAST_BUTTON_LABELS


 def get_message_buttons_selector_keyboard(language: str = "ru") -> types.InlineKeyboardMarkup:
@@ -45,16 +43,17 @@ def get_updated_message_buttons_selector_keyboard(selected_buttons: list, langua
    return get_updated_message_buttons_selector_keyboard_with_media(selected_buttons, False, language)


-def create_broadcast_keyboard(selected_buttons: list) -> Optional[types.InlineKeyboardMarkup]:
+def create_broadcast_keyboard(selected_buttons: list, language: str = "ru") -> Optional[types.InlineKeyboardMarkup]:
    selected_buttons = selected_buttons or []
    keyboard: list[list[types.InlineKeyboardButton]] = []
+    button_config_map = get_broadcast_button_config(language)

    for row in BUTTON_ROWS:
        row_buttons: list[types.InlineKeyboardButton] = []
        for button_key in row:
            if button_key not in selected_buttons:
                continue
-            button_config = BUTTON_CONFIG[button_key]
+            button_config = button_config_map[button_key]
            row_buttons.append(
                types.InlineKeyboardButton(
                    text=button_config["text"],
@@ -628,7 +627,8 @@ async def confirm_button_selection(
        media_info = f"\n🖼️ <b>Медиафайл:</b> {media_type_names.get(media_type, media_type)}"
    
    ordered_keys = [button_key for row in BUTTON_ROWS for button_key in row]
-    selected_names = [BUTTON_LABELS[key] for key in ordered_keys if key in selected_buttons]
+    button_labels = get_broadcast_button_labels(db_user.language)
+    selected_names = [button_labels[key] for key in ordered_keys if key in selected_buttons]
    if selected_names:
        buttons_info = f"\n📘 <b>Кнопки:</b> {', '.join(selected_names)}"
    else:
@@ -745,7 +745,7 @@ async def confirm_broadcast(
    sent_count = 0
    failed_count = 0
    
-    broadcast_keyboard = create_broadcast_keyboard(selected_buttons)
+    broadcast_keyboard = create_broadcast_keyboard(selected_buttons, db_user.language)
    
    for user in users:
        try:
@@ -2,8 +2,10 @@ import asyncio
 import logging
 from datetime import datetime, timedelta
 from aiogram import Router, F
-from aiogram.types import Message, CallbackQuery
+from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
 from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.exceptions import TelegramBadRequest

 from app.config import settings
 from app.database.database import get_db
@@ -12,11 +14,370 @@ from app.utils.decorators import admin_required
 from app.utils.pagination import paginate_list
 from app.keyboards.admin import get_monitoring_keyboard, get_admin_main_keyboard
 from app.localization.texts import get_texts
+from app.services.notification_settings_service import NotificationSettingsService
+from app.states import AdminStates

 logger = logging.getLogger(__name__)
 router = Router()


+def _format_toggle(enabled: bool) -> str:
+    return "🟢 Вкл" if enabled else "🔴 Выкл"
+
+
+def _build_notification_settings_view(language: str):
+    texts = get_texts(language)
+    config = NotificationSettingsService.get_config()
+
+    second_percent = NotificationSettingsService.get_second_wave_discount_percent()
+    second_hours = NotificationSettingsService.get_second_wave_valid_hours()
+    third_percent = NotificationSettingsService.get_third_wave_discount_percent()
+    third_hours = NotificationSettingsService.get_third_wave_valid_hours()
+    third_days = NotificationSettingsService.get_third_wave_trigger_days()
+
+    trial_1h_status = _format_toggle(config["trial_inactive_1h"].get("enabled", True))
+    trial_24h_status = _format_toggle(config["trial_inactive_24h"].get("enabled", True))
+    trial_channel_status = _format_toggle(
+        config["trial_channel_unsubscribed"].get("enabled", True)
+    )
+    expired_1d_status = _format_toggle(config["expired_1d"].get("enabled", True))
+    second_wave_status = _format_toggle(config["expired_second_wave"].get("enabled", True))
+    third_wave_status = _format_toggle(config["expired_third_wave"].get("enabled", True))
+
+    summary_text = (
+        "🔔 <b>Уведомления пользователям</b>\n\n"
+        f"• 1 час после триала: {trial_1h_status}\n"
+        f"• 24 часа после триала: {trial_24h_status}\n"
+        f"• Отписка от канала: {trial_channel_status}\n"
+        f"• 1 день после истечения: {expired_1d_status}\n"
+        f"• 2-3 дня (скидка {second_percent}% / {second_hours} ч): {second_wave_status}\n"
+        f"• {third_days} дней (скидка {third_percent}% / {third_hours} ч): {third_wave_status}"
+    )
+
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text=f"{trial_1h_status} • 1 час после триала", callback_data="admin_mon_notify_toggle_trial_1h")],
+        [InlineKeyboardButton(text="🧪 Тест: 1 час после триала", callback_data="admin_mon_notify_preview_trial_1h")],
+        [InlineKeyboardButton(text=f"{trial_24h_status} • 24 часа после триала", callback_data="admin_mon_notify_toggle_trial_24h")],
+        [InlineKeyboardButton(text="🧪 Тест: 24 часа после триала", callback_data="admin_mon_notify_preview_trial_24h")],
+        [InlineKeyboardButton(text=f"{trial_channel_status} • Отписка от канала", callback_data="admin_mon_notify_toggle_trial_channel")],
+        [InlineKeyboardButton(text="🧪 Тест: отписка от канала", callback_data="admin_mon_notify_preview_trial_channel")],
+        [InlineKeyboardButton(text=f"{expired_1d_status} • 1 день после истечения", callback_data="admin_mon_notify_toggle_expired_1d")],
+        [InlineKeyboardButton(text="🧪 Тест: 1 день после истечения", callback_data="admin_mon_notify_preview_expired_1d")],
+        [InlineKeyboardButton(text=f"{second_wave_status} • 2-3 дня со скидкой", callback_data="admin_mon_notify_toggle_expired_2d")],
+        [InlineKeyboardButton(text="🧪 Тест: скидка 2-3 день", callback_data="admin_mon_notify_preview_expired_2d")],
+        [InlineKeyboardButton(text=f"✏️ Скидка 2-3 дня: {second_percent}%", callback_data="admin_mon_notify_edit_2d_percent")],
+        [InlineKeyboardButton(text=f"⏱️ Срок скидки 2-3 дня: {second_hours} ч", callback_data="admin_mon_notify_edit_2d_hours")],
+        [InlineKeyboardButton(text=f"{third_wave_status} • {third_days} дней со скидкой", callback_data="admin_mon_notify_toggle_expired_nd")],
+        [InlineKeyboardButton(text="🧪 Тест: скидка спустя дни", callback_data="admin_mon_notify_preview_expired_nd")],
+        [InlineKeyboardButton(text=f"✏️ Скидка {third_days} дней: {third_percent}%", callback_data="admin_mon_notify_edit_nd_percent")],
+        [InlineKeyboardButton(text=f"⏱️ Срок скидки {third_days} дней: {third_hours} ч", callback_data="admin_mon_notify_edit_nd_hours")],
+        [InlineKeyboardButton(text=f"📆 Порог уведомления: {third_days} дн.", callback_data="admin_mon_notify_edit_nd_threshold")],
+        [InlineKeyboardButton(text="🧪 Отправить все тесты", callback_data="admin_mon_notify_preview_all")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_mon_settings")],
+    ])
+
+    return summary_text, keyboard
+
+
+def _build_notification_preview_message(language: str, notification_type: str):
+    texts = get_texts(language)
+    now = datetime.now()
+    price_30_days = settings.format_price(settings.PRICE_30_DAYS)
+
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+    header = "🧪 <b>Тестовое уведомление мониторинга</b>\n\n"
+
+    if notification_type == "trial_inactive_1h":
+        template = texts.get(
+            "TRIAL_INACTIVE_1H",
+            (
+                "⏳ <b>Прошёл час, а подключения нет</b>\n\n"
+                "Если возникли сложности с запуском — воспользуйтесь инструкциями."
+            ),
+        )
+        message = template.format(
+            price=price_30_days,
+            end_date=(now + timedelta(days=settings.TRIAL_DURATION_DAYS)).strftime("%d.%m.%Y %H:%M"),
+        )
+        keyboard = InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                        callback_data="subscription_connect",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("MY_SUBSCRIPTION_BUTTON", "📱 Моя подписка"),
+                        callback_data="menu_subscription",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUPPORT_BUTTON", "🆘 Поддержка"),
+                        callback_data="menu_support",
+                    )
+                ],
+            ]
+        )
+    elif notification_type == "trial_inactive_24h":
+        template = texts.get(
+            "TRIAL_INACTIVE_24H",
+            (
+                "⏳ <b>Вы ещё не подключились к VPN</b>\n\n"
+                "Прошли сутки с активации тестового периода, но трафик не зафиксирован."
+                "\n\nНажмите кнопку ниже, чтобы подключиться."
+            ),
+        )
+        message = template.format(
+            price=price_30_days,
+            end_date=(now + timedelta(days=1)).strftime("%d.%m.%Y %H:%M"),
+        )
+        keyboard = InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                        callback_data="subscription_connect",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("MY_SUBSCRIPTION_BUTTON", "📱 Моя подписка"),
+                        callback_data="menu_subscription",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUPPORT_BUTTON", "🆘 Поддержка"),
+                        callback_data="menu_support",
+                    )
+                ],
+            ]
+        )
+    elif notification_type == "trial_channel_unsubscribed":
+        template = texts.get(
+            "TRIAL_CHANNEL_UNSUBSCRIBED",
+            (
+                "🚫 <b>Доступ приостановлен</b>\n\n"
+                "Мы не нашли вашу подписку на наш канал, поэтому тестовая подписка отключена.\n\n"
+                "Подпишитесь на канал и нажмите «{check_button}», чтобы вернуть доступ."
+            ),
+        )
+        check_button = texts.t("CHANNEL_CHECK_BUTTON", "✅ Я подписался")
+        message = template.format(check_button=check_button)
+        buttons: list[list[InlineKeyboardButton]] = []
+        if settings.CHANNEL_LINK:
+            buttons.append(
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("CHANNEL_SUBSCRIBE_BUTTON", "🔗 Подписаться"),
+                        url=settings.CHANNEL_LINK,
+                    )
+                ]
+            )
+        buttons.append(
+            [
+                InlineKeyboardButton(
+                    text=check_button,
+                    callback_data="sub_channel_check",
+                )
+            ]
+        )
+        keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
+    elif notification_type == "expired_1d":
+        template = texts.get(
+            "SUBSCRIPTION_EXPIRED_1D",
+            (
+                "⛔ <b>Подписка закончилась</b>\n\n"
+                "Доступ был отключён {end_date}. Продлите подписку, чтобы вернуться в сервис."
+            ),
+        )
+        message = template.format(
+            end_date=(now - timedelta(days=1)).strftime("%d.%m.%Y %H:%M"),
+            price=price_30_days,
+        )
+        keyboard = InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUBSCRIPTION_EXTEND", "💎 Продлить подписку"),
+                        callback_data="subscription_extend",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("BALANCE_TOPUP", "💳 Пополнить баланс"),
+                        callback_data="balance_topup",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUPPORT_BUTTON", "🆘 Поддержка"),
+                        callback_data="menu_support",
+                    )
+                ],
+            ]
+        )
+    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}."
+            ),
+        )
+        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,
+        )
+        keyboard = InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(
+                        text="🎁 Получить скидку",
+                        callback_data="claim_discount_preview",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUBSCRIPTION_EXTEND", "💎 Продлить подписку"),
+                        callback_data="subscription_extend",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("BALANCE_TOPUP", "💳 Пополнить баланс"),
+                        callback_data="balance_topup",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUPPORT_BUTTON", "🆘 Поддержка"),
+                        callback_data="menu_support",
+                    )
+                ],
+            ]
+        )
+    elif notification_type == "expired_nd":
+        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}."
+            ),
+        )
+        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"),
+        )
+        keyboard = InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(
+                        text="🎁 Получить скидку",
+                        callback_data="claim_discount_preview",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUBSCRIPTION_EXTEND", "💎 Продлить подписку"),
+                        callback_data="subscription_extend",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("BALANCE_TOPUP", "💳 Пополнить баланс"),
+                        callback_data="balance_topup",
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("SUPPORT_BUTTON", "🆘 Поддержка"),
+                        callback_data="menu_support",
+                    )
+                ],
+            ]
+        )
+    else:
+        raise ValueError(f"Unsupported notification type: {notification_type}")
+
+    footer = "\n\n<i>Сообщение отправлено только вам для проверки оформления.</i>"
+    return header + message + footer, keyboard
+
+
+async def _send_notification_preview(bot, chat_id: int, language: str, notification_type: str) -> None:
+    message, keyboard = _build_notification_preview_message(language, notification_type)
+    await bot.send_message(
+        chat_id,
+        message,
+        parse_mode="HTML",
+        reply_markup=keyboard,
+    )
+
+
+async def _render_notification_settings(callback: CallbackQuery) -> None:
+    language = (callback.from_user.language_code or settings.DEFAULT_LANGUAGE)
+    text, keyboard = _build_notification_settings_view(language)
+    await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+
+
+async def _render_notification_settings_for_state(
+    bot,
+    chat_id: int,
+    message_id: int,
+    language: str,
+    business_connection_id: str | None = None,
+) -> None:
+    text, keyboard = _build_notification_settings_view(language)
+
+    edit_kwargs = {
+        "text": text,
+        "chat_id": chat_id,
+        "message_id": message_id,
+        "parse_mode": "HTML",
+        "reply_markup": keyboard,
+    }
+
+    if business_connection_id:
+        edit_kwargs["business_connection_id"] = business_connection_id
+
+    try:
+        await bot.edit_message_text(**edit_kwargs)
+    except TelegramBadRequest as exc:
+        if "no text in the message to edit" in (exc.message or "").lower():
+            caption_kwargs = {
+                "chat_id": chat_id,
+                "message_id": message_id,
+                "caption": text,
+                "parse_mode": "HTML",
+                "reply_markup": keyboard,
+            }
+
+            if business_connection_id:
+                caption_kwargs["business_connection_id"] = business_connection_id
+
+            await bot.edit_message_caption(**caption_kwargs)
+        else:
+            raise
+
@router.callback_query(F.data == "admin_monitoring")
@admin_required
 async def admin_monitoring_menu(callback: CallbackQuery):
@@ -43,7 +404,8 @@ async def admin_monitoring_menu(callback: CallbackQuery):
 🔧 Выберите действие:
 """
            
-            keyboard = get_monitoring_keyboard()
+            language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+            keyboard = get_monitoring_keyboard(language)
            await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
            break
            
@@ -52,6 +414,287 @@ async def admin_monitoring_menu(callback: CallbackQuery):
        await callback.answer("❌ Ошибка получения данных", show_alert=True)


+@router.callback_query(F.data == "admin_mon_settings")
+@admin_required
+async def admin_monitoring_settings(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        global_status = "🟢 Включены" if NotificationSettingsService.are_notifications_globally_enabled() else "🔴 Отключены"
+        second_percent = NotificationSettingsService.get_second_wave_discount_percent()
+        third_percent = NotificationSettingsService.get_third_wave_discount_percent()
+        third_days = NotificationSettingsService.get_third_wave_trigger_days()
+
+        text = (
+            "⚙️ <b>Настройки мониторинга</b>\n\n"
+            f"🔔 <b>Уведомления пользователям:</b> {global_status}\n"
+            f"• Скидка 2-3 дня: {second_percent}%\n"
+            f"• Скидка после {third_days} дней: {third_percent}%\n\n"
+            "Выберите раздел для настройки."
+        )
+
+        from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+        keyboard = InlineKeyboardMarkup(inline_keyboard=[
+            [InlineKeyboardButton(text="🔔 Уведомления пользователям", callback_data="admin_mon_notify_settings")],
+            [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_submenu_settings")],
+        ])
+
+        await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+
+    except Exception as e:
+        logger.error(f"Ошибка отображения настроек мониторинга: {e}")
+        await callback.answer("❌ Не удалось открыть настройки", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_settings")
+@admin_required
+async def admin_notify_settings(callback: CallbackQuery):
+    try:
+        await _render_notification_settings(callback)
+    except Exception as e:
+        logger.error(f"Ошибка отображения настроек уведомлений: {e}")
+        await callback.answer("❌ Не удалось загрузить настройки", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_toggle_trial_1h")
+@admin_required
+async def toggle_trial_1h_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_trial_inactive_1h_enabled()
+    NotificationSettingsService.set_trial_inactive_1h_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_trial_1h")
+@admin_required
+async def preview_trial_1h_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "trial_inactive_1h")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send trial 1h preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_toggle_trial_24h")
+@admin_required
+async def toggle_trial_24h_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_trial_inactive_24h_enabled()
+    NotificationSettingsService.set_trial_inactive_24h_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_trial_24h")
+@admin_required
+async def preview_trial_24h_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "trial_inactive_24h")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send trial 24h preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_toggle_trial_channel")
+@admin_required
+async def toggle_trial_channel_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_trial_channel_unsubscribed_enabled()
+    NotificationSettingsService.set_trial_channel_unsubscribed_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_trial_channel")
+@admin_required
+async def preview_trial_channel_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "trial_channel_unsubscribed")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send trial channel preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_toggle_expired_1d")
+@admin_required
+async def toggle_expired_1d_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_expired_1d_enabled()
+    NotificationSettingsService.set_expired_1d_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_expired_1d")
+@admin_required
+async def preview_expired_1d_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "expired_1d")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send expired 1d preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_toggle_expired_2d")
+@admin_required
+async def toggle_second_wave_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_second_wave_enabled()
+    NotificationSettingsService.set_second_wave_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_expired_2d")
+@admin_required
+async def preview_second_wave_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "expired_2d")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send second wave preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_toggle_expired_nd")
+@admin_required
+async def toggle_third_wave_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_third_wave_enabled()
+    NotificationSettingsService.set_third_wave_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_expired_nd")
+@admin_required
+async def preview_third_wave_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "expired_nd")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send third wave preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_all")
+@admin_required
+async def preview_all_notifications(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        chat_id = callback.from_user.id
+        for notification_type in [
+            "trial_inactive_1h",
+            "trial_inactive_24h",
+            "trial_channel_unsubscribed",
+            "expired_1d",
+            "expired_2d",
+            "expired_nd",
+        ]:
+            await _send_notification_preview(callback.bot, chat_id, language, notification_type)
+        await callback.answer("✅ Все тестовые уведомления отправлены")
+    except Exception as exc:
+        logger.error("Failed to send all notification previews: %s", exc)
+        await callback.answer("❌ Не удалось отправить тесты", show_alert=True)
+
+
+async def _start_notification_value_edit(
+    callback: CallbackQuery,
+    state: FSMContext,
+    setting_key: str,
+    field: str,
+    prompt_key: str,
+    default_prompt: str,
+):
+    language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+    await state.set_state(AdminStates.editing_notification_value)
+    await state.update_data(
+        notification_setting_key=setting_key,
+        notification_setting_field=field,
+        settings_message_chat=callback.message.chat.id,
+        settings_message_id=callback.message.message_id,
+        settings_business_connection_id=(
+            str(getattr(callback.message, "business_connection_id", None))
+            if getattr(callback.message, "business_connection_id", None) is not None
+            else None
+        ),
+        settings_language=language,
+    )
+    texts = get_texts(language)
+    await callback.answer()
+    await callback.message.answer(texts.get(prompt_key, default_prompt))
+
+
+@router.callback_query(F.data == "admin_mon_notify_edit_2d_percent")
+@admin_required
+async def edit_second_wave_percent(callback: CallbackQuery, state: FSMContext):
+    await _start_notification_value_edit(
+        callback,
+        state,
+        "expired_second_wave",
+        "percent",
+        "NOTIFY_PROMPT_SECOND_PERCENT",
+        "Введите новый процент скидки для уведомления через 2-3 дня (0-100):",
+    )
+
+
+@router.callback_query(F.data == "admin_mon_notify_edit_2d_hours")
+@admin_required
+async def edit_second_wave_hours(callback: CallbackQuery, state: FSMContext):
+    await _start_notification_value_edit(
+        callback,
+        state,
+        "expired_second_wave",
+        "hours",
+        "NOTIFY_PROMPT_SECOND_HOURS",
+        "Введите количество часов действия скидки (1-168):",
+    )
+
+
+@router.callback_query(F.data == "admin_mon_notify_edit_nd_percent")
+@admin_required
+async def edit_third_wave_percent(callback: CallbackQuery, state: FSMContext):
+    await _start_notification_value_edit(
+        callback,
+        state,
+        "expired_third_wave",
+        "percent",
+        "NOTIFY_PROMPT_THIRD_PERCENT",
+        "Введите новый процент скидки для позднего предложения (0-100):",
+    )
+
+
+@router.callback_query(F.data == "admin_mon_notify_edit_nd_hours")
+@admin_required
+async def edit_third_wave_hours(callback: CallbackQuery, state: FSMContext):
+    await _start_notification_value_edit(
+        callback,
+        state,
+        "expired_third_wave",
+        "hours",
+        "NOTIFY_PROMPT_THIRD_HOURS",
+        "Введите количество часов действия скидки (1-168):",
+    )
+
+
+@router.callback_query(F.data == "admin_mon_notify_edit_nd_threshold")
+@admin_required
+async def edit_third_wave_threshold(callback: CallbackQuery, state: FSMContext):
+    await _start_notification_value_edit(
+        callback,
+        state,
+        "expired_third_wave",
+        "trigger",
+        "NOTIFY_PROMPT_THIRD_DAYS",
+        "Через сколько дней после истечения отправлять предложение? (минимум 2):",
+    )
+
+
@router.callback_query(F.data == "admin_mon_start")
@admin_required
 async def start_monitoring_callback(callback: CallbackQuery):
@@ -366,5 +1009,74 @@ async def monitoring_command(message: Message):
        await message.answer(f"❌ Ошибка: {str(e)}")


+@router.message(AdminStates.editing_notification_value)
+async def process_notification_value_input(message: Message, state: FSMContext):
+    data = await state.get_data()
+    if not data:
+        await state.clear()
+        await message.answer("ℹ️ Контекст утерян, попробуйте снова из меню настроек.")
+        return
+
+    raw_value = (message.text or "").strip()
+    try:
+        value = int(raw_value)
+    except (TypeError, ValueError):
+        language = data.get("settings_language") or message.from_user.language_code or settings.DEFAULT_LANGUAGE
+        texts = get_texts(language)
+        await message.answer(texts.get("NOTIFICATION_VALUE_INVALID", "❌ Введите целое число."))
+        return
+
+    key = data.get("notification_setting_key")
+    field = data.get("notification_setting_field")
+    language = data.get("settings_language") or message.from_user.language_code or settings.DEFAULT_LANGUAGE
+    texts = get_texts(language)
+
+    success = False
+    if key == "expired_second_wave" and field == "percent":
+        success = NotificationSettingsService.set_second_wave_discount_percent(value)
+    elif key == "expired_second_wave" and field == "hours":
+        success = NotificationSettingsService.set_second_wave_valid_hours(value)
+    elif key == "expired_third_wave" and field == "percent":
+        success = NotificationSettingsService.set_third_wave_discount_percent(value)
+    elif key == "expired_third_wave" and field == "hours":
+        success = NotificationSettingsService.set_third_wave_valid_hours(value)
+    elif key == "expired_third_wave" and field == "trigger":
+        success = NotificationSettingsService.set_third_wave_trigger_days(value)
+
+    if not success:
+        await message.answer(texts.get("NOTIFICATION_VALUE_INVALID", "❌ Некорректное значение, попробуйте снова."))
+        return
+
+    back_keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text=texts.get("BACK", "⬅️ Назад"),
+                    callback_data="admin_mon_notify_settings",
+                )
+            ]
+        ]
+    )
+
+    await message.answer(
+        texts.get("NOTIFICATION_VALUE_UPDATED", "✅ Настройки обновлены."),
+        reply_markup=back_keyboard,
+    )
+
+    chat_id = data.get("settings_message_chat")
+    message_id = data.get("settings_message_id")
+    business_connection_id = data.get("settings_business_connection_id")
+    if chat_id and message_id:
+        await _render_notification_settings_for_state(
+            message.bot,
+            chat_id,
+            message_id,
+            language,
+            business_connection_id=business_connection_id,
+        )
+
+    await state.clear()
+
+
 def register_handlers(dp):
    dp.include_router(router)
@@ -30,14 +30,22 @@ async def show_remnawave_menu(
 ):
   remnawave_service = RemnaWaveService()
   connection_test = await remnawave_service.test_api_connection()
-   
-   status_emoji = "✅" if connection_test["status"] == "connected" else "❌"
-   
+
+   status = connection_test.get("status")
+   if status == "connected":
+       status_emoji = "✅"
+   elif status == "not_configured":
+       status_emoji = "ℹ️"
+   else:
+       status_emoji = "❌"
+
+   api_url_display = settings.REMNAWAVE_API_URL or "—"
+
   text = f"""
 🖥️ <b>Управление Remnawave</b>

-📡 <b>Соединение:</b> {status_emoji} {connection_test["message"]}
-🌐 <b>URL:</b> <code>{settings.REMNAWAVE_API_URL}</code>
+📡 <b>Соединение:</b> {status_emoji} {connection_test.get("message", "Нет данных")}
+🌐 <b>URL:</b> <code>{api_url_display}</code>

 Выберите действие:
 """
@@ -194,7 +202,7 @@ async def show_traffic_stats(
    remnawave_service = RemnaWaveService()
    
    try:
-        async with remnawave_service.api as api:
+        async with remnawave_service.get_api_client() as api:
            bandwidth_stats = await api.get_bandwidth_stats()
            
            realtime_usage = await api.get_nodes_realtime_usage()
@@ -0,0 +1,117 @@
+import logging
+from aiogram import Dispatcher, F, types
+from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.keyboards.admin import (
+    get_admin_report_result_keyboard,
+    get_admin_reports_keyboard,
+)
+from app.localization.texts import get_texts
+from app.services.reporting_service import (
+    ReportPeriod,
+    ReportingServiceError,
+    reporting_service,
+)
+from app.utils.decorators import admin_required, error_handler
+
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_reports_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    await callback.message.edit_text(
+        "📊 <b>Отчеты</b>\n\n"
+        "Выберите период, чтобы отправить отчет в админский топик.",
+        reply_markup=get_admin_reports_keyboard(db_user.language),
+        parse_mode="HTML",
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def send_daily_report(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    await _send_report(callback, ReportPeriod.DAILY, db_user.language)
+
+
+@admin_required
+@error_handler
+async def send_weekly_report(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    await _send_report(callback, ReportPeriod.WEEKLY, db_user.language)
+
+
+@admin_required
+@error_handler
+async def send_monthly_report(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    await _send_report(callback, ReportPeriod.MONTHLY, db_user.language)
+
+
+async def _send_report(
+    callback: types.CallbackQuery,
+    period: ReportPeriod,
+    language: str,
+) -> None:
+    try:
+        report_text = await reporting_service.send_report(period, send_to_topic=True)
+    except ReportingServiceError as exc:
+        logger.warning("Не удалось отправить отчет: %s", exc)
+        await callback.answer(str(exc), show_alert=True)
+        return
+    except Exception as exc:  # noqa: BLE001
+        logger.error("Непредвиденная ошибка при отправке отчета: %s", exc)
+        await callback.answer("Не удалось отправить отчет. Попробуйте позже.", show_alert=True)
+        return
+
+    await callback.message.answer(
+        report_text,
+        reply_markup=get_admin_report_result_keyboard(language),
+    )
+    await callback.answer("Отчет отправлен в топик")
+
+
+@admin_required
+@error_handler
+async def close_report_message(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    texts = get_texts(db_user.language)
+
+    try:
+        await callback.message.delete()
+    except (TelegramBadRequest, TelegramForbiddenError) as exc:
+        logger.warning("Не удалось закрыть сообщение отчета: %s", exc)
+        await callback.answer(texts.t("REPORT_CLOSE_ERROR", "Не удалось закрыть отчет."), show_alert=True)
+        return
+
+    await callback.answer(texts.t("REPORT_CLOSED", "Отчет закрыт."))
+
+
+def register_handlers(dp: Dispatcher) -> None:
+    dp.callback_query.register(show_reports_menu, F.data == "admin_reports")
+    dp.callback_query.register(send_daily_report, F.data == "admin_reports_daily")
+    dp.callback_query.register(send_weekly_report, F.data == "admin_reports_weekly")
+    dp.callback_query.register(send_monthly_report, F.data == "admin_reports_monthly")
+    dp.callback_query.register(close_report_message, F.data == "admin_close_report")
+
@@ -1,3 +1,4 @@
+import html
 import logging
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
@@ -6,10 +7,18 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.states import AdminStates
 from app.database.models import User
 from app.database.crud.server_squad import (
-    get_all_server_squads, get_server_squad_by_id, update_server_squad,
-    delete_server_squad, sync_with_remnawave, get_server_statistics,
-    create_server_squad, get_available_server_squads
+    get_all_server_squads,
+    get_server_squad_by_id,
+    update_server_squad,
+    delete_server_squad,
+    sync_with_remnawave,
+    get_server_statistics,
+    create_server_squad,
+    get_available_server_squads,
+    update_server_squad_promo_groups,
+    get_server_connected_users,
 )
+from app.database.crud.promo_group import get_promo_groups_with_counts
 from app.services.remnawave_service import RemnaWaveService
 from app.utils.decorators import admin_required, error_handler
 from app.utils.cache import cache
@@ -17,6 +26,116 @@ from app.utils.cache import cache
 logger = logging.getLogger(__name__)


+def _build_server_edit_view(server):
+    status_emoji = "✅ Доступен" if server.is_available else "❌ Недоступен"
+    price_text = f"{int(server.price_rubles)} ₽" if server.price_kopeks > 0 else "Бесплатно"
+    promo_groups_text = (
+        ", ".join(sorted(pg.name for pg in server.allowed_promo_groups))
+        if server.allowed_promo_groups
+        else "Не выбраны"
+    )
+
+    text = f"""
+🌐 <b>Редактирование сервера</b>
+
+<b>Информация:</b>
+• ID: {server.id}
+• UUID: <code>{server.squad_uuid}</code>
+• Название: {server.display_name}
+• Оригинальное: {server.original_name or 'Не указано'}
+• Статус: {status_emoji}
+
+<b>Настройки:</b>
+• Цена: {price_text}
+• Код страны: {server.country_code or 'Не указан'}
+• Лимит пользователей: {server.max_users or 'Без лимита'}
+• Текущих пользователей: {server.current_users}
+• Промогруппы: {promo_groups_text}
+
+<b>Описание:</b>
+{server.description or 'Не указано'}
+
+Выберите что изменить:
+"""
+
+    keyboard = [
+        [
+            types.InlineKeyboardButton(
+                text="✏️ Название", callback_data=f"admin_server_edit_name_{server.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="💰 Цена", callback_data=f"admin_server_edit_price_{server.id}"
+            ),
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="🌍 Страна", callback_data=f"admin_server_edit_country_{server.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server.id}"
+            ),
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="👥 Юзеры", callback_data=f"admin_server_users_{server.id}"
+            ),
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="🎯 Промогруппы", callback_data=f"admin_server_edit_promo_{server.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="📝 Описание", callback_data=f"admin_server_edit_desc_{server.id}"
+            ),
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="❌ Отключить" if server.is_available else "✅ Включить",
+                callback_data=f"admin_server_toggle_{server.id}",
+            )
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="🗑️ Удалить", callback_data=f"admin_server_delete_{server.id}"
+            ),
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers_list"),
+        ],
+    ]
+
+    return text, types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def _build_server_promo_groups_keyboard(server_id: int, promo_groups, selected_ids):
+    keyboard = []
+    for group in promo_groups:
+        emoji = "✅" if group["id"] in selected_ids else "⚪"
+        keyboard.append(
+            [
+                types.InlineKeyboardButton(
+                    text=f"{emoji} {group['name']}",
+                    callback_data=f"admin_server_promo_toggle_{server_id}_{group['id']}",
+                )
+            ]
+        )
+
+    keyboard.append(
+        [
+            types.InlineKeyboardButton(
+                text="💾 Сохранить", callback_data=f"admin_server_promo_save_{server_id}"
+            )
+        ]
+    )
+    keyboard.append(
+        [
+            types.InlineKeyboardButton(
+                text="⬅️ Назад", callback_data=f"admin_server_edit_{server_id}"
+            )
+        ]
+    )
+
+    return types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
@admin_required
@error_handler
 async def show_servers_menu(
@@ -164,9 +283,9 @@ async def sync_servers_with_remnawave(
            )
            return
        
-        created, updated, disabled = await sync_with_remnawave(db, squads)
+        created, updated, removed = await sync_with_remnawave(db, squads)
        
-        await cache.delete("available_countries")
+        await cache.delete_pattern("available_countries*")
        
        text = f"""
 ✅ <b>Синхронизация завершена</b>
@@ -174,7 +293,7 @@ async def sync_servers_with_remnawave(
 📊 <b>Результаты:</b>
 • Создано новых серверов: {created}
 • Обновлено существующих: {updated}
-• Отключено неактивных: {disabled}
+• Удалено отсутствующих: {removed}
 • Всего обработано: {len(squads)}

 ℹ️ Новые серверы созданы как недоступные.
@@ -202,7 +321,7 @@ async def sync_servers_with_remnawave(
                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
            ])
        )
-    
+
    await callback.answer()


@@ -216,65 +335,161 @@ async def show_server_edit_menu(
    
    server_id = int(callback.data.split('_')[-1])
    server = await get_server_squad_by_id(db, server_id)
-    
+
    if not server:
        await callback.answer("❌ Сервер не найден!", show_alert=True)
        return
-    
-    status_emoji = "✅ Доступен" if server.is_available else "❌ Недоступен"
-    price_text = f"{int(server.price_rubles)} ₽" if server.price_kopeks > 0 else "Бесплатно"
-    
-    text = f"""
-🌐 <b>Редактирование сервера</b>

-<b>Информация:</b>
-• ID: {server.id}
-• UUID: <code>{server.squad_uuid}</code>
-• Название: {server.display_name}
-• Оригинальное: {server.original_name or 'Не указано'}
-• Статус: {status_emoji}
+    text, keyboard = _build_server_edit_view(server)

-<b>Настройки:</b>
-• Цена: {price_text}
-• Код страны: {server.country_code or 'Не указан'}
-• Лимит пользователей: {server.max_users or 'Без лимита'}
-• Текущих пользователей: {server.current_users}
+    await callback.message.edit_text(
+        text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+    await callback.answer()

-<b>Описание:</b>
-{server.description or 'Не указано'}

-Выберите что изменить:
-"""
-    
-    keyboard = [
-        [
-            types.InlineKeyboardButton(text="✏️ Название", callback_data=f"admin_server_edit_name_{server.id}"),
-            types.InlineKeyboardButton(text="💰 Цена", callback_data=f"admin_server_edit_price_{server.id}")
-        ],
-        [
-            types.InlineKeyboardButton(text="🌍 Страна", callback_data=f"admin_server_edit_country_{server.id}"),
-            types.InlineKeyboardButton(text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server.id}")
-        ],
-        [
-            types.InlineKeyboardButton(text="📝 Описание", callback_data=f"admin_server_edit_desc_{server.id}")
-        ],
-        [
-            types.InlineKeyboardButton(
-                text="❌ Отключить" if server.is_available else "✅ Включить",
-                callback_data=f"admin_server_toggle_{server.id}"
-            )
-        ],
-        [
-            types.InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_server_delete_{server.id}"),
-            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers_list")
-        ]
+@admin_required
+@error_handler
+async def show_server_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+
+    payload = callback.data.split("admin_server_users_", 1)[-1]
+    payload_parts = payload.split("_")
+
+    server_id = int(payload_parts[0])
+    page = int(payload_parts[1]) if len(payload_parts) > 1 else 1
+    page = max(page, 1)
+    server = await get_server_squad_by_id(db, server_id)
+
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+
+    users = await get_server_connected_users(db, server_id)
+    total_users = len(users)
+
+    page_size = 10
+    total_pages = max((total_users + page_size - 1) // page_size, 1)
+
+    if page > total_pages:
+        page = total_pages
+
+    start_index = (page - 1) * page_size
+    end_index = start_index + page_size
+    page_users = users[start_index:end_index]
+
+    safe_name = html.escape(server.display_name or "—")
+    safe_uuid = html.escape(server.squad_uuid or "—")
+
+    header = [
+        "🌐 <b>Пользователи сервера</b>",
+        "",
+        f"• Сервер: {safe_name}",
+        f"• UUID: <code>{safe_uuid}</code>",
+        f"• Подключений: {total_users}",
    ]
-    
+
+    if total_pages > 1:
+        header.append(f"• Страница: {page}/{total_pages}")
+
+    header.append("")
+
+    text = "\n".join(header)
+
+    def _get_status_icon(status_text: str) -> str:
+        if not status_text:
+            return ""
+
+        parts = status_text.split(" ", 1)
+        return parts[0] if parts else status_text
+
+    if users:
+        lines = []
+        for index, user in enumerate(page_users, start=start_index + 1):
+            safe_user_name = html.escape(user.full_name)
+            lines.append(f"{index}. {safe_user_name}")
+
+        text += "\n" + "\n".join(lines)
+    else:
+        text += "Пользователи не найдены."
+
+    keyboard: list[list[types.InlineKeyboardButton]] = []
+
+    for user in page_users:
+        display_name = user.full_name
+        if len(display_name) > 30:
+            display_name = display_name[:27] + "..."
+
+        subscription_status = (
+            user.subscription.status_display
+            if user.subscription
+            else "❌ Нет подписки"
+        )
+        status_icon = _get_status_icon(subscription_status)
+
+        if status_icon:
+            button_text = f"{status_icon} {display_name}"
+        else:
+            button_text = display_name
+
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text=button_text,
+                callback_data=f"admin_user_manage_{user.id}",
+            )
+        ])
+
+    if total_pages > 1:
+        navigation_buttons: list[types.InlineKeyboardButton] = []
+
+        if page > 1:
+            navigation_buttons.append(
+                types.InlineKeyboardButton(
+                    text="⬅️ Предыдущая",
+                    callback_data=f"admin_server_users_{server_id}_{page - 1}",
+                )
+            )
+
+        navigation_buttons.append(
+            types.InlineKeyboardButton(
+                text=f"Стр. {page}/{total_pages}",
+                callback_data=f"admin_server_users_{server_id}_{page}",
+            )
+        )
+
+        if page < total_pages:
+            navigation_buttons.append(
+                types.InlineKeyboardButton(
+                    text="Следующая ➡️",
+                    callback_data=f"admin_server_users_{server_id}_{page + 1}",
+                )
+            )
+
+        keyboard.append(navigation_buttons)
+
+    keyboard.append([
+        types.InlineKeyboardButton(
+            text="⬅️ К серверу", callback_data=f"admin_server_edit_{server_id}"
+        )
+    ])
+
+    keyboard.append([
+        types.InlineKeyboardButton(
+            text="⬅️ К списку", callback_data="admin_servers_list"
+        )
+    ])
+
    await callback.message.edit_text(
        text,
        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
-        parse_mode="HTML"
+        parse_mode="HTML",
    )
+
    await callback.answer()


@@ -296,65 +511,18 @@ async def toggle_server_availability(
    new_status = not server.is_available
    await update_server_squad(db, server_id, is_available=new_status)
    
-    await cache.delete("available_countries")
+    await cache.delete_pattern("available_countries*")
    
    status_text = "включен" if new_status else "отключен"
    await callback.answer(f"✅ Сервер {status_text}!")
    
    server = await get_server_squad_by_id(db, server_id)
    
-    status_emoji = "✅ Доступен" if server.is_available else "❌ Недоступен"
-    price_text = f"{int(server.price_rubles)} ₽" if server.price_kopeks > 0 else "Бесплатно"
-    
-    text = f"""
-🌐 <b>Редактирование сервера</b>
+    text, keyboard = _build_server_edit_view(server)

-<b>Информация:</b>
-• ID: {server.id}
-• UUID: <code>{server.squad_uuid}</code>
-• Название: {server.display_name}
-• Оригинальное: {server.original_name or 'Не указано'}
-• Статус: {status_emoji}
-
-<b>Настройки:</b>
-• Цена: {price_text}
-• Код страны: {server.country_code or 'Не указан'}
-• Лимит пользователей: {server.max_users or 'Без лимита'}
-• Текущих пользователей: {server.current_users}
-
-<b>Описание:</b>
-{server.description or 'Не указано'}
-
-Выберите что изменить:
-"""
-    
-    keyboard = [
-        [
-            types.InlineKeyboardButton(text="✏️ Название", callback_data=f"admin_server_edit_name_{server.id}"),
-            types.InlineKeyboardButton(text="💰 Цена", callback_data=f"admin_server_edit_price_{server.id}")
-        ],
-        [
-            types.InlineKeyboardButton(text="🌍 Страна", callback_data=f"admin_server_edit_country_{server.id}"),
-            types.InlineKeyboardButton(text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server.id}")
-        ],
-        [
-            types.InlineKeyboardButton(text="📝 Описание", callback_data=f"admin_server_edit_desc_{server.id}")
-        ],
-        [
-            types.InlineKeyboardButton(
-                text="❌ Отключить" if server.is_available else "✅ Включить",
-                callback_data=f"admin_server_toggle_{server.id}"
-            )
-        ],
-        [
-            types.InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_server_delete_{server.id}"),
-            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers_list")
-        ]
-    ]
-    
    await callback.message.edit_text(
        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        reply_markup=keyboard,
        parse_mode="HTML"
    )

@@ -422,7 +590,7 @@ async def process_server_price_edit(
        if server:
            await state.clear()
            
-            await cache.delete("available_countries")
+            await cache.delete_pattern("available_countries*")
            
            price_text = f"{int(price_rubles)} ₽" if price_kopeks > 0 else "Бесплатно"
            await message.answer(
@@ -497,7 +665,7 @@ async def process_server_name_edit(
    if server:
        await state.clear()
        
-        await cache.delete("available_countries")
+        await cache.delete_pattern("available_countries*")
        
        await message.answer(
            f"✅ Название сервера изменено на: <b>{new_name}</b>",
@@ -570,7 +738,7 @@ async def delete_server_execute(
    success = await delete_server_squad(db, server_id)
    
    if success:
-        await cache.delete("available_countries")
+        await cache.delete_pattern("available_countries*")
        
        await callback.message.edit_text(
            f"✅ Сервер <b>{server.display_name}</b> успешно удален!",
@@ -701,7 +869,7 @@ async def process_server_country_edit(
    if server:
        await state.clear()
        
-        await cache.delete("available_countries")
+        await cache.delete_pattern("available_countries*")
        
        country_text = new_country or "Удален"
        await message.answer(
@@ -847,11 +1015,12 @@ async def process_server_description_edit(
        return
    
    server = await update_server_squad(db, server_id, description=new_description)
-    
+
    if server:
        await state.clear()
-        
+
        desc_text = new_description or "Удалено"
+        await cache.delete_pattern("available_countries*")
        await message.answer(
            f"✅ Описание сервера изменено:\n\n<i>{desc_text}</i>",
            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
@@ -862,6 +1031,147 @@ async def process_server_description_edit(
    else:
        await message.answer("❌ Ошибка при обновлении сервера")

+
+@admin_required
+@error_handler
+async def start_server_edit_promo_groups(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession,
+):
+
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+
+    promo_groups_data = await get_promo_groups_with_counts(db)
+    promo_groups = [
+        {"id": group.id, "name": group.name, "is_default": group.is_default}
+        for group, _ in promo_groups_data
+    ]
+
+    if not promo_groups:
+        await callback.answer("❌ Не найдены промогруппы", show_alert=True)
+        return
+
+    selected_ids = {pg.id for pg in server.allowed_promo_groups}
+    if not selected_ids:
+        default_group = next((pg for pg in promo_groups if pg["is_default"]), None)
+        if default_group:
+            selected_ids.add(default_group["id"])
+
+    await state.set_state(AdminStates.editing_server_promo_groups)
+    await state.set_data(
+        {
+            "server_id": server_id,
+            "promo_groups": promo_groups,
+            "selected_promo_groups": list(selected_ids),
+            "server_name": server.display_name,
+        }
+    )
+
+    text = (
+        "🎯 <b>Настройка промогрупп</b>\n\n"
+        f"Сервер: <b>{server.display_name}</b>\n\n"
+        "Выберите промогруппы, которым будет доступен этот сервер.\n"
+        "Должна быть выбрана минимум одна промогруппа."
+    )
+
+    await callback.message.edit_text(
+        text,
+        reply_markup=_build_server_promo_groups_keyboard(server_id, promo_groups, selected_ids),
+        parse_mode="HTML",
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_server_promo_group(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession,
+):
+
+    parts = callback.data.split('_')
+    server_id = int(parts[4])
+    group_id = int(parts[5])
+
+    data = await state.get_data()
+    if not data or data.get("server_id") != server_id:
+        await callback.answer("⚠️ Сессия редактирования устарела", show_alert=True)
+        return
+
+    selected = set(int(pg_id) for pg_id in data.get("selected_promo_groups", []))
+    promo_groups = data.get("promo_groups", [])
+
+    if group_id in selected:
+        if len(selected) == 1:
+            await callback.answer("⚠️ Нельзя отключить последнюю промогруппу", show_alert=True)
+            return
+        selected.remove(group_id)
+        message = "Промогруппа отключена"
+    else:
+        selected.add(group_id)
+        message = "Промогруппа добавлена"
+
+    await state.update_data(selected_promo_groups=list(selected))
+
+    await callback.message.edit_reply_markup(
+        reply_markup=_build_server_promo_groups_keyboard(server_id, promo_groups, selected)
+    )
+    await callback.answer(message)
+
+
+@admin_required
+@error_handler
+async def save_server_promo_groups(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession,
+):
+
+    data = await state.get_data()
+    if not data:
+        await callback.answer("⚠️ Нет данных для сохранения", show_alert=True)
+        return
+
+    server_id = data.get("server_id")
+    selected = data.get("selected_promo_groups", [])
+
+    if not selected:
+        await callback.answer("❌ Выберите хотя бы одну промогруппу", show_alert=True)
+        return
+
+    try:
+        server = await update_server_squad_promo_groups(db, server_id, selected)
+    except ValueError as exc:
+        await callback.answer(f"❌ {exc}", show_alert=True)
+        return
+
+    if not server:
+        await callback.answer("❌ Сервер не найден", show_alert=True)
+        return
+
+    await cache.delete_pattern("available_countries*")
+    await state.clear()
+
+    text, keyboard = _build_server_edit_view(server)
+
+    await callback.message.edit_text(
+        text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+    await callback.answer("✅ Промогруппы обновлены!")
+
+
@admin_required
@error_handler
 async def sync_server_user_counts_handler(
@@ -934,12 +1244,23 @@ def register_handlers(dp: Dispatcher):
    dp.callback_query.register(sync_server_user_counts_handler, F.data == "admin_servers_sync_counts")
    dp.callback_query.register(show_server_detailed_stats, F.data == "admin_servers_stats")
    
-    dp.callback_query.register(show_server_edit_menu, F.data.startswith("admin_server_edit_") & ~F.data.contains("name") & ~F.data.contains("price") & ~F.data.contains("country") & ~F.data.contains("limit") & ~F.data.contains("desc"))
+    dp.callback_query.register(
+        show_server_edit_menu,
+        F.data.startswith("admin_server_edit_")
+        & ~F.data.contains("name")
+        & ~F.data.contains("price")
+        & ~F.data.contains("country")
+        & ~F.data.contains("limit")
+        & ~F.data.contains("desc")
+        & ~F.data.contains("promo"),
+    )
    dp.callback_query.register(toggle_server_availability, F.data.startswith("admin_server_toggle_"))
-    
+    dp.callback_query.register(show_server_users, F.data.startswith("admin_server_users_"))
+
    dp.callback_query.register(start_server_edit_name, F.data.startswith("admin_server_edit_name_"))
    dp.callback_query.register(start_server_edit_price, F.data.startswith("admin_server_edit_price_"))
-    dp.callback_query.register(start_server_edit_country, F.data.startswith("admin_server_edit_country_"))      
+    dp.callback_query.register(start_server_edit_country, F.data.startswith("admin_server_edit_country_"))
+    dp.callback_query.register(start_server_edit_promo_groups, F.data.startswith("admin_server_edit_promo_"))
    dp.callback_query.register(start_server_edit_limit, F.data.startswith("admin_server_edit_limit_"))         
    dp.callback_query.register(start_server_edit_description, F.data.startswith("admin_server_edit_desc_"))     
    
@@ -947,7 +1268,9 @@ def register_handlers(dp: Dispatcher):
    dp.message.register(process_server_price_edit, AdminStates.editing_server_price)
    dp.message.register(process_server_country_edit, AdminStates.editing_server_country)            
    dp.message.register(process_server_limit_edit, AdminStates.editing_server_limit)                
-    dp.message.register(process_server_description_edit, AdminStates.editing_server_description)    
+    dp.message.register(process_server_description_edit, AdminStates.editing_server_description)
+    dp.callback_query.register(toggle_server_promo_group, F.data.startswith("admin_server_promo_toggle_"))
+    dp.callback_query.register(save_server_promo_groups, F.data.startswith("admin_server_promo_save_"))
    
    dp.callback_query.register(delete_server_confirm, F.data.startswith("admin_server_delete_") & ~F.data.contains("confirm"))
    dp.callback_query.register(delete_server_execute, F.data.startswith("admin_server_delete_confirm_"))
@@ -4,9 +4,11 @@ import html
 import contextlib
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
 from sqlalchemy.ext.asyncio import AsyncSession

 from app.database.models import User
+from app.config import settings
 from app.localization.texts import get_texts
 from app.utils.decorators import admin_required, error_handler
 from app.services.support_settings_service import SupportSettingsService
@@ -20,28 +22,114 @@ def _get_support_settings_keyboard(language: str) -> types.InlineKeyboardMarkup:
    texts = get_texts(language)
    mode = SupportSettingsService.get_system_mode()
    menu_enabled = SupportSettingsService.is_support_menu_enabled()
+    admin_notif = SupportSettingsService.get_admin_ticket_notifications_enabled()
+    user_notif = SupportSettingsService.get_user_ticket_notifications_enabled()
+    sla_enabled = SupportSettingsService.get_sla_enabled()
+    sla_minutes = SupportSettingsService.get_sla_minutes()

    rows: list[list[types.InlineKeyboardButton]] = []

+    status_enabled = texts.t("ADMIN_SUPPORT_SETTINGS_STATUS_ENABLED", "Включены")
+    status_disabled = texts.t("ADMIN_SUPPORT_SETTINGS_STATUS_DISABLED", "Отключены")
+
+    def mode_button(label_key: str, default: str, active: bool) -> str:
+        prefix = "🔘" if active else "⚪"
+        return f"{prefix} {texts.t(label_key, default)}"
+
    rows.append([
        types.InlineKeyboardButton(
-            text=("✅ Пункт 'Техподдержка' в меню" if menu_enabled else "🚫 Пункт 'Техподдержка' в меню"),
+            text=(
+                f"{'✅' if menu_enabled else '🚫'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_MENU_LABEL', 'Пункт «Техподдержка» в меню')}"
+            ),
            callback_data="admin_support_toggle_menu"
        )
    ])

    rows.append([
-        types.InlineKeyboardButton(text=("🔘 Тикеты" if mode == "tickets" else "⚪ Тикеты"), callback_data="admin_support_mode_tickets"),
-        types.InlineKeyboardButton(text=("🔘 Контакт" if mode == "contact" else "⚪ Контакт"), callback_data="admin_support_mode_contact"),
-        types.InlineKeyboardButton(text=("🔘 Оба" if mode == "both" else "⚪ Оба"), callback_data="admin_support_mode_both"),
+        types.InlineKeyboardButton(
+            text=mode_button("ADMIN_SUPPORT_SETTINGS_MODE_TICKETS", "Тикеты", mode == "tickets"),
+            callback_data="admin_support_mode_tickets"
+        ),
+        types.InlineKeyboardButton(
+            text=mode_button("ADMIN_SUPPORT_SETTINGS_MODE_CONTACT", "Контакт", mode == "contact"),
+            callback_data="admin_support_mode_contact"
+        ),
+        types.InlineKeyboardButton(
+            text=mode_button("ADMIN_SUPPORT_SETTINGS_MODE_BOTH", "Оба", mode == "both"),
+            callback_data="admin_support_mode_both"
+        ),
    ])

    rows.append([
-        types.InlineKeyboardButton(text="📝 Изменить описание", callback_data="admin_support_edit_desc")
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_EDIT_DESCRIPTION", "📝 Изменить описание"),
+            callback_data="admin_support_edit_desc"
+        )
+    ])
+
+    # Notifications block
+    rows.append([
+        types.InlineKeyboardButton(
+            text=(
+                f"{'🔔' if admin_notif else '🔕'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_ADMIN_NOTIFICATIONS', 'Админ-уведомления')}: "
+                f"{status_enabled if admin_notif else status_disabled}"
+            ),
+            callback_data="admin_support_toggle_admin_notifications"
+        )
+    ])
+    rows.append([
+        types.InlineKeyboardButton(
+            text=(
+                f"{'🔔' if user_notif else '🔕'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_USER_NOTIFICATIONS', 'Пользовательские уведомления')}: "
+                f"{status_enabled if user_notif else status_disabled}"
+            ),
+            callback_data="admin_support_toggle_user_notifications"
+        )
+    ])
+
+    # SLA block
+    rows.append([
+        types.InlineKeyboardButton(
+            text=(
+                f"{'⏰' if sla_enabled else '⏹️'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_SLA_LABEL', 'SLA')}: "
+                f"{status_enabled if sla_enabled else status_disabled}"
+            ),
+            callback_data="admin_support_toggle_sla"
+        )
+    ])
+    rows.append([
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_SLA_TIME", "⏳ Время SLA: {minutes} мин").format(minutes=sla_minutes),
+            callback_data="admin_support_set_sla_minutes"
+        )
+    ])
+
+    # Moderators
+    moderators = SupportSettingsService.get_moderators()
+    mod_count = len(moderators)
+    rows.append([
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_MODERATORS_COUNT", "🧑‍⚖️ Модераторы: {count}").format(count=mod_count),
+            callback_data="admin_support_list_moderators"
+        )
+    ])
+    rows.append([
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_ADD_MODERATOR", "➕ Назначить модератора"),
+            callback_data="admin_support_add_moderator"
+        ),
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_REMOVE_MODERATOR", "➖ Удалить модератора"),
+            callback_data="admin_support_remove_moderator"
+        )
    ])

    rows.append([
-        types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_communications")
+        types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_support")
    ])

    return types.InlineKeyboardMarkup(inline_keyboard=rows)
@@ -57,8 +145,8 @@ async def show_support_settings(
    texts = get_texts(db_user.language)
    desc = SupportSettingsService.get_support_info_text(db_user.language)
    await callback.message.edit_text(
-        "🛟 <b>Настройки поддержки</b>\n\n" +
-        "Режим работы и видимость в меню. Ниже текущее описание меню поддержки:\n\n" +
+        texts.t("ADMIN_SUPPORT_SETTINGS_TITLE", "🛟 <b>Настройки поддержки</b>") + "\n\n" +
+        texts.t("ADMIN_SUPPORT_SETTINGS_DESCRIPTION", "Режим работы и видимость в меню. Ниже текущее описание меню поддержки:") + "\n\n" +
        desc,
        reply_markup=_get_support_settings_keyboard(db_user.language),
        parse_mode="HTML"
@@ -78,6 +166,163 @@ async def toggle_support_menu(
    await show_support_settings(callback, db_user, db)


+@admin_required
+@error_handler
+async def toggle_admin_notifications(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
+    current = SupportSettingsService.get_admin_ticket_notifications_enabled()
+    SupportSettingsService.set_admin_ticket_notifications_enabled(not current)
+    await show_support_settings(callback, db_user, db)
+
+
+@admin_required
+@error_handler
+async def toggle_user_notifications(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
+    current = SupportSettingsService.get_user_ticket_notifications_enabled()
+    SupportSettingsService.set_user_ticket_notifications_enabled(not current)
+    await show_support_settings(callback, db_user, db)
+
+
+@admin_required
+@error_handler
+async def toggle_sla(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
+    current = SupportSettingsService.get_sla_enabled()
+    SupportSettingsService.set_sla_enabled(not current)
+    await show_support_settings(callback, db_user, db)
+
+
+class SupportAdvancedStates(StatesGroup):
+    waiting_for_sla_minutes = State()
+    waiting_for_moderator_id = State()
+
+
+@admin_required
+@error_handler
+async def start_set_sla_minutes(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
+    await callback.message.edit_text(
+        texts.t(
+            "ADMIN_SUPPORT_SLA_SETUP_PROMPT",
+            "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):"
+        ),
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
+        )
+    )
+    await state.set_state(SupportAdvancedStates.waiting_for_sla_minutes)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def handle_sla_minutes(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
+    text = (message.text or "").strip()
+    try:
+        minutes = int(text)
+        if minutes <= 0 or minutes > 1440:
+            raise ValueError()
+    except Exception:
+        await message.answer(texts.t("ADMIN_SUPPORT_SLA_INVALID", "❌ Введите корректное число минут (1-1440)"))
+        return
+    SupportSettingsService.set_sla_minutes(minutes)
+    await state.clear()
+    markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
+    )
+    await message.answer(texts.t("ADMIN_SUPPORT_SLA_SAVED", "✅ Значение SLA сохранено"), reply_markup=markup)
+
+
+@admin_required
+@error_handler
+async def start_add_moderator(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
+    await callback.message.edit_text(
+        texts.t(
+            "ADMIN_SUPPORT_ASSIGN_MODERATOR_PROMPT",
+            "🧑‍⚖️ <b>Назначение модератора</b>\n\nОтправьте Telegram ID пользователя (число)"
+        ),
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
+        )
+    )
+    await state.set_state(SupportAdvancedStates.waiting_for_moderator_id)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_remove_moderator(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
+    await callback.message.edit_text(
+        texts.t(
+            "ADMIN_SUPPORT_REMOVE_MODERATOR_PROMPT",
+            "🧑‍⚖️ <b>Удаление модератора</b>\n\nОтправьте Telegram ID пользователя (число)"
+        ),
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
+        )
+    )
+    await state.set_state(SupportAdvancedStates.waiting_for_moderator_id)
+    # We'll reuse the same state; next message will decide action via flag
+    await state.update_data(action="remove_moderator")
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def handle_moderator_id(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
+    data = await state.get_data()
+    action = data.get("action", "add")
+    text = (message.text or "").strip()
+    try:
+        tid = int(text)
+    except Exception:
+        await message.answer(texts.t("ADMIN_SUPPORT_INVALID_TELEGRAM_ID", "❌ Введите корректный Telegram ID (число)"))
+        return
+    if action == "remove_moderator":
+        ok = SupportSettingsService.remove_moderator(tid)
+        msg = (
+            texts.t("ADMIN_SUPPORT_MODERATOR_REMOVED_SUCCESS", "✅ Модератор {tid} удалён").format(tid=tid)
+            if ok
+            else texts.t("ADMIN_SUPPORT_MODERATOR_REMOVED_FAIL", "❌ Не удалось удалить модератора")
+        )
+    else:
+        ok = SupportSettingsService.add_moderator(tid)
+        msg = (
+            texts.t("ADMIN_SUPPORT_MODERATOR_ADDED_SUCCESS", "✅ Пользователь {tid} назначен модератором").format(tid=tid)
+            if ok
+            else texts.t("ADMIN_SUPPORT_MODERATOR_ADDED_FAIL", "❌ Не удалось назначить модератора")
+        )
+    await state.clear()
+    markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
+    )
+    await message.answer(msg, reply_markup=markup)
+
+
+@admin_required
+@error_handler
+async def list_moderators(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
+    texts = get_texts(db_user.language)
+    moderators = SupportSettingsService.get_moderators()
+    if not moderators:
+        await callback.answer(texts.t("ADMIN_SUPPORT_MODERATORS_EMPTY", "Список пуст"), show_alert=True)
+        return
+    text = (
+        texts.t("ADMIN_SUPPORT_MODERATORS_TITLE", "🧑‍⚖️ <b>Модераторы</b>") +
+        "\n\n" + "\n".join([f"• <code>{tid}</code>" for tid in moderators])
+    )
+    markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
+    )
+    await callback.message.edit_text(text, parse_mode="HTML", reply_markup=markup)
+    await callback.answer()
+
+
@admin_required
@error_handler
 async def set_mode_tickets(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
@@ -109,7 +354,10 @@ async def start_edit_desc(callback: types.CallbackQuery, db_user: User, db: Asyn

    kb_rows: list[list[types.InlineKeyboardButton]] = []
    kb_rows.append([
-        types.InlineKeyboardButton(text="📨 Прислать текст", callback_data="admin_support_send_desc")
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SEND_DESCRIPTION", "📨 Прислать текст"),
+            callback_data="admin_support_send_desc"
+        )
    ])
    # Подготовим блок контакта (отдельным инлайном)
    from app.config import settings
@@ -119,19 +367,19 @@ async def start_edit_desc(callback: types.CallbackQuery, db_user: User, db: Asyn
    ])

    text_parts = [
-        "📝 <b>Редактирование описания поддержки</b>",
+        texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_TITLE", "📝 <b>Редактирование описания поддержки</b>"),
        "",
-        "Текущее описание:",
+        texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_CURRENT", "Текущее описание:"),
        "",
        f"<code>{html.escape(current_desc_plain)}</code>",
    ]
    if support_contact_display:
        text_parts += [
            "",
-            "<b>Контакт для режима \u00abКонтакт\u00bb</b>",
+            texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_TITLE", "<b>Контакт для режима «Контакт»</b>"),
            f"<code>{html.escape(support_contact_display)}</code>",
            "",
-            "Добавьте в описание при необходимости.",
+            texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_HINT", "Добавьте в описание при необходимости."),
        ]
    await callback.message.edit_text(
        "\n".join(text_parts),
@@ -145,24 +393,26 @@ async def start_edit_desc(callback: types.CallbackQuery, db_user: User, db: Asyn
@admin_required
@error_handler
 async def handle_new_desc(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    new_text = message.html_text or message.text
    SupportSettingsService.set_support_info_text(db_user.language, new_text)
    await state.clear()
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
    )
-    await message.answer("✅ Описание обновлено.", reply_markup=markup)
+    await message.answer(texts.t("ADMIN_SUPPORT_DESCRIPTION_UPDATED", "✅ Описание обновлено."), reply_markup=markup)


@admin_required
@error_handler
 async def send_desc_copy(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
    # send plain text for easy copying
+    texts = get_texts(db_user.language)
    current_desc_html = SupportSettingsService.get_support_info_text(db_user.language)
    current_desc_plain = re.sub(r"<[^>]+>", "", current_desc_html)
    # attach delete button to the sent message
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
    )
    if len(current_desc_plain) <= 4000:
        await callback.message.answer(current_desc_plain, reply_markup=markup)
@@ -174,17 +424,25 @@ async def send_desc_copy(callback: types.CallbackQuery, db_user: User, db: Async
            is_last = (chunk + 4000) >= len(current_desc_plain)
            await callback.message.answer(next_chunk, reply_markup=(markup if is_last else None))
            chunk += 4000
-    await callback.answer("Текст отправлен ниже")
+    await callback.answer(texts.t("ADMIN_SUPPORT_DESCRIPTION_SENT", "Текст отправлен ниже"))


-@admin_required
@error_handler
 async def delete_sent_message(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
+    # Allow admins and moderators to delete informational notifications
+    try:
+        may_delete = (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id))
+    except Exception:
+        may_delete = False
+    texts = get_texts(db_user.language if db_user else 'ru')
+    if not may_delete:
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    try:
        await callback.message.delete()
    finally:
        with contextlib.suppress(Exception):
-            await callback.answer("Сообщение удалено")
+            await callback.answer(texts.t("ADMIN_SUPPORT_MESSAGE_DELETED", "Сообщение удалено"))


 def register_handlers(dp: Dispatcher):
@@ -196,6 +454,15 @@ def register_handlers(dp: Dispatcher):
    dp.callback_query.register(start_edit_desc, F.data == "admin_support_edit_desc")
    dp.callback_query.register(send_desc_copy, F.data == "admin_support_send_desc")
    dp.callback_query.register(delete_sent_message, F.data == "admin_support_delete_msg")
+    dp.callback_query.register(toggle_admin_notifications, F.data == "admin_support_toggle_admin_notifications")
+    dp.callback_query.register(toggle_user_notifications, F.data == "admin_support_toggle_user_notifications")
+    dp.callback_query.register(toggle_sla, F.data == "admin_support_toggle_sla")
+    dp.callback_query.register(start_set_sla_minutes, F.data == "admin_support_set_sla_minutes")
+    dp.callback_query.register(start_add_moderator, F.data == "admin_support_add_moderator")
+    dp.callback_query.register(start_remove_moderator, F.data == "admin_support_remove_moderator")
+    dp.callback_query.register(list_moderators, F.data == "admin_support_list_moderators")
    dp.message.register(handle_new_desc, SupportSettingsStates.waiting_for_desc)
+    dp.message.register(handle_sla_minutes, SupportAdvancedStates.waiting_for_sla_minutes)
+    dp.message.register(handle_moderator_id, SupportAdvancedStates.waiting_for_moderator_id)


@@ -0,0 +1,165 @@
+import logging
+from datetime import datetime
+from html import escape
+from pathlib import Path
+
+from aiogram import Dispatcher, F, types
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, FSInputFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+LOG_PREVIEW_LIMIT = 2300
+
+
+def _resolve_log_path() -> Path:
+    log_path = Path(settings.LOG_FILE)
+    if not log_path.is_absolute():
+        log_path = Path.cwd() / log_path
+    return log_path
+
+
+def _format_preview_block(text: str) -> str:
+    escaped_text = escape(text) if text else ""
+    return f"<blockquote expandable><pre><code>{escaped_text}</code></pre></blockquote>"
+
+
+def _build_logs_message(log_path: Path) -> str:
+    if not log_path.exists():
+        message = (
+            "🧾 <b>Системные логи</b>\n\n"
+            f"Файл <code>{log_path}</code> пока не создан.\n"
+            "Логи появятся автоматически после первой записи."
+        )
+        return message
+
+    try:
+        content = log_path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as error:  # pragma: no cover - защита от проблем чтения
+        logger.error("Ошибка чтения лог-файла %s: %s", log_path, error)
+        message = (
+            "❌ <b>Ошибка чтения логов</b>\n\n"
+            f"Не удалось прочитать файл <code>{log_path}</code>."
+        )
+        return message
+
+    total_length = len(content)
+    stats = log_path.stat()
+    updated_at = datetime.fromtimestamp(stats.st_mtime)
+
+    if not content:
+        preview_text = "Лог-файл пуст."
+        truncated = False
+    else:
+        preview_text = content[-LOG_PREVIEW_LIMIT:]
+        truncated = total_length > LOG_PREVIEW_LIMIT
+
+    details_lines = [
+        "🧾 <b>Системные логи</b>",
+        "",
+        f"📁 <b>Файл:</b> <code>{log_path}</code>",
+        f"🕒 <b>Обновлен:</b> {updated_at.strftime('%d.%m.%Y %H:%M:%S')}",
+        f"🧮 <b>Размер:</b> {total_length} символов",
+        (
+            f"👇 Показаны последние {LOG_PREVIEW_LIMIT} символов."
+            if truncated
+            else "📄 Показано все содержимое файла."
+        ),
+        "",
+        _format_preview_block(preview_text),
+    ]
+
+    return "\n".join(details_lines)
+
+
+def _get_logs_keyboard() -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[
+            [InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_system_logs_refresh")],
+            [InlineKeyboardButton(text="⬇️ Скачать лог", callback_data="admin_system_logs_download")],
+            [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_submenu_system")],
+        ]
+    )
+
+
+@admin_required
+@error_handler
+async def show_system_logs(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    log_path = _resolve_log_path()
+    message = _build_logs_message(log_path)
+
+    reply_markup = _get_logs_keyboard()
+    await callback.message.edit_text(message, reply_markup=reply_markup, parse_mode="HTML")
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def refresh_system_logs(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    log_path = _resolve_log_path()
+    message = _build_logs_message(log_path)
+
+    reply_markup = _get_logs_keyboard()
+    await callback.message.edit_text(message, reply_markup=reply_markup, parse_mode="HTML")
+    await callback.answer("🔄 Обновлено")
+
+
+@admin_required
+@error_handler
+async def download_system_logs(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    log_path = _resolve_log_path()
+
+    if not log_path.exists() or not log_path.is_file():
+        await callback.answer("❌ Лог-файл не найден", show_alert=True)
+        return
+
+    try:
+        await callback.answer("⬇️ Отправляю лог...")
+
+        document = FSInputFile(log_path)
+        stats = log_path.stat()
+        updated_at = datetime.fromtimestamp(stats.st_mtime).strftime("%d.%m.%Y %H:%M:%S")
+        caption = (
+            f"🧾 Лог-файл <code>{log_path.name}</code>\n"
+            f"📁 Путь: <code>{log_path}</code>\n"
+            f"🕒 Обновлен: {updated_at}"
+        )
+        await callback.message.answer_document(document=document, caption=caption, parse_mode="HTML")
+    except Exception as error:  # pragma: no cover - защита от ошибок отправки
+        logger.error("Ошибка отправки лог-файла %s: %s", log_path, error)
+        await callback.message.answer(
+            "❌ <b>Не удалось отправить лог-файл</b>\n\n"
+            "Проверьте журналы приложения или повторите попытку позже.",
+            parse_mode="HTML",
+        )
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(
+        show_system_logs,
+        F.data == "admin_system_logs",
+    )
+    dp.callback_query.register(
+        refresh_system_logs,
+        F.data == "admin_system_logs_refresh",
+    )
+    dp.callback_query.register(
+        download_system_logs,
+        F.data == "admin_system_logs_download",
+    )
@@ -1,6 +1,7 @@
 import logging
 from typing import List, Dict, Any, Optional
 from aiogram import Dispatcher, types, F, Bot
+from aiogram.exceptions import TelegramBadRequest
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, desc, and_
@@ -18,6 +19,7 @@ from app.keyboards.inline import (
 from app.localization.texts import get_texts
 from app.utils.pagination import paginate_list, get_pagination_info
 from app.services.admin_notification_service import AdminNotificationService
+from app.services.support_settings_service import SupportSettingsService
 from app.config import settings
 from app.utils.cache import RateLimitCache

@@ -33,6 +35,11 @@ async def show_admin_tickets(
    db: AsyncSession
 ):
    """Показать все тикеты для админов"""
+    # permission gate: admin or active moderator only
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    texts = get_texts(db_user.language)
    
    # Определяем текущую страницу и scope
@@ -59,6 +66,8 @@ async def show_admin_tickets(
    # total count for proper pagination
    total_count = await TicketCRUD.count_tickets_by_statuses(db, statuses)
    total_pages = max(1, (total_count + page_size - 1) // page_size) if total_count > 0 else 1
+    if current_page < 1:
+        current_page = 1
    if current_page > total_pages:
        current_page = total_pages
    offset = (current_page - 1) * page_size
@@ -70,20 +79,48 @@ async def show_admin_tickets(
    ticket_data = []
    for ticket in tickets:
        user_name = ticket.user.full_name if ticket.user else "Unknown"
+        username = ticket.user.username if ticket.user else None
+        telegram_id = ticket.user.telegram_id if ticket.user else None
        ticket_data.append({
            'id': ticket.id,
            'title': ticket.title,
            'status_emoji': ticket.status_emoji,
            'priority_emoji': ticket.priority_emoji,
            'user_name': user_name,
+            'username': username,
+            'telegram_id': telegram_id,
            'is_closed': ticket.is_closed,
            'locked_emoji': ("🔒" if ticket.is_user_reply_blocked else "")
        })
    
    # Итоговые страницы уже посчитаны выше
-    await callback.message.edit_text(
-        texts.t("ADMIN_TICKETS_TITLE", "🎫 Все тикеты поддержки:"),
-        reply_markup=get_admin_tickets_keyboard(ticket_data, current_page=current_page, total_pages=total_pages, language=db_user.language, scope=scope)
+    header_text = (
+        texts.t("ADMIN_TICKETS_TITLE_OPEN", "🎫 Открытые тикеты поддержки:")
+        if scope == "open"
+        else texts.t("ADMIN_TICKETS_TITLE_CLOSED", "🎫 Закрытые тикеты поддержки:")
+    )
+    # Determine proper back target for moderators
+    back_cb = "admin_submenu_support"
+    try:
+        if not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id):
+            back_cb = "moderator_panel"
+    except Exception:
+        pass
+
+    keyboard = get_admin_tickets_keyboard(
+        ticket_data,
+        current_page=current_page,
+        total_pages=total_pages,
+        language=db_user.language,
+        scope=scope,
+        back_callback=back_cb,
+    )
+    from app.utils.photo_message import edit_or_answer_photo
+    await edit_or_answer_photo(
+        callback=callback,
+        caption=header_text,
+        keyboard=keyboard,
+        parse_mode="HTML",
    )
    await callback.answer()

@@ -96,6 +133,11 @@ async def view_admin_ticket(
    ticket_id: Optional[int] = None
 ):
    """Показать детали тикета для админа"""
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
+    
    if ticket_id is None:
        try:
            ticket_id = int((callback.data or "").split("_")[-1])
@@ -131,9 +173,13 @@ async def view_admin_ticket(
    }.get(ticket.status, ticket.status)
    
    user_name = ticket.user.full_name if ticket.user else "Unknown"
-    
+    telegram_id_display = ticket.user.telegram_id if ticket.user else "—"
+    username_display = (ticket.user.username or "отсутствует") if ticket.user else "отсутствует"
+
    ticket_text = f"🎫 Тикет #{ticket.id}\n\n"
    ticket_text += f"👤 Пользователь: {user_name}\n"
+    ticket_text += f"🆔 Telegram ID: <code>{telegram_id_display}</code>\n"
+    ticket_text += f"📱 Username: @{username_display}\n"
    ticket_text += f"📝 Заголовок: {ticket.title}\n"
    ticket_text += f"📊 Статус: {ticket.status_emoji} {status_text}\n"
    ticket_text += f"📅 Создан: {ticket.created_at.strftime('%d.%m.%Y %H:%M')}\n"
@@ -158,34 +204,58 @@ async def view_admin_ticket(
    # Добавим кнопку "Вложения", если есть фото
    has_photos = any(getattr(m, "has_media", False) and getattr(m, "media_type", None) == "photo" for m in ticket.messages or [])
    keyboard = get_admin_ticket_view_keyboard(
-        ticket_id, 
-        ticket.is_closed, 
-        db_user.language
+        ticket_id,
+        ticket.is_closed,
+        db_user.language,
+        is_user_blocked=ticket.is_user_reply_blocked
    )
+    # Кнопка открытия профиля пользователя в админке
+    try:
+        if ticket.user:
+            admin_profile_btn = types.InlineKeyboardButton(
+                text="👤 К пользователю",
+                callback_data=f"admin_user_manage_{ticket.user.id}_from_ticket_{ticket.id}"
+            )
+            keyboard.inline_keyboard.insert(0, [admin_profile_btn])
+    except Exception:
+        pass
+    # Кнопки ЛС и профиль
+    try:
+        if ticket.user and ticket.user.telegram_id:
+            buttons_row = []
+            # DM: при наличии username используем tg://resolve, иначе fallback по ID
+            if ticket.user.username:
+                pm_url = f"tg://resolve?domain={ticket.user.username}"
+            else:
+                pm_url = f"tg://user?id={ticket.user.telegram_id}"
+            buttons_row.append(types.InlineKeyboardButton(text="✉ Написать в ЛС", url=pm_url))
+            # Профиль: по ID
+            profile_url = f"tg://user?id={ticket.user.telegram_id}"
+            buttons_row.append(types.InlineKeyboardButton(text="👤 Профиль", url=profile_url))
+            if buttons_row:
+                keyboard.inline_keyboard.insert(0, buttons_row)
+    except Exception:
+        pass
    if has_photos:
        try:
            keyboard.inline_keyboard.insert(0, [types.InlineKeyboardButton(text=texts.t("TICKET_ATTACHMENTS", "📎 Вложения"), callback_data=f"admin_ticket_attachments_{ticket_id}")])
        except Exception:
            pass

-    # Сначала пробуем отредактировать; если не вышло — удалим и отправим новое
-    try:
-        await callback.message.edit_text(
-            ticket_text,
-            reply_markup=keyboard,
-        )
-    except Exception:
+    # Рендер через фото-утилиту (с логотипом), внутри есть фоллбеки на текст
+    from app.utils.photo_message import edit_or_answer_photo
+    await edit_or_answer_photo(
+        callback=callback,
+        caption=ticket_text,
+        keyboard=keyboard,
+        parse_mode="HTML",
+    )
+    # сохраняем id для дальнейших действий (ответ/статусы)
+    if state is not None:
        try:
-            await callback.message.delete()
+            await state.update_data(ticket_id=ticket_id)
        except Exception:
            pass
-        await callback.message.answer(
-            ticket_text,
-            reply_markup=keyboard,
-        )
-    # сохраняем id для дальнейших действий (ответ/статусы)
-    if state:
-        await state.update_data(ticket_id=ticket_id)
    await callback.answer()


@@ -195,6 +265,10 @@ async def reply_to_admin_ticket(
    db_user: User
 ):
    """Начать ответ на тикет от админа"""
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    ticket_id = int(callback.data.replace("admin_reply_ticket_", ""))
    
    await state.update_data(ticket_id=ticket_id, reply_mode=True)
@@ -214,6 +288,11 @@ async def handle_admin_ticket_reply(
    db_user: User,
    db: AsyncSession
 ):
+    if not (settings.is_admin(message.from_user.id) or SupportSettingsService.is_moderator(message.from_user.id)):
+        texts = get_texts(db_user.language)
+        await message.answer(texts.ACCESS_DENIED)
+        await state.clear()
+        return
    # Проверяем, что пользователь в правильном состоянии
    current_state = await state.get_state()
    if current_state != AdminTicketStates.waiting_for_reply:
@@ -388,17 +467,53 @@ async def close_admin_ticket(
    db: AsyncSession
 ):
    """Закрыть тикет админом"""
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    ticket_id = int(callback.data.replace("admin_close_ticket_", ""))
    
    try:
        success = await TicketCRUD.close_ticket(db, ticket_id)
        
        if success:
+            # audit
+            try:
+                is_mod = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
+                # обогатим details контактами пользователя тикета
+                details = {}
+                try:
+                    t = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_user=True)
+                    if t and t.user:
+                        details.update({
+                            "target_telegram_id": t.user.telegram_id,
+                            "target_username": t.user.username,
+                        })
+                except Exception:
+                    pass
+                await TicketCRUD.add_support_audit(
+                    db,
+                    actor_user_id=db_user.id if db_user else None,
+                    actor_telegram_id=callback.from_user.id,
+                    is_moderator=is_mod,
+                    action="close_ticket",
+                    ticket_id=ticket_id,
+                    target_user_id=None,
+                    details=details
+                )
+            except Exception:
+                pass
            texts = get_texts(db_user.language)
-            await callback.answer(
-                texts.t("TICKET_CLOSED", "✅ Тикет закрыт."),
-                show_alert=True
-            )
+            # Notify with deletable inline message
+            try:
+                await callback.message.answer(
+                    texts.t("TICKET_CLOSED", "✅ Тикет закрыт."),
+                    reply_markup=types.InlineKeyboardMarkup(
+                        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+                    )
+                )
+            except Exception:
+                await callback.answer(texts.t("TICKET_CLOSED", "✅ Тикет закрыт."), show_alert=True)
            
            # Обновляем inline-клавиатуру в текущем сообщении без кнопок действий
            await callback.message.edit_reply_markup(
@@ -426,6 +541,10 @@ async def cancel_admin_ticket_reply(
    db_user: User
 ):
    """Отменить ответ админа на тикет"""
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    await state.clear()
    
    texts = get_texts(db_user.language)
@@ -448,13 +567,22 @@ async def block_user_in_ticket(
    db_user: User,
    db: AsyncSession
 ):
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    ticket_id = int(callback.data.replace("admin_block_user_ticket_", ""))
    texts = get_texts(db_user.language)
+    # Save original ticket message ids to update it after blocking without reopening
+    try:
+        await state.update_data(origin_chat_id=callback.message.chat.id, origin_message_id=callback.message.message_id)
+    except Exception:
+        pass
    await callback.message.edit_text(
        texts.t("ENTER_BLOCK_MINUTES", "Введите количество минут для блокировки пользователя (например, 15):"),
        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
            [types.InlineKeyboardButton(
-                text=texts.t("CANCEL_REPLY", "❌ Отменить ответ"),
+                text=texts.t("CANCEL_REPLY", "❌ Отменить ввод"),
                callback_data="cancel_admin_ticket_reply"
            )]
        ])
@@ -470,6 +598,12 @@ async def handle_admin_block_duration_input(
    db_user: User,
    db: AsyncSession
 ):
+    # permission gate for message flow
+    if not (settings.is_admin(message.from_user.id) or SupportSettingsService.is_moderator(message.from_user.id)):
+        texts = get_texts(db_user.language)
+        await message.answer(texts.ACCESS_DENIED)
+        await state.clear()
+        return
    # Проверяем состояние
    current_state = await state.get_state()
    if current_state != AdminTicketStates.waiting_for_block_duration:
@@ -482,6 +616,8 @@ async def handle_admin_block_duration_input(
    
    data = await state.get_data()
    ticket_id = data.get("ticket_id")
+    origin_chat_id = data.get("origin_chat_id")
+    origin_message_id = data.get("origin_message_id")
    try:
        minutes = int(reply_text)
        minutes = max(1, min(60*24*365, minutes))  # максимум 1 год
@@ -505,15 +641,101 @@ async def handle_admin_block_duration_input(
        
        until = datetime.utcnow() + timedelta(minutes=minutes)
        ok = await TicketCRUD.set_user_reply_block(db, ticket_id, permanent=False, until=until)
-        if ok:
-            await message.answer(f"✅ Пользователь заблокирован на {minutes} минут")
-        else:
+        if not ok:
            await message.answer("❌ Ошибка блокировки")
-        await state.clear()
-        await message.answer(
-            "✅ Блокировка установлена. Откройте тикет заново для обновления состояния.",
-            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[[types.InlineKeyboardButton(text="👁️ Посмотреть тикет", callback_data=f"admin_view_ticket_{ticket_id}")]])
-        )
+            return
+        # audit
+        try:
+            is_mod = (not settings.is_admin(message.from_user.id) and SupportSettingsService.is_moderator(message.from_user.id))
+            await TicketCRUD.add_support_audit(
+                db,
+                actor_user_id=db_user.id if db_user else None,
+                actor_telegram_id=message.from_user.id,
+                is_moderator=is_mod,
+                action="block_user_timed",
+                ticket_id=ticket_id,
+                target_user_id=ticket.user_id if ticket else None,
+                details={"minutes": minutes}
+            )
+        except Exception:
+            pass
+        # Refresh original ticket card (caption/text and buttons) in place
+        try:
+            updated = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_messages=True, load_user=True)
+            texts = get_texts(db_user.language)
+            status_text = {
+                TicketStatus.OPEN.value: texts.t("TICKET_STATUS_OPEN", "Открыт"),
+                TicketStatus.ANSWERED.value: texts.t("TICKET_STATUS_ANSWERED", "Отвечен"),
+                TicketStatus.CLOSED.value: texts.t("TICKET_STATUS_CLOSED", "Закрыт"),
+                TicketStatus.PENDING.value: texts.t("TICKET_STATUS_PENDING", "В ожидании")
+            }.get(updated.status, updated.status)
+            user_name = updated.user.full_name if updated.user else "Unknown"
+            ticket_text = f"🎫 Тикет #{updated.id}\n\n"
+            ticket_text += f"👤 Пользователь: {user_name}\n"
+            ticket_text += f"📝 Заголовок: {updated.title}\n"
+            ticket_text += f"📊 Статус: {updated.status_emoji} {status_text}\n"
+            ticket_text += f"📅 Создан: {updated.created_at.strftime('%d.%m.%Y %H:%M')}\n"
+            ticket_text += f"🔄 Обновлен: {updated.updated_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+            if updated.is_user_reply_blocked:
+                if updated.user_reply_block_permanent:
+                    ticket_text += "🚫 Пользователь заблокирован навсегда для ответов в этом тикете\n"
+                elif updated.user_reply_block_until:
+                    ticket_text += f"⏳ Блок до: {updated.user_reply_block_until.strftime('%d.%m.%Y %H:%M')}\n"
+            if updated.messages:
+                ticket_text += f"💬 Сообщения ({len(updated.messages)}):\n\n"
+                for msg in updated.messages:
+                    sender = "👤 Пользователь" if msg.is_user_message else "🛠️ Поддержка"
+                    ticket_text += f"{sender} ({msg.created_at.strftime('%d.%m %H:%M')}):\n"
+                    ticket_text += f"{msg.message_text}\n\n"
+                    if getattr(msg, "has_media", False) and getattr(msg, "media_type", None) == "photo":
+                        ticket_text += "📎 Вложение: фото\n\n"
+
+            kb = get_admin_ticket_view_keyboard(updated.id, updated.is_closed, db_user.language, is_user_blocked=updated.is_user_reply_blocked)
+            # Кнопка открытия профиля пользователя в админке
+            try:
+                if updated.user:
+                    admin_profile_btn = types.InlineKeyboardButton(
+                        text="👤 К пользователю",
+                        callback_data=f"admin_user_manage_{updated.user.id}_from_ticket_{updated.id}"
+                    )
+                    kb.inline_keyboard.insert(0, [admin_profile_btn])
+            except Exception:
+                pass
+            # Кнопки ЛС и профиль при обновлении карточки
+            try:
+                if updated.user and updated.user.telegram_id:
+                    buttons_row = []
+                    if updated.user.username:
+                        pm_url = f"tg://resolve?domain={updated.user.username}"
+                    else:
+                        pm_url = f"tg://user?id={updated.user.telegram_id}"
+                    buttons_row.append(types.InlineKeyboardButton(text="✉ Написать в ЛС", url=pm_url))
+                    profile_url = f"tg://user?id={updated.user.telegram_id}"
+                    buttons_row.append(types.InlineKeyboardButton(text="👤 Профиль", url=profile_url))
+                    if buttons_row:
+                        kb.inline_keyboard.insert(0, buttons_row)
+            except Exception:
+                pass
+            has_photos = any(getattr(m, "has_media", False) and getattr(m, "media_type", None) == "photo" for m in updated.messages or [])
+            if has_photos:
+                try:
+                    kb.inline_keyboard.insert(0, [types.InlineKeyboardButton(text=texts.t("TICKET_ATTACHMENTS", "📎 Вложения"), callback_data=f"admin_ticket_attachments_{updated.id}")])
+                except Exception:
+                    pass
+            if origin_chat_id and origin_message_id:
+                try:
+                    await message.bot.edit_message_caption(chat_id=origin_chat_id, message_id=origin_message_id, caption=ticket_text, reply_markup=kb, parse_mode="HTML")
+                except Exception:
+                    try:
+                        await message.bot.edit_message_text(chat_id=origin_chat_id, message_id=origin_message_id, text=ticket_text, reply_markup=kb, parse_mode="HTML")
+                    except Exception:
+                        await message.answer(f"✅ Пользователь заблокирован на {minutes} минут")
+            else:
+                await message.answer(f"✅ Пользователь заблокирован на {minutes} минут")
+        except Exception:
+            await message.answer(f"✅ Пользователь заблокирован на {minutes} минут")
+        finally:
+            await state.clear()
    except Exception as e:
        logger.error(f"Error setting block duration: {e}")
        texts = get_texts(db_user.language)
@@ -522,19 +744,54 @@ async def handle_admin_block_duration_input(

 

-
- 
-
 async def unblock_user_in_ticket(
    callback: types.CallbackQuery,
    db_user: User,
    db: AsyncSession,
    state: FSMContext
 ):
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    ticket_id = int(callback.data.replace("admin_unblock_user_ticket_", ""))
    ok = await TicketCRUD.set_user_reply_block(db, ticket_id, permanent=False, until=None)
    if ok:
-        await callback.answer("✅ Блок снят")
+        try:
+            await callback.message.answer(
+                "✅ Блок снят",
+                reply_markup=types.InlineKeyboardMarkup(
+                    inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+                )
+            )
+        except Exception:
+            await callback.answer("✅ Блок снят")
+        # audit
+        try:
+            is_mod = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
+            ticket_id = int(callback.data.replace("admin_unblock_user_ticket_", ""))
+            details = {}
+            try:
+                t = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_user=True)
+                if t and t.user:
+                    details.update({
+                        "target_telegram_id": t.user.telegram_id,
+                        "target_username": t.user.username,
+                    })
+            except Exception:
+                pass
+            await TicketCRUD.add_support_audit(
+                db,
+                actor_user_id=db_user.id if db_user else None,
+                actor_telegram_id=callback.from_user.id,
+                is_moderator=is_mod,
+                action="unblock_user",
+                ticket_id=ticket_id,
+                target_user_id=None,
+                details=details
+            )
+        except Exception:
+            pass
        await view_admin_ticket(callback, db_user, db, state)
    else:
        await callback.answer("❌ Ошибка", show_alert=True)
@@ -546,10 +803,47 @@ async def block_user_permanently(
    db: AsyncSession,
    state: FSMContext
 ):
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
    ticket_id = int(callback.data.replace("admin_block_user_perm_ticket_", ""))
    ok = await TicketCRUD.set_user_reply_block(db, ticket_id, permanent=True, until=None)
    if ok:
-        await callback.answer("✅ Пользователь заблокирован навсегда")
+        try:
+            await callback.message.answer(
+                "✅ Пользователь заблокирован навсегда",
+                reply_markup=types.InlineKeyboardMarkup(
+                    inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+                )
+            )
+        except Exception:
+            await callback.answer("✅ Пользователь заблокирован")
+        # audit
+        try:
+            is_mod = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
+            details = {}
+            try:
+                t = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_user=True)
+                if t and t.user:
+                    details.update({
+                        "target_telegram_id": t.user.telegram_id,
+                        "target_username": t.user.username,
+                    })
+            except Exception:
+                pass
+            await TicketCRUD.add_support_audit(
+                db,
+                actor_user_id=db_user.id if db_user else None,
+                actor_telegram_id=callback.from_user.id,
+                is_moderator=is_mod,
+                action="block_user_perm",
+                ticket_id=ticket_id,
+                target_user_id=None,
+                details=details
+            )
+        except Exception:
+            pass
        await view_admin_ticket(callback, db_user, db, state)
    else:
        await callback.answer("❌ Ошибка", show_alert=True)
@@ -558,6 +852,12 @@ async def block_user_permanently(
 async def notify_user_about_ticket_reply(bot: Bot, ticket: Ticket, reply_text: str, db: AsyncSession):
    """Уведомить пользователя о новом ответе в тикете"""
    try:
+        # Respect runtime toggle for user ticket notifications
+        try:
+            if not SupportSettingsService.get_user_ticket_notifications_enabled():
+                return
+        except Exception:
+            pass
        from app.localization.texts import get_texts
        
        # Получаем тикет с пользователем
@@ -655,6 +955,11 @@ def register_handlers(dp: Dispatcher):
        db_user: User,
        db: AsyncSession
    ):
+        # permission gate for attachments view
+        if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+            texts = get_texts(db_user.language)
+            await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+            return
        texts = get_texts(db_user.language)
        try:
            ticket_id = int(callback.data.replace("admin_ticket_attachments_", ""))
@@ -3,7 +3,6 @@ from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.config import settings
 from app.database.models import User
 from app.states import AdminStates
 from app.keyboards.admin import get_welcome_text_keyboard, get_admin_main_keyboard
@@ -44,16 +43,16 @@ async def show_welcome_text_panel(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
-    status_emoji = "🟢" if settings['is_enabled'] else "🔴"
-    status_text = "включено" if settings['is_enabled'] else "отключено"
+    welcome_settings = await get_current_welcome_text_settings(db)
+    status_emoji = "🟢" if welcome_settings['is_enabled'] else "🔴"
+    status_text = "включено" if welcome_settings['is_enabled'] else "отключено"
    
    await callback.message.edit_text(
        f"👋 Управление приветственным текстом\n\n"
        f"{status_emoji} <b>Статус:</b> {status_text}\n\n"
        f"Здесь вы можете управлять текстом, который показывается новым пользователям после регистрации.\n\n"
        f"💡 Доступные плейсхолдеры для автозамены:",
-        reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+        reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
        parse_mode="HTML"
    )
    await callback.answer()
@@ -89,11 +88,11 @@ async def show_current_welcome_text(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
-    current_text = settings['text']
-    is_enabled = settings['is_enabled']
-    
-    if not settings['id']:
+    welcome_settings = await get_current_welcome_text_settings(db)
+    current_text = welcome_settings['text']
+    is_enabled = welcome_settings['is_enabled']
+
+    if not welcome_settings['id']:
        status = "📝 Используется стандартный текст:"
    else:
        status = "📝 Текущий приветственный текст:"
@@ -121,7 +120,7 @@ async def show_placeholders_help(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
+    welcome_settings = await get_current_welcome_text_settings(db)
    placeholders = get_available_placeholders()
    placeholders_text = "\n".join([f"• <code>{key}</code>\n  {desc}" for key, desc in placeholders.items()])
    
@@ -137,7 +136,7 @@ async def show_placeholders_help(
    
    await callback.message.edit_text(
        help_text,
-        reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+        reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
        parse_mode="HTML"
    )
    await callback.answer()
@@ -149,12 +148,12 @@ async def show_formatting_help(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
+    welcome_settings = await get_current_welcome_text_settings(db)
    formatting_info = get_telegram_formatting_info()
    
    await callback.message.edit_text(
        formatting_info,
-        reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+        reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
        parse_mode="HTML"
    )
    await callback.answer()
@@ -167,8 +166,8 @@ async def start_edit_welcome_text(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
-    current_text = settings['text']
+    welcome_settings = await get_current_welcome_text_settings(db)
+    current_text = welcome_settings['text']
    
    placeholders = get_available_placeholders()
    placeholders_text = "\n".join([f"• <code>{key}</code> - {desc}" for key, desc in placeholders.items()])
@@ -206,9 +205,9 @@ async def process_welcome_text_edit(
    success = await set_welcome_text(db, new_text, db_user.id)
    
    if success:
-        settings = await get_current_welcome_text_settings(db)
-        status_emoji = "🟢" if settings['is_enabled'] else "🔴"
-        status_text = "включено" if settings['is_enabled'] else "отключено"
+        welcome_settings = await get_current_welcome_text_settings(db)
+        status_emoji = "🟢" if welcome_settings['is_enabled'] else "🔴"
+        status_text = "включено" if welcome_settings['is_enabled'] else "отключено"
        
        placeholders = get_available_placeholders()
        placeholders_text = "\n".join([f"• <code>{key}</code>" for key in placeholders.keys()])
@@ -219,14 +218,14 @@ async def process_welcome_text_edit(
            f"Новый текст:\n"
            f"<code>{new_text}</code>\n\n"
            f"💡 Будут заменяться плейсхолдеры: {placeholders_text}",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    else:
-        settings = await get_current_welcome_text_settings(db)
+        welcome_settings = await get_current_welcome_text_settings(db)
        await message.answer(
            "❌ Ошибка при сохранении текста. Попробуйте еще раз.",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled'])
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled'])
        )
    
    await state.clear()
@@ -242,9 +241,9 @@ async def reset_welcome_text(
    success = await set_welcome_text(db, default_text, db_user.id)
    
    if success:
-        settings = await get_current_welcome_text_settings(db)
-        status_emoji = "🟢" if settings['is_enabled'] else "🔴"
-        status_text = "включено" if settings['is_enabled'] else "отключено"
+        welcome_settings = await get_current_welcome_text_settings(db)
+        status_emoji = "🟢" if welcome_settings['is_enabled'] else "🔴"
+        status_text = "включено" if welcome_settings['is_enabled'] else "отключено"
        
        await callback.message.edit_text(
            f"✅ Приветственный текст сброшен на стандартный!\n\n"
@@ -252,14 +251,14 @@ async def reset_welcome_text(
            f"Стандартный текст:\n"
            f"<code>{default_text}</code>\n\n"
            f"💡 Плейсхолдер <code>{{user_name}}</code> будет заменяться на имя пользователя",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    else:
-        settings = await get_current_welcome_text_settings(db)
+        welcome_settings = await get_current_welcome_text_settings(db)
        await callback.message.edit_text(
            "❌ Ошибка при сбросе текста. Попробуйте еще раз.",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled'])
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled'])
        )
    
    await callback.answer()
@@ -281,14 +280,14 @@ async def show_preview_welcome_text(
    test_user = TestUser()
    preview_text = await get_welcome_text_for_user(db, test_user)
    
-    settings = await get_current_welcome_text_settings(db)
+    welcome_settings = await get_current_welcome_text_settings(db)
    
    if preview_text:
        await callback.message.edit_text(
            f"👁️ Предварительный просмотр\n\n"
            f"Как будет выглядеть текст для пользователя 'Иван' (@test_user):\n\n"
            f"<code>{preview_text}</code>",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    else:
@@ -296,7 +295,7 @@ async def show_preview_welcome_text(
            f"👁️ Предварительный просмотр\n\n"
            f"🔴 Приветственные сообщения отключены.\n"
            f"Новые пользователи не будут получать приветственный текст после регистрации.",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    
@@ -1,3 +1,4 @@
+import html
 import logging
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
@@ -332,6 +333,84 @@ async def start_yookassa_sbp_payment(
    await callback.answer()


+@error_handler
+async def start_mulenpay_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_mulenpay_enabled():
+        await callback.answer("❌ Оплата через Mulen Pay временно недоступна", show_alert=True)
+        return
+
+    message_text = texts.t(
+        "MULENPAY_TOPUP_PROMPT",
+        (
+            "💳 <b>Оплата через Mulen Pay</b>\n\n"
+            "Введите сумму для пополнения от 100 до 100 000 ₽.\n"
+            "Оплата происходит через защищенную платформу Mulen Pay."
+        ),
+    )
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED:
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language)
+        if quick_amount_buttons:
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="mulenpay")
+    await callback.answer()
+
+
+@error_handler
+async def start_pal24_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_pal24_enabled():
+        await callback.answer("❌ Оплата через PayPalych временно недоступна", show_alert=True)
+        return
+
+    message_text = texts.t(
+        "PAL24_TOPUP_PROMPT",
+        (
+            "🏦 <b>Оплата через PayPalych (СБП)</b>\n\n"
+            "Введите сумму для пополнения от 100 до 1 000 000 ₽.\n"
+            "Оплата проходит через систему быстрых платежей PayPalych."
+        ),
+    )
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED:
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language)
+        if quick_amount_buttons:
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="pal24")
+    await callback.answer()
+
+
@error_handler
 async def start_tribute_payment(
    callback: types.CallbackQuery,
@@ -523,10 +602,18 @@ async def process_topup_amount(
            from app.database.database import AsyncSessionLocal
            async with AsyncSessionLocal() as db:
                await process_yookassa_payment_amount(message, db_user, db, amount_kopeks, state)
-        elif payment_method == "yookassa_sbp": 
+        elif payment_method == "yookassa_sbp":
            from app.database.database import AsyncSessionLocal
            async with AsyncSessionLocal() as db:
                await process_yookassa_sbp_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "mulenpay":
+            from app.database.database import AsyncSessionLocal
+            async with AsyncSessionLocal() as db:
+                await process_mulenpay_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "pal24":
+            from app.database.database import AsyncSessionLocal
+            async with AsyncSessionLocal() as db:
+                await process_pal24_payment_amount(message, db_user, db, amount_kopeks, state)
        elif payment_method == "cryptobot":
            from app.database.database import AsyncSessionLocal
            async with AsyncSessionLocal() as db:
@@ -760,6 +847,341 @@ async def process_yookassa_sbp_payment_amount(
        await state.clear()


+@error_handler
+async def process_mulenpay_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_mulenpay_enabled():
+        await message.answer("❌ Оплата через Mulen Pay временно недоступна")
+        return
+
+    if amount_kopeks < settings.MULENPAY_MIN_AMOUNT_KOPEKS:
+        await message.answer(
+            f"Минимальная сумма пополнения: {settings.format_price(settings.MULENPAY_MIN_AMOUNT_KOPEKS)}"
+        )
+        return
+
+    if amount_kopeks > settings.MULENPAY_MAX_AMOUNT_KOPEKS:
+        await message.answer(
+            f"Максимальная сумма пополнения: {settings.format_price(settings.MULENPAY_MAX_AMOUNT_KOPEKS)}"
+        )
+        return
+
+    amount_rubles = amount_kopeks / 100
+
+    try:
+        payment_service = PaymentService(message.bot)
+        payment_result = await payment_service.create_mulenpay_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            language=db_user.language,
+        )
+
+        if not payment_result or not payment_result.get("payment_url"):
+            await message.answer(
+                texts.t(
+                    "MULENPAY_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа Mulen Pay. Попробуйте позже или обратитесь в поддержку.",
+                )
+            )
+            await state.clear()
+            return
+
+        payment_url = payment_result.get("payment_url")
+        mulen_payment_id = payment_result.get("mulen_payment_id")
+        local_payment_id = payment_result.get("local_payment_id")
+
+        keyboard = types.InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    types.InlineKeyboardButton(
+                        text=texts.t(
+                            "MULENPAY_PAY_BUTTON",
+                            "💳 Оплатить через Mulen Pay",
+                        ),
+                        url=payment_url,
+                    )
+                ],
+                [
+                    types.InlineKeyboardButton(
+                        text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                        callback_data=f"check_mulenpay_{local_payment_id}",
+                    )
+                ],
+                [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+            ]
+        )
+
+        payment_id_display = mulen_payment_id if mulen_payment_id is not None else local_payment_id
+
+        message_template = texts.t(
+            "MULENPAY_PAYMENT_INSTRUCTIONS",
+            (
+                "💳 <b>Оплата через Mulen Pay</b>\n\n"
+                "💰 Сумма: {amount}\n"
+                "🆔 ID платежа: {payment_id}\n\n"
+                "📱 <b>Инструкция:</b>\n"
+                "1. Нажмите кнопку ‘Оплатить через Mulen Pay’\n"
+                "2. Следуйте подсказкам платежной системы\n"
+                "3. Подтвердите перевод\n"
+                "4. Средства зачислятся автоматически\n\n"
+                "❓ Если возникнут проблемы, обратитесь в {support}"
+            ),
+        )
+
+        message_text = message_template.format(
+            amount=settings.format_price(amount_kopeks),
+            payment_id=payment_id_display,
+            support=settings.get_support_contact_display_html(),
+        )
+
+        await message.answer(
+            message_text,
+            reply_markup=keyboard,
+            parse_mode="HTML",
+        )
+
+        await state.clear()
+
+        logger.info(
+            "Создан MulenPay платеж для пользователя %s: %s₽, ID: %s",
+            db_user.telegram_id,
+            amount_rubles,
+            payment_id_display,
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка создания MulenPay платежа: {e}")
+        await message.answer(
+            texts.t(
+                "MULENPAY_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа Mulen Pay. Попробуйте позже или обратитесь в поддержку.",
+            )
+        )
+        await state.clear()
+
+
+@error_handler
+async def process_pal24_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_pal24_enabled():
+        await message.answer("❌ Оплата через PayPalych временно недоступна")
+        return
+
+    if amount_kopeks < settings.PAL24_MIN_AMOUNT_KOPEKS:
+        min_rubles = settings.PAL24_MIN_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Минимальная сумма для оплаты через PayPalych: {min_rubles:.0f} ₽")
+        return
+
+    if amount_kopeks > settings.PAL24_MAX_AMOUNT_KOPEKS:
+        max_rubles = settings.PAL24_MAX_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Максимальная сумма для оплаты через PayPalych: {max_rubles:,.0f} ₽".replace(',', ' '))
+        return
+
+    try:
+        payment_service = PaymentService(message.bot)
+        payment_result = await payment_service.create_pal24_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            language=db_user.language,
+        )
+
+        if not payment_result:
+            await message.answer(
+                texts.t(
+                    "PAL24_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+                )
+            )
+            await state.clear()
+            return
+
+        sbp_url = (
+            payment_result.get("sbp_url")
+            or payment_result.get("transfer_url")
+        )
+        card_url = payment_result.get("card_url")
+        fallback_url = (
+            payment_result.get("link_page_url")
+            or payment_result.get("link_url")
+        )
+
+        if not (sbp_url or card_url or fallback_url):
+            await message.answer(
+                texts.t(
+                    "PAL24_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+                )
+            )
+            await state.clear()
+            return
+
+        if not sbp_url:
+            sbp_url = fallback_url
+
+        bill_id = payment_result.get("bill_id")
+        local_payment_id = payment_result.get("local_payment_id")
+
+        pay_buttons: list[list[types.InlineKeyboardButton]] = []
+        steps: list[str] = []
+        step_counter = 1
+
+        default_sbp_text = texts.t(
+            "PAL24_SBP_PAY_BUTTON",
+            "🏦 Оплатить через PayPalych (СБП)",
+        )
+        sbp_button_text = settings.get_pal24_sbp_button_text(default_sbp_text)
+
+        if sbp_url:
+            pay_buttons.append(
+                [
+                    types.InlineKeyboardButton(
+                        text=sbp_button_text,
+                        url=sbp_url,
+                    )
+                ]
+            )
+            steps.append(
+                texts.t(
+                    "PAL24_INSTRUCTION_BUTTON",
+                    "{step}. Нажмите кнопку «{button}»",
+                ).format(step=step_counter, button=html.escape(sbp_button_text))
+            )
+            step_counter += 1
+
+        default_card_text = texts.t(
+            "PAL24_CARD_PAY_BUTTON",
+            "💳 Оплатить банковской картой (PayPalych)",
+        )
+        card_button_text = settings.get_pal24_card_button_text(default_card_text)
+
+        if card_url and card_url != sbp_url:
+            pay_buttons.append(
+                [
+                    types.InlineKeyboardButton(
+                        text=card_button_text,
+                        url=card_url,
+                    )
+                ]
+            )
+            steps.append(
+                texts.t(
+                    "PAL24_INSTRUCTION_BUTTON",
+                    "{step}. Нажмите кнопку «{button}»",
+                ).format(step=step_counter, button=html.escape(card_button_text))
+            )
+            step_counter += 1
+
+        if not pay_buttons and fallback_url:
+            pay_buttons.append(
+                [
+                    types.InlineKeyboardButton(
+                        text=sbp_button_text,
+                        url=fallback_url,
+                    )
+                ]
+            )
+            steps.append(
+                texts.t(
+                    "PAL24_INSTRUCTION_BUTTON",
+                    "{step}. Нажмите кнопку «{button}»",
+                ).format(step=step_counter, button=html.escape(sbp_button_text))
+            )
+            step_counter += 1
+
+        follow_template = texts.t(
+            "PAL24_INSTRUCTION_FOLLOW",
+            "{step}. Следуйте подсказкам платёжной системы",
+        )
+        steps.append(follow_template.format(step=step_counter))
+        step_counter += 1
+
+        confirm_template = texts.t(
+            "PAL24_INSTRUCTION_CONFIRM",
+            "{step}. Подтвердите перевод",
+        )
+        steps.append(confirm_template.format(step=step_counter))
+        step_counter += 1
+
+        success_template = texts.t(
+            "PAL24_INSTRUCTION_COMPLETE",
+            "{step}. Средства зачислятся автоматически",
+        )
+        steps.append(success_template.format(step=step_counter))
+
+        message_template = texts.t(
+            "PAL24_PAYMENT_INSTRUCTIONS",
+            (
+                "🏦 <b>Оплата через PayPalych</b>\n\n"
+                "💰 Сумма: {amount}\n"
+                "🆔 ID счета: {bill_id}\n\n"
+                "📱 <b>Инструкция:</b>\n{steps}\n\n"
+                "❓ Если возникнут проблемы, обратитесь в {support}"
+            ),
+        )
+
+        keyboard_rows = pay_buttons + [
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                    callback_data=f"check_pal24_{local_payment_id}",
+                )
+            ],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+        ]
+
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_rows)
+
+        message_text = message_template.format(
+            amount=settings.format_price(amount_kopeks),
+            bill_id=bill_id,
+            steps="\n".join(steps),
+            support=settings.get_support_contact_display_html(),
+        )
+
+        await message.answer(
+            message_text,
+            reply_markup=keyboard,
+            parse_mode="HTML",
+        )
+
+        await state.clear()
+
+        logger.info(
+            "Создан PayPalych счет для пользователя %s: %s₽, ID: %s",
+            db_user.telegram_id,
+            amount_kopeks / 100,
+            bill_id,
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка создания PayPalych платежа: {e}")
+        await message.answer(
+            texts.t(
+                "PAL24_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+            )
+        )
+        await state.clear()
+
+
@error_handler
 async def check_yookassa_payment_status(
    callback: types.CallbackQuery,
@@ -815,6 +1237,144 @@ async def check_yookassa_payment_status(
        logger.error(f"Ошибка проверки статуса платежа: {e}")
        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)

+
+@error_handler
+async def check_mulenpay_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        payment_service = PaymentService(callback.bot)
+        status_info = await payment_service.get_mulenpay_payment_status(db, local_payment_id)
+
+        if not status_info:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+
+        payment = status_info["payment"]
+
+        status_labels = {
+            "created": ("⏳", "Ожидает оплаты"),
+            "processing": ("⌛", "Обрабатывается"),
+            "success": ("✅", "Оплачен"),
+            "canceled": ("❌", "Отменен"),
+            "error": ("⚠️", "Ошибка"),
+            "hold": ("🔒", "Холд"),
+            "unknown": ("❓", "Неизвестно"),
+        }
+
+        emoji, status_text = status_labels.get(payment.status, ("❓", "Неизвестно"))
+
+        message_lines = [
+            "💳 Статус платежа Mulen Pay:\n\n",
+            f"🆔 ID: {payment.mulen_payment_id or payment.id}\n",
+            f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n",
+            f"📊 Статус: {emoji} {status_text}\n",
+            f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}\n",
+        ]
+
+        if payment.is_paid:
+            message_lines.append("\n✅ Платеж успешно завершен! Средства уже на балансе.")
+        elif payment.status in {"created", "processing"}:
+            message_lines.append(
+                "\n⏳ Платеж еще не завершен. Завершите оплату по ссылке и проверьте статус позже."
+            )
+            if payment.payment_url:
+                message_lines.append(f"\n🔗 Ссылка на оплату: {payment.payment_url}")
+        elif payment.status in {"canceled", "error"}:
+            message_lines.append(
+                f"\n❌ Платеж не был завершен. Попробуйте создать новый платеж или обратитесь в {settings.get_support_contact_display()}"
+            )
+
+        message_text = "".join(message_lines)
+
+        if len(message_text) > 190:
+            await callback.message.answer(message_text)
+            await callback.answer("ℹ️ Статус платежа отправлен в чат", show_alert=True)
+        else:
+            await callback.answer(message_text, show_alert=True)
+
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса MulenPay: {e}")
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
+
+
+@error_handler
+async def check_pal24_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession,
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        payment_service = PaymentService(callback.bot)
+        status_info = await payment_service.get_pal24_payment_status(db, local_payment_id)
+
+        if not status_info:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+
+        payment = status_info["payment"]
+
+        status_labels = {
+            "NEW": ("⏳", "Ожидает оплаты"),
+            "PROCESS": ("⌛", "Обрабатывается"),
+            "SUCCESS": ("✅", "Оплачен"),
+            "FAIL": ("❌", "Отменен"),
+            "UNDERPAID": ("⚠️", "Недоплата"),
+            "OVERPAID": ("⚠️", "Переплата"),
+        }
+
+        emoji, status_text = status_labels.get(payment.status, ("❓", "Неизвестно"))
+
+        metadata = payment.metadata_json or {}
+        links_meta = metadata.get("links") if isinstance(metadata, dict) else None
+        if not isinstance(links_meta, dict):
+            links_meta = {}
+
+        sbp_link = links_meta.get("sbp") or payment.link_url
+        card_link = links_meta.get("card")
+
+        if not card_link and payment.link_page_url and payment.link_page_url != sbp_link:
+            card_link = payment.link_page_url
+
+        message_lines = [
+            "🏦 Статус платежа PayPalych:",
+            "",
+            f"🆔 ID счета: {payment.bill_id}",
+            f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}",
+            f"📊 Статус: {emoji} {status_text}",
+            f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}",
+        ]
+
+        if payment.is_paid:
+            message_lines.append("")
+            message_lines.append("✅ Платеж успешно завершен! Средства уже на балансе.")
+        elif payment.status in {"NEW", "PROCESS"}:
+            message_lines.append("")
+            message_lines.append("⏳ Платеж еще не завершен. Оплатите счет и проверьте статус позже.")
+            if sbp_link:
+                message_lines.append("")
+                message_lines.append(f"🏦 СБП: {sbp_link}")
+            if card_link and card_link != sbp_link:
+                message_lines.append(f"💳 Банковская карта: {card_link}")
+        elif payment.status in {"FAIL", "UNDERPAID", "OVERPAID"}:
+            message_lines.append("")
+            message_lines.append(
+                f"❌ Платеж не завершен корректно. Обратитесь в {settings.get_support_contact_display()}"
+            )
+
+        await callback.answer()
+        await callback.message.answer(
+            "\n".join(message_lines),
+            disable_web_page_preview=True,
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса PayPalych: {e}")
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
+
+
@error_handler
 async def start_cryptobot_payment(
    callback: types.CallbackQuery,
@@ -1085,6 +1645,18 @@ async def handle_quick_amount_selection(
                await process_yookassa_sbp_payment_amount(
                    callback.message, db_user, db, amount_kopeks, state
                )
+        elif payment_method == "mulenpay":
+            from app.database.database import AsyncSessionLocal
+            async with AsyncSessionLocal() as db:
+                await process_mulenpay_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "pal24":
+            from app.database.database import AsyncSessionLocal
+            async with AsyncSessionLocal() as db:
+                await process_pal24_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
        else:
            await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
            return
@@ -1096,6 +1668,77 @@ async def handle_quick_amount_selection(
        await callback.answer("❌ Ошибка обработки запроса", show_alert=True)


+@error_handler
+async def handle_topup_amount_callback(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    try:
+        _, method, amount_str = callback.data.split("|", 2)
+        amount_kopeks = int(amount_str)
+    except ValueError:
+        await callback.answer("❌ Некорректный запрос", show_alert=True)
+        return
+
+    if amount_kopeks <= 0:
+        await callback.answer("❌ Некорректная сумма", show_alert=True)
+        return
+
+    try:
+        if method == "yookassa":
+            from app.database.database import AsyncSessionLocal
+
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "yookassa_sbp":
+            from app.database.database import AsyncSessionLocal
+
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_sbp_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "mulenpay":
+            from app.database.database import AsyncSessionLocal
+
+            async with AsyncSessionLocal() as db:
+                await process_mulenpay_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "pal24":
+            from app.database.database import AsyncSessionLocal
+
+            async with AsyncSessionLocal() as db:
+                await process_pal24_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "cryptobot":
+            from app.database.database import AsyncSessionLocal
+
+            async with AsyncSessionLocal() as db:
+                await process_cryptobot_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "stars":
+            await process_stars_payment_amount(
+                callback.message, db_user, amount_kopeks, state
+            )
+        elif method == "tribute":
+            await start_tribute_payment(callback, db_user)
+            return
+        else:
+            await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
+            return
+
+        await callback.answer()
+
+    except Exception as error:
+        logger.error(f"Ошибка быстрого пополнения: {error}")
+        await callback.answer("❌ Ошибка обработки запроса", show_alert=True)
+
+
 def register_handlers(dp: Dispatcher):
    
    dp.callback_query.register(
@@ -1132,12 +1775,22 @@ def register_handlers(dp: Dispatcher):
        start_yookassa_sbp_payment,
        F.data == "topup_yookassa_sbp"
    )
-    
+
+    dp.callback_query.register(
+        start_mulenpay_payment,
+        F.data == "topup_mulenpay"
+    )
+
+    dp.callback_query.register(
+        start_pal24_payment,
+        F.data == "topup_pal24"
+    )
+
    dp.callback_query.register(
        check_yookassa_payment_status,
        F.data.startswith("check_yookassa_")
    )
-    
+
    dp.callback_query.register(
        start_tribute_payment,
        F.data == "topup_tribute"
@@ -1168,6 +1821,16 @@ def register_handlers(dp: Dispatcher):
        F.data.startswith("check_cryptobot_")
    )

+    dp.callback_query.register(
+        check_mulenpay_payment_status,
+        F.data.startswith("check_mulenpay_")
+    )
+
+    dp.callback_query.register(
+        check_pal24_payment_status,
+        F.data.startswith("check_pal24_")
+    )
+
    dp.callback_query.register(
        handle_payment_methods_unavailable,
        F.data == "payment_methods_unavailable"
@@ -1178,3 +1841,8 @@ def register_handlers(dp: Dispatcher):
        handle_quick_amount_selection,
        F.data.startswith("quick_amount_")
    )
+
+    dp.callback_query.register(
+        handle_topup_amount_callback,
+        F.data.startswith("topup_amount|")
+    )
@@ -1,5 +1,6 @@
 import logging
 from aiogram import Dispatcher, types, F
+from aiogram.filters import StateFilter
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession

@@ -120,5 +121,11 @@ def register_handlers(dp: Dispatcher):
    )

    # Самый последний: ловим любые неизвестные текстовые сообщения
-    dp.message.register(handle_unknown_message)
+    # Исключаем специальные сервисные события (например, успешные платежи),
+    # чтобы их обработка не прерывалась общим хендлером неизвестных сообщений
+    dp.message.register(
+        handle_unknown_message,
+        StateFilter(None),
+        F.successful_payment.is_(None)
+    )
    
@@ -1,21 +1,22 @@
 import logging
 from aiogram import Dispatcher, types, F
+from aiogram.filters import StateFilter
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
-from datetime import datetime, timedelta 
+from datetime import datetime

 from app.config import settings
 from app.database.crud.user import get_user_by_telegram_id, update_user
-from app.keyboards.inline import get_main_menu_keyboard
+from app.keyboards.inline import get_main_menu_keyboard, get_language_selection_keyboard
 from app.localization.texts import get_texts, get_rules
 from app.database.models import User
-from app.utils.user_utils import mark_user_as_had_paid_subscription
 from app.database.crud.user_message import get_random_active_message
 from app.services.subscription_checkout_service import (
    has_subscription_checkout_draft,
    should_offer_checkout_resume,
 )
 from app.utils.photo_message import edit_or_answer_photo
+from app.services.support_settings_service import SupportSettingsService

 logger = logging.getLogger(__name__)

@@ -23,11 +24,12 @@ logger = logging.getLogger(__name__)
 async def show_main_menu(
    callback: types.CallbackQuery,
    db_user: User,
-    db: AsyncSession
+    db: AsyncSession,
+    *,
+    skip_callback_answer: bool = False,
 ):
    texts = get_texts(db_user.language)

-    from datetime import datetime
    db_user.last_activity = datetime.utcnow()
    await db.commit()

@@ -42,12 +44,18 @@ async def show_main_menu(
    draft_exists = await has_subscription_checkout_draft(db_user.id)
    show_resume_checkout = should_offer_checkout_resume(db_user, draft_exists)

+    is_admin = settings.is_admin(db_user.telegram_id)
+    is_moderator = (not is_admin) and SupportSettingsService.is_moderator(
+        db_user.telegram_id
+    )
+
    await edit_or_answer_photo(
        callback=callback,
        caption=menu_text,
        keyboard=get_main_menu_keyboard(
            language=db_user.language,
-            is_admin=settings.is_admin(db_user.telegram_id),
+            is_admin=is_admin,
+            is_moderator=is_moderator,
            has_had_paid_subscription=db_user.has_had_paid_subscription,
            has_active_subscription=has_active_subscription,
            subscription_is_active=subscription_is_active,
@@ -57,23 +65,13 @@ async def show_main_menu(
        ),
        parse_mode="HTML",
    )
-    await callback.answer()
-
-
-async def mark_user_as_had_paid_subscription(
-    db: AsyncSession,
-    user: User
-) -> None:
-    if not user.has_had_paid_subscription:
-        user.has_had_paid_subscription = True
-        user.updated_at = datetime.utcnow()
-        await db.commit()
-        logger.info(f"🎯 Пользователь {user.telegram_id} отмечен как имевший платную подписку")
+    if not skip_callback_answer:
+        await callback.answer()


 async def show_service_rules(
-    callback: types.CallbackQuery, 
-    db_user: User, 
+    callback: types.CallbackQuery,
+    db_user: User,
    db: AsyncSession
 ):
    from app.database.crud.rules import get_current_rules_content
@@ -93,6 +91,90 @@ async def show_service_rules(
    await callback.answer()


+async def show_language_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_language_selection_enabled():
+        await callback.answer(
+            texts.t(
+                "LANGUAGE_SELECTION_DISABLED",
+                "⚙️ Выбор языка временно недоступен.",
+            ),
+            show_alert=True,
+        )
+        return
+
+    await edit_or_answer_photo(
+        callback=callback,
+        caption=texts.t("LANGUAGE_PROMPT", "🌐 Выберите язык интерфейса:"),
+        keyboard=get_language_selection_keyboard(
+            current_language=db_user.language,
+            include_back=True,
+            language=db_user.language,
+        ),
+        parse_mode="HTML",
+    )
+    await callback.answer()
+
+
+async def process_language_change(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_language_selection_enabled():
+        await callback.answer(
+            texts.t(
+                "LANGUAGE_SELECTION_DISABLED",
+                "⚙️ Выбор языка временно недоступен.",
+            ),
+            show_alert=True,
+        )
+        return
+
+    selected_raw = (callback.data or "").split(":", 1)[-1]
+    normalized_selected = selected_raw.strip().lower()
+
+    available_map = {
+        lang.strip().lower(): lang.strip()
+        for lang in settings.get_available_languages()
+        if isinstance(lang, str) and lang.strip()
+    }
+
+    if normalized_selected not in available_map:
+        await callback.answer("❌ Unsupported language", show_alert=True)
+        return
+
+    resolved_language = available_map[normalized_selected].lower()
+
+    if db_user.language.lower() == normalized_selected:
+        await show_main_menu(
+            callback,
+            db_user,
+            db,
+            skip_callback_answer=True,
+        )
+        await callback.answer(texts.t("LANGUAGE_SELECTED", "🌐 Язык интерфейса обновлен."))
+        return
+
+    updated_user = await update_user(db, db_user, language=resolved_language)
+    texts = get_texts(updated_user.language)
+
+    await show_main_menu(
+        callback,
+        updated_user,
+        db,
+        skip_callback_answer=True,
+    )
+    await callback.answer(texts.t("LANGUAGE_SELECTED", "🌐 Язык интерфейса обновлен."))
+
+
 async def handle_back_to_menu(
    callback: types.CallbackQuery,
    state: FSMContext,
@@ -114,12 +196,18 @@ async def handle_back_to_menu(
    draft_exists = await has_subscription_checkout_draft(db_user.id)
    show_resume_checkout = should_offer_checkout_resume(db_user, draft_exists)

+    is_admin = settings.is_admin(db_user.telegram_id)
+    is_moderator = (not is_admin) and SupportSettingsService.is_moderator(
+        db_user.telegram_id
+    )
+
    await edit_or_answer_photo(
        callback=callback,
        caption=menu_text,
        keyboard=get_main_menu_keyboard(
            language=db_user.language,
-            is_admin=settings.is_admin(db_user.telegram_id),
+            is_admin=is_admin,
+            is_moderator=is_moderator,
            has_had_paid_subscription=db_user.has_had_paid_subscription,
            has_active_subscription=has_active_subscription,
            subscription_is_active=subscription_is_active,
@@ -237,3 +325,14 @@ def register_handlers(dp: Dispatcher):
        show_service_rules,
        F.data == "menu_rules"
    )
+
+    dp.callback_query.register(
+        show_language_menu,
+        F.data == "menu_language"
+    )
+
+    dp.callback_query.register(
+        process_language_change,
+        F.data.startswith("language_select:"),
+        StateFilter(None)
+    )
@@ -9,6 +9,7 @@ from app.database.models import User
 from app.keyboards.inline import get_back_keyboard
 from app.localization.texts import get_texts
 from app.services.promocode_service import PromoCodeService
+from app.services.admin_notification_service import AdminNotificationService
 from app.utils.decorators import error_handler

 logger = logging.getLogger(__name__)
@@ -61,6 +62,21 @@ async def process_promocode(
            reply_markup=get_back_keyboard(db_user.language)
        )
        logger.info(f"✅ Пользователь {db_user.telegram_id} активировал промокод {code}")
+
+        try:
+            notification_service = AdminNotificationService(message.bot)
+            await notification_service.send_promocode_activation_notification(
+                db,
+                db_user,
+                result.get("promocode", {"code": code}),
+                result["description"],
+            )
+        except Exception as notify_error:
+            logger.error(
+                "Ошибка отправки админ уведомления об активации промокода %s: %s",
+                code,
+                notify_error,
+            )
    else:
        error_messages = {
            "not_found": texts.PROMOCODE_INVALID,
@@ -18,7 +18,9 @@ async def handle_pre_checkout_query(query: types.PreCheckoutQuery):
    try:
        logger.info(f"📋 Pre-checkout query от {query.from_user.id}: {query.total_amount} XTR, payload: {query.invoice_payload}")

-        if not query.invoice_payload or not query.invoice_payload.startswith("balance_"):
+        allowed_prefixes = ("balance_", "admin_stars_test_")
+
+        if not query.invoice_payload or not query.invoice_payload.startswith(allowed_prefixes):
            logger.warning(f"Невалидный payload: {query.invoice_payload}")
            await query.answer(
                ok=False,
@@ -17,14 +17,20 @@ from app.database.crud.campaign import (
    get_campaign_by_start_parameter,
    get_campaign_by_id,
 )
-from app.database.models import UserStatus
+from app.database.models import UserStatus, SubscriptionStatus
 from app.keyboards.inline import (
-    get_rules_keyboard, get_main_menu_keyboard, get_post_registration_keyboard
+    get_rules_keyboard,
+    get_main_menu_keyboard,
+    get_post_registration_keyboard,
+    get_language_selection_keyboard,
 )
 from app.localization.loader import DEFAULT_LANGUAGE
 from app.localization.texts import get_texts, get_rules
 from app.services.referral_service import process_referral_registration
 from app.services.campaign_service import AdvertisingCampaignService
+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.database.crud.user_message import get_random_active_message

@@ -71,8 +77,8 @@ async def _apply_campaign_bonus_if_needed(


 async def handle_potential_referral_code(
-    message: types.Message, 
-    state: FSMContext, 
+    message: types.Message,
+    state: FSMContext,
    db: AsyncSession
 ):
    current_state = await state.get_state()
@@ -132,7 +138,80 @@ async def handle_potential_referral_code(
    else:
        await complete_registration(message, state, db)
    
-    return True 
+    return True
+
+
+def _get_language_prompt_text() -> str:
+    return "🌐 Выберите язык / Choose your language:"
+
+
+async def _prompt_language_selection(message: types.Message, state: FSMContext) -> None:
+    logger.info(f"🌐 LANGUAGE: Запрос выбора языка для пользователя {message.from_user.id}")
+
+    await state.set_state(RegistrationStates.waiting_for_language)
+    await message.answer(
+        _get_language_prompt_text(),
+        reply_markup=get_language_selection_keyboard(),
+    )
+
+
+async def _continue_registration_after_language(
+    *,
+    message: types.Message | None,
+    callback: types.CallbackQuery | None,
+    state: FSMContext,
+    db: AsyncSession,
+) -> None:
+    data = await state.get_data() or {}
+    language = data.get('language', DEFAULT_LANGUAGE)
+    texts = get_texts(language)
+
+    target_message = callback.message if callback else message
+    if not target_message:
+        logger.warning("⚠️ LANGUAGE: Нет доступного сообщения для продолжения регистрации")
+        return
+
+    async def _complete_registration_wrapper():
+        if callback:
+            await complete_registration_from_callback(callback, state, db)
+        else:
+            await complete_registration(message, state, db)
+
+    if settings.SKIP_RULES_ACCEPT:
+        logger.info("⚙️ LANGUAGE: SKIP_RULES_ACCEPT включен - пропускаем правила")
+
+        if data.get('referral_code'):
+            referrer = await get_user_by_referral_code(db, data['referral_code'])
+            if referrer:
+                data['referrer_id'] = referrer.id
+                await state.set_data(data)
+                logger.info(f"✅ LANGUAGE: Реферер найден: {referrer.id}")
+
+        if settings.SKIP_REFERRAL_CODE or data.get('referral_code'):
+            await _complete_registration_wrapper()
+        else:
+            try:
+                await target_message.answer(
+                    texts.t(
+                        "REFERRAL_CODE_QUESTION",
+                        "У вас есть реферальный код? Введите его или нажмите 'Пропустить'",
+                    ),
+                    reply_markup=get_referral_code_keyboard(language)
+                )
+                await state.set_state(RegistrationStates.waiting_for_referral_code)
+                logger.info("🔍 LANGUAGE: Ожидание ввода реферального кода")
+            except Exception as error:
+                logger.error(f"Ошибка при показе вопроса о реферальном коде после выбора языка: {error}")
+                await _complete_registration_wrapper()
+        return
+
+    rules_text = await get_rules(language)
+    await target_message.answer(
+        rules_text,
+        reply_markup=get_rules_keyboard(language)
+    )
+    await state.set_state(RegistrationStates.waiting_for_rules_accept)
+    logger.info("📋 LANGUAGE: Правила отправлены после выбора языка")


 async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession, db_user=None):
@@ -164,6 +243,22 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
        await state.update_data(referral_code=referral_code)
    
    user = db_user if db_user else await get_user_by_telegram_id(db, message.from_user.id)
+
+    if campaign:
+        try:
+            notification_service = AdminNotificationService(message.bot)
+            await notification_service.send_campaign_link_visit_notification(
+                db,
+                message.from_user,
+                campaign,
+                user,
+            )
+        except Exception as notify_error:
+            logger.error(
+                "Ошибка отправки админ уведомления о переходе по кампании %s: %s",
+                campaign.id,
+                notify_error,
+            )
    
    if user and user.status != UserStatus.DELETED.value:
        logger.info(f"✅ Активный пользователь найден: {user.telegram_id}")
@@ -228,17 +323,23 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
            subscription_is_active = user.subscription.is_active
        
        menu_text = await get_main_menu_text(user, texts, db)
-        
+
+        is_admin = settings.is_admin(user.telegram_id)
+        is_moderator = (not is_admin) and SupportSettingsService.is_moderator(
+            user.telegram_id
+        )
+
        await message.answer(
            menu_text,
            reply_markup=get_main_menu_keyboard(
                language=user.language,
-                is_admin=settings.is_admin(user.telegram_id),
+                is_admin=is_admin,
                has_had_paid_subscription=user.has_had_paid_subscription,
                has_active_subscription=has_active_subscription,
                subscription_is_active=subscription_is_active,
                balance_kopeks=user.balance_kopeks,
-                subscription=user.subscription
+                subscription=user.subscription,
+                is_moderator=is_moderator,
            ),
            parse_mode="HTML"
        )
@@ -308,55 +409,128 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession,
    else:
        logger.info(f"🆕 Новый пользователь, начинаем регистрацию")
    
-    language = DEFAULT_LANGUAGE
-    texts = get_texts(language)
-    
    data = await state.get_data() or {}
-    data['language'] = language
-    await state.set_data(data)
-    logger.info(f"💾 Установлен язык по умолчанию: {language}")
-    if settings.SKIP_RULES_ACCEPT:
-        logger.info("⚙️ SKIP_RULES_ACCEPT включен - пропускаем принятие правил")
-        if data.get('referral_code'):
-            referrer = await get_user_by_referral_code(db, data['referral_code'])
-            if referrer:
-                data['referrer_id'] = referrer.id
-                await state.set_data(data)
-                logger.info(f"✅ Реферер найден: {referrer.id}")
+    if not data.get('language'):
+        if settings.is_language_selection_enabled():
+            await _prompt_language_selection(message, state)
+            return

-        if settings.SKIP_REFERRAL_CODE or data.get('referral_code'):
-            await complete_registration(message, state, db)
-        else:
-            try:
-                await message.answer(
-                    texts.t(
-                        "REFERRAL_CODE_QUESTION",
-                        "У вас есть реферальный код? Введите его или нажмите 'Пропустить'",
-                    ),
-                    reply_markup=get_referral_code_keyboard(language)
+        default_language = (
+            (settings.DEFAULT_LANGUAGE or DEFAULT_LANGUAGE)
+            if isinstance(settings.DEFAULT_LANGUAGE, str)
+            else DEFAULT_LANGUAGE
+        )
+        normalized_default = default_language.split("-")[0].lower()
+        data['language'] = normalized_default
+        await state.set_data(data)
+        logger.info(
+            "🌐 LANGUAGE: выбор языка отключен, устанавливаем язык по умолчанию '%s'",
+            normalized_default,
+        )
+
+    await _continue_registration_after_language(
+        message=message,
+        callback=None,
+        state=state,
+        db=db,
+    )
+
+
+async def process_language_selection(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    logger.info(
+        f"🌐 LANGUAGE: Пользователь {callback.from_user.id} выбрал язык ({callback.data})"
+    )
+
+    if not settings.is_language_selection_enabled():
+        data = await state.get_data() or {}
+        default_language = (
+            (settings.DEFAULT_LANGUAGE or DEFAULT_LANGUAGE)
+            if isinstance(settings.DEFAULT_LANGUAGE, str)
+            else DEFAULT_LANGUAGE
+        )
+        normalized_default = default_language.split("-")[0].lower()
+        data['language'] = normalized_default
+        await state.set_data(data)
+
+        texts = get_texts(normalized_default)
+
+        try:
+            await callback.message.edit_text(
+                texts.t(
+                    "LANGUAGE_SELECTION_DISABLED",
+                    "⚙️ Выбор языка временно недоступен. Используем язык по умолчанию.",
                )
-                await state.set_state(RegistrationStates.waiting_for_referral_code)
-                logger.info("🔍 Ожидание ввода реферального кода")
-            except Exception as e:
-                logger.error(f"Ошибка при показе вопроса о реферальном коде: {e}")
-                await complete_registration(message, state, db)
+            )
+        except Exception:
+            await callback.message.answer(
+                texts.t(
+                    "LANGUAGE_SELECTION_DISABLED",
+                    "⚙️ Выбор языка временно недоступен. Используем язык по умолчанию.",
+                )
+            )
+
+        await callback.answer()
+
+        await _continue_registration_after_language(
+            message=None,
+            callback=callback,
+            state=state,
+            db=db,
+        )
        return

-    rules_text = await get_rules(language)
-    await message.answer(
-        rules_text,
-        reply_markup=get_rules_keyboard(language)
-    )
-    logger.info(f"📋 Правила отправлены")
+    selected_raw = (callback.data or "").split(":", 1)[-1]
+    normalized_selected = selected_raw.strip().lower()

-    await state.set_state(RegistrationStates.waiting_for_rules_accept)
-    current_state = await state.get_state()
-    logger.info(f"📊 Установлено состояние: {current_state}")
+    available_map = {
+        lang.strip().lower(): lang.strip()
+        for lang in settings.get_available_languages()
+        if isinstance(lang, str) and lang.strip()
+    }
+
+    if normalized_selected not in available_map:
+        logger.warning(
+            f"⚠️ LANGUAGE: Выбран недоступный язык '{normalized_selected}' пользователем {callback.from_user.id}"
+        )
+        await callback.answer("❌ Unsupported language", show_alert=True)
+        return
+
+    resolved_language = available_map[normalized_selected].lower()
+
+    data = await state.get_data() or {}
+    data['language'] = resolved_language
+    await state.set_data(data)
+
+    texts = get_texts(resolved_language)
+
+    try:
+        await callback.message.edit_text(
+            texts.t("LANGUAGE_SELECTED", "🌐 Язык интерфейса обновлен."),
+        )
+    except Exception as error:
+        logger.warning(
+            f"⚠️ LANGUAGE: Не удалось обновить сообщение выбора языка: {error}")
+        await callback.message.answer(
+            texts.t("LANGUAGE_SELECTED", "🌐 Язык интерфейса обновлен."),
+        )
+
+    await callback.answer()
+
+    await _continue_registration_after_language(
+        message=None,
+        callback=callback,
+        state=state,
+        db=db,
+    )


 async def process_rules_accept(
-    callback: types.CallbackQuery, 
-    state: FSMContext, 
+    callback: types.CallbackQuery,
+    state: FSMContext,
    db: AsyncSession
 ):
    
@@ -561,18 +735,25 @@ async def complete_registration_from_callback(
            subscription_is_active = existing_user.subscription.is_active
        
        menu_text = await get_main_menu_text(existing_user, texts, db)
-        
+
+        is_admin = settings.is_admin(existing_user.telegram_id)
+        is_moderator = (
+            (not is_admin)
+            and SupportSettingsService.is_moderator(existing_user.telegram_id)
+        )
+
        try:
            await callback.message.answer(
                menu_text,
                reply_markup=get_main_menu_keyboard(
                    language=existing_user.language,
-                    is_admin=settings.is_admin(existing_user.telegram_id),
+                    is_admin=is_admin,
                    has_had_paid_subscription=existing_user.has_had_paid_subscription,
                    has_active_subscription=has_active_subscription,
                    subscription_is_active=subscription_is_active,
                    balance_kopeks=existing_user.balance_kopeks,
-                    subscription=existing_user.subscription
+                    subscription=existing_user.subscription,
+                    is_moderator=is_moderator,
                ),
                parse_mode="HTML"
            )
@@ -591,7 +772,16 @@ async def complete_registration_from_callback(
    data = await state.get_data() or {}
    language = data.get('language', DEFAULT_LANGUAGE)
    texts = get_texts(language)
-    
+
+    campaign_id = data.get('campaign_id')
+    is_new_user_registration = (
+        existing_user is None
+        or (
+            existing_user
+            and existing_user.status == UserStatus.DELETED.value
+        )
+    )
+
    referrer_id = data.get('referrer_id')
    if not referrer_id and data.get('referral_code'):
        referrer = await get_user_by_referral_code(db, data['referral_code'])
@@ -689,7 +879,16 @@ async def complete_registration_from_callback(
    from app.database.crud.welcome_text import get_welcome_text_for_user
    offer_text = await get_welcome_text_for_user(db, callback.from_user)

-    if offer_text:
+    skip_welcome_offer = bool(campaign_id) and is_new_user_registration
+
+    if skip_welcome_offer:
+        logger.info(
+            "ℹ️ Пропускаем приветственное предложение для нового пользователя %s из рекламной кампании %s",
+            user.telegram_id,
+            campaign_id,
+        )
+
+    if offer_text and not skip_welcome_offer:
        try:
            await callback.message.answer(
                offer_text,
@@ -708,18 +907,25 @@ async def complete_registration_from_callback(
            subscription_is_active = user.subscription.is_active
        
        menu_text = await get_main_menu_text(user, texts, db)
-        
+
+        is_admin = settings.is_admin(user.telegram_id)
+        is_moderator = (
+            (not is_admin)
+            and SupportSettingsService.is_moderator(user.telegram_id)
+        )
+
        try:
            await callback.message.answer(
                menu_text,
                reply_markup=get_main_menu_keyboard(
                    language=user.language,
-                    is_admin=settings.is_admin(user.telegram_id),
+                    is_admin=is_admin,
                    has_had_paid_subscription=user.has_had_paid_subscription,
                    has_active_subscription=has_active_subscription,
                    subscription_is_active=subscription_is_active,
                    balance_kopeks=user.balance_kopeks,
-                    subscription=user.subscription
+                    subscription=user.subscription,
+                    is_moderator=is_moderator,
                ),
                parse_mode="HTML"
            )
@@ -767,18 +973,25 @@ async def complete_registration(
            subscription_is_active = existing_user.subscription.is_active
        
        menu_text = await get_main_menu_text(existing_user, texts, db)
-        
+
+        is_admin = settings.is_admin(existing_user.telegram_id)
+        is_moderator = (
+            (not is_admin)
+            and SupportSettingsService.is_moderator(existing_user.telegram_id)
+        )
+
        try:
            await message.answer(
                menu_text,
                reply_markup=get_main_menu_keyboard(
                    language=existing_user.language,
-                    is_admin=settings.is_admin(existing_user.telegram_id),
+                    is_admin=is_admin,
                    has_had_paid_subscription=existing_user.has_had_paid_subscription,
                    has_active_subscription=has_active_subscription,
                    subscription_is_active=subscription_is_active,
                    balance_kopeks=existing_user.balance_kopeks,
-                    subscription=existing_user.subscription
+                    subscription=existing_user.subscription,
+                    is_moderator=is_moderator,
                ),
                parse_mode="HTML"
            )
@@ -797,7 +1010,16 @@ async def complete_registration(
    data = await state.get_data() or {}
    language = data.get('language', DEFAULT_LANGUAGE)
    texts = get_texts(language)
-    
+
+    campaign_id = data.get('campaign_id')
+    is_new_user_registration = (
+        existing_user is None
+        or (
+            existing_user
+            and existing_user.status == UserStatus.DELETED.value
+        )
+    )
+
    referrer_id = data.get('referrer_id')
    if not referrer_id and data.get('referral_code'):
        referrer = await get_user_by_referral_code(db, data['referral_code'])
@@ -895,7 +1117,16 @@ async def complete_registration(
    from app.database.crud.welcome_text import get_welcome_text_for_user
    offer_text = await get_welcome_text_for_user(db, message.from_user)

-    if offer_text:
+    skip_welcome_offer = bool(campaign_id) and is_new_user_registration
+
+    if skip_welcome_offer:
+        logger.info(
+            "ℹ️ Пропускаем приветственное предложение для нового пользователя %s из рекламной кампании %s",
+            user.telegram_id,
+            campaign_id,
+        )
+
+    if offer_text and not skip_welcome_offer:
        try:
            await message.answer(
                offer_text,
@@ -914,18 +1145,25 @@ async def complete_registration(
            subscription_is_active = user.subscription.is_active
        
        menu_text = await get_main_menu_text(user, texts, db)
-        
+
+        is_admin = settings.is_admin(user.telegram_id)
+        is_moderator = (
+            (not is_admin)
+            and SupportSettingsService.is_moderator(user.telegram_id)
+        )
+
        try:
            await message.answer(
                menu_text,
                reply_markup=get_main_menu_keyboard(
                    language=user.language,
-                    is_admin=settings.is_admin(user.telegram_id),
+                    is_admin=is_admin,
                    has_had_paid_subscription=user.has_had_paid_subscription,
                    has_active_subscription=has_active_subscription,
                    subscription_is_active=subscription_is_active,
                    balance_kopeks=user.balance_kopeks,
-                    subscription=user.subscription
+                    subscription=user.subscription,
+                    is_moderator=is_moderator,
                ),
                parse_mode="HTML"
            )
@@ -1033,8 +1271,9 @@ def get_referral_code_keyboard(language: str):

 async def get_main_menu_text(user, texts, db: AsyncSession):

+    import html
    base_text = texts.MAIN_MENU.format(
-        user_name=user.full_name,
+        user_name=html.escape(user.full_name or ""),
        subscription_status=_get_subscription_status(user, texts)
    )

@@ -1052,8 +1291,9 @@ async def get_main_menu_text(user, texts, db: AsyncSession):

 async def get_main_menu_text_simple(user_name, texts, db: AsyncSession):

+    import html
    base_text = texts.MAIN_MENU.format(
-        user_name=user_name,
+        user_name=html.escape(user_name or ""),
        subscription_status=_get_subscription_status_simple(texts)
    )

@@ -1105,6 +1345,34 @@ async def required_sub_channel_check(
                show_alert=True,
            )

+        if user and user.subscription:
+            subscription = user.subscription
+            if (
+                subscription.is_trial
+                and subscription.status == SubscriptionStatus.DISABLED.value
+            ):
+                subscription.status = SubscriptionStatus.ACTIVE.value
+                subscription.updated_at = datetime.utcnow()
+                await db.commit()
+                await db.refresh(subscription)
+                logger.info(
+                    "✅ Триальная подписка пользователя %s восстановлена после подтверждения подписки на канал",
+                    user.telegram_id,
+                )
+
+                try:
+                    subscription_service = SubscriptionService()
+                    if user.remnawave_uuid:
+                        await subscription_service.update_remnawave_user(db, subscription)
+                    else:
+                        await subscription_service.create_remnawave_user(db, subscription)
+                except Exception as api_error:
+                    logger.error(
+                        "❌ Ошибка обновления RemnaWave при восстановлении подписки пользователя %s: %s",
+                        user.telegram_id if user else query.from_user.id,
+                        api_error,
+                    )
+
        await query.answer(
            texts.t("CHANNEL_SUBSCRIBE_THANKS", "✅ Спасибо за подписку"),
            show_alert=True,
@@ -1124,14 +1392,21 @@ async def required_sub_channel_check(
            from app.utils.message_patch import LOGO_PATH
            from aiogram.types import FSInputFile

+            is_admin = settings.is_admin(user.telegram_id)
+            is_moderator = (
+                (not is_admin)
+                and SupportSettingsService.is_moderator(user.telegram_id)
+            )
+
            keyboard = get_main_menu_keyboard(
                language=user.language,
-                is_admin=settings.is_admin(user.telegram_id),
+                is_admin=is_admin,
                has_had_paid_subscription=user.has_had_paid_subscription,
                has_active_subscription=has_active_subscription,
                subscription_is_active=subscription_is_active,
                balance_kopeks=user.balance_kopeks,
                subscription=user.subscription,
+                is_moderator=is_moderator,
            )

            if settings.ENABLE_LOGO_MODE:
@@ -1226,7 +1501,14 @@ def register_handlers(dp: Dispatcher):
        StateFilter(RegistrationStates.waiting_for_rules_accept)
    )
    logger.info("✅ Зарегистрирован process_rules_accept")
-    
+
+    dp.callback_query.register(
+        process_language_selection,
+        F.data.startswith("language_select:"),
+        StateFilter(RegistrationStates.waiting_for_language)
+    )
+    logger.info("✅ Зарегистрирован process_language_selection")
+
    dp.callback_query.register(
        process_referral_code_skip,
        F.data == "referral_skip",
@@ -9,6 +9,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.database.models import User, Ticket, TicketStatus
 from app.database.crud.ticket import TicketCRUD, TicketMessageCRUD
+from app.database.crud.user import get_user_by_id
 from app.keyboards.inline import (
    get_ticket_cancel_keyboard,
    get_my_tickets_keyboard,
@@ -374,12 +375,17 @@ async def show_my_tickets(
        except ValueError:
            current_page = 1
    
-    # Получаем тикеты пользователя (открытые/закрытые отдельно)
-    all_tickets = await TicketCRUD.get_user_tickets(db, db_user.id, limit=100)
-    open_tickets = [t for t in all_tickets if t.status != TicketStatus.CLOSED.value]
-    closed_tickets = [t for t in all_tickets if t.status == TicketStatus.CLOSED.value]
-    
-    if not open_tickets and not closed_tickets:
+    # Пагинация открытых тикетов из БД
+    per_page = 10
+    total_open = await TicketCRUD.count_user_tickets_by_statuses(db, db_user.id, [TicketStatus.OPEN.value, TicketStatus.ANSWERED.value, TicketStatus.PENDING.value])
+    total_pages = max(1, (total_open + per_page - 1) // per_page)
+    current_page = max(1, min(current_page, total_pages))
+    offset = (current_page - 1) * per_page
+    open_tickets = await TicketCRUD.get_user_tickets_by_statuses(db, db_user.id, [TicketStatus.OPEN.value, TicketStatus.ANSWERED.value, TicketStatus.PENDING.value], limit=per_page, offset=offset)
+
+    # Проверка на отсутствие тикетов совсем (ни открытых, ни закрытых)
+    has_closed_any = await TicketCRUD.count_user_tickets_by_statuses(db, db_user.id, [TicketStatus.CLOSED.value]) > 0
+    if not open_tickets and not has_closed_any:
        await callback.message.edit_text(
            texts.t("NO_TICKETS", "У вас пока нет тикетов."),
            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
@@ -400,32 +406,18 @@ async def show_my_tickets(
        await callback.answer()
        return
    
-    # Открытые с пагинацией
-    open_data = []
-    for t in open_tickets:
-        if t.status != TicketStatus.CLOSED.value:
-            open_data.append({'id': t.id, 'title': t.title, 'status_emoji': t.status_emoji})
-    per_page = 10
-    pag = get_pagination_info(total_count=len(open_data), page=current_page, per_page=per_page)
-    # Корректируем текущую страницу в допустимые границы
-    current_page = max(1, min(current_page, pag["total_pages"]))
-    start_index = (current_page - 1) * per_page
-    end_index = start_index + per_page
-    page_items = open_data[start_index:end_index]
-    keyboard = get_my_tickets_keyboard(page_items, current_page=current_page, total_pages=pag["total_pages"], language=db_user.language)
+    # Открытые с пагинацией (DB)
+    open_data = [{'id': t.id, 'title': t.title, 'status_emoji': t.status_emoji} for t in open_tickets]
+    keyboard = get_my_tickets_keyboard(open_data, current_page=current_page, total_pages=total_pages, language=db_user.language, page_prefix="my_tickets_page_")
    # Добавим кнопку перехода к закрытым
    keyboard.inline_keyboard.insert(0, [types.InlineKeyboardButton(text=texts.t("VIEW_CLOSED_TICKETS", "🟢 Закрытые тикеты"), callback_data="my_tickets_closed")])
-    # Покажем список тикетов c логотипом, если режим включен
-    if settings.ENABLE_LOGO_MODE and callback.message.photo:
-        from app.utils.photo_message import edit_or_answer_photo
-        await edit_or_answer_photo(
-            callback=callback,
-            caption=texts.t("MY_TICKETS_TITLE", "📋 Ваши тикеты:"),
-            keyboard=keyboard,
-            parse_mode="HTML",
-        )
-    else:
-        await callback.message.edit_text(texts.t("MY_TICKETS_TITLE", "📋 Ваши тикеты:"), reply_markup=keyboard)
+    # Всегда используем фото-рендер с логотипом (утилита сама сделает фоллбек при необходимости)
+    await edit_or_answer_photo(
+        callback=callback,
+        caption=texts.t("MY_TICKETS_TITLE", "📋 Ваши тикеты:"),
+        keyboard=keyboard,
+        parse_mode="HTML",
+    )
    await callback.answer()


@@ -435,9 +427,18 @@ async def show_my_tickets_closed(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    # Пагинация (при необходимости можно добавить аналогично open)
-    tickets = await TicketCRUD.get_user_tickets(db, db_user.id, status=TicketStatus.CLOSED.value, limit=10)
-    if not tickets:
+    # Пагинация закрытых
+    current_page = 1
+    data_str = callback.data
+    if data_str.startswith("my_tickets_closed_page_"):
+        try:
+            current_page = int(data_str.replace("my_tickets_closed_page_", ""))
+        except ValueError:
+            current_page = 1
+
+    per_page = 10
+    total_closed = await TicketCRUD.count_user_tickets_by_statuses(db, db_user.id, [TicketStatus.CLOSED.value])
+    if total_closed == 0:
        await callback.message.edit_text(
            texts.t("NO_CLOSED_TICKETS", "Закрытых тикетов пока нет."),
            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
@@ -447,19 +448,19 @@ async def show_my_tickets_closed(
        )
        await callback.answer()
        return
+    total_pages = max(1, (total_closed + per_page - 1) // per_page)
+    current_page = max(1, min(current_page, total_pages))
+    offset = (current_page - 1) * per_page
+    tickets = await TicketCRUD.get_user_tickets_by_statuses(db, db_user.id, [TicketStatus.CLOSED.value], limit=per_page, offset=offset)
    data = [{'id': t.id, 'title': t.title, 'status_emoji': t.status_emoji} for t in tickets]
-    kb = get_my_tickets_keyboard(data, current_page=1, language=db_user.language)
+    kb = get_my_tickets_keyboard(data, current_page=current_page, total_pages=total_pages, language=db_user.language, page_prefix="my_tickets_closed_page_")
    kb.inline_keyboard.insert(0, [types.InlineKeyboardButton(text=texts.t("BACK_TO_OPEN_TICKETS", "🔴 Открытые тикеты"), callback_data="my_tickets")])
-    if settings.ENABLE_LOGO_MODE and callback.message.photo:
-        from app.utils.photo_message import edit_or_answer_photo
-        await edit_or_answer_photo(
-            callback=callback,
-            caption=texts.t("CLOSED_TICKETS_TITLE", "🟢 Закрытые тикеты:"),
-            keyboard=kb,
-            parse_mode="HTML",
-        )
-    else:
-        await callback.message.edit_text(texts.t("CLOSED_TICKETS_TITLE", "🟢 Закрытые тикеты:"), reply_markup=kb)
+    await edit_or_answer_photo(
+        callback=callback,
+        caption=texts.t("CLOSED_TICKETS_TITLE", "🟢 Закрытые тикеты:"),
+        keyboard=kb,
+        parse_mode="HTML",
+    )
    await callback.answer()


@@ -758,7 +759,10 @@ async def handle_ticket_reply(
        if ticket.status == TicketStatus.CLOSED.value:
            texts = get_texts(db_user.language)
            await message.answer(
-                texts.t("TICKET_CLOSED", "✅ Тикет закрыт.")
+                texts.t("TICKET_CLOSED", "✅ Тикет закрыт."),
+                reply_markup=types.InlineKeyboardMarkup(
+                    inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("CLOSE_NOTIFICATION", "❌ Закрыть уведомление"), callback_data=f"close_ticket_notification_{ticket.id}")]]
+                )
            )
            await state.clear()
            return
@@ -767,7 +771,10 @@ async def handle_ticket_reply(
        if ticket.status == TicketStatus.CLOSED.value or ticket.is_user_reply_blocked:
            texts = get_texts(db_user.language)
            await message.answer(
-                texts.t("TICKET_CLOSED_NO_REPLY", "❌ Тикет закрыт, ответить невозможно.")
+                texts.t("TICKET_CLOSED_NO_REPLY", "❌ Тикет закрыт, ответить невозможно."),
+                reply_markup=types.InlineKeyboardMarkup(
+                    inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("CLOSE_NOTIFICATION", "❌ Закрыть уведомление"), callback_data=f"close_ticket_notification_{ticket.id}")]]
+                )
            )
            await state.clear()
            return
@@ -929,10 +936,21 @@ async def notify_admins_about_new_ticket(ticket: Ticket, db: AsyncSession):
        if len(title) > 60:
            title = title[:57] + "..."

+        # Загрузим пользователя, чтобы отобразить реальный Telegram ID и username
+        try:
+            user = await get_user_by_id(db, ticket.user_id)
+        except Exception:
+            user = None
+        full_name = user.full_name if user else "Unknown"
+        telegram_id_display = user.telegram_id if user else "—"
+        username_display = (user.username or "отсутствует") if user else "отсутствует"
+
        notification_text = (
            f"🎫 <b>НОВЫЙ ТИКЕТ</b>\n\n"
            f"🆔 <b>ID:</b> <code>{ticket.id}</code>\n"
-            f"👤 <b>User ID:</b> <code>{ticket.user_id}</code>\n"
+            f"👤 <b>Пользователь:</b> {full_name}\n"
+            f"🆔 <b>Telegram ID:</b> <code>{telegram_id_display}</code>\n"
+            f"📱 <b>Username:</b> @{username_display}\n"
            f"📝 <b>Заголовок:</b> {title or '—'}\n"
            f"📅 <b>Создан:</b> {ticket.created_at.strftime('%d.%m.%Y %H:%M')}\n"
        )
@@ -981,6 +999,10 @@ def register_handlers(dp: Dispatcher):
        show_my_tickets_closed,
        F.data == "my_tickets_closed"
    )
+    dp.callback_query.register(
+        show_my_tickets_closed,
+        F.data.startswith("my_tickets_closed_page_")
+    )
    
    dp.callback_query.register(
        view_ticket,
@@ -8,11 +8,20 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
 from app.localization.loader import DEFAULT_LANGUAGE
 from app.localization.texts import get_texts
-from app.utils.pricing_utils import format_period_description
+from app.utils.pricing_utils import format_period_description, apply_percentage_discount
+from app.utils.subscription_utils import (
+    get_display_subscription_link,
+    get_happ_cryptolink_redirect_link,
+)
 import logging

 logger = logging.getLogger(__name__)

+_LANGUAGE_DISPLAY_NAMES = {
+    "ru": "🇷🇺 Русский",
+    "en": "🇬🇧 English",
+}
+
 def get_rules_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
@@ -58,6 +67,49 @@ def get_post_registration_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKe
    ])


+def get_language_selection_keyboard(
+    current_language: Optional[str] = None,
+    *,
+    include_back: bool = False,
+    language: str = DEFAULT_LANGUAGE,
+) -> InlineKeyboardMarkup:
+    available_languages = settings.get_available_languages()
+
+    buttons: List[List[InlineKeyboardButton]] = []
+    row: List[InlineKeyboardButton] = []
+
+    normalized_current = (current_language or "").lower()
+
+    for index, lang_code in enumerate(available_languages, start=1):
+        normalized_code = lang_code.lower()
+        display_name = _LANGUAGE_DISPLAY_NAMES.get(
+            normalized_code,
+            normalized_code.upper(),
+        )
+
+        prefix = "✅ " if normalized_code == normalized_current and normalized_current else ""
+
+        row.append(
+            InlineKeyboardButton(
+                text=f"{prefix}{display_name}",
+                callback_data=f"language_select:{normalized_code}",
+            )
+        )
+
+        if len(row) == 2:
+            buttons.append(row)
+            row = []
+
+    if row:
+        buttons.append(row)
+
+    if include_back:
+        texts = get_texts(language)
+        buttons.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
+
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
 def get_main_menu_keyboard(
    language: str = DEFAULT_LANGUAGE,
    is_admin: bool = False,
@@ -67,6 +119,8 @@ def get_main_menu_keyboard(
    balance_kopeks: int = 0,
    subscription=None,
    show_resume_checkout: bool = False,
+    *,
+    is_moderator: bool = False,
 ) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    
@@ -85,13 +139,24 @@ def get_main_menu_keyboard(

    if has_active_subscription and subscription_is_active:
        connect_mode = settings.CONNECT_BUTTON_MODE
+        subscription_link = get_display_subscription_link(subscription)
+
+        def _fallback_connect_button() -> InlineKeyboardButton:
+            return InlineKeyboardButton(
+                text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                callback_data="subscription_connect",
+            )
+
        if connect_mode == "miniapp_subscription":
-            keyboard.append([
-                InlineKeyboardButton(
-                    text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
-                    web_app=types.WebAppInfo(url=subscription.subscription_url)
-                )
-            ])
+            if subscription_link:
+                keyboard.append([
+                    InlineKeyboardButton(
+                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                        web_app=types.WebAppInfo(url=subscription_link)
+                    )
+                ])
+            else:
+                keyboard.append([_fallback_connect_button()])
        elif connect_mode == "miniapp_custom":
            keyboard.append([
                InlineKeyboardButton(
@@ -100,19 +165,31 @@ def get_main_menu_keyboard(
                )
            ])
        elif connect_mode == "link":
-            keyboard.append([
-                InlineKeyboardButton(
-                    text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
-                    url=subscription.subscription_url
-                )
-            ])
+            if subscription_link:
+                keyboard.append([
+                    InlineKeyboardButton(
+                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                        url=subscription_link
+                    )
+                ])
+            else:
+                keyboard.append([_fallback_connect_button()])
+        elif connect_mode == "happ_cryptolink":
+            if subscription_link:
+                keyboard.append([
+                    InlineKeyboardButton(
+                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                        callback_data="open_subscription_link",
+                    )
+                ])
+            else:
+                keyboard.append([_fallback_connect_button()])
        else:
-            keyboard.append([
-                InlineKeyboardButton(
-                    text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
-                    callback_data="subscription_connect"
-                )
-            ])
+            keyboard.append([_fallback_connect_button()])
+
+        happ_row = get_happ_download_button_row(texts)
+        if happ_row:
+            keyboard.append(happ_row)

        keyboard.append([
            InlineKeyboardButton(text=balance_button_text, callback_data="menu_balance"),
@@ -170,6 +247,15 @@ def get_main_menu_keyboard(
            keyboard.append([
                InlineKeyboardButton(text=server_status_text, url=status_url)
            ])
+    elif server_status_mode == "external_link_miniapp":
+        status_url = settings.get_server_status_external_url()
+        if status_url:
+            keyboard.append([
+                InlineKeyboardButton(
+                    text=server_status_text,
+                    web_app=types.WebAppInfo(url=status_url),
+                )
+            ])
    elif server_status_mode == "xray":
        keyboard.append([
            InlineKeyboardButton(text=server_status_text, callback_data="menu_server_status")
@@ -186,6 +272,11 @@ def get_main_menu_keyboard(
        support_row.append(InlineKeyboardButton(text=texts.MENU_SUPPORT, callback_data="menu_support"))
    support_row.append(InlineKeyboardButton(text=texts.MENU_RULES, callback_data="menu_rules"))
    keyboard.append(support_row)
+
+    if settings.is_language_selection_enabled():
+        keyboard.append([
+            InlineKeyboardButton(text=texts.MENU_LANGUAGE, callback_data="menu_language")
+        ])
    if settings.DEBUG:
        print(f"DEBUG KEYBOARD: is_admin={is_admin}, добавляем админ кнопку: {is_admin}")

@@ -198,10 +289,104 @@ def get_main_menu_keyboard(
    else:
        if settings.DEBUG:
            print("DEBUG KEYBOARD: Админ кнопка НЕ добавлена")
+    # Moderator access (limited support panel)
+    if (not is_admin) and is_moderator:
+        keyboard.append([
+            InlineKeyboardButton(text="🧑‍⚖️ Модерация", callback_data="moderator_panel")
+        ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


+def get_happ_download_button_row(texts) -> Optional[List[InlineKeyboardButton]]:
+    if not settings.is_happ_download_button_enabled():
+        return None
+
+    return [
+        InlineKeyboardButton(
+            text=texts.t("HAPP_DOWNLOAD_BUTTON", "⬇️ Скачать Happ"),
+            callback_data="subscription_happ_download"
+        )
+    ]
+
+
+def get_happ_cryptolink_keyboard(
+    subscription_link: str,
+    language: str = DEFAULT_LANGUAGE,
+    redirect_link: Optional[str] = None,
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    final_redirect_link = redirect_link or get_happ_cryptolink_redirect_link(subscription_link)
+
+    buttons: List[List[InlineKeyboardButton]] = []
+
+    if final_redirect_link:
+        buttons.append([
+            InlineKeyboardButton(
+                text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                url=final_redirect_link,
+            )
+        ])
+
+    buttons.extend([
+        [
+            InlineKeyboardButton(
+                text=texts.t("HAPP_PLATFORM_IOS", "🍎 iOS"),
+                callback_data="happ_download_ios",
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=texts.t("HAPP_PLATFORM_ANDROID", "🤖 Android"),
+                callback_data="happ_download_android",
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=texts.t("HAPP_PLATFORM_MACOS", "🖥️ Mac OS"),
+                callback_data="happ_download_macos",
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=texts.t("HAPP_PLATFORM_WINDOWS", "💻 Windows"),
+                callback_data="happ_download_windows",
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=texts.t("BACK_TO_MAIN_MENU_BUTTON", "⬅️ В главное меню"),
+                callback_data="back_to_menu",
+            )
+        ],
+    ])
+
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
+def get_happ_download_platform_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    buttons = [
+        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_IOS", "🍎 iOS"), callback_data="happ_download_ios")],
+        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_ANDROID", "🤖 Android"), callback_data="happ_download_android")],
+        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_MACOS", "🖥️ Mac OS"), callback_data="happ_download_macos")],
+        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_WINDOWS", "💻 Windows"), callback_data="happ_download_windows")],
+        [InlineKeyboardButton(text=texts.BACK, callback_data="happ_download_close")],
+    ]
+
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
+def get_happ_download_link_keyboard(language: str, link: str) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    buttons = [
+        [InlineKeyboardButton(text=texts.t("HAPP_DOWNLOAD_OPEN_LINK", "🔗 Открыть ссылку"), url=link)],
+        [InlineKeyboardButton(text=texts.BACK, callback_data="happ_download_back")],
+    ]
+
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
 def get_back_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
@@ -254,29 +439,39 @@ def get_server_status_keyboard(
 def get_insufficient_balance_keyboard(
    language: str = DEFAULT_LANGUAGE,
    resume_callback: str | None = None,
-    ) -> InlineKeyboardMarkup:
+    amount_kopeks: int | None = None,
+) -> InlineKeyboardMarkup:

    texts = get_texts(language)
-    keyboard: list[list[InlineKeyboardButton]] = [
-        [
-            InlineKeyboardButton(
-                text=texts.GO_TO_BALANCE_TOP_UP,
-                callback_data="balance_topup",
+    keyboard = get_payment_methods_keyboard(amount_kopeks or 0, language)
+
+    back_row_index: int | None = None
+
+    if keyboard.inline_keyboard:
+        last_row = keyboard.inline_keyboard[-1]
+        if (
+            len(last_row) == 1
+            and isinstance(last_row[0], InlineKeyboardButton)
+            and last_row[0].callback_data in {"menu_balance", "back_to_menu"}
+        ):
+            keyboard.inline_keyboard[-1][0] = InlineKeyboardButton(
+                text=texts.t("PAYMENT_RETURN_HOME_BUTTON", "🏠 На главную"),
+                callback_data="back_to_menu",
            )
-        ]
-    ]
+            back_row_index = len(keyboard.inline_keyboard) - 1

    if resume_callback:
-        keyboard.append([
+        return_row = [
            InlineKeyboardButton(
                text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
                callback_data=resume_callback,
            )
-        ])
+        ]

-    keyboard.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
+        insert_index = back_row_index if back_row_index is not None else len(keyboard.inline_keyboard)
+        keyboard.inline_keyboard.insert(insert_index, return_row)

-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+    return keyboard


 def get_subscription_keyboard(
@@ -291,14 +486,15 @@ def get_subscription_keyboard(
    keyboard = []

    if has_subscription:
-        if subscription and subscription.subscription_url:
+        subscription_link = get_display_subscription_link(subscription) if subscription else None
+        if subscription_link:
            connect_mode = settings.CONNECT_BUTTON_MODE
-            
+
            if connect_mode == "miniapp_subscription":
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
-                        web_app=types.WebAppInfo(url=subscription.subscription_url)
+                        web_app=types.WebAppInfo(url=subscription_link)
                    )
                ])
            elif connect_mode == "miniapp_custom":
@@ -315,12 +511,34 @@ def get_subscription_keyboard(
                    ])
            elif connect_mode == "link":
                keyboard.append([
-                    InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), url=subscription.subscription_url)
+                    InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), url=subscription_link)
+                ])
+            elif connect_mode == "happ_cryptolink":
+                keyboard.append([
+                    InlineKeyboardButton(
+                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                        callback_data="open_subscription_link",
+                    )
                ])
            else:
                keyboard.append([
                    InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
                ])
+        elif settings.CONNECT_BUTTON_MODE == "miniapp_custom":
+            keyboard.append([
+                InlineKeyboardButton(
+                    text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
+                    web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
+                )
+            ])
+        else:
+            keyboard.append([
+                InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
+            ])
+
+        happ_row = get_happ_download_button_row(texts)
+        if happ_row:
+            keyboard.append(happ_row)

        if not is_trial:
            keyboard.append([
@@ -351,8 +569,11 @@ def get_subscription_keyboard(
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)

-def get_payment_methods_keyboard_with_cart(language: str = "ru") -> InlineKeyboardMarkup:
-    keyboard = get_payment_methods_keyboard(0, language)
+def get_payment_methods_keyboard_with_cart(
+    language: str = "ru",
+    amount_kopeks: int = 0,
+) -> InlineKeyboardMarkup:
+    keyboard = get_payment_methods_keyboard(amount_kopeks, language)
    
    # Добавляем кнопку "Очистить корзину"
    keyboard.inline_keyboard.append([
@@ -380,21 +601,26 @@ def get_subscription_confirm_keyboard_with_cart(language: str = "ru") -> InlineK
        )]
    ])

-def get_insufficient_balance_keyboard_with_cart(language: str = "ru") -> InlineKeyboardMarkup:
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(
-            text="💰 Пополнить баланс",
-            callback_data="balance_topup"
-        )],
-        [InlineKeyboardButton(
-            text="🗑️ Очистить корзину",
-            callback_data="clear_saved_cart"
-        )],
-        [InlineKeyboardButton(
-            text="🔙 Назад",
-            callback_data="back_to_menu"
-        )]
-    ])
+def get_insufficient_balance_keyboard_with_cart(
+    language: str = "ru",
+    amount_kopeks: int = 0,
+) -> InlineKeyboardMarkup:
+    keyboard = get_insufficient_balance_keyboard(
+        language,
+        amount_kopeks=amount_kopeks,
+    )
+
+    keyboard.inline_keyboard.insert(
+        0,
+        [
+            InlineKeyboardButton(
+                text="🗑️ Очистить корзину и вернуться",
+                callback_data="clear_saved_cart",
+            )
+        ],
+    )
+
+    return keyboard

 def get_trial_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
    texts = get_texts(language)
@@ -608,67 +834,89 @@ def get_balance_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMark
 def get_payment_methods_keyboard(amount_kopeks: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
-    
-    
+
+    amount_kopeks = max(0, int(amount_kopeks or 0))
+
+    def _build_callback(method: str) -> str:
+        if amount_kopeks > 0:
+            return f"topup_amount|{method}|{amount_kopeks}"
+        return f"topup_{method}"
+
    if settings.TELEGRAM_STARS_ENABLED:
        keyboard.append([
            InlineKeyboardButton(
-                text=texts.t("PAYMENT_TELEGRAM_STARS", "⭐ Telegram Stars"), 
-                callback_data="topup_stars"
+                text=texts.t("PAYMENT_TELEGRAM_STARS", "⭐ Telegram Stars"),
+                callback_data=_build_callback("stars")
            )
        ])

    if settings.is_yookassa_enabled():
        keyboard.append([
            InlineKeyboardButton(
-                text=texts.t("PAYMENT_CARD_YOOKASSA", "💳 Банковская карта (YooKassa)"), 
-                callback_data="topup_yookassa"
+                text=texts.t("PAYMENT_CARD_YOOKASSA", "💳 Банковская карта (YooKassa)"),
+                callback_data=_build_callback("yookassa")
            )
        ])
-        
+
        if settings.YOOKASSA_SBP_ENABLED:
            keyboard.append([
                InlineKeyboardButton(
-                    text=texts.t("PAYMENT_SBP_YOOKASSA", "🏦 Оплатить по СБП (YooKassa)"), 
-                    callback_data="topup_yookassa_sbp"
+                    text=texts.t("PAYMENT_SBP_YOOKASSA", "🏦 Оплатить по СБП (YooKassa)"),
+                    callback_data=_build_callback("yookassa_sbp")
                )
            ])

    if settings.TRIBUTE_ENABLED:
        keyboard.append([
            InlineKeyboardButton(
-                text=texts.t("PAYMENT_CARD_TRIBUTE", "💳 Банковская карта (Tribute)"), 
-                callback_data="topup_tribute"
+                text=texts.t("PAYMENT_CARD_TRIBUTE", "💳 Банковская карта (Tribute)"),
+                callback_data=_build_callback("tribute")
+            )
+        ])
+
+    if settings.is_mulenpay_enabled():
+        keyboard.append([
+            InlineKeyboardButton(
+                text=texts.t("PAYMENT_CARD_MULENPAY", "💳 Банковская карта (Mulen Pay)"),
+                callback_data=_build_callback("mulenpay")
+            )
+        ])
+
+    if settings.is_pal24_enabled():
+        keyboard.append([
+            InlineKeyboardButton(
+                text=texts.t("PAYMENT_CARD_PAL24", "🏦 СБП (PayPalych)"),
+                callback_data=_build_callback("pal24")
            )
        ])

    if settings.is_cryptobot_enabled():
        keyboard.append([
            InlineKeyboardButton(
-                text=texts.t("PAYMENT_CRYPTOBOT", "🪙 Криптовалюта (CryptoBot)"), 
-                callback_data="topup_cryptobot"
+                text=texts.t("PAYMENT_CRYPTOBOT", "🪙 Криптовалюта (CryptoBot)"),
+                callback_data=_build_callback("cryptobot")
            )
        ])

    keyboard.append([
        InlineKeyboardButton(
-            text=texts.t("PAYMENT_VIA_SUPPORT", "🛠️ Через поддержку"), 
+            text=texts.t("PAYMENT_VIA_SUPPORT", "🛠️ Через поддержку"),
            callback_data="topup_support"
        )
    ])
-    
-    if len(keyboard) == 1:  
+
+    if len(keyboard) == 1:
        keyboard.insert(0, [
            InlineKeyboardButton(
                text=texts.t("PAYMENTS_TEMPORARILY_UNAVAILABLE", "⚠️ Способы оплаты временно недоступны"),
                callback_data="payment_methods_unavailable"
            )
        ])
-    
+
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
    ])
-    
+
    return InlineKeyboardMarkup(inline_keyboard=keyboard)

 def get_yookassa_payment_keyboard(
@@ -931,7 +1179,11 @@ def get_extend_subscription_keyboard(language: str = DEFAULT_LANGUAGE) -> Inline
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


-def get_add_traffic_keyboard(language: str = DEFAULT_LANGUAGE, subscription_end_date: datetime = None) -> InlineKeyboardMarkup:
+def get_add_traffic_keyboard(
+    language: str = DEFAULT_LANGUAGE,
+    subscription_end_date: datetime = None,
+    discount_percent: int = 0,
+) -> InlineKeyboardMarkup:
    from app.utils.pricing_utils import get_remaining_months
    from app.config import settings
    texts = get_texts(language)
@@ -963,8 +1215,13 @@ def get_add_traffic_keyboard(language: str = DEFAULT_LANGUAGE, subscription_end_
    for package in enabled_packages:
        gb = package['gb']
        price_per_month = package['price']
-        total_price = price_per_month * months_multiplier
-        
+        discounted_per_month, discount_per_month = apply_percentage_discount(
+            price_per_month,
+            discount_percent,
+        )
+        total_price = discounted_per_month * months_multiplier
+        total_discount = discount_per_month * months_multiplier
+
        if gb == 0:
            if language == "ru":
                text = f"♾️ Безлимитный трафик - {total_price//100} ₽{period_text}"
@@ -975,7 +1232,10 @@ def get_add_traffic_keyboard(language: str = DEFAULT_LANGUAGE, subscription_end_
                text = f"📊 +{gb} ГБ трафика - {total_price//100} ₽{period_text}"
            else:
                text = f"📊 +{gb} GB traffic - {total_price//100} ₽{period_text}"
-        
+
+        if discount_percent > 0 and total_discount > 0:
+            text += f" (скидка {discount_percent}%: -{total_discount//100}₽)"
+
        buttons.append([
            InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
        ])
@@ -989,7 +1249,12 @@ def get_add_traffic_keyboard(language: str = DEFAULT_LANGUAGE, subscription_end_
    
    return InlineKeyboardMarkup(inline_keyboard=buttons)
    
-def get_change_devices_keyboard(current_devices: int, language: str = DEFAULT_LANGUAGE, subscription_end_date: datetime = None) -> InlineKeyboardMarkup:
+def get_change_devices_keyboard(
+    current_devices: int,
+    language: str = DEFAULT_LANGUAGE,
+    subscription_end_date: datetime = None,
+    discount_percent: int = 0,
+) -> InlineKeyboardMarkup:
    from app.utils.pricing_utils import get_remaining_months
    from app.config import settings
    texts = get_texts(language)
@@ -1026,8 +1291,17 @@ def get_change_devices_keyboard(current_devices: int, language: str = DEFAULT_LA
            
            if chargeable_devices > 0:
                price_per_month = chargeable_devices * device_price_per_month
-                total_price = price_per_month * months_multiplier
+                discounted_per_month, discount_per_month = apply_percentage_discount(
+                    price_per_month,
+                    discount_percent,
+                )
+                total_price = discounted_per_month * months_multiplier
                price_text = f" (+{total_price//100}₽{period_text})"
+                if discount_percent > 0 and discount_per_month * months_multiplier > 0:
+                    price_text += (
+                        f" (скидка {discount_percent}%:"
+                        f" -{(discount_per_month * months_multiplier)//100}₽)"
+                    )
                action_text = ""
            else:
                price_text = " (бесплатно)"
@@ -1104,7 +1378,8 @@ def get_manage_countries_keyboard(
    selected: List[str],
    current_subscription_countries: List[str],
    language: str = DEFAULT_LANGUAGE,
-    subscription_end_date: datetime = None
+    subscription_end_date: datetime = None,
+    discount_percent: int = 0,
 ) -> InlineKeyboardMarkup:
    from app.utils.pricing_utils import get_remaining_months

@@ -1119,10 +1394,18 @@ def get_manage_countries_keyboard(
    total_cost = 0
    
    for country in countries:
+        if not country.get('is_available', True):
+            continue
+
        uuid = country['uuid']
        name = country['name']
        price_per_month = country['price_kopeks']
-        
+
+        discounted_per_month, discount_per_month = apply_percentage_discount(
+            price_per_month,
+            discount_percent,
+        )
+
        if uuid in current_subscription_countries:
            if uuid in selected:
                icon = "✅"
@@ -1131,17 +1414,31 @@ def get_manage_countries_keyboard(
        else:
            if uuid in selected:
                icon = "➕"
-                total_cost += price_per_month * months_multiplier
+                total_cost += discounted_per_month * months_multiplier
            else:
                icon = "⚪"
-        
+
        if uuid not in current_subscription_countries and uuid in selected:
-            total_price = price_per_month * months_multiplier
+            total_price = discounted_per_month * months_multiplier
            if months_multiplier > 1:
-                price_text = f" ({price_per_month//100}₽/мес × {months_multiplier} = {total_price//100}₽)"
-                logger.info(f"🔍 Сервер {name}: {price_per_month/100}₽/мес × {months_multiplier} мес = {total_price/100}₽")
+                price_text = (
+                    f" ({discounted_per_month//100}₽/мес × {months_multiplier} = {total_price//100}₽)"
+                )
+                logger.info(
+                    "🔍 Сервер %s: %.2f₽/мес × %s мес = %.2f₽ (скидка %.2f₽)",
+                    name,
+                    discounted_per_month / 100,
+                    months_multiplier,
+                    total_price / 100,
+                    (discount_per_month * months_multiplier) / 100,
+                )
            else:
                price_text = f" ({total_price//100}₽)"
+            if discount_percent > 0 and discount_per_month * months_multiplier > 0:
+                price_text += (
+                    f" (скидка {discount_percent}%:"
+                    f" -{(discount_per_month * months_multiplier)//100}₽)"
+                )
            display_name = f"{icon} {name}{price_text}"
        else:
            display_name = f"{icon} {name}"
@@ -1226,9 +1523,18 @@ def get_connection_guide_keyboard(
        if app_buttons:
            keyboard.append(app_buttons)
    
-    keyboard.append([
-        InlineKeyboardButton(text=texts.t("COPY_SUBSCRIPTION_LINK", "📋 Скопировать ссылку подписки"), url=subscription_url)
-    ])
+    if settings.is_happ_cryptolink_mode():
+        copy_button = InlineKeyboardButton(
+            text=texts.t("COPY_SUBSCRIPTION_LINK", "📋 Скопировать ссылку подписки"),
+            callback_data="open_subscription_link",
+        )
+    else:
+        copy_button = InlineKeyboardButton(
+            text=texts.t("COPY_SUBSCRIPTION_LINK", "📋 Скопировать ссылку подписки"),
+            url=subscription_url,
+        )
+
+    keyboard.append([copy_button])
    
    keyboard.extend([
        [
@@ -1299,9 +1605,18 @@ def get_specific_app_keyboard(
        if app_buttons:
            keyboard.append(app_buttons)
    
-    keyboard.append([
-        InlineKeyboardButton(text=texts.t("COPY_SUBSCRIPTION_LINK", "📋 Скопировать ссылку подписки"), url=subscription_url)
-    ])
+    if settings.is_happ_cryptolink_mode():
+        copy_button = InlineKeyboardButton(
+            text=texts.t("COPY_SUBSCRIPTION_LINK", "📋 Скопировать ссылку подписки"),
+            callback_data="open_subscription_link",
+        )
+    else:
+        copy_button = InlineKeyboardButton(
+            text=texts.t("COPY_SUBSCRIPTION_LINK", "📋 Скопировать ссылку подписки"),
+            url=subscription_url,
+        )
+
+    keyboard.append([copy_button])
    
    if 'additionalAfterAddSubscriptionStep' in app and 'buttons' in app['additionalAfterAddSubscriptionStep']:
        for button in app['additionalAfterAddSubscriptionStep']['buttons']:
@@ -1542,7 +1857,8 @@ def get_my_tickets_keyboard(
    tickets: List[dict],
    current_page: int = 1,
    total_pages: int = 1,
-    language: str = DEFAULT_LANGUAGE
+    language: str = DEFAULT_LANGUAGE,
+    page_prefix: str = "my_tickets_page_"
 ) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
@@ -1570,7 +1886,7 @@ def get_my_tickets_keyboard(
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_PREV", "⬅️"),
-                    callback_data=f"my_tickets_page_{current_page - 1}"
+                    callback_data=f"{page_prefix}{current_page - 1}"
                )
            )
        
@@ -1585,7 +1901,7 @@ def get_my_tickets_keyboard(
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_NEXT", "➡️"),
-                    callback_data=f"my_tickets_page_{current_page + 1}"
+                    callback_data=f"{page_prefix}{current_page + 1}"
                )
            )
        
@@ -1648,7 +1964,9 @@ def get_admin_tickets_keyboard(
    current_page: int = 1,
    total_pages: int = 1,
    language: str = DEFAULT_LANGUAGE,
-    scope: str = "all"
+    scope: str = "all",
+    *,
+    back_callback: str = "admin_submenu_support"
 ) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
@@ -1660,10 +1978,22 @@ def get_admin_tickets_keyboard(
        status_emoji = ticket.get('status_emoji', '❓')
        if ticket.get('is_closed', False):
            status_emoji = '✅'
-        user_name = ticket.get('user_name', 'Unknown')[:15]
+        user_name = ticket.get('user_name', 'Unknown')
+        username = ticket.get('username')
+        telegram_id = ticket.get('telegram_id')
+        # Сформируем компактное отображение: Имя (@username | ID)
+        name_parts = [user_name[:15]]
+        contact_parts = []
+        if username:
+            contact_parts.append(f"@{username}")
+        if telegram_id:
+            contact_parts.append(str(telegram_id))
+        if contact_parts:
+            name_parts.append(f"({' | '.join(contact_parts)})")
+        name_display = ' '.join(name_parts)
        title = ticket.get('title', 'Без названия')[:20]
        locked_emoji = ticket.get('locked_emoji', '')
-        button_text = f"{status_emoji} #{ticket['id']} {locked_emoji} {user_name}: {title}".replace("  ", " ")
+        button_text = f"{status_emoji} #{ticket['id']} {locked_emoji} {name_display}: {title}".replace("  ", " ")
        row = [InlineKeyboardButton(text=button_text, callback_data=f"admin_view_ticket_{ticket['id']}")]
        if ticket.get('is_closed', False):
            closed_rows.append(row)
@@ -1713,7 +2043,7 @@ def get_admin_tickets_keyboard(
        keyboard.append(nav_row)
    
    keyboard.append([
-        InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_communications")
+        InlineKeyboardButton(text=texts.BACK, callback_data=back_callback)
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)
@@ -1722,7 +2052,9 @@ def get_admin_tickets_keyboard(
 def get_admin_ticket_view_keyboard(
    ticket_id: int,
    is_closed: bool = False,
-    language: str = DEFAULT_LANGUAGE
+    language: str = DEFAULT_LANGUAGE,
+    *,
+    is_user_blocked: bool = False
 ) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
@@ -1743,14 +2075,16 @@ def get_admin_ticket_view_keyboard(
            )
        ])
    
-    # Block controls: first row Unblock + Block forever, second row Block by time
-    keyboard.append([
-        InlineKeyboardButton(text=texts.t("UNBLOCK", "✅ Разблокировать"), callback_data=f"admin_unblock_user_ticket_{ticket_id}"),
-        InlineKeyboardButton(text=texts.t("BLOCK_FOREVER", "🚫 Блок навсегда"), callback_data=f"admin_block_user_perm_ticket_{ticket_id}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton(text=texts.t("BLOCK_BY_TIME", "⏳ Блокировка по времени"), callback_data=f"admin_block_user_ticket_{ticket_id}")
-    ])
+    # Блок-контролы: когда не заблокирован — показать два варианта, когда заблокирован — только "Разблокировать"
+    if is_user_blocked:
+        keyboard.append([
+            InlineKeyboardButton(text=texts.t("UNBLOCK", "✅ Разблокировать"), callback_data=f"admin_unblock_user_ticket_{ticket_id}")
+        ])
+    else:
+        keyboard.append([
+            InlineKeyboardButton(text=texts.t("BLOCK_FOREVER", "🚫 Заблокировать"), callback_data=f"admin_block_user_perm_ticket_{ticket_id}"),
+            InlineKeyboardButton(text=texts.t("BLOCK_BY_TIME", "⏳ Блок по времени"), callback_data=f"admin_block_user_ticket_{ticket_id}")
+        ])
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="admin_tickets")
@@ -1,24 +1,56 @@
 {
  "ADD_COUNTRIES_BUTTON": "🌐 Add countries",
+  "COUNTRY_MANAGEMENT_UNAVAILABLE": "ℹ️ Server management is unavailable — only one server is accessible",
+  "COUNTRY_MANAGEMENT_PROMPT": "🌍 <b>Manage subscription countries</b>\n\n📋 <b>Current countries ({current_count}):</b>\n{current_list}\n\n💡 <b>How it works:</b>\n✅ — currently connected\n➕ — will be added (paid)\n➖ — will be removed (free)\n⚪ — not selected\n\n⚠️ <b>Important:</b> Reconnecting removed countries will be charged again!",
+  "COUNTRY_MANAGEMENT_NONE": "No countries connected",
+  "PAID_FEATURE_ONLY": "⚠ This feature is available only for paid subscriptions",
+  "PAID_FEATURE_ONLY_SHORT": "⚠ Paid subscriptions only",
+  "COUNTRY_NOT_AVAILABLE_PROMOGROUP": "❌ This server is not available for your promo group",
+  "COUNTRY_CHANGES_NOT_FOUND": "⚠️ No changes detected",
+  "COUNTRY_CHANGES_SUCCESS_HEADER": "✅ <b>Countries updated!</b>\n\n",
+  "COUNTRY_CHANGES_ADDED_HEADER": "➕ <b>Added countries:</b>\n",
+  "COUNTRY_CHANGES_CHARGED": "💰 Charged: {amount} (for {months} mo)",
+  "COUNTRY_CHANGES_DISCOUNT_INFO": " (discount {percent}%: -{amount})",
+  "COUNTRY_CHANGES_REMOVED_HEADER": "➖ <b>Removed countries:</b>\n",
+  "COUNTRY_CHANGES_REMOVED_WARNING": "ℹ️ Reconnecting later will be charged",
+  "COUNTRY_CHANGES_ACTIVE_COUNT": "🌐 <b>Active countries:</b> {count}",
  "ADMIN_MAIN_MENU": "🏠 Main menu",
  "ADMIN_CAMPAIGNS": "📣 Promotional campaigns",
  "AUTOPAY_BUTTON": "💳 Auto payment",
  "AUTOPAY_SET_DAYS_BUTTON": "⚙️ Configure days",
+  "AUTOPAY_STATUS_ENABLED": "enabled",
+  "AUTOPAY_STATUS_DISABLED": "disabled",
+  "AUTOPAY_MENU_TEXT": "💳 <b>Auto payment</b>\n\n📊 <b>Status:</b> {status}\n⏰ <b>Charge:</b> {days} days before expiry\n\nChoose an action:",
+  "AUTOPAY_TOGGLE_SUCCESS": "✅ Autopay {status}!",
+  "AUTOPAY_SELECT_DAYS_PROMPT": "⏰ Choose how many days before expiry to charge the payment:",
+  "AUTOPAY_DAYS_SET": "✅ Set to {days} days!",
  "BACK": "⬅️ Back",
  "BACK_TO_SUBSCRIPTION": "⬅️ Back to subscription",
  "BALANCE_BUTTON_DEFAULT": "💰 Balance: {balance}",
  "CANCEL": "❌ Cancel",
  "CHANGE_DEVICES_BUTTON": "📱 Change devices",
+  "CHANGE_DEVICES_PROMPT": "📱 <b>Adjust device limit</b>\n\nCurrent limit: {current_devices} devices\nChoose the new number of devices:\n\n💡 <b>Important:</b>\n• Increasing — extra cost prorated by remaining time\n• Decreasing — payments are not refunded",
  "CHANNEL_CHECK_BUTTON": "✅ I have joined",
  "CHANNEL_REQUIRED_TEXT": "🔒 Please join the announcement channel to access the bot, then press the button below.",
  "CHANNEL_SUBSCRIBE_BUTTON": "🔗 Subscribe",
  "CHANNEL_SUBSCRIBE_REQUIRED_ALERT": "❌ You haven't joined the channel!",
  "CHANNEL_SUBSCRIBE_THANKS": "✅ Thanks for subscribing",
+  "TRIAL_CHANNEL_UNSUBSCRIBED": "\n🚫 <b>Access paused</b>\n\nWe couldn't find your subscription to our channel, so the trial plan has been disabled.\n\nJoin the channel and tap “{check_button}” to restore access.",
  "CHECK_STATUS_BUTTON": "📊 Check status",
  "CHOOSE_ANOTHER_DEVICE": "📱 Choose another device",
  "CONFIRM": "✅ Confirm",
  "CONFIRM_CHANGE_BUTTON": "✅ Confirm change",
  "CONNECT_BUTTON": "🔗 Connect",
+  "HAPP_DOWNLOAD_BUTTON": "⬇️ Download Happ",
+  "HAPP_DOWNLOAD_PROMPT": "📥 <b>Download Happ</b>\nChoose your device:",
+  "HAPP_PLATFORM_IOS": "🍎 iOS",
+  "HAPP_PLATFORM_ANDROID": "🤖 Android",
+  "HAPP_PLATFORM_MACOS": "🖥️ Mac OS",
+  "HAPP_PLATFORM_WINDOWS": "💻 Windows",
+  "HAPP_PLATFORM_PC": "💻 PC",
+  "HAPP_DOWNLOAD_LINK_MESSAGE": "⬇️ Download Happ for {platform}:",
+  "HAPP_DOWNLOAD_LINK_NOT_SET": "❌ Download link for this device is not configured",
+  "HAPP_DOWNLOAD_OPEN_LINK": "🔗 Open link",
  "CONTINUE": "➡️ Continue",
  "CONTINUE_BUTTON": "➡️ Continue",
  "COPY_SUBSCRIPTION_LINK": "📋 Copy subscription link",
@@ -37,12 +69,34 @@
  "GO_TO_BALANCE_TOP_UP": "💳 Go to balance top up",
  "RETURN_TO_SUBSCRIPTION_CHECKOUT": "⬅️ Return to subscription checkout",
  "INSUFFICIENT_BALANCE": "❌ Insufficient balance.\n\nTop up {amount} and try again.",
+  "ADDON_INSUFFICIENT_FUNDS_MESSAGE": "⚠️ <b>Insufficient funds</b>\n\nService price: {required}\nBalance: {balance}\nMissing: {missing}\n\nChoose a top-up method. The amount will be filled in automatically.",
+  "LANGUAGE_PROMPT": "🌐 Choose the interface language:",
  "LANGUAGE_SELECTED": "🌐 Interface language set: <b>English</b>",
  "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_BUTTON": "🏠 Main menu",
  "MANAGE_DEVICES_BUTTON": "🔧 Manage devices",
+  "DEVICE_UUID_NOT_FOUND": "❌ User UUID not found",
+  "DEVICE_NONE_CONNECTED": "ℹ️ You have no connected devices",
+  "DEVICE_FETCH_INFO_ERROR": "❌ Failed to load device information",
+  "DEVICE_MANAGEMENT_OVERVIEW": "🔄 <b>Device management</b>\n\n📊 Total connected: {total} devices\n📄 Page {page} of {pages}\n\n",
+  "DEVICE_MANAGEMENT_CONNECTED_HEADER": "<b>Connected devices:</b>\n",
+  "DEVICE_MANAGEMENT_LIST_ITEM": "• {device}\n",
+  "DEVICE_MANAGEMENT_ACTIONS": "\n💡 <b>Actions:</b>\n• Select a device to reset\n• Or reset all devices at once",
+  "DEVICE_FETCH_ERROR": "❌ Failed to load devices",
+  "DEVICE_PAGE_LOAD_ERROR": "❌ Failed to open the page",
+  "DEVICE_RESET_INVALID_REQUEST": "❌ Error: invalid request",
+  "DEVICE_RESET_PARSE_ERROR": "❌ Failed to process the request",
+  "DEVICE_RESET_SUCCESS": "✅ Device {device} has been reset!",
+  "DEVICE_RESET_ALL_DONE": "ℹ️ All devices have been reset",
+  "DEVICE_RESET_ID_FAILED": "❌ Unable to get device ID",
+  "DEVICE_RESET_NOT_FOUND": "❌ Device not found",
+  "DEVICE_RESET_ERROR": "❌ Failed to reset the device",
+  "DEVICE_LIST_FETCH_ERROR": "❌ Failed to load device list",
+  "DEVICE_RESET_ALL_SUCCESS_MESSAGE": "✅ <b>All devices have been reset!</b>\n\n🔄 Reset: {count} devices\n📱 You can now reconnect your devices\n\n💡 Use the link from the 'My subscription' section to reconnect",
+  "DEVICE_RESET_PARTIAL_MESSAGE": "⚠️ <b>Devices reset partially</b>\n\n✅ Removed: {success} devices\n❌ Failed to remove: {failed} devices\n\nTry again or contact support.",
+  "DEVICE_RESET_ALL_FAILED_MESSAGE": "❌ <b>Couldn't reset devices</b>\n\nPlease try again later or contact support.\n\nTotal devices: {total}",
  "MENU_BALANCE": "💰 Balance",
  "MENU_SUBSCRIPTION": "📱 Subscription",
  "MENU_TRIAL": "🎁 Trial subscription",
@@ -85,6 +139,9 @@
  "SHOW_SUBSCRIPTION_LINK": "📋 Show subscription link",
  "SKIP_BUTTON": "Skip ➡️",
  "SUBSCRIPTION_SETTINGS_BUTTON": "⚙️ Subscription settings",
+  "SUBSCRIPTION_SETTINGS_PAID_ONLY": "⚠️ Settings are available only for paid subscriptions",
+  "SUBSCRIPTION_SETTINGS_OVERVIEW": "⚙️ <b>Subscription settings</b>\n\n📊 <b>Current parameters:</b>\n🌐 Countries: {countries_count}\n📈 Traffic: {traffic_used} / {traffic_limit}\n📱 Devices: {devices_used} / {devices_limit}\n\nChoose what you want to change:",
+  "SUBSCRIPTION_ACTIVE_REQUIRED": "⚠️ You don't have an active subscription!",
  "SUB_STATUS_ACTIVE_FEW_DAYS": "💎 Active\n⚠️ expires in {days} days",
  "SUB_STATUS_ACTIVE_LONG": "💎 Active\n📅 until {end_date} ({days} days)",
  "SUB_STATUS_ACTIVE_TODAY": "💎 Active\n⚠️ expires today!",
@@ -126,7 +183,16 @@
  "ADMIN_PROMO_GROUPS": "💳 Promo groups",
  "ADMIN_PROMO_GROUPS_TITLE": "💳 <b>Promo groups</b>",
  "ADMIN_PROMO_GROUPS_SUMMARY": "Groups total: {count}\nMembers total: {members}",
-  "ADMIN_PROMO_GROUPS_DISCOUNTS": "Discounts — servers: {servers}%, traffic: {traffic}%, devices: {devices}%",
+  "ADMIN_PROMO_GROUP_DISCOUNTS_HEADER": "💸 Promo group discounts:",
+  "ADMIN_PROMO_GROUP_DISCOUNT_LINE_SERVERS": "• Servers: {percent}%",
+  "ADMIN_PROMO_GROUP_DISCOUNT_LINE_TRAFFIC": "• Traffic: {percent}%",
+  "ADMIN_PROMO_GROUP_DISCOUNT_LINE_DEVICES": "• Devices: {percent}%",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_ENABLED": "🧩 Add-on discounts: <b>enabled</b>",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_DISABLED": "🧩 Add-on discounts: <b>disabled</b>",
+  "ADMIN_PROMO_GROUP_TOGGLE_ADDON_DISCOUNT_ENABLE": "🧩 Enable add-on discounts",
+  "ADMIN_PROMO_GROUP_TOGGLE_ADDON_DISCOUNT_DISABLE": "🧩 Disable add-on discounts",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_UPDATED_ENABLED": "🧩 Add-on purchase discounts are <b>enabled</b>.",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_UPDATED_DISABLED": "🧩 Add-on purchase discounts are <b>disabled</b>.",
  "ADMIN_PROMO_GROUPS_DEFAULT_LABEL": " (default)",
  "ADMIN_PROMO_GROUPS_MEMBERS_COUNT": "Members: {count}",
  "ADMIN_PROMO_GROUPS_EMPTY": "No promo groups found.",
@@ -141,6 +207,22 @@
  "ADMIN_USER_PROMO_GROUP_ALREADY": "ℹ️ The user is already in this promo group.",
  "ADMIN_USER_PROMO_GROUP_ERROR": "❌ Failed to update the user's promo group.",
  "ADMIN_USER_PROMO_GROUP_BACK": "⬅️ Back to user",
+  "ADMIN_USER_MANAGEMENT_PROFILE": "👤 <b>User management</b>\n\n<b>Main information:</b>\n• Name: {name}\n• ID: <code>{telegram_id}</code>\n• Username: {username}\n• Status: {status}\n• Language: {language}\n\n<b>Finances:</b>\n• Balance: {balance}\n• Transactions: {transactions}\n\n<b>Activity:</b>\n• Registration: {registration}\n• Last activity: {last_activity}\n• Days since registration: {registration_days}",
+  "ADMIN_USER_USERNAME_NOT_SET": "not set",
+  "ADMIN_USER_STATUS_ACTIVE": "✅ Active",
+  "ADMIN_USER_STATUS_BLOCKED": "🚫 Blocked",
+  "ADMIN_USER_STATUS_DELETED": "🗑️ Deleted",
+  "ADMIN_USER_STATUS_UNKNOWN": "❓ Unknown",
+  "ADMIN_USER_LAST_ACTIVITY_UNKNOWN": "Unknown",
+  "ADMIN_USER_SUBSCRIPTION_TYPE_TRIAL": "🎁 Trial",
+  "ADMIN_USER_SUBSCRIPTION_TYPE_PAID": "💎 Paid",
+  "ADMIN_USER_SUBSCRIPTION_STATUS_ACTIVE": "✅ Active",
+  "ADMIN_USER_SUBSCRIPTION_STATUS_INACTIVE": "❌ Inactive",
+  "ADMIN_USER_TRAFFIC_USAGE": "{used}/{limit} GB",
+  "ADMIN_USER_MANAGEMENT_SUBSCRIPTION": "<b>Subscription:</b>\n• Type: {type}\n• Status: {status}\n• Until: {end_date}\n• Traffic: {traffic}\n• Devices: {devices}\n• Countries: {countries}",
+  "ADMIN_USER_MANAGEMENT_SUBSCRIPTION_NONE": "<b>Subscription:</b> None",
+  "ADMIN_USER_MANAGEMENT_PROMO_GROUP": "<b>Promo group:</b>\n• Name: {name}\n• Server discount: {server_discount}%\n• Traffic discount: {traffic_discount}%\n• Device discount: {device_discount}%",
+  "ADMIN_USER_MANAGEMENT_PROMO_GROUP_NONE": "<b>Promo group:</b> Not assigned",
  "ADMIN_PROMO_GROUP_DETAILS_TITLE": "💳 <b>Promo group:</b> {name}",
  "ADMIN_PROMO_GROUP_DETAILS_MEMBERS": "Members: {count}",
  "ADMIN_PROMO_GROUP_DETAILS_DEFAULT": "This is the default group.",
@@ -198,6 +280,19 @@
  "DEVICES_LIMIT_EXCEEDED": "⚠️ Maximum device limit exceeded ({limit})",
  "DEVICES_MINIMUM_LIMIT": "⚠️ Minimum number of devices: {limit}",
  "DEVICES_NO_CHANGE": "ℹ️ Device limit was not changed",
+  "PAYMENT_CHARGE_ERROR": "⚠️ Failed to charge the payment",
+  "DEVICE_CHANGE_ACTION_INCREASE": "increase to {count}",
+  "DEVICE_CHANGE_EXTRA_COST": "Extra payment: {amount} (for {months} mo)",
+  "DEVICE_CHANGE_DISCOUNT_INFO": " (discount {percent}%: -{amount})",
+  "DEVICE_CHANGE_FREE": "Free",
+  "DEVICE_CHANGE_ACTION_DECREASE": "decrease to {count}",
+  "DEVICE_CHANGE_NO_REFUND": "Payments are not refunded",
+  "DEVICE_CHANGE_CONFIRMATION": "📱 <b>Confirm change</b>\n\nCurrent amount: {current} devices\nNew amount: {new} devices\n\nAction: {action}\n💰 {cost}\n\nApply this change?",
+  "DEVICE_CHANGE_INCREASE_SUCCESS": "✅ Device limit increased!\n\n",
+  "DEVICE_CHANGE_RESULT_LINE": "📱 Was: {old} → Now: {new}\n",
+  "DEVICE_CHANGE_CHARGED": "💰 Charged: {amount}",
+  "DEVICE_CHANGE_DECREASE_SUCCESS": "✅ Device limit decreased!\n\n",
+  "DEVICE_CHANGE_NO_REFUND_INFO": "ℹ️ Payments are not refunded",
  "INVALID_AMOUNT": "❌ Invalid amount",
  "MAINTENANCE_MODE_ACTIVE": "\n🔧 Maintenance in progress!\n\nThe service is temporarily unavailable while we improve performance.\n\n⏰ Estimated completion time: unknown\n🔄 Please try again later\n\nWe apologize for the inconvenience.\n",
  "MAINTENANCE_MODE_API_ERROR": "\n🔧 Maintenance in progress!\n\nThe service is temporarily unavailable due to connection issues with the servers.\n\n⏰ We're working on it. Please try again in a few minutes.\n\n🔄 Last check: {last_check}\n",
@@ -278,6 +373,9 @@
  "TRIAL_ALREADY_USED": "❌ The trial subscription has already been used",
  "TRIAL_AVAILABLE": "\n🎁 <b>Trial subscription</b>\n\nYou can get a free trial plan:\n\n⏰ <b>Duration:</b> {days} days\n📈 <b>Traffic:</b> {traffic} GB\n📱 <b>Devices:</b> {devices} pcs\n🌍 <b>Server:</b> {server_name}\n\nActivate the trial subscription?\n",
  "TRIAL_ENDING_SOON": "\n🎁 <b>The trial subscription is ending soon!</b>\n\nYour trial expires in a few hours.\n\n💎 <b>Don't want to lose VPN access?</b>\nSwitch to the full subscription!\n\n🔥 <b>Special offer:</b>\n• 30 days for {price}\n• Unlimited traffic\n• All servers available\n• Speeds up to 1 Gbit/s\n\n⚡️ Activate before the trial ends!\n",
+  "TRAFFIC_FIXED_MODE": "⚠️ Traffic is fixed in the current mode and cannot be changed",
+  "TRAFFIC_ALREADY_UNLIMITED": "⚠ You already have unlimited traffic",
+  "ADD_TRAFFIC_PROMPT": "📈 <b>Add traffic to your subscription</b>\n\nCurrent limit: {current_traffic}\nChoose extra traffic:",
  "USER_NOT_FOUND": "❌ User not found",
  "MENU_LANGUAGE": "🌐 Language",
  "SUBSCRIPTION_STATUS_EXPIRED": "Expired",
@@ -310,7 +408,9 @@
  "SUBSCRIPTION_CONNECT_MINIAPP_MESSAGE": "📱 <b>Connect subscription</b>\n\n🚀 Tap the button below to open the subscription in the Telegram mini app:",
  "SUBSCRIPTION_CONNECT_CUSTOM_MESSAGE": "🚀 <b>Connect subscription</b>\n\n📱 Tap the button below to open the app:",
  "SUBSCRIPTION_CONNECT_LINK_MESSAGE": "🚀 <b>Connect subscription</b>\n\n🔗 Tap the button below to open the subscription link:",
+  "SUBSCRIPTION_LINK_HIDDEN_NOTICE": "ℹ️ The subscription link is available via the buttons below or in the “My subscription” section.",
  "SUBSCRIPTION_CONNECT_DEVICE_MESSAGE": "📱 <b>Connect subscription</b>\n\n🔗 <b>Subscription link:</b>\n<code>{subscription_url}</code>\n\n💡 <b>Choose your device</b> to get detailed setup instructions:",
+  "SUBSCRIPTION_CONNECT_DEVICE_MESSAGE_HIDDEN": "📱 <b>Connect subscription</b>\n\nℹ️ The subscription link is available via the buttons below or in the “My subscription” section.\n\n💡 <b>Choose your device</b> to get detailed setup instructions:",
  "SUBSCRIPTION_LINK_UNAVAILABLE": "❌ Subscription link is unavailable",
  "SUBSCRIPTION_DEVICE_APPS_NOT_FOUND": "❌ No apps found for this device",
  "SUBSCRIPTION_DEVICE_GUIDE_TITLE": "📱 <b>Setup for {device_name}</b>",
@@ -392,6 +492,7 @@
  "PAYMENT_METHODS_TITLE": "💳 <b>Balance top-up methods</b>",
  "PAYMENT_METHODS_PROMPT": "Choose the payment method that suits you:",
  "PAYMENT_METHODS_FOOTER": "Choose a top-up method:",
+  "PAYMENT_RETURN_HOME_BUTTON": "🏠 Main menu",
  "PAYMENT_METHOD_STARS_NAME": "⭐ <b>Telegram Stars</b>",
  "PAYMENT_METHOD_STARS_DESCRIPTION": "fast and convenient",
  "PAYMENT_METHOD_YOOKASSA_NAME": "💳 <b>Bank card</b>",
@@ -402,5 +503,200 @@
  "PAYMENT_METHOD_CRYPTOBOT_DESCRIPTION": "via CryptoBot",
  "PAYMENT_METHOD_SUPPORT_NAME": "🛠️ <b>Support team</b>",
  "PAYMENT_METHOD_SUPPORT_DESCRIPTION": "other options",
-  "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ Automated payment methods are temporarily unavailable. Contact support to top up your balance."
+  "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ Automated payment methods are temporarily unavailable. Contact support to top up your balance.",
+  "ADMIN_MONITORING_SETTINGS": "⚙️ Monitoring settings",
+  "ADMIN_PROMO_GROUP_AUTO_ASSIGN_DISABLED": "Auto assignment by total spending: disabled",
+  "ADMIN_PROMO_GROUP_AUTO_ASSIGN_LINE": "Auto assignment by total spending from {amount} ₽",
+  "ADMIN_PROMO_GROUP_CREATE_AUTO_ASSIGN_PROMPT": "Enter total spending (in ₽) required for automatic assignment. Send 0 to disable.",
+  "ADMIN_PROMO_GROUP_CREATE_PERIOD_PROMPT": "Enter subscription period discounts (e.g. 30:10, 90:15). Send 0 if none.",
+  "ADMIN_PROMO_GROUP_EDIT_AUTO_ASSIGN_PROMPT": "Enter total spending (in ₽) for auto assignment. Current value: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_AUTO_ASSIGN": "🤖 Auto assignment by spending",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_DEVICES": "📱 Device discount",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_NAME": "✏️ Rename",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_PERIODS": "⏳ Period discounts",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_SERVERS": "🖥 Server discount",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_TRAFFIC": "🌐 Traffic discount",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_HINT": "Select a parameter to change:",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_TITLE": "✏️ Promo group settings “{name}”",
+  "ADMIN_PROMO_GROUP_EDIT_PERIOD_PROMPT": "Enter new period discounts (current: {current}). Send 0 if none.",
+  "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_REPORTS": "📊 Reports",
+  "ADMIN_TICKETS_TITLE": "🎫 All support tickets:",
+  "ADMIN_TICKETS_TITLE_CLOSED": "🎫 Closed support tickets:",
+  "ADMIN_TICKETS_TITLE_OPEN": "🎫 Open support tickets:",
+  "ADMIN_TICKET_REPLY_INPUT": "Enter support reply:",
+  "ADMIN_TICKET_REPLY_SENT": "✅ Reply sent!",
+  "ATTACHMENTS_SENT": "✅ Attachments sent.",
+  "BACK_TO_MENU": "🏠 Back to menu",
+  "BACK_TO_OPEN_TICKETS": "🔴 Open tickets",
+  "BACK_TO_SUPPORT": "⬅️ Back to support",
+  "BACK_TO_TICKETS": "⬅️ Back to tickets",
+  "BALANCE_TOPUP": "💳 Top up balance",
+  "BLOCK_BY_TIME": "⏳ Temporary block",
+  "BLOCK_FOREVER": "🚫 Block permanently",
+  "CAMPAIGN_EXISTING_USERL": "ℹ️ This promotional link is available to new users only.",
+  "CANCEL_REPLY": "❌ Cancel reply",
+  "CANCEL_TICKET_CREATION": "❌ Cancel ticket creation",
+  "CLOSED_TICKETS": "🟢 Closed",
+  "CLOSED_TICKETS_HEADER": "🟢 Closed tickets",
+  "CLOSED_TICKETS_TITLE": "🟢 Closed tickets:",
+  "CLOSE_NOTIFICATION": "❌ Close notification",
+  "CLOSE_TICKET": "🔒 Close ticket",
+  "CONTACT_SUPPORT_BUTTON": "💬 Contact support",
+  "CREATE_TICKET_BUTTON": "🎫 Create ticket",
+  "DELETE_MESSAGE": "🗑 Delete",
+  "DISCOUNT_BONUS_DESCRIPTION": "Renewal discount bonus",
+  "DISCOUNT_CLAIM_ALREADY": "ℹ️ This discount has already been activated.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Failed to credit the discount. Please try again later.",
+  "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.",
+  "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",
+  "MULENPAY_PAYMENT_ERROR": "❌ Failed to create Mulen Pay payment. Please try again later or contact support.",
+  "MULENPAY_PAYMENT_INSTRUCTIONS": "💳 <b>Mulen Pay payment</b>\n\n💰 Amount: {amount}\n🆔 Payment ID: {payment_id}\n\n📱 <b>How to pay:</b>\n1. Press ‘Pay with Mulen Pay’\n2. Follow the instructions on the payment page\n3. Confirm the transfer\n4. Funds will be credited automatically\n\n❓ Need help? Contact {support}",
+  "MULENPAY_PAY_BUTTON": "💳 Pay with Mulen Pay",
+  "MULENPAY_TOPUP_PROMPT": "💳 <b>Mulen Pay payment</b>\n\nEnter an amount between 100 and 100,000 ₽.\nThe payment is processed by the secure Mulen Pay platform.",
+  "MY_TICKETS_BUTTON": "📋 My tickets",
+  "MY_TICKETS_TITLE": "📋 Your tickets:",
+  "NOTIFICATION_CLOSED": "Notification closed.",
+  "NOTIFICATION_VALUE_INVALID": "❌ Invalid value, please enter a number.",
+  "NOTIFICATION_VALUE_UPDATED": "✅ Settings updated.",
+  "NOTIFY_PROMPT_SECOND_HOURS": "Enter the number of hours the discount is active (1-168):",
+  "NOTIFY_PROMPT_SECOND_PERCENT": "Enter a new discount percentage for the 2-3 day reminder (0-100):",
+  "NOTIFY_PROMPT_THIRD_DAYS": "After how many days without a subscription should we send the offer? (minimum 2):",
+  "NOTIFY_PROMPT_THIRD_HOURS": "Enter the number of hours the late discount is active (1-168):",
+  "NOTIFY_PROMPT_THIRD_PERCENT": "Enter a new discount percentage for the late offer (0-100):",
+  "NO_ATTACHMENTS": "No attachments.",
+  "NO_CLOSED_TICKETS": "There are no closed tickets yet.",
+  "NO_TICKETS": "You don't have any tickets yet.",
+  "NO_TICKETS_ADMIN": "No tickets to display.",
+  "OPEN_TICKETS": "🔴 Open",
+  "OPEN_TICKETS_HEADER": "🔴 Open tickets",
+  "PAL24_PAYMENT_ERROR": "❌ Failed to create a PayPalych payment. Please try again later or contact support.",
+  "PAL24_PAYMENT_INSTRUCTIONS": "🏦 <b>PayPalych (SBP) payment</b>\n\n💰 Amount: {amount}\n🆔 Invoice ID: {bill_id}\n\n📱 <b>How to pay:</b>\n1. Press ‘Pay with PayPalych (SBP)’\n2. Follow the system prompts\n3. Confirm the transfer\n4. Funds will be credited automatically\n\n❓ Need help? Contact {support}",
+  "PAL24_PAY_BUTTON": "🏦 Pay with PayPalych (SBP)",
+  "PAL24_TOPUP_PROMPT": "🏦 <b>PayPalych (SBP) payment</b>\n\nEnter an amount between 100 and 1,000,000 ₽.\nThe payment is processed via the PayPalych Faster Payments System.",
+  "PAYMENT_CARD_MULENPAY": "💳 Bank card (Mulen Pay)",
+  "PAYMENT_CARD_PAL24": "🏦 SBP (PayPalych)",
+  "PAYMENT_METHOD_MULENPAY_DESCRIPTION": "via Mulen Pay",
+  "PAYMENT_METHOD_MULENPAY_NAME": "💳 <b>Bank card (Mulen Pay)</b>",
+  "PAYMENT_METHOD_PAL24_DESCRIPTION": "via Faster Payments System",
+  "PAYMENT_METHOD_PAL24_NAME": "🏦 <b>SBP (PayPalych)</b>",
+  "REPLY_TO_TICKET": "💬 Reply",
+  "REPORT_CLOSE": "❌ Close",
+  "REPORT_CLOSED": "✅ Report closed.",
+  "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_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.",
+  "SUBSCRIPTION_HAPP_OPEN_BUTTON_HINT": "▶️ Tap the \"Connect\" button below to open Happ and add the subscription automatically.",
+  "SUBSCRIPTION_HAPP_OPEN_HINT": "💡 If the link doesn't open automatically, copy it manually:",
+  "SUBSCRIPTION_HAPP_OPEN_LINK": "<a href=\"{subscription_link}\">🔓 Open link in Happ</a>",
+  "SUBSCRIPTION_HAPP_OPEN_TITLE": "🔗 <b>Connect via Happ</b>",
+  "SUPPORT_BUTTON": "🆘 Support",
+  "TICKET_ALREADY_OPEN": "You already have an open ticket. Please close it first.",
+  "TICKET_ATTACHMENTS": "📎 Attachments",
+  "TICKET_CLOSED": "✅ Ticket closed.",
+  "TICKET_CLOSED_NO_REPLY": "❌ The ticket is closed; replying is not possible.",
+  "TICKET_CLOSE_ERROR": "❌ Error closing ticket.",
+  "TICKET_CREATED_SUCCESS": "✅ Ticket #{ticket_id} created successfully!\n\nTitle: {title}\n\nWe will respond to you soon.",
+  "TICKET_CREATE_ERROR": "❌ An error occurred while creating the ticket. Please try again later.",
+  "TICKET_CREATION_CANCELLED": "Ticket creation cancelled.",
+  "TICKET_CREATION_ERROR": "❌ An error occurred while creating the ticket. Please try again later.",
+  "TICKET_MARKED_ANSWERED": "✅ Ticket marked as answered.",
+  "TICKET_MESSAGE_INPUT": "Now describe your problem or question:",
+  "TICKET_MESSAGE_TOO_SHORT": "Message must contain at least 10 characters. Try again:",
+  "TICKET_NOT_FOUND": "Ticket not found.",
+  "TICKET_PRIORITY_HIGH": "🟠 High",
+  "TICKET_PRIORITY_LOW": "🟢 Low",
+  "TICKET_PRIORITY_NORMAL": "🟡 Normal",
+  "TICKET_PRIORITY_SELECT": "Select ticket priority:",
+  "TICKET_PRIORITY_URGENT": "🔴 Urgent",
+  "TICKET_REPLY_CANCELLED": "Reply cancelled.",
+  "TICKET_REPLY_ERROR": "❌ An error occurred while sending the reply. Please try again later.",
+  "TICKET_REPLY_INPUT": "Enter your reply:",
+  "TICKET_REPLY_NOTIFICATION": "🎫 Reply received for ticket #{ticket_id}\n\n{reply_preview}\n\nClick the button below to go to the ticket:",
+  "TICKET_REPLY_SENT": "✅ Your reply has been sent!",
+  "TICKET_REPLY_TOO_SHORT": "Reply must contain at least 5 characters. Try again:",
+  "TICKET_STATUS_ANSWERED": "Answered",
+  "TICKET_STATUS_CLOSED": "Closed",
+  "TICKET_STATUS_OPEN": "Open",
+  "TICKET_STATUS_PENDING": "Pending",
+  "TICKET_TITLE_INPUT": "Enter ticket title:",
+  "TICKET_TITLE_TOO_LONG": "Title is too long. Maximum 255 characters. Try again:",
+  "TICKET_TITLE_TOO_SHORT": "Title must contain at least 5 characters. Try again:",
+  "TICKET_UPDATE_ERROR": "❌ Error updating ticket.",
+  "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!",
+  "UNBLOCK": "✅ Unblock",
+  "USER_BLOCKED_FOREVER": "You are blocked from contacting support.",
+  "USER_BLOCKED_UNTIL": "You are blocked until {time}",
+  "VIEW_CLOSED_TICKETS": "🟢 Closed tickets",
+  "VIEW_TICKET": "👁️ View ticket",
+  "ADMIN_USERS_SUBMENU_TITLE": "👥 **User and subscription management**\n\n",
+  "ADMIN_PROMO_SUBMENU_TITLE": "💰 **Promo codes and statistics**\n\n",
+  "ADMIN_COMMUNICATIONS_SUBMENU_TITLE": "📨 **Communications**\n\n",
+  "ADMIN_COMMUNICATIONS_SUBMENU_DESCRIPTION": "Manage broadcasts and interface texts:",
+  "ADMIN_SUBMENU_SELECT_SECTION": "Choose a section:",
+  "ADMIN_SUPPORT_SUBMENU_TITLE": "🛟 **Support**\n\n",
+  "ADMIN_SUPPORT_SUBMENU_DESCRIPTION": "Manage tickets and support settings:",
+  "ADMIN_SUPPORT_SUBMENU_DESCRIPTION_MODERATOR": "Ticket access only.",
+  "ADMIN_SUPPORT_MODERATION_TITLE": "🧑‍⚖️ <b>Support moderation</b>",
+  "ADMIN_SUPPORT_MODERATION_DESCRIPTION": "Access to support tickets.",
+  "ADMIN_SUPPORT_AUDIT_TITLE": "🧾 <b>Moderator audit</b>",
+  "ADMIN_SUPPORT_AUDIT_EMPTY": "Nothing here yet",
+  "ADMIN_SUPPORT_AUDIT_ROLE_MODERATOR": "Moderator",
+  "ADMIN_SUPPORT_AUDIT_ROLE_ADMIN": "Admin",
+  "ADMIN_SUPPORT_AUDIT_ACTION_CLOSE_TICKET": "Ticket closed",
+  "ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_TIMED": "Timed block",
+  "ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_PERM": "Permanent block",
+  "ADMIN_SUPPORT_AUDIT_ACTION_UNBLOCK": "Unblock",
+  "ADMIN_SETTINGS_SUBMENU_TITLE": "⚙️ **System settings**\n\n",
+  "ADMIN_SETTINGS_SUBMENU_DESCRIPTION": "Manage Remnawave, monitoring and other settings:",
+  "ADMIN_SYSTEM_SUBMENU_TITLE": "🛠️ **System tools**\n\n",
+  "ADMIN_SYSTEM_SUBMENU_DESCRIPTION": "Reports, updates, logs, backups and system operations:",
+  "ADMIN_SUPPORT_SETTINGS_STATUS_ENABLED": "Enabled",
+  "ADMIN_SUPPORT_SETTINGS_STATUS_DISABLED": "Disabled",
+  "ADMIN_SUPPORT_SETTINGS_MENU_LABEL": "\"Support\" menu item",
+  "ADMIN_SUPPORT_SETTINGS_MODE_TICKETS": "Tickets",
+  "ADMIN_SUPPORT_SETTINGS_MODE_CONTACT": "Contact",
+  "ADMIN_SUPPORT_SETTINGS_MODE_BOTH": "Both",
+  "ADMIN_SUPPORT_SETTINGS_EDIT_DESCRIPTION": "📝 Edit description",
+  "ADMIN_SUPPORT_SETTINGS_ADMIN_NOTIFICATIONS": "Admin notifications",
+  "ADMIN_SUPPORT_SETTINGS_USER_NOTIFICATIONS": "User notifications",
+  "ADMIN_SUPPORT_SETTINGS_SLA_LABEL": "SLA",
+  "ADMIN_SUPPORT_SETTINGS_SLA_TIME": "⏳ SLA time: {minutes} min",
+  "ADMIN_SUPPORT_SETTINGS_MODERATORS_COUNT": "🧑‍⚖️ Moderators: {count}",
+  "ADMIN_SUPPORT_SETTINGS_ADD_MODERATOR": "➕ Assign moderator",
+  "ADMIN_SUPPORT_SETTINGS_REMOVE_MODERATOR": "➖ Remove moderator",
+  "ADMIN_SUPPORT_SETTINGS_TITLE": "🛟 <b>Support settings</b>",
+  "ADMIN_SUPPORT_SETTINGS_DESCRIPTION": "Working hours and menu visibility. Current support menu description:",
+  "ADMIN_SUPPORT_SLA_SETUP_PROMPT": "⏳ <b>SLA configuration</b>\n\nEnter the response wait time in minutes (integer > 0):",
+  "ADMIN_SUPPORT_SLA_INVALID": "❌ Enter a valid number of minutes (1-1440)",
+  "ADMIN_SUPPORT_SLA_SAVED": "✅ SLA value saved",
+  "ADMIN_SUPPORT_ASSIGN_MODERATOR_PROMPT": "🧑‍⚖️ <b>Assign moderator</b>\n\nSend the user's Telegram ID (number)",
+  "ADMIN_SUPPORT_REMOVE_MODERATOR_PROMPT": "🧑‍⚖️ <b>Remove moderator</b>\n\nSend the user's Telegram ID (number)",
+  "ADMIN_SUPPORT_INVALID_TELEGRAM_ID": "❌ Enter a valid Telegram ID (number)",
+  "ADMIN_SUPPORT_MODERATOR_REMOVED_SUCCESS": "✅ Moderator {tid} removed",
+  "ADMIN_SUPPORT_MODERATOR_REMOVED_FAIL": "❌ Failed to remove moderator",
+  "ADMIN_SUPPORT_MODERATOR_ADDED_SUCCESS": "✅ User {tid} assigned as moderator",
+  "ADMIN_SUPPORT_MODERATOR_ADDED_FAIL": "❌ Failed to assign moderator",
+  "ADMIN_SUPPORT_MODERATORS_EMPTY": "List is empty",
+  "ADMIN_SUPPORT_MODERATORS_TITLE": "🧑‍⚖️ <b>Moderators</b>",
+  "ADMIN_SUPPORT_SEND_DESCRIPTION": "📨 Send description",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_TITLE": "📝 <b>Editing support description</b>",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_CURRENT": "Current description:",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_TITLE": "<b>Contact for \"Contact\" mode</b>",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_HINT": "Add to the description if needed.",
+  "ADMIN_SUPPORT_DESCRIPTION_UPDATED": "✅ Description updated.",
+  "ADMIN_SUPPORT_DESCRIPTION_SENT": "Description sent below",
+  "ADMIN_SUPPORT_MESSAGE_DELETED": "Message deleted"
 }
@@ -1,6 +1,20 @@
 {
  "ACCESS_DENIED": "❌ Доступ запрещен",
  "ADD_COUNTRIES_BUTTON": "🌐 Добавить страны",
+  "COUNTRY_MANAGEMENT_UNAVAILABLE": "ℹ️ Управление серверами недоступно - доступен только один сервер",
+  "COUNTRY_MANAGEMENT_PROMPT": "🌍 <b>Управление странами подписки</b>\n\n📋 <b>Текущие страны ({current_count}):</b>\n{current_list}\n\n💡 <b>Инструкция:</b>\n✅ - страна подключена\n➕ - будет добавлена (платно)\n➖ - будет отключена (бесплатно)\n⚪ - не выбрана\n\n⚠️ <b>Важно:</b> Повторное подключение отключенных стран будет платным!",
+  "COUNTRY_MANAGEMENT_NONE": "Нет подключенных стран",
+  "PAID_FEATURE_ONLY": "⚠ Эта функция доступна только для платных подписок",
+  "PAID_FEATURE_ONLY_SHORT": "⚠ Только для платных подписок",
+  "COUNTRY_NOT_AVAILABLE_PROMOGROUP": "❌ Сервер недоступен для вашей промогруппы",
+  "COUNTRY_CHANGES_NOT_FOUND": "⚠️ Изменения не обнаружены",
+  "COUNTRY_CHANGES_SUCCESS_HEADER": "✅ <b>Страны успешно обновлены!</b>\n\n",
+  "COUNTRY_CHANGES_ADDED_HEADER": "➕ <b>Добавлены страны:</b>\n",
+  "COUNTRY_CHANGES_CHARGED": "💰 Списано: {amount} (за {months} мес)",
+  "COUNTRY_CHANGES_DISCOUNT_INFO": " (скидка {percent}%: -{amount})",
+  "COUNTRY_CHANGES_REMOVED_HEADER": "➖ <b>Отключены страны:</b>\n",
+  "COUNTRY_CHANGES_REMOVED_WARNING": "ℹ️ Повторное подключение будет платным",
+  "COUNTRY_CHANGES_ACTIVE_COUNT": "🌐 <b>Активных стран:</b> {count}",
  "ADMIN_MAIN_MENU": "🏠 Главное меню",
  "ADMIN_CAMPAIGNS": "📣 Рекламные кампании",
  "ADMIN_MESSAGES": "📨 Рассылки",
@@ -14,7 +28,16 @@
  "ADMIN_PROMO_GROUPS": "💳 Промогруппы",
  "ADMIN_PROMO_GROUPS_TITLE": "💳 <b>Промогруппы</b>",
  "ADMIN_PROMO_GROUPS_SUMMARY": "Всего групп: {count}\nВсего участников: {members}",
-  "ADMIN_PROMO_GROUPS_DISCOUNTS": "Скидки — серверы: {servers}%, трафик: {traffic}%, устройства: {devices}%",
+  "ADMIN_PROMO_GROUP_DISCOUNTS_HEADER": "💸 Скидки промогруппы:",
+  "ADMIN_PROMO_GROUP_DISCOUNT_LINE_SERVERS": "• Серверы: {percent}%",
+  "ADMIN_PROMO_GROUP_DISCOUNT_LINE_TRAFFIC": "• Трафик: {percent}%",
+  "ADMIN_PROMO_GROUP_DISCOUNT_LINE_DEVICES": "• Устройства: {percent}%",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_ENABLED": "🧩 Скидки на доп. услуги: <b>включены</b>",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_DISABLED": "🧩 Скидки на доп. услуги: <b>отключены</b>",
+  "ADMIN_PROMO_GROUP_TOGGLE_ADDON_DISCOUNT_ENABLE": "🧩 Включить скидки на доп. услуги",
+  "ADMIN_PROMO_GROUP_TOGGLE_ADDON_DISCOUNT_DISABLE": "🧩 Отключить скидки на доп. услуги",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_UPDATED_ENABLED": "🧩 Скидки на докупку доп. услуг <b>включены</b>.",
+  "ADMIN_PROMO_GROUP_ADDON_DISCOUNT_UPDATED_DISABLED": "🧩 Скидки на докупку доп. услуг <b>отключены</b>.",
  "ADMIN_PROMO_GROUPS_DEFAULT_LABEL": " (базовая)",
  "ADMIN_PROMO_GROUPS_MEMBERS_COUNT": "Участников: {count}",
  "ADMIN_PROMO_GROUPS_EMPTY": "Промогруппы не найдены.",
@@ -29,6 +52,22 @@
  "ADMIN_USER_PROMO_GROUP_ALREADY": "ℹ️ Пользователь уже состоит в этой промогруппе.",
  "ADMIN_USER_PROMO_GROUP_ERROR": "❌ Не удалось обновить промогруппу пользователя.",
  "ADMIN_USER_PROMO_GROUP_BACK": "⬅️ К пользователю",
+  "ADMIN_USER_MANAGEMENT_PROFILE": "👤 <b>Управление пользователем</b>\n\n<b>Основная информация:</b>\n• Имя: {name}\n• ID: <code>{telegram_id}</code>\n• Username: {username}\n• Статус: {status}\n• Язык: {language}\n\n<b>Финансы:</b>\n• Баланс: {balance}\n• Транзакций: {transactions}\n\n<b>Активность:</b>\n• Регистрация: {registration}\n• Последняя активность: {last_activity}\n• Дней с регистрации: {registration_days}",
+  "ADMIN_USER_USERNAME_NOT_SET": "не указан",
+  "ADMIN_USER_STATUS_ACTIVE": "✅ Активен",
+  "ADMIN_USER_STATUS_BLOCKED": "🚫 Заблокирован",
+  "ADMIN_USER_STATUS_DELETED": "🗑️ Удален",
+  "ADMIN_USER_STATUS_UNKNOWN": "❓ Неизвестно",
+  "ADMIN_USER_LAST_ACTIVITY_UNKNOWN": "Неизвестно",
+  "ADMIN_USER_SUBSCRIPTION_TYPE_TRIAL": "🎁 Триал",
+  "ADMIN_USER_SUBSCRIPTION_TYPE_PAID": "💎 Платная",
+  "ADMIN_USER_SUBSCRIPTION_STATUS_ACTIVE": "✅ Активна",
+  "ADMIN_USER_SUBSCRIPTION_STATUS_INACTIVE": "❌ Неактивна",
+  "ADMIN_USER_TRAFFIC_USAGE": "{used}/{limit} ГБ",
+  "ADMIN_USER_MANAGEMENT_SUBSCRIPTION": "<b>Подписка:</b>\n• Тип: {type}\n• Статус: {status}\n• До: {end_date}\n• Трафик: {traffic}\n• Устройства: {devices}\n• Стран: {countries}",
+  "ADMIN_USER_MANAGEMENT_SUBSCRIPTION_NONE": "<b>Подписка:</b> Отсутствует",
+  "ADMIN_USER_MANAGEMENT_PROMO_GROUP": "<b>Промогруппа:</b>\n• Название: {name}\n• Скидка на сервера: {server_discount}%\n• Скидка на трафик: {traffic_discount}%\n• Скидка на устройства: {device_discount}%",
+  "ADMIN_USER_MANAGEMENT_PROMO_GROUP_NONE": "<b>Промогруппа:</b> Не назначена",
  "ADMIN_PROMO_GROUP_DETAILS_TITLE": "💳 <b>Промогруппа:</b> {name}",
  "ADMIN_PROMO_GROUP_DETAILS_MEMBERS": "Участников: {count}",
  "ADMIN_PROMO_GROUP_DETAILS_DEFAULT": "Это базовая группа.",
@@ -55,12 +94,20 @@
  "ADMIN_PROMO_GROUP_DELETED": "Промогруппа «{name}» удалена.",
  "ADMIN_SUBSCRIPTIONS": "📱 Подписки",
  "ADMIN_USERS": "👥 Пользователи",
+  "ADMIN_TICKETS_TITLE_OPEN": "🎫 Открытые тикеты поддержки:",
+  "ADMIN_TICKETS_TITLE_CLOSED": "🎫 Закрытые тикеты поддержки:",
  "AUTOPAY_BUTTON": "💳 Автоплатёж",
  "AUTOPAY_DISABLED_TEXT": "Отключен - не забудьте продлить вручную!",
  "AUTOPAY_ENABLED_TEXT": "Включен - подписка продлится автоматически",
  "AUTOPAY_FAILED": "\n❌ <b>Ошибка автоплатежа</b>\n\nНе удалось списать средства для продления подписки.\nНедостаточно средств на балансе: {balance}\nТребуется: {required}\n\nПополните баланс и продлите подписку вручную.\n",
  "AUTOPAY_SET_DAYS_BUTTON": "⚙️ Настроить дни",
  "AUTOPAY_SUCCESS": "\n✅ <b>Автоплатеж выполнен</b>\n\nВаша подписка автоматически продлена на {days} дней.\nСписано с баланса: {amount}\n",
+  "AUTOPAY_STATUS_ENABLED": "включен",
+  "AUTOPAY_STATUS_DISABLED": "выключен",
+  "AUTOPAY_MENU_TEXT": "💳 <b>Автоплатеж</b>\n\n📊 <b>Статус:</b> {status}\n⏰ <b>Списание за:</b> {days} дн. до окончания\n\nВыберите действие:",
+  "AUTOPAY_TOGGLE_SUCCESS": "✅ Автоплатеж {status}!",
+  "AUTOPAY_SELECT_DAYS_PROMPT": "⏰ Выберите за сколько дней до окончания списывать средства:",
+  "AUTOPAY_DAYS_SET": "✅ Установлено {days} дней!",
  "BACK": "⬅️ Назад",
  "BACK_TO_SUBSCRIPTION": "⬅️ К подписке",
  "BALANCE_BUTTON": "💰 Баланс: {balance}",
@@ -82,6 +129,7 @@
  "PROMO_GROUP_PERIOD_DISCOUNT_ITEM": "{period} — {percent}%",
  "CANCEL": "❌ Отмена",
  "CHANGE_DEVICES_BUTTON": "📱 Изменить устройства",
+  "CHANGE_DEVICES_PROMPT": "📱 <b>Изменение количества устройств</b>\n\nТекущий лимит: {current_devices} устройств\nВыберите новое количество устройств:\n\n💡 <b>Важно:</b>\n• При увеличении - доплата пропорционально оставшемуся времени\n• При уменьшении - возврат средств не производится",
  "CHANGE_DEVICES_CONFIRM": "\n    📱 <b>Подтверждение изменения</b>\n\n    Текущее количество: {current_devices} устройств\n    Новое количество: {new_devices} устройств\n\n    Действие: {action}\n    💰 {cost}\n\n    Подтвердить изменение?\n    ",
  "CHANGE_DEVICES_INFO": "\n    📱 <b>Изменение количества устройств</b>\n\n    Текущий лимит: {current_devices} устройств\n\n    Выберите новое количество устройств:\n\n    💡 <b>Важно:</b>\n    • При увеличении - доплата пропорционально оставшемуся времени\n    • При уменьшении - возврат средств не производится\n    ",
  "CHANGE_DEVICES_SUCCESS_DECREASE": "\n    ✅ Количество устройств уменьшено!\n\n    📱 Было: {old_count} → Стало: {new_count}\n    ℹ️ Возврат средств не производится\n    ",
@@ -92,11 +140,22 @@
  "CHANNEL_SUBSCRIBE_BUTTON": "🔗 Подписаться",
  "CHANNEL_SUBSCRIBE_REQUIRED_ALERT": "❌ Вы не подписались на канал!",
  "CHANNEL_SUBSCRIBE_THANKS": "✅ Спасибо за подписку",
+  "TRIAL_CHANNEL_UNSUBSCRIBED": "\n🚫 <b>Доступ приостановлен</b>\n\nМы не нашли вашу подписку на наш канал, поэтому тестовая подписка отключена.\n\nПодпишитесь на канал и нажмите «{check_button}», чтобы вернуть доступ.",
  "CHECK_STATUS_BUTTON": "📊 Проверить статус",
  "CHOOSE_ANOTHER_DEVICE": "📱 Выбрать другое устройство",
  "CONFIRM": "✅ Подтвердить",
  "CONFIRM_CHANGE_BUTTON": "✅ Подтвердить изменение",
  "CONNECT_BUTTON": "🔗 Подключиться",
+  "HAPP_DOWNLOAD_BUTTON": "⬇️ Скачать Happ",
+  "HAPP_DOWNLOAD_PROMPT": "📥 <b>Скачать Happ</b>\nВыберите ваше устройство:",
+  "HAPP_PLATFORM_IOS": "🍎 iOS",
+  "HAPP_PLATFORM_ANDROID": "🤖 Android",
+  "HAPP_PLATFORM_MACOS": "🖥️ Mac OS",
+  "HAPP_PLATFORM_WINDOWS": "💻 Windows",
+  "HAPP_PLATFORM_PC": "💻 ПК",
+  "HAPP_DOWNLOAD_LINK_MESSAGE": "⬇️ Скачайте Happ для {platform}:",
+  "HAPP_DOWNLOAD_LINK_NOT_SET": "❌ Ссылка для этого устройства не настроена",
+  "HAPP_DOWNLOAD_OPEN_LINK": "🔗 Открыть ссылку",
  "CONTACT_SUPPORT": "💬 Написать в поддержку",
  "CONTINUE": "➡️ Продолжить",
  "CONTINUE_BUTTON": "✅ Продолжить",
@@ -107,6 +166,19 @@
  "DEVICES_LIMIT_EXCEEDED": "⚠️ Превышен максимальный лимит устройств ({limit})",
  "DEVICES_MINIMUM_LIMIT": "⚠️ Минимальное количество устройств: {limit}",
  "DEVICES_NO_CHANGE": "ℹ️ Количество устройств не изменилось",
+  "PAYMENT_CHARGE_ERROR": "⚠️ Ошибка списания средств",
+  "DEVICE_CHANGE_ACTION_INCREASE": "увеличить до {count}",
+  "DEVICE_CHANGE_EXTRA_COST": "Доплата: {amount} (за {months} мес)",
+  "DEVICE_CHANGE_DISCOUNT_INFO": " (скидка {percent}%: -{amount})",
+  "DEVICE_CHANGE_FREE": "Бесплатно",
+  "DEVICE_CHANGE_ACTION_DECREASE": "уменьшить до {count}",
+  "DEVICE_CHANGE_NO_REFUND": "Возврат средств не производится",
+  "DEVICE_CHANGE_CONFIRMATION": "📱 <b>Подтверждение изменения</b>\n\nТекущее количество: {current} устройств\nНовое количество: {new} устройств\n\nДействие: {action}\n💰 {cost}\n\nПодтвердить изменение?",
+  "DEVICE_CHANGE_INCREASE_SUCCESS": "✅ Количество устройств увеличено!\n\n",
+  "DEVICE_CHANGE_RESULT_LINE": "📱 Было: {old} → Стало: {new}\n",
+  "DEVICE_CHANGE_CHARGED": "💰 Списано: {amount}",
+  "DEVICE_CHANGE_DECREASE_SUCCESS": "✅ Количество устройств уменьшено!\n\n",
+  "DEVICE_CHANGE_NO_REFUND_INFO": "ℹ️ Возврат средств не производится",
  "DEVICE_CONNECTION_HELP": "❓ Как подключить устройство заново?",
  "DEVICE_GUIDE_ANDROID": "🤖 Android",
  "DEVICE_GUIDE_ANDROID_TV": "📺 Android TV",
@@ -121,7 +193,9 @@
  "GO_TO_BALANCE_TOP_UP": "💳 Перейти к пополнению баланса",
  "RETURN_TO_SUBSCRIPTION_CHECKOUT": "⬅️ Вернуться к оформлению подписки",
  "INSUFFICIENT_BALANCE": "❌ Недостаточно средств на балансе.  \n    \n    <b>Пополните баланс на {amount} и попробуйте снова.</b>\n    ",
+  "ADDON_INSUFFICIENT_FUNDS_MESSAGE": "⚠️ <b>Недостаточно средств</b>\n\nСтоимость услуги: {required}\nНа балансе: {balance}\nНе хватает: {missing}\n\nВыберите способ пополнения. Сумма подставится автоматически.",
  "INVALID_AMOUNT": "❌ Неверная сумма",
+  "LANGUAGE_PROMPT": "🌐 Выберите язык интерфейса:",
  "LANGUAGE_SELECTED": "🌐 Язык интерфейса установлен: <b>Русский</b>",
  "LOADING": "⏳ Загрузка...",
  "MAINTENANCE_MODE_ACTIVE": "\n🔧 Технические работы!\n\nСервис временно недоступен. Ведутся технические работы по улучшению качества обслуживания.\n\n⏰ Ориентировочное время завершения: неизвестно\n🔄 Попробуйте позже\n\nПриносим извинения за временные неудобства.\n",
@@ -130,6 +204,26 @@
  "MAIN_MENU_ACTION_PROMPT": "Выберите действие:",
  "MAIN_MENU_BUTTON": "🏠 Главное меню",
  "MANAGE_DEVICES_BUTTON": "🔧 Управление устройствами",
+  "DEVICE_UUID_NOT_FOUND": "❌ UUID пользователя не найден",
+  "DEVICE_NONE_CONNECTED": "ℹ️ У вас нет подключенных устройств",
+  "DEVICE_FETCH_INFO_ERROR": "❌ Ошибка получения информации об устройствах",
+  "DEVICE_MANAGEMENT_OVERVIEW": "🔄 <b>Управление устройствами</b>\n\n📊 Всего подключено: {total} устройств\n📄 Страница {page} из {pages}\n\n",
+  "DEVICE_MANAGEMENT_CONNECTED_HEADER": "<b>Подключенные устройства:</b>\n",
+  "DEVICE_MANAGEMENT_LIST_ITEM": "• {device}\n",
+  "DEVICE_MANAGEMENT_ACTIONS": "\n💡 <b>Действия:</b>\n• Выберите устройство для сброса\n• Или сбросьте все устройства сразу",
+  "DEVICE_FETCH_ERROR": "❌ Ошибка получения устройств",
+  "DEVICE_PAGE_LOAD_ERROR": "❌ Ошибка загрузки страницы",
+  "DEVICE_RESET_INVALID_REQUEST": "❌ Ошибка: некорректный запрос",
+  "DEVICE_RESET_PARSE_ERROR": "❌ Ошибка обработки запроса",
+  "DEVICE_RESET_SUCCESS": "✅ Устройство {device} успешно сброшено!",
+  "DEVICE_RESET_ALL_DONE": "ℹ️ Все устройства сброшены",
+  "DEVICE_RESET_ID_FAILED": "❌ Не удалось получить ID устройства",
+  "DEVICE_RESET_NOT_FOUND": "❌ Устройство не найдено",
+  "DEVICE_RESET_ERROR": "❌ Ошибка сброса устройства",
+  "DEVICE_LIST_FETCH_ERROR": "❌ Ошибка получения списка устройств",
+  "DEVICE_RESET_ALL_SUCCESS_MESSAGE": "✅ <b>Все устройства успешно сброшены!</b>\n\n🔄 Сброшено: {count} устройств\n📱 Теперь вы можете заново подключить свои устройства\n\n💡 Используйте ссылку из раздела 'Моя подписка' для повторного подключения",
+  "DEVICE_RESET_PARTIAL_MESSAGE": "⚠️ <b>Частичный сброс устройств</b>\n\n✅ Удалено: {success} устройств\n❌ Не удалось удалить: {failed} устройств\n\nПопробуйте еще раз или обратитесь в поддержку.",
+  "DEVICE_RESET_ALL_FAILED_MESSAGE": "❌ <b>Не удалось сбросить устройства</b>\n\nПопробуйте еще раз позже или обратитесь в техподдержку.\n\nВсего устройств: {total}",
  "MENU_ADMIN": "⚙️ Админ-панель",
  "MENU_BALANCE": "💰 Баланс",
  "MENU_BUY_SUBSCRIPTION": "💎 Купить подписку",
@@ -211,6 +305,9 @@
  "SUBSCRIPTION_NONE": "❌ Нет активной подписки",
  "SUBSCRIPTION_NOT_FOUND": "❌ Подписка не найдена",
  "SUBSCRIPTION_PURCHASED": "🎉 Подписка успешно приобретена!",
+  "SUBSCRIPTION_SETTINGS_PAID_ONLY": "⚠️ Настройки доступны только для платных подписок",
+  "SUBSCRIPTION_SETTINGS_OVERVIEW": "⚙️ <b>Настройки подписки</b>\n\n📊 <b>Текущие параметры:</b>\n🌐 Стран: {countries_count}\n📈 Трафик: {traffic_used} / {traffic_limit}\n📱 Устройства: {devices_used} / {devices_limit}\n\nВыберите что хотите изменить:",
+  "SUBSCRIPTION_ACTIVE_REQUIRED": "⚠️ У вас нет активной подписки!",
  "SUBSCRIPTION_SETTINGS_BUTTON": "⚙️ Настройки подписки",
  "SUBSCRIPTION_SUMMARY": "\n📋 <b>Итоговая конфигурация</b>\n\n📅 <b>Период:</b> {period} дней\n📈 <b>Трафик:</b> {traffic}\n🌍 <b>Страны:</b> {countries}\n📱 <b>Устройства:</b> {devices}\n\n💰 <b>Итого к оплате:</b> {total_price}\n\nПодтвердить покупку?\n",
  "SUBSCRIPTION_TRIAL": "🧪 Тестовая подписка",
@@ -274,6 +371,9 @@
  "TRIAL_ALREADY_USED": "❌ Тестовая подписка уже была использована",
  "TRIAL_AVAILABLE": "\n🎁 <b>Тестовая подписка</b>\n\nВы можете получить бесплатную тестовую подписку:\n\n⏰ <b>Период:</b> {days} дней\n📈 <b>Трафик:</b> {traffic} ГБ\n📱 <b>Устройства:</b> {devices} шт.\n🌍 <b>Сервер:</b> {server_name}\n\nАктивировать тестовую подписку?\n",
  "TRIAL_ENDING_SOON": "\n🎁 <b>Тестовая подписка скоро закончится!</b>\n\nВаша тестовая подписка истекает через несколько часов.\n\n💎 <b>Не хотите остаться без VPN?</b>\nПереходите на полную подписку!\n\n🔥 <b>Специальное предложение:</b>\n• 30 дней всего за {price}\n• Безлимитный трафик  \n• Все серверы доступны\n• Скорость до 1ГБит/сек\n\n⚡️ Успейте оформить до окончания тестового периода!\n",
+  "TRAFFIC_FIXED_MODE": "⚠️ В текущем режиме трафик фиксированный и не может быть изменен",
+  "TRAFFIC_ALREADY_UNLIMITED": "⚠ У вас уже безлимитный трафик",
+  "ADD_TRAFFIC_PROMPT": "📈 <b>Добавить трафик к подписке</b>\n\nТекущий лимит: {current_traffic}\nВыберите дополнительный трафик:",
  "UNKNOWN_CALLBACK_ALERT": "❓ Неизвестная команда. Попробуйте ещё раз.",
  "UNKNOWN_COMMAND_MESSAGE": "❓ Не понимаю эту команду. Используйте кнопки меню.",
  "USER_NOT_FOUND": "❌ Пользователь не найден",
@@ -310,7 +410,9 @@
  "SUBSCRIPTION_CONNECT_MINIAPP_MESSAGE": "📱 <b>Подключить подписку</b>\n\n🚀 Нажмите кнопку ниже, чтобы открыть подписку в мини-приложении Telegram:",
  "SUBSCRIPTION_CONNECT_CUSTOM_MESSAGE": "🚀 <b>Подключить подписку</b>\n\n📱 Нажмите кнопку ниже, чтобы открыть приложение:",
  "SUBSCRIPTION_CONNECT_LINK_MESSAGE": "🚀 <b>Подключить подписку</b>\n\n🔗 Нажмите кнопку ниже, чтобы открыть ссылку подписки:",
+  "SUBSCRIPTION_LINK_HIDDEN_NOTICE": "ℹ️ Ссылка подписки доступна по кнопкам ниже или в разделе «Моя подписка».",
  "SUBSCRIPTION_CONNECT_DEVICE_MESSAGE": "📱 <b>Подключить подписку</b>\n\n🔗 <b>Ссылка подписки:</b>\n<code>{subscription_url}</code>\n\n💡 <b>Выберите ваше устройство</b> для получения подробной инструкции по настройке:",
+  "SUBSCRIPTION_CONNECT_DEVICE_MESSAGE_HIDDEN": "📱 <b>Подключить подписку</b>\n\nℹ️ Ссылка подписки доступна по кнопкам ниже или в разделе «Моя подписка».\n\n💡 <b>Выберите ваше устройство</b> для получения подробной инструкции по настройке:",
  "SUBSCRIPTION_LINK_UNAVAILABLE": "❌ Ссылка подписки недоступна",
  "SUBSCRIPTION_DEVICE_APPS_NOT_FOUND": "❌ Приложения для этого устройства не найдены",
  "SUBSCRIPTION_DEVICE_GUIDE_TITLE": "📱 <b>Настройка для {device_name}</b>",
@@ -392,6 +494,7 @@
  "PAYMENT_METHODS_TITLE": "💳 <b>Способы пополнения баланса</b>",
  "PAYMENT_METHODS_PROMPT": "Выберите удобный для вас способ оплаты:",
  "PAYMENT_METHODS_FOOTER": "Выберите способ пополнения:",
+  "PAYMENT_RETURN_HOME_BUTTON": "🏠 На главную",
  "PAYMENT_METHOD_STARS_NAME": "⭐ <b>Telegram Stars</b>",
  "PAYMENT_METHOD_STARS_DESCRIPTION": "быстро и удобно",
  "PAYMENT_METHOD_YOOKASSA_NAME": "💳 <b>Банковская карта</b>",
@@ -402,5 +505,198 @@
  "PAYMENT_METHOD_CRYPTOBOT_DESCRIPTION": "через CryptoBot",
  "PAYMENT_METHOD_SUPPORT_NAME": "🛠️ <b>Через поддержку</b>",
  "PAYMENT_METHOD_SUPPORT_DESCRIPTION": "другие способы",
-  "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку."
+  "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку.",
+  "ADMIN_MONITORING_SETTINGS": "⚙️ Настройки мониторинга",
+  "ADMIN_PROMO_GROUP_AUTO_ASSIGN_DISABLED": "Автовыдача по суммарным тратам: отключена",
+  "ADMIN_PROMO_GROUP_AUTO_ASSIGN_LINE": "Автовыдача по суммарным тратам: от {amount} ₽",
+  "ADMIN_PROMO_GROUP_CREATE_AUTO_ASSIGN_PROMPT": "Введите сумму общих трат (в ₽) для автоматической выдачи этой группы. Отправьте 0, чтобы отключить.",
+  "ADMIN_PROMO_GROUP_CREATE_PERIOD_PROMPT": "Введите скидки на периоды подписки (например, 30:10, 90:15). Отправьте 0, если без скидок.",
+  "ADMIN_PROMO_GROUP_EDIT_AUTO_ASSIGN_PROMPT": "Введите сумму общих трат (в ₽) для автовыдачи. Текущее значение: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_AUTO_ASSIGN": "🤖 Автовыдача по тратам",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_DEVICES": "📱 Скидка на устройства",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_NAME": "✏️ Изменить название",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_PERIODS": "⏳ Скидки по периодам",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_SERVERS": "🖥 Скидка на серверы",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_TRAFFIC": "🌐 Скидка на трафик",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_HINT": "Выберите параметр для изменения:",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_TITLE": "✏️ Настройки промогруппы «{name}»",
+  "ADMIN_PROMO_GROUP_EDIT_PERIOD_PROMPT": "Введите новые скидки на периоды (текущие: {current}). Отправьте 0, если без скидок.",
+  "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_REPORTS": "📊 Отчеты",
+  "ADMIN_TICKETS_TITLE": "🎫 Все тикеты поддержки:",
+  "ADMIN_TICKET_REPLY_INPUT": "Введите ответ от поддержки:",
+  "ADMIN_TICKET_REPLY_SENT": "✅ Ответ отправлен!",
+  "ATTACHMENTS_SENT": "✅ Вложения отправлены.",
+  "BACK_TO_MENU": "🏠 В главное меню",
+  "BACK_TO_OPEN_TICKETS": "🔴 Открытые тикеты",
+  "BACK_TO_SUPPORT": "⬅️ К поддержке",
+  "BACK_TO_TICKETS": "⬅️ К тикетам",
+  "BALANCE_TOPUP": "💳 Пополнить баланс",
+  "BLOCK_BY_TIME": "⏳ Блокировка по времени",
+  "BLOCK_FOREVER": "🚫 Заблокировать",
+  "CAMPAIGN_EXISTING_USERL": "ℹ️ Эта рекламная ссылка доступна только новым пользователям.",
+  "CANCEL_REPLY": "❌ Отменить ответ",
+  "CANCEL_TICKET_CREATION": "❌ Отменить создание тикета",
+  "CLOSED_TICKETS": "🟢 Закрытые",
+  "CLOSED_TICKETS_HEADER": "🟢 Закрытые тикеты",
+  "CLOSED_TICKETS_TITLE": "🟢 Закрытые тикеты:",
+  "CLOSE_NOTIFICATION": "❌ Закрыть уведомление",
+  "CLOSE_TICKET": "🔒 Закрыть тикет",
+  "CONTACT_SUPPORT_BUTTON": "💬 Связаться с поддержкой",
+  "CREATE_TICKET_BUTTON": "🎫 Создать тикет",
+  "DELETE_MESSAGE": "🗑 Удалить",
+  "DISCOUNT_BONUS_DESCRIPTION": "Скидка за продление подписки",
+  "DISCOUNT_CLAIM_ALREADY": "ℹ️ Скидка уже была активирована ранее.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Не удалось начислить скидку. Попробуйте позже.",
+  "DISCOUNT_CLAIM_EXPIRED": "⚠️ Время действия предложения истекло.",
+  "DISCOUNT_CLAIM_NOT_FOUND": "❌ Предложение не найдено.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 Скидка {percent}% активирована! На баланс начислено {amount}.",
+  "ENTER_BLOCK_MINUTES": "Введите количество минут для блокировки пользователя (например, 15):",
+  "LANGUAGE_SELECTION_DISABLED": "⚙️ Выбор языка временно недоступен. Используем язык по умолчанию.",
+  "MARK_AS_ANSWERED": "✅ Отметить как отвеченный",
+  "MULENPAY_PAYMENT_ERROR": "❌ Ошибка создания платежа Mulen Pay. Попробуйте позже или обратитесь в поддержку.",
+  "MULENPAY_PAYMENT_INSTRUCTIONS": "💳 <b>Оплата через Mulen Pay</b>\n\n💰 Сумма: {amount}\n🆔 ID платежа: {payment_id}\n\n📱 <b>Инструкция:</b>\n1. Нажмите кнопку ‘Оплатить через Mulen Pay’\n2. Следуйте подсказкам платежной системы\n3. Подтвердите перевод\n4. Средства зачислятся автоматически\n\n❓ Если возникнут проблемы, обратитесь в {support}",
+  "MULENPAY_PAY_BUTTON": "💳 Оплатить через Mulen Pay",
+  "MULENPAY_TOPUP_PROMPT": "💳 <b>Оплата через Mulen Pay</b>\n\nВведите сумму для пополнения от 100 до 100 000 ₽.\nОплата происходит через защищенную платформу Mulen Pay.",
+  "MY_TICKETS_BUTTON": "📋 Мои тикеты",
+  "MY_TICKETS_TITLE": "📋 Ваши тикеты:",
+  "NOTIFICATION_CLOSED": "Уведомление закрыто.",
+  "NOTIFICATION_VALUE_INVALID": "❌ Некорректное значение, укажите число.",
+  "NOTIFICATION_VALUE_UPDATED": "✅ Настройки обновлены.",
+  "NOTIFY_PROMPT_SECOND_HOURS": "Введите количество часов действия скидки (1-168):",
+  "NOTIFY_PROMPT_SECOND_PERCENT": "Введите новый процент скидки для уведомления через 2-3 дня (0-100):",
+  "NOTIFY_PROMPT_THIRD_DAYS": "Через сколько дней после истечения отправлять предложение? (минимум 2):",
+  "NOTIFY_PROMPT_THIRD_HOURS": "Введите количество часов действия скидки (1-168):",
+  "NOTIFY_PROMPT_THIRD_PERCENT": "Введите новый процент скидки для позднего предложения (0-100):",
+  "NO_ATTACHMENTS": "Вложений нет.",
+  "NO_CLOSED_TICKETS": "Закрытых тикетов пока нет.",
+  "NO_TICKETS": "У вас пока нет тикетов.",
+  "NO_TICKETS_ADMIN": "Нет тикетов для отображения.",
+  "OPEN_TICKETS": "🔴 Открытые",
+  "OPEN_TICKETS_HEADER": "🔴 Открытые тикеты",
+  "PAL24_PAYMENT_ERROR": "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+  "PAL24_PAYMENT_INSTRUCTIONS": "🏦 <b>Оплата через PayPalych (СБП)</b>\n\n💰 Сумма: {amount}\n🆔 ID счета: {bill_id}\n\n📱 <b>Инструкция:</b>\n1. Нажмите кнопку ‘Оплатить через PayPalych (СБП)’\n2. Следуйте подсказкам платежной системы\n3. Подтвердите перевод\n4. Средства зачислятся автоматически\n\n❓ Если возникнут проблемы, обратитесь в {support}",
+  "PAL24_PAY_BUTTON": "🏦 Оплатить через PayPalych (СБП)",
+  "PAL24_TOPUP_PROMPT": "🏦 <b>Оплата через PayPalych (СБП)</b>\n\nВведите сумму для пополнения от 100 до 1 000 000 ₽.\nОплата проходит через систему быстрых платежей PayPalych.",
+  "PAYMENT_CARD_MULENPAY": "💳 Банковская карта (Mulen Pay)",
+  "PAYMENT_CARD_PAL24": "🏦 СБП (PayPalych)",
+  "PAYMENT_METHOD_MULENPAY_DESCRIPTION": "через Mulen Pay",
+  "PAYMENT_METHOD_MULENPAY_NAME": "💳 <b>Банковская карта (Mulen Pay)</b>",
+  "PAYMENT_METHOD_PAL24_DESCRIPTION": "через систему быстрых платежей",
+  "PAYMENT_METHOD_PAL24_NAME": "🏦 <b>СБП (PayPalych)</b>",
+  "REPLY_TO_TICKET": "💬 Ответить",
+  "REPORT_CLOSE": "❌ Закрыть",
+  "REPORT_CLOSED": "✅ Отчет закрыт.",
+  "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_EXTEND": "💎 Продлить подписку",
+  "SUBSCRIPTION_HAPP_CRYPTOLINK_BLOCK": "<blockquote expandable><code>{crypto_link}</code></blockquote>",
+  "SUBSCRIPTION_HAPP_LINK_PROMPT": "🔒 Ссылка на подписку создана. Нажмите кнопку \"Подключиться\" ниже, чтобы открыть её в Happ.",
+  "SUBSCRIPTION_HAPP_OPEN_BUTTON_HINT": "▶️ Нажмите кнопку \"Подключиться\" ниже, чтобы открыть Happ и добавить подписку автоматически.",
+  "SUBSCRIPTION_HAPP_OPEN_HINT": "💡 Если ссылка не открывается автоматически, скопируйте её вручную:",
+  "SUBSCRIPTION_HAPP_OPEN_LINK": "<a href=\"{subscription_link}\">🔓 Открыть ссылку в Happ</a>",
+  "SUBSCRIPTION_HAPP_OPEN_TITLE": "🔗 <b>Подключение через Happ</b>",
+  "SUPPORT_BUTTON": "🆘 Поддержка",
+  "TICKET_ALREADY_OPEN": "У вас уже есть незакрытый тикет. Сначала закройте его.",
+  "TICKET_ATTACHMENTS": "📎 Вложения",
+  "TICKET_CLOSED": "✅ Тикет закрыт.",
+  "TICKET_CLOSED_NO_REPLY": "❌ Тикет закрыт, ответить невозможно.",
+  "TICKET_CLOSE_ERROR": "❌ Ошибка при закрытии тикета.",
+  "TICKET_CREATED_SUCCESS": "✅ Тикет #{ticket_id} успешно создан!\n\nЗаголовок: {title}\n\nМы ответим вам в ближайшее время.",
+  "TICKET_CREATE_ERROR": "❌ Произошла ошибка при создании тикета. Попробуйте позже.",
+  "TICKET_CREATION_CANCELLED": "Создание тикета отменено.",
+  "TICKET_CREATION_ERROR": "❌ Произошла ошибка при создании тикета. Попробуйте позже.",
+  "TICKET_MARKED_ANSWERED": "✅ Тикет отмечен как отвеченный.",
+  "TICKET_MESSAGE_INPUT": "Опишите проблему (до 500 символов) или отправьте фото c подписью:",
+  "TICKET_MESSAGE_TOO_SHORT": "Сообщение должно содержать минимум 10 символов. Попробуйте еще раз:",
+  "TICKET_NOT_FOUND": "Тикет не найден.",
+  "TICKET_PRIORITY_HIGH": "🟠 Высокий",
+  "TICKET_PRIORITY_LOW": "🟢 Низкий",
+  "TICKET_PRIORITY_NORMAL": "🟡 Обычный",
+  "TICKET_PRIORITY_SELECT": "Выберите приоритет тикета:",
+  "TICKET_PRIORITY_URGENT": "🔴 Срочный",
+  "TICKET_REPLY_CANCELLED": "Ответ отменен.",
+  "TICKET_REPLY_ERROR": "❌ Произошла ошибка при отправке ответа. Попробуйте позже.",
+  "TICKET_REPLY_INPUT": "Введите ваш ответ:",
+  "TICKET_REPLY_NOTIFICATION": "🎫 Получен ответ по тикету #{ticket_id}\n\n{reply_preview}\n\nНажмите кнопку ниже, чтобы перейти к тикету:",
+  "TICKET_REPLY_SENT": "✅ Ваш ответ отправлен!",
+  "TICKET_REPLY_TOO_SHORT": "Ответ должен содержать минимум 5 символов. Попробуйте еще раз:",
+  "TICKET_STATUS_ANSWERED": "Отвечен",
+  "TICKET_STATUS_CLOSED": "Закрыт",
+  "TICKET_STATUS_OPEN": "Открыт",
+  "TICKET_STATUS_PENDING": "В ожидании",
+  "TICKET_TITLE_INPUT": "Введите заголовок тикета:",
+  "TICKET_TITLE_TOO_LONG": "Заголовок слишком длинный. Максимум 255 символов. Попробуйте еще раз:",
+  "TICKET_TITLE_TOO_SHORT": "Заголовок должен содержать минимум 5 символов. Попробуйте еще раз:",
+  "TICKET_UPDATE_ERROR": "❌ Ошибка при обновлении тикета.",
+  "TRIAL_INACTIVE_1H": "⏳ <b>Прошёл час, а подключение не выполнено</b>\n\nЕсли возникли сложности — откройте инструкцию и следуйте шагам. Мы всегда готовы помочь!",
+  "TRIAL_INACTIVE_24H": "⏳ <b>Прошли сутки с начала теста</b>\n\nМы не видим трафика по вашей подписке. Загляните в инструкцию или напишите в поддержку — поможем подключиться!",
+  "UNBLOCK": "✅ Разблокировать",
+  "USER_BLOCKED_FOREVER": "Вы заблокированы для обращений в поддержку.",
+  "USER_BLOCKED_UNTIL": "Вы заблокированы до {time}",
+  "VIEW_CLOSED_TICKETS": "🟢 Закрытые тикеты",
+  "VIEW_TICKET": "👁️ Посмотреть тикет",
+  "ADMIN_USERS_SUBMENU_TITLE": "👥 **Управление пользователями и подписками**\n\n",
+  "ADMIN_PROMO_SUBMENU_TITLE": "💰 **Промокоды и статистика**\n\n",
+  "ADMIN_COMMUNICATIONS_SUBMENU_TITLE": "📨 **Коммуникации**\n\n",
+  "ADMIN_COMMUNICATIONS_SUBMENU_DESCRIPTION": "Управление рассылками и текстами интерфейса:",
+  "ADMIN_SUBMENU_SELECT_SECTION": "Выберите нужный раздел:",
+  "ADMIN_SUPPORT_SUBMENU_TITLE": "🛟 **Поддержка**\n\n",
+  "ADMIN_SUPPORT_SUBMENU_DESCRIPTION": "Управление тикетами и настройками поддержки:",
+  "ADMIN_SUPPORT_SUBMENU_DESCRIPTION_MODERATOR": "Доступ к тикетам.",
+  "ADMIN_SUPPORT_MODERATION_TITLE": "🧑‍⚖️ <b>Модерация поддержки</b>",
+  "ADMIN_SUPPORT_MODERATION_DESCRIPTION": "Доступ к тикетам поддержки.",
+  "ADMIN_SUPPORT_AUDIT_TITLE": "🧾 <b>Аудит модераторов</b>",
+  "ADMIN_SUPPORT_AUDIT_EMPTY": "Пока пусто",
+  "ADMIN_SUPPORT_AUDIT_ROLE_MODERATOR": "Модератор",
+  "ADMIN_SUPPORT_AUDIT_ROLE_ADMIN": "Админ",
+  "ADMIN_SUPPORT_AUDIT_ACTION_CLOSE_TICKET": "Закрытие тикета",
+  "ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_TIMED": "Блокировка (время)",
+  "ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_PERM": "Блокировка (навсегда)",
+  "ADMIN_SUPPORT_AUDIT_ACTION_UNBLOCK": "Снятие блока",
+  "ADMIN_SETTINGS_SUBMENU_TITLE": "⚙️ **Настройки системы**\n\n",
+  "ADMIN_SETTINGS_SUBMENU_DESCRIPTION": "Управление Remnawave, мониторингом и другими настройками:",
+  "ADMIN_SYSTEM_SUBMENU_TITLE": "🛠️ **Системные функции**\n\n",
+  "ADMIN_SYSTEM_SUBMENU_DESCRIPTION": "Отчеты, обновления, логи, резервные копии и системные операции:",
+  "ADMIN_SUPPORT_SETTINGS_STATUS_ENABLED": "Включены",
+  "ADMIN_SUPPORT_SETTINGS_STATUS_DISABLED": "Отключены",
+  "ADMIN_SUPPORT_SETTINGS_MENU_LABEL": "Пункт «Техподдержка» в меню",
+  "ADMIN_SUPPORT_SETTINGS_MODE_TICKETS": "Тикеты",
+  "ADMIN_SUPPORT_SETTINGS_MODE_CONTACT": "Контакт",
+  "ADMIN_SUPPORT_SETTINGS_MODE_BOTH": "Оба",
+  "ADMIN_SUPPORT_SETTINGS_EDIT_DESCRIPTION": "📝 Изменить описание",
+  "ADMIN_SUPPORT_SETTINGS_ADMIN_NOTIFICATIONS": "Админ-уведомления",
+  "ADMIN_SUPPORT_SETTINGS_USER_NOTIFICATIONS": "Пользовательские уведомления",
+  "ADMIN_SUPPORT_SETTINGS_SLA_LABEL": "SLA",
+  "ADMIN_SUPPORT_SETTINGS_SLA_TIME": "⏳ Время SLA: {minutes} мин",
+  "ADMIN_SUPPORT_SETTINGS_MODERATORS_COUNT": "🧑‍⚖️ Модераторы: {count}",
+  "ADMIN_SUPPORT_SETTINGS_ADD_MODERATOR": "➕ Назначить модератора",
+  "ADMIN_SUPPORT_SETTINGS_REMOVE_MODERATOR": "➖ Удалить модератора",
+  "ADMIN_SUPPORT_SETTINGS_TITLE": "🛟 <b>Настройки поддержки</b>",
+  "ADMIN_SUPPORT_SETTINGS_DESCRIPTION": "Режим работы и видимость в меню. Ниже текущее описание меню поддержки:",
+  "ADMIN_SUPPORT_SLA_SETUP_PROMPT": "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):",
+  "ADMIN_SUPPORT_SLA_INVALID": "❌ Введите корректное число минут (1-1440)",
+  "ADMIN_SUPPORT_SLA_SAVED": "✅ Значение SLA сохранено",
+  "ADMIN_SUPPORT_ASSIGN_MODERATOR_PROMPT": "🧑‍⚖️ <b>Назначение модератора</b>\n\nОтправьте Telegram ID пользователя (число)",
+  "ADMIN_SUPPORT_REMOVE_MODERATOR_PROMPT": "🧑‍⚖️ <b>Удаление модератора</b>\n\nОтправьте Telegram ID пользователя (число)",
+  "ADMIN_SUPPORT_INVALID_TELEGRAM_ID": "❌ Введите корректный Telegram ID (число)",
+  "ADMIN_SUPPORT_MODERATOR_REMOVED_SUCCESS": "✅ Модератор {tid} удалён",
+  "ADMIN_SUPPORT_MODERATOR_REMOVED_FAIL": "❌ Не удалось удалить модератора",
+  "ADMIN_SUPPORT_MODERATOR_ADDED_SUCCESS": "✅ Пользователь {tid} назначен модератором",
+  "ADMIN_SUPPORT_MODERATOR_ADDED_FAIL": "❌ Не удалось назначить модератора",
+  "ADMIN_SUPPORT_MODERATORS_EMPTY": "Список пуст",
+  "ADMIN_SUPPORT_MODERATORS_TITLE": "🧑‍⚖️ <b>Модераторы</b>",
+  "ADMIN_SUPPORT_SEND_DESCRIPTION": "📨 Прислать текст",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_TITLE": "📝 <b>Редактирование описания поддержки</b>",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_CURRENT": "Текущее описание:",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_TITLE": "<b>Контакт для режима «Контакт»</b>",
+  "ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_HINT": "Добавьте в описание при необходимости.",
+  "ADMIN_SUPPORT_DESCRIPTION_UPDATED": "✅ Описание обновлено.",
+  "ADMIN_SUPPORT_DESCRIPTION_SENT": "Текст отправлен ниже",
+  "ADMIN_SUPPORT_MESSAGE_DELETED": "Сообщение удалено"
 }
@@ -12,6 +12,7 @@ from app.database.crud.user import get_user_by_telegram_id, create_user
 from app.services.remnawave_service import RemnaWaveService
 from app.states import RegistrationStates
 from app.utils.check_reg_process import is_registration_process
+from app.utils.validators import sanitize_telegram_name

 logger = logging.getLogger(__name__)

@@ -23,7 +24,7 @@ async def _refresh_remnawave_description(
 ) -> None:
    try:
        remnawave_service = RemnaWaveService()
-        async with remnawave_service.api as api:
+        async with remnawave_service.get_api_client() as api:
            await api.update_user(uuid=remnawave_uuid, description=description)
        logger.info(
            f"✅ [Middleware] Описание пользователя {telegram_id} обновлено в RemnaWave"
@@ -115,6 +116,7 @@ class AuthMiddleware(BaseMiddleware):
                            current_state = await state.get_state()
                        
                        registration_states = [
+                            RegistrationStates.waiting_for_language.state,
                            RegistrationStates.waiting_for_rules_accept.state,
                            RegistrationStates.waiting_for_referral_code.state
                        ]
@@ -125,7 +127,10 @@ class AuthMiddleware(BaseMiddleware):
                            or (
                                isinstance(event, CallbackQuery)
                                and event.data
-                                and (event.data in ['rules_accept', 'rules_decline', 'referral_skip'])
+                                and (
+                                    event.data in ['rules_accept', 'rules_decline', 'referral_skip']
+                                    or event.data.startswith('language_select:')
+                                )
                            )
                        )
                        
@@ -158,15 +163,17 @@ class AuthMiddleware(BaseMiddleware):
                        logger.info(f"🔄 [Middleware] Username обновлен для {user.id}: '{old_username}' → '{db_user.username}'")
                        profile_updated = True
                    
-                    if db_user.first_name != user.first_name:
+                    safe_first = sanitize_telegram_name(user.first_name)
+                    safe_last = sanitize_telegram_name(user.last_name)
+                    if db_user.first_name != safe_first:
                        old_first_name = db_user.first_name
-                        db_user.first_name = user.first_name
+                        db_user.first_name = safe_first
                        logger.info(f"🔄 [Middleware] Имя обновлено для {user.id}: '{old_first_name}' → '{db_user.first_name}'")
                        profile_updated = True
                    
-                    if db_user.last_name != user.last_name:
+                    if db_user.last_name != safe_last:
                        old_last_name = db_user.last_name
-                        db_user.last_name = user.last_name
+                        db_user.last_name = safe_last
                        logger.info(f"🔄 [Middleware] Фамилия обновлена для {user.id}: '{old_last_name}' → '{db_user.last_name}'")
                        profile_updated = True
                    
@@ -7,10 +7,15 @@ from aiogram.types import TelegramObject, Update, Message, CallbackQuery
 from aiogram.enums import ChatMemberStatus

 from app.config import settings
+from app.database.database import get_db
+from app.database.crud.subscription import deactivate_subscription
+from app.database.crud.user import get_user_by_telegram_id
+from app.database.models import SubscriptionStatus
 from app.keyboards.inline import get_channel_sub_keyboard
 from app.localization.loader import DEFAULT_LANGUAGE
 from app.localization.texts import get_texts
 from app.utils.check_reg_process import is_registration_process
+from app.services.subscription_service import SubscriptionService

 logger = logging.getLogger(__name__)

@@ -49,6 +54,16 @@ class ChannelCheckerMiddleware(BaseMiddleware):
            return await handler(event, data)


+        # Админам разрешаем пропускать проверку подписки, чтобы не блокировать
+        # работу панели управления даже при отсутствии подписки. Важно делать
+        # это до обращения к состоянию, чтобы не выполнять лишние операции.
+        if settings.is_admin(telegram_id):
+            logger.debug(
+                "✅ Пользователь %s является администратором — пропускаем проверку подписки",
+                telegram_id,
+            )
+            return await handler(event, data)
+
        state: FSMContext = data.get('state')
        current_state = None

@@ -85,11 +100,14 @@ class ChannelCheckerMiddleware(BaseMiddleware):
                return await handler(event, data)
            elif member.status in self.BAD_MEMBER_STATUS:
                logger.info(f"❌ Пользователь {telegram_id} не подписан на канал (статус: {member.status})")
-                
+
+                if telegram_id:
+                    await self._deactivate_trial_subscription(telegram_id)
+
                if isinstance(event, CallbackQuery) and event.data == "sub_channel_check":
                    await event.answer("❌ Вы еще не подписались на канал! Подпишитесь и попробуйте снова.", show_alert=True)
-                    return 
-                
+                    return
+
                return await self._deny_message(event, bot, channel_link)
            else:
                logger.warning(f"⚠️ Неожиданный статус пользователя {telegram_id}: {member.status}")
@@ -110,6 +128,53 @@ class ChannelCheckerMiddleware(BaseMiddleware):
            logger.error(f"❌ Неожиданная ошибка при проверке подписки: {e}")
            return await handler(event, data)

+    async def _deactivate_trial_subscription(self, telegram_id: int) -> None:
+        async for db in get_db():
+            try:
+                user = await get_user_by_telegram_id(db, telegram_id)
+                if not user or not user.subscription:
+                    logger.debug(
+                        "⚠️ Пользователь %s отсутствует или не имеет подписки — пропускаем деактивацию",
+                        telegram_id,
+                    )
+                    break
+
+                subscription = user.subscription
+                if (not subscription.is_trial or
+                        subscription.status != SubscriptionStatus.ACTIVE.value):
+                    logger.debug(
+                        "ℹ️ Подписка пользователя %s не требует деактивации (trial=%s, status=%s)",
+                        telegram_id,
+                        subscription.is_trial,
+                        subscription.status,
+                    )
+                    break
+
+                await deactivate_subscription(db, subscription)
+                logger.info(
+                    "🚫 Триальная подписка пользователя %s отключена после отписки от канала",
+                    telegram_id,
+                )
+
+                if user.remnawave_uuid:
+                    service = SubscriptionService()
+                    try:
+                        await service.disable_remnawave_user(user.remnawave_uuid)
+                    except Exception as api_error:
+                        logger.error(
+                            "❌ Не удалось отключить пользователя RemnaWave %s: %s",
+                            user.remnawave_uuid,
+                            api_error,
+                        )
+            except Exception as db_error:
+                logger.error(
+                    "❌ Ошибка деактивации подписки пользователя %s после отписки: %s",
+                    telegram_id,
+                    db_error,
+                )
+            finally:
+                break
+
    @staticmethod
    async def _deny_message(event: TelegramObject, bot: Bot, channel_link: str):
        logger.debug("🚫 Отправляем сообщение о необходимости подписки")
@@ -3,11 +3,21 @@ from typing import Optional, Dict, Any, List
 from datetime import datetime
 from aiogram import Bot, types
 from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
+from sqlalchemy import select, func
 from sqlalchemy.ext.asyncio import AsyncSession

 from app.config import settings
-from app.database.models import User, Subscription, Transaction
+from app.database.crud.promo_group import get_promo_group_by_id
 from app.database.crud.user import get_user_by_id
+from app.database.models import (
+    AdvertisingCampaign,
+    PromoCodeType,
+    PromoGroup,
+    Subscription,
+    Transaction,
+    TransactionType,
+    User,
+)

 logger = logging.getLogger(__name__)

@@ -24,20 +34,141 @@ class AdminNotificationService:
    async def _get_referrer_info(self, db: AsyncSession, referred_by_id: Optional[int]) -> str:
        if not referred_by_id:
            return "Нет"
-        
+
        try:
            referrer = await get_user_by_id(db, referred_by_id)
            if not referrer:
                return f"ID {referred_by_id} (не найден)"
-            
+
            if referrer.username:
                return f"@{referrer.username} (ID: {referred_by_id})"
            else:
                return f"ID {referrer.telegram_id}"
-                
+
        except Exception as e:
            logger.error(f"Ошибка получения данных рефера {referred_by_id}: {e}")
            return f"ID {referred_by_id}"
+
+    async def _get_user_promo_group(self, db: AsyncSession, user: User) -> Optional[PromoGroup]:
+        if getattr(user, "promo_group", None):
+            return user.promo_group
+
+        if not user.promo_group_id:
+            return None
+
+        try:
+            await db.refresh(user, attribute_names=["promo_group"])
+        except Exception:
+            # relationship might not be available — fallback to direct fetch
+            pass
+
+        if getattr(user, "promo_group", None):
+            return user.promo_group
+
+        try:
+            return await get_promo_group_by_id(db, user.promo_group_id)
+        except Exception as e:
+            logger.error(
+                "Ошибка загрузки промогруппы %s пользователя %s: %s",
+                user.promo_group_id,
+                user.telegram_id,
+                e,
+            )
+            return None
+
+    def _format_promo_group_discounts(self, promo_group: PromoGroup) -> List[str]:
+        discount_lines: List[str] = []
+
+        discount_map = {
+            "servers": ("Серверы", promo_group.server_discount_percent),
+            "traffic": ("Трафик", promo_group.traffic_discount_percent),
+            "devices": ("Устройства", promo_group.device_discount_percent),
+        }
+
+        for _, (title, percent) in discount_map.items():
+            if percent and percent > 0:
+                discount_lines.append(f"• {title}: -{percent}%")
+
+        period_discounts_raw = promo_group.period_discounts or {}
+        period_items: List[tuple[int, int]] = []
+
+        if isinstance(period_discounts_raw, dict):
+            for raw_days, raw_percent in period_discounts_raw.items():
+                try:
+                    days = int(raw_days)
+                    percent = int(raw_percent)
+                except (TypeError, ValueError):
+                    continue
+
+                if percent > 0:
+                    period_items.append((days, percent))
+
+        period_items.sort(key=lambda item: item[0])
+
+        if period_items:
+            formatted_periods = ", ".join(
+                f"{days} д. — -{percent}%" for days, percent in period_items
+            )
+            discount_lines.append(f"• Периоды: {formatted_periods}")
+
+        if promo_group.apply_discounts_to_addons:
+            discount_lines.append("• Доп. услуги: ✅ скидка действует")
+        else:
+            discount_lines.append("• Доп. услуги: ❌ без скидки")
+
+        return discount_lines
+
+    def _format_promo_group_block(
+        self,
+        promo_group: Optional[PromoGroup],
+        *,
+        title: str = "Промогруппа",
+        icon: str = "🏷️",
+    ) -> str:
+        if not promo_group:
+            return f"{icon} <b>{title}:</b> —"
+
+        lines = [f"{icon} <b>{title}:</b> {promo_group.name}"]
+
+        discount_lines = self._format_promo_group_discounts(promo_group)
+        if discount_lines:
+            lines.append("💸 <b>Скидки:</b>")
+            lines.extend(discount_lines)
+        else:
+            lines.append("💸 <b>Скидки:</b> отсутствуют")
+
+        return "\n".join(lines)
+
+    def _get_promocode_type_display(self, promo_type: Optional[str]) -> str:
+        mapping = {
+            PromoCodeType.BALANCE.value: "💰 Бонус на баланс",
+            PromoCodeType.SUBSCRIPTION_DAYS.value: "⏰ Доп. дни подписки",
+            PromoCodeType.TRIAL_SUBSCRIPTION.value: "🎁 Триал подписка",
+        }
+
+        if not promo_type:
+            return "ℹ️ Не указан"
+
+        return mapping.get(promo_type, f"ℹ️ {promo_type}")
+
+    def _format_campaign_bonus(self, campaign: AdvertisingCampaign) -> List[str]:
+        if campaign.is_balance_bonus:
+            return [
+                f"💰 Баланс: {settings.format_price(campaign.balance_bonus_kopeks or 0)}",
+            ]
+
+        if campaign.is_subscription_bonus:
+            default_devices = getattr(settings, "DEFAULT_DEVICE_LIMIT", 1)
+            details = [
+                f"📅 Дней подписки: {campaign.subscription_duration_days or 0}",
+                f"📊 Трафик: {campaign.subscription_traffic_gb or 0} ГБ",
+                f"📱 Устройства: {campaign.subscription_device_limit or default_devices}",
+            ]
+            if campaign.subscription_squads:
+                details.append(f"🌐 Сквады: {len(campaign.subscription_squads)} шт.")
+            return details
+
+        return ["ℹ️ Бонусы не предусмотрены"]
    
    async def send_trial_activation_notification(
        self,
@@ -51,7 +182,9 @@ class AdminNotificationService:
        try:
            user_status = "🆕 Новый" if not user.has_had_paid_subscription else "🔄 Существующий"
            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
-            
+            promo_group = await self._get_user_promo_group(db, user)
+            promo_block = self._format_promo_group_block(promo_group)
+
            message = f"""🎯 <b>АКТИВАЦИЯ ТРИАЛА</b>

 👤 <b>Пользователь:</b> {user.full_name}
@@ -59,6 +192,8 @@ class AdminNotificationService:
 📱 <b>Username:</b> @{user.username or 'отсутствует'}
 👥 <b>Статус:</b> {user_status}

+{promo_block}
+
 ⏰ <b>Параметры триала:</b>
 📅 Период: {settings.TRIAL_DURATION_DAYS} дней
 📊 Трафик: {settings.TRIAL_TRAFFIC_LIMIT_GB} ГБ
@@ -101,7 +236,9 @@ class AdminNotificationService:
            servers_info = await self._get_servers_info(subscription.connected_squads)
            payment_method = self._get_payment_method_display(transaction.payment_method)
            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
-            
+            promo_group = await self._get_user_promo_group(db, user)
+            promo_block = self._format_promo_group_block(promo_group)
+
            message = f"""💎 <b>{event_type}</b>

 👤 <b>Пользователь:</b> {user.full_name}
@@ -109,6 +246,8 @@ class AdminNotificationService:
 📱 <b>Username:</b> @{user.username or 'отсутствует'}
 👥 <b>Статус:</b> {user_status}

+{promo_block}
+
 💰 <b>Платеж:</b>
 💵 Сумма: {settings.format_price(transaction.amount_kopeks)}
 💳 Способ: {payment_method}
@@ -213,13 +352,30 @@ class AdminNotificationService:
    ) -> bool:
        if not self._is_enabled():
            return False
-        
+
        try:
-            topup_status = "🆕 Первое пополнение" if not user.has_made_first_topup else "🔄 Пополнение"
+            deposit_count_result = await db.execute(
+                select(func.count())
+                .select_from(Transaction)
+                .where(
+                    Transaction.user_id == user.id,
+                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.is_completed.is_(True)
+                )
+            )
+            deposit_count = deposit_count_result.scalar_one() or 0
+            topup_status = "🆕 Первое пополнение" if deposit_count <= 1 else "🔄 Пополнение"
            payment_method = self._get_payment_method_display(transaction.payment_method)
            balance_change = user.balance_kopeks - old_balance
            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
-            
+            subscription_result = await db.execute(
+                select(Subscription).where(Subscription.user_id == user.id)
+            )
+            subscription = subscription_result.scalar_one_or_none()
+            subscription_status = self._get_subscription_status(subscription)
+            promo_group = await self._get_user_promo_group(db, user)
+            promo_block = self._format_promo_group_block(promo_group)
+
            message = f"""💰 <b>ПОПОЛНЕНИЕ БАЛАНСА</b>

 👤 <b>Пользователь:</b> {user.full_name}
@@ -227,6 +383,8 @@ class AdminNotificationService:
 📱 <b>Username:</b> @{user.username or 'отсутствует'}
 💳 <b>Статус:</b> {topup_status}

+{promo_block}
+
 💰 <b>Детали пополнения:</b>
 💵 Сумма: {settings.format_price(transaction.amount_kopeks)}
 💳 Способ: {payment_method}
@@ -238,7 +396,7 @@ class AdminNotificationService:
 ➕ Изменение: +{settings.format_price(balance_change)}

 🔗 <b>Реферер:</b> {referrer_info}
-📱 <b>Подписка:</b> {self._get_subscription_status(user)}
+📱 <b>Подписка:</b> {subscription_status}

 ⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
            
@@ -255,21 +413,31 @@ class AdminNotificationService:
        subscription: Subscription,
        transaction: Transaction,
        extended_days: int,
-        old_end_date: datetime
+        old_end_date: datetime,
+        *,
+        new_end_date: datetime | None = None,
+        balance_after: int | None = None,
    ) -> bool:
        if not self._is_enabled():
            return False
-        
+
        try:
            payment_method = self._get_payment_method_display(transaction.payment_method)
            servers_info = await self._get_servers_info(subscription.connected_squads)
-            
+            promo_group = await self._get_user_promo_group(db, user)
+            promo_block = self._format_promo_group_block(promo_group)
+
+            current_end_date = new_end_date or subscription.end_date
+            current_balance = balance_after if balance_after is not None else user.balance_kopeks
+
            message = f"""⏰ <b>ПРОДЛЕНИЕ ПОДПИСКИ</b>

 👤 <b>Пользователь:</b> {user.full_name}
 🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>
 📱 <b>Username:</b> @{user.username or 'отсутствует'}

+{promo_block}
+
 💰 <b>Платеж:</b>
 💵 Сумма: {settings.format_price(transaction.amount_kopeks)}
 💳 Способ: {payment_method}
@@ -278,23 +446,206 @@ class AdminNotificationService:
 📅 <b>Продление:</b>
 ➕ Добавлено дней: {extended_days}
 📆 Было до: {old_end_date.strftime('%d.%m.%Y %H:%M')}
-📆 Стало до: {subscription.end_date.strftime('%d.%m.%Y %H:%M')}
+📆 Стало до: {current_end_date.strftime('%d.%m.%Y %H:%M')}

 📱 <b>Текущие параметры:</b>
 📊 Трафик: {self._format_traffic(subscription.traffic_limit_gb)}
 📱 Устройства: {subscription.device_limit}
 🌐 Серверы: {servers_info}

-💰 <b>Баланс после операции:</b> {settings.format_price(user.balance_kopeks)}
+💰 <b>Баланс после операции:</b> {settings.format_price(current_balance)}

 ⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
-            
+
            return await self._send_message(message)
-            
+
        except Exception as e:
            logger.error(f"Ошибка отправки уведомления о продлении: {e}")
            return False
-    
+
+    async def send_promocode_activation_notification(
+        self,
+        db: AsyncSession,
+        user: User,
+        promocode_data: Dict[str, Any],
+        effect_description: str,
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+
+        try:
+            promo_group = await self._get_user_promo_group(db, user)
+            promo_block = self._format_promo_group_block(promo_group)
+            type_display = self._get_promocode_type_display(promocode_data.get("type"))
+            usage_info = f"{promocode_data.get('current_uses', 0)}/{promocode_data.get('max_uses', 0)}"
+
+            message_lines = [
+                "🎫 <b>АКТИВАЦИЯ ПРОМОКОДА</b>",
+                "",
+                f"👤 <b>Пользователь:</b> {user.full_name}",
+                f"🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>",
+                f"📱 <b>Username:</b> @{user.username or 'отсутствует'}",
+                "",
+                promo_block,
+                "",
+                "🎟️ <b>Промокод:</b>",
+                f"🔖 Код: <code>{promocode_data.get('code')}</code>",
+                f"🧾 Тип: {type_display}",
+                f"📊 Использования: {usage_info}",
+            ]
+
+            balance_bonus = promocode_data.get("balance_bonus_kopeks", 0)
+            if balance_bonus:
+                message_lines.append(
+                    f"💰 Бонус на баланс: {settings.format_price(balance_bonus)}"
+                )
+
+            subscription_days = promocode_data.get("subscription_days", 0)
+            if subscription_days:
+                message_lines.append(f"📅 Доп. дни подписки: {subscription_days}")
+
+            valid_until = promocode_data.get("valid_until")
+            if valid_until:
+                message_lines.append(
+                    f"⏳ Действует до: {valid_until.strftime('%d.%m.%Y %H:%M')}"
+                    if isinstance(valid_until, datetime)
+                    else f"⏳ Действует до: {valid_until}"
+                )
+
+            message_lines.extend(
+                [
+                    "",
+                    "📝 <b>Эффект:</b>",
+                    effect_description.strip() or "✅ Промокод активирован",
+                    "",
+                    f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>",
+                ]
+            )
+
+            return await self._send_message("\n".join(message_lines))
+
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об активации промокода: {e}")
+            return False
+
+    async def send_campaign_link_visit_notification(
+        self,
+        db: AsyncSession,
+        telegram_user: types.User,
+        campaign: AdvertisingCampaign,
+        user: Optional[User] = None,
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+
+        try:
+            user_status = "🆕 Новый пользователь" if not user else "👥 Уже зарегистрирован"
+            promo_block = (
+                self._format_promo_group_block(await self._get_user_promo_group(db, user))
+                if user
+                else self._format_promo_group_block(None)
+            )
+
+            full_name = telegram_user.full_name or telegram_user.username or str(telegram_user.id)
+            username = f"@{telegram_user.username}" if telegram_user.username else "отсутствует"
+
+            message_lines = [
+                "📣 <b>ПЕРЕХОД ПО РЕКЛАМНОЙ КАМПАНИИ</b>",
+                "",
+                f"🧾 <b>Кампания:</b> {campaign.name}",
+                f"🆔 ID кампании: {campaign.id}",
+                f"🔗 Start-параметр: <code>{campaign.start_parameter}</code>",
+                "",
+                f"👤 <b>Пользователь:</b> {full_name}",
+                f"🆔 <b>Telegram ID:</b> <code>{telegram_user.id}</code>",
+                f"📱 <b>Username:</b> {username}",
+                user_status,
+                "",
+                promo_block,
+                "",
+                "🎯 <b>Бонус кампании:</b>",
+            ]
+
+            bonus_lines = self._format_campaign_bonus(campaign)
+            message_lines.extend(bonus_lines)
+
+            message_lines.extend(
+                [
+                    "",
+                    f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>",
+                ]
+            )
+
+            return await self._send_message("\n".join(message_lines))
+
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о переходе по кампании: {e}")
+            return False
+
+    async def send_user_promo_group_change_notification(
+        self,
+        db: AsyncSession,
+        user: User,
+        old_group: Optional[PromoGroup],
+        new_group: PromoGroup,
+        *,
+        reason: Optional[str] = None,
+        initiator: Optional[User] = None,
+        automatic: bool = False,
+    ) -> bool:
+        if not self._is_enabled():
+            return False
+
+        try:
+            title = "🤖 АВТОМАТИЧЕСКАЯ СМЕНА ПРОМОГРУППЫ" if automatic else "👥 СМЕНА ПРОМОГРУППЫ"
+            initiator_line = None
+            if initiator:
+                initiator_line = (
+                    f"👮 <b>Инициатор:</b> {initiator.full_name} (ID: {initiator.telegram_id})"
+                )
+            elif automatic:
+                initiator_line = "🤖 Автоматическое назначение"
+
+            message_lines = [
+                f"{title}",
+                "",
+                f"👤 <b>Пользователь:</b> {user.full_name}",
+                f"🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>",
+                f"📱 <b>Username:</b> @{user.username or 'отсутствует'}",
+                "",
+                self._format_promo_group_block(new_group, title="Новая промогруппа", icon="🏆"),
+            ]
+
+            if old_group and old_group.id != new_group.id:
+                message_lines.extend(
+                    [
+                        "",
+                        self._format_promo_group_block(
+                            old_group, title="Предыдущая промогруппа", icon="♻️"
+                        ),
+                    ]
+                )
+
+            if initiator_line:
+                message_lines.extend(["", initiator_line])
+
+            if reason:
+                message_lines.extend(["", f"📝 Причина: {reason}"])
+
+            message_lines.extend(
+                [
+                    "",
+                    f"💰 Баланс пользователя: {settings.format_price(user.balance_kopeks)}",
+                    f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>",
+                ]
+            )
+
+            return await self._send_message("\n".join(message_lines))
+
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о смене промогруппы: {e}")
+            return False
+
    async def _send_message(self, text: str, reply_markup: types.InlineKeyboardMarkup | None = None, *, ticket_event: bool = False) -> bool:
        if not self.chat_id:
            logger.warning("ADMIN_NOTIFICATIONS_CHAT_ID не настроен")
@@ -341,6 +692,8 @@ class AdminNotificationService:
            'telegram_stars': '⭐ Telegram Stars',
            'yookassa': '💳 YooKassa (карта)',
            'tribute': '💎 Tribute (карта)',
+            'mulenpay': '💳 Mulen Pay (карта)',
+            'pal24': '🏦 PayPalych (СБП)',
            'manual': '🛠️ Вручную (админ)',
            'balance': '💰 С баланса'
        }
@@ -348,22 +701,21 @@ class AdminNotificationService:
        if not payment_method:
            return '💰 С баланса'
            
-        return method_names.get(payment_method, f'💰 С баланса')
+        return method_names.get(payment_method, '💰 С баланса')
    
    def _format_traffic(self, traffic_gb: int) -> str:
        if traffic_gb == 0:
            return "∞ Безлимит"
        return f"{traffic_gb} ГБ"
    
-    def _get_subscription_status(self, user: User) -> str:
-        if not user.subscription:
+    def _get_subscription_status(self, subscription: Optional[Subscription]) -> str:
+        if not subscription:
            return "❌ Нет подписки"
-        
-        sub = user.subscription
-        if sub.is_trial:
-            return f"🎯 Триал (до {sub.end_date.strftime('%d.%m')})"
-        elif sub.is_active:
-            return f"✅ Активна (до {sub.end_date.strftime('%d.%m')})"
+
+        if subscription.is_trial:
+            return f"🎯 Триал (до {subscription.end_date.strftime('%d.%m')})"
+        elif subscription.is_active:
+            return f"✅ Активна (до {subscription.end_date.strftime('%d.%m')})"
        else:
            return "❌ Неактивна"
    
@@ -396,40 +748,32 @@ class AdminNotificationService:
                if details.get("auto_enabled", False):
                    icon = "⚠️"
                    title = "АВТОМАТИЧЕСКОЕ ВКЛЮЧЕНИЕ ТЕХРАБОТ"
-                    alert_type = "warning"
                else:
                    icon = "🔧"
                    title = "ВКЛЮЧЕНИЕ ТЕХРАБОТ"
-                    alert_type = "info"
                    
            elif event_type == "disable":
                icon = "✅"
                title = "ОТКЛЮЧЕНИЕ ТЕХРАБОТ"
-                alert_type = "success"
                
            elif event_type == "api_status":
                if status == "online":
                    icon = "🟢"
                    title = "API REMNAWAVE ВОССТАНОВЛЕНО"
-                    alert_type = "success"
                else:
                    icon = "🔴"
                    title = "API REMNAWAVE НЕДОСТУПНО"
-                    alert_type = "error"
                    
            elif event_type == "monitoring":
                if status == "started":
                    icon = "🔍"
                    title = "МОНИТОРИНГ ЗАПУЩЕН"
-                    alert_type = "info"
                else:
                    icon = "⏹️"
                    title = "МОНИТОРИНГ ОСТАНОВЛЕН"
-                    alert_type = "info"
            else:
                icon = "ℹ️"
                title = "СИСТЕМА ТЕХРАБОТ"
-                alert_type = "info"
            
            message_parts = [f"{icon} <b>{title}</b>", ""]
            
@@ -619,103 +963,6 @@ class AdminNotificationService:
            logger.error(f"Ошибка отправки уведомления о статусе панели Remnawave: {e}")
            return False

-    async def send_remnawave_panel_status_notification(
-        self,
-        status: str,
-        details: Dict[str, Any] = None
-    ) -> bool:
-        if not self._is_enabled():
-            return False
-        
-        try:
-            details = details or {}
-            
-            status_config = {
-                "online": {"icon": "🟢", "title": "ПАНЕЛЬ REMNAWAVE ДОСТУПНА", "alert_type": "success"},
-                "offline": {"icon": "🔴", "title": "ПАНЕЛЬ REMNAWAVE НЕДОСТУПНА", "alert_type": "error"},
-                "degraded": {"icon": "🟡", "title": "ПАНЕЛЬ REMNAWAVE РАБОТАЕТ СО СБОЯМИ", "alert_type": "warning"},
-                "maintenance": {"icon": "🔧", "title": "ПАНЕЛЬ REMNAWAVE НА ОБСЛУЖИВАНИИ", "alert_type": "info"}
-            }
-            
-            config = status_config.get(status, status_config["offline"])
-            
-            message_parts = [
-                f"{config['icon']} <b>{config['title']}</b>",
-                ""
-            ]
-            
-            if details.get("api_url"):
-                message_parts.append(f"🔗 <b>URL:</b> {details['api_url']}")
-                
-            if details.get("response_time"):
-                message_parts.append(f"⚡ <b>Время отклика:</b> {details['response_time']} сек")
-                
-            if details.get("last_check"):
-                last_check = details["last_check"]
-                if isinstance(last_check, str):
-                    from datetime import datetime
-                    last_check = datetime.fromisoformat(last_check)
-                message_parts.append(f"🕐 <b>Последняя проверка:</b> {last_check.strftime('%H:%M:%S')}")
-                
-            if status == "online":
-                if details.get("uptime"):
-                    message_parts.append(f"⏱️ <b>Время работы:</b> {details['uptime']}")
-                    
-                if details.get("users_online"):
-                    message_parts.append(f"👥 <b>Пользователей онлайн:</b> {details['users_online']}")
-                    
-                message_parts.append("")
-                message_parts.append("✅ Все системы работают нормально.")
-                
-            elif status == "offline":
-                if details.get("error"):
-                    error_msg = str(details["error"])[:150]
-                    message_parts.append(f"❌ <b>Ошибка:</b> {error_msg}")
-                    
-                if details.get("consecutive_failures"):
-                    message_parts.append(f"🔄 <b>Неудачных попыток:</b> {details['consecutive_failures']}")
-                    
-                message_parts.append("")
-                message_parts.append("⚠️ Панель недоступна. Проверьте соединение и статус сервера.")
-                
-            elif status == "degraded":
-                if details.get("issues"):
-                    issues = details["issues"]
-                    if isinstance(issues, list):
-                        message_parts.append("⚠️ <b>Обнаруженные проблемы:</b>")
-                        for issue in issues[:3]: 
-                            message_parts.append(f"   • {issue}")
-                    else:
-                        message_parts.append(f"⚠️ <b>Проблема:</b> {issues}")
-                        
-                message_parts.append("")
-                message_parts.append("Панель работает, но возможны задержки или сбои.")
-                
-            elif status == "maintenance":
-                if details.get("maintenance_reason"):
-                    message_parts.append(f"🔧 <b>Причина:</b> {details['maintenance_reason']}")
-                    
-                if details.get("estimated_duration"):
-                    message_parts.append(f"⏰ <b>Ожидаемая длительность:</b> {details['estimated_duration']}")
-                    
-                if details.get("manual_message"):
-                    message_parts.append(f"💬 <b>Сообщение:</b> {details['manual_message']}")
-                    
-                message_parts.append("")
-                message_parts.append("Панель временно недоступна для обслуживания.")
-            
-            from datetime import datetime
-            message_parts.append("")
-            message_parts.append(f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>")
-            
-            message = "\n".join(message_parts)
-            
-            return await self._send_message(message)
-            
-        except Exception as e:
-            logger.error(f"Ошибка отправки уведомления о статусе панели Remnawave: {e}")
-            return False
-
    async def send_subscription_update_notification(
        self,
        db: AsyncSession,
@@ -731,50 +978,64 @@ class AdminNotificationService:
        
        try:
            referrer_info = await self._get_referrer_info(db, user.referred_by_id)
-            
+            promo_group = await self._get_user_promo_group(db, user)
+            promo_block = self._format_promo_group_block(promo_group)
+
            update_types = {
                "traffic": ("📊 ИЗМЕНЕНИЕ ТРАФИКА", "трафик"),
-                "devices": ("📱 ИЗМЕНЕНИЕ УСТРОЙСТВ", "количество устройств"), 
+                "devices": ("📱 ИЗМЕНЕНИЕ УСТРОЙСТВ", "количество устройств"),
                "servers": ("🌐 ИЗМЕНЕНИЕ СЕРВЕРОВ", "серверы")
            }
-            
+
            title, param_name = update_types.get(update_type, ("⚙️ ИЗМЕНЕНИЕ ПОДПИСКИ", "параметры"))
-            
-            message = f"""{title}

-    👤 <b>Пользователь:</b> {user.full_name}
-    🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>
-    📱 <b>Username:</b> @{user.username or 'отсутствует'}
-
-    🔧 <b>Изменение:</b>
-    📋 Параметр: {param_name}"""
+            message_lines = [
+                f"{title}",
+                "",
+                f"👤 <b>Пользователь:</b> {user.full_name}",
+                f"🆔 <b>Telegram ID:</b> <code>{user.telegram_id}</code>",
+                f"📱 <b>Username:</b> @{user.username or 'отсутствует'}",
+                "",
+                promo_block,
+                "",
+                "🔧 <b>Изменение:</b>",
+                f"📋 Параметр: {param_name}",
+            ]

            if update_type == "servers":
                old_servers_info = await self._format_servers_detailed(old_value)
                new_servers_info = await self._format_servers_detailed(new_value)
-                
-                message += f"""
-    📉 Было: {old_servers_info}
-    📈 Стало: {new_servers_info}"""
+                message_lines.extend(
+                    [
+                        f"📉 Было: {old_servers_info}",
+                        f"📈 Стало: {new_servers_info}",
+                    ]
+                )
            else:
-                message += f"""
-    📉 Было: {self._format_update_value(old_value, update_type)}
-    📈 Стало: {self._format_update_value(new_value, update_type)}"""
+                message_lines.extend(
+                    [
+                        f"📉 Было: {self._format_update_value(old_value, update_type)}",
+                        f"📈 Стало: {self._format_update_value(new_value, update_type)}",
+                    ]
+                )

            if price_paid > 0:
-                message += f"\n💰 Доплачено: {settings.format_price(price_paid)}"
+                message_lines.append(f"💰 Доплачено: {settings.format_price(price_paid)}")
            else:
-                message += f"\n💸 Бесплатно"
+                message_lines.append("💸 Бесплатно")

-            message += f"""
+            message_lines.extend(
+                [
+                    "",
+                    f"📅 <b>Подписка действует до:</b> {subscription.end_date.strftime('%d.%m.%Y %H:%M')}",
+                    f"💰 <b>Баланс после операции:</b> {settings.format_price(user.balance_kopeks)}",
+                    f"🔗 <b>Рефер:</b> {referrer_info}",
+                    "",
+                    f"⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>",
+                ]
+            )

-    📅 <b>Подписка действует до:</b> {subscription.end_date.strftime('%d.%m.%Y %H:%M')}
-    💰 <b>Баланс после операции:</b> {settings.format_price(user.balance_kopeks)}
-    🔗 <b>Рефер:</b> {referrer_info}
-
-    ⏰ <i>{datetime.now().strftime('%d.%m.%Y %H:%M:%S')}</i>"""
-            
-            return await self._send_message(message)
+            return await self._send_message("\n".join(message_lines))
            
        except Exception as e:
            logger.error(f"Ошибка отправки уведомления об изменении подписки: {e}")
@@ -818,7 +1079,13 @@ class AdminNotificationService:
        """Публичный метод для отправки уведомлений по тикетам в админ-топик.
        Учитывает настройки включенности в settings.
        """
-        if not self._is_enabled():
+        # Respect runtime toggle for admin ticket notifications
+        try:
+            from app.services.support_settings_service import SupportSettingsService
+            runtime_enabled = SupportSettingsService.get_admin_ticket_notifications_enabled()
+        except Exception:
+            runtime_enabled = True
+        if not (self._is_enabled() and runtime_enabled):
            return False
        return await self._send_message(text, reply_markup=keyboard, ticket_event=True)

@@ -12,6 +12,7 @@ import aiofiles
 from aiogram.types import FSInputFile
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, text, inspect
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import selectinload

 from app.config import settings
@@ -21,7 +22,10 @@ from app.database.models import (
    ReferralEarning, Squad, ServiceRule, SystemSetting, MonitoringLog,
    SubscriptionConversion, SentNotification, BroadcastHistory,
    ServerSquad, SubscriptionServer, UserMessage, YooKassaPayment,
-    CryptoBotPayment, WelcomeText, Base
+    CryptoBotPayment, WelcomeText, Base, PromoGroup, AdvertisingCampaign,
+    AdvertisingCampaignRegistration, SupportAuditLog, Ticket, TicketMessage,
+    MulenPayPayment, Pal24Payment, DiscountOffer, WebApiToken,
+    server_squad_promo_groups
 )

 logger = logging.getLogger(__name__)
@@ -30,7 +34,7 @@ logger = logging.getLogger(__name__)
@dataclass
 class BackupMetadata:
    timestamp: str
-    version: str = "1.1" 
+    version: str = "1.2"
    database_type: str = "postgresql"
    backup_type: str = "full"
    tables_count: int = 0
@@ -61,32 +65,43 @@ class BackupService:
        self._settings = self._load_settings()
        
        self.backup_models_ordered = [
-            ServiceRule, 
            SystemSetting,
+            ServiceRule,
            Squad,
-            PromoCode,
            ServerSquad,
-            
-            User, 
-            
-            WelcomeText, 
+            PromoGroup,
+            User,
+            PromoCode,
+            WelcomeText,
+            UserMessage,
            Subscription,
+            SubscriptionServer,
+            SubscriptionConversion,
            Transaction,
            YooKassaPayment,
            CryptoBotPayment,
+            MulenPayPayment,
+            Pal24Payment,
            PromoCodeUse,
            ReferralEarning,
-            SubscriptionConversion,
+            SentNotification,
+            DiscountOffer,
            BroadcastHistory,
-            UserMessage,
-            
-            SentNotification, 
-            SubscriptionServer,  
+            AdvertisingCampaign,
+            AdvertisingCampaignRegistration,
+            Ticket,
+            TicketMessage,
+            SupportAuditLog,
+            WebApiToken,
        ]
-        
+
        if self._settings.include_logs:
            self.backup_models_ordered.append(MonitoringLog)

+        self.association_tables = {
+            "server_squad_promo_groups": server_squad_promo_groups,
+        }
+
    def _load_settings(self) -> BackupSettings:
        return BackupSettings(
            auto_backup_enabled=os.getenv("BACKUP_AUTO_ENABLED", "true").lower() == "true",
@@ -164,6 +179,7 @@ class BackupService:
                models_to_backup.append(MonitoringLog)
            
            backup_data = {}
+            association_data = {}
            total_records = 0
            
            async for db in get_db():
@@ -207,7 +223,11 @@ class BackupService:
                        total_records += len(table_data)
                        
                        logger.info(f"✅ Экспортировано {len(table_data)} записей из {table_name}")
-                    
+
+                    association_data = await self._export_association_tables(db)
+                    for records in association_data.values():
+                        total_records += len(records)
+
                    break
                except Exception as e:
                    logger.error(f"Ошибка при экспорте данных: {e}")
@@ -219,7 +239,7 @@ class BackupService:
                timestamp=datetime.utcnow().isoformat(),
                database_type="postgresql" if settings.is_postgresql() else "sqlite",
                backup_type="full",
-                tables_count=len(models_to_backup),
+                tables_count=len(models_to_backup) + len(association_data),
                total_records=total_records,
                compressed=compress,
                created_by=created_by,
@@ -232,10 +252,17 @@ class BackupService:
                filename += ".gz"
            
            backup_path = self.backup_dir / filename
-            
+
+            file_snapshots = await self._collect_file_snapshots()
+
            backup_structure = {
                "metadata": asdict(metadata),
-                "data": backup_data
+                "data": backup_data,
+                "associations": association_data,
+                "files": file_snapshots,
+                "config": {
+                    "backup_settings": asdict(self._settings)
+                }
            }
            
            if compress:
@@ -264,7 +291,7 @@ class BackupService:
            size_mb = file_size / 1024 / 1024
            message = (f"✅ Бекап успешно создан!\n"
                      f"📁 Файл: {filename}\n"
-                      f"📊 Таблиц: {len(models_to_backup)}\n"
+                      f"📊 Таблиц: {metadata.tables_count}\n"
                      f"📈 Записей: {total_records:,}\n"
                      f"💾 Размер: {size_mb:.2f} MB")
            
@@ -312,6 +339,8 @@ class BackupService:
            
            metadata = backup_structure.get("metadata", {})
            backup_data = backup_structure.get("data", {})
+            association_data = backup_structure.get("associations", {})
+            file_snapshots = backup_structure.get("files", {})
            
            if not backup_data:
                return False, "❌ Файл бекапа не содержит данных"
@@ -329,60 +358,55 @@ class BackupService:
                        await self._clear_database_tables(db)
                    
                    models_by_table = {model.__tablename__: model for model in self.backup_models_ordered}
-                    
-                    await self._restore_users_without_referrals(db, backup_data, models_by_table)
-                    
-                    for model in self.backup_models_ordered:
-                        table_name = model.__tablename__
-                        
-                        if table_name == "users":
+
+                    pre_restore_tables = {"promo_groups"}
+                    for table_name in pre_restore_tables:
+                        model = models_by_table.get(table_name)
+                        if not model:
                            continue
-                            
+
                        records = backup_data.get(table_name, [])
                        if not records:
                            continue
-                        
+
                        logger.info(f"🔥 Восстанавливаем таблицу {table_name} ({len(records)} записей)")
-                        
-                        for record_data in records:
-                            try:
-                                processed_data = self._process_record_data(record_data, model, table_name)
-                                
-                                primary_key_col = self._get_primary_key_column(model)
-                                
-                                if primary_key_col and primary_key_col in processed_data:
-                                    existing_record = await db.execute(
-                                        select(model).where(
-                                            getattr(model, primary_key_col) == processed_data[primary_key_col]
-                                        )
-                                    )
-                                    existing = existing_record.scalar_one_or_none()
-                                    
-                                    if existing and not clear_existing:
-                                        for key, value in processed_data.items():
-                                            if key != primary_key_col:
-                                                setattr(existing, key, value)
-                                        logger.debug(f"Обновлена существующая запись {primary_key_col}={processed_data[primary_key_col]} в {table_name}")
-                                    else:
-                                        instance = model(**processed_data)
-                                        db.add(instance)
-                                else:
-                                    instance = model(**processed_data)
-                                    db.add(instance)
-                                
-                                restored_records += 1
-                                
-                            except Exception as e:
-                                logger.error(f"Ошибка восстановления записи в {table_name}: {e}")
-                                logger.error(f"Проблемные данные: {record_data}")
-                                await db.rollback()
-                                raise e
-                        
-                        restored_tables += 1
-                        logger.info(f"✅ Таблица {table_name} восстановлена")
-                    
+                        restored = await self._restore_table_records(db, model, table_name, records, clear_existing)
+                        restored_records += restored
+
+                        if restored:
+                            restored_tables += 1
+                            logger.info(f"✅ Таблица {table_name} восстановлена")
+
+                    await self._restore_users_without_referrals(db, backup_data, models_by_table)
+
+                    for model in self.backup_models_ordered:
+                        table_name = model.__tablename__
+
+                        if table_name == "users" or table_name in pre_restore_tables:
+                            continue
+
+                        records = backup_data.get(table_name, [])
+                        if not records:
+                            continue
+
+                        logger.info(f"🔥 Восстанавливаем таблицу {table_name} ({len(records)} записей)")
+                        restored = await self._restore_table_records(db, model, table_name, records, clear_existing)
+                        restored_records += restored
+
+                        if restored:
+                            restored_tables += 1
+                            logger.info(f"✅ Таблица {table_name} восстановлена")
+
                    await self._update_user_referrals(db, backup_data)
-                    
+
+                    assoc_tables, assoc_records = await self._restore_association_tables(
+                        db,
+                        association_data,
+                        clear_existing
+                    )
+                    restored_tables += assoc_tables
+                    restored_records += assoc_records
+
                    await db.commit()
                    
                    break
@@ -403,6 +427,11 @@ class BackupService:
            
            if self.bot:
                await self._send_backup_notification("restore_success", message)
+
+            if file_snapshots:
+                restored_files = await self._restore_file_snapshots(file_snapshots)
+                if restored_files:
+                    logger.info(f"📁 Восстановлено файлов конфигурации: {restored_files}")
            
            return True, message
            
@@ -549,14 +578,156 @@ class BackupService:
                return col.name
        return None

+    async def _export_association_tables(self, db: AsyncSession) -> Dict[str, List[Dict[str, Any]]]:
+        association_data: Dict[str, List[Dict[str, Any]]] = {}
+
+        for table_name, table_obj in self.association_tables.items():
+            try:
+                logger.info(f"📊 Экспортируем таблицу связей: {table_name}")
+                result = await db.execute(select(table_obj))
+                rows = result.mappings().all()
+                association_data[table_name] = [dict(row) for row in rows]
+                logger.info(
+                    f"✅ Экспортировано {len(rows)} связей из {table_name}"
+                )
+            except Exception as e:
+                logger.error(f"Ошибка экспорта таблицы связей {table_name}: {e}")
+
+        return association_data
+
+    async def _restore_association_tables(
+        self,
+        db: AsyncSession,
+        association_data: Dict[str, List[Dict[str, Any]]],
+        clear_existing: bool
+    ) -> Tuple[int, int]:
+        if not association_data:
+            return 0, 0
+
+        restored_tables = 0
+        restored_records = 0
+
+        if "server_squad_promo_groups" in association_data:
+            restored = await self._restore_server_squad_promo_groups(
+                db,
+                association_data["server_squad_promo_groups"],
+                clear_existing
+            )
+            restored_tables += 1
+            restored_records += restored
+
+        return restored_tables, restored_records
+
+    async def _restore_server_squad_promo_groups(
+        self,
+        db: AsyncSession,
+        records: List[Dict[str, Any]],
+        clear_existing: bool
+    ) -> int:
+        if not records:
+            return 0
+
+        if clear_existing:
+            await db.execute(server_squad_promo_groups.delete())
+
+        restored = 0
+
+        for record in records:
+            server_id = record.get("server_squad_id")
+            promo_id = record.get("promo_group_id")
+
+            if server_id is None or promo_id is None:
+                logger.warning(
+                    "Пропущена некорректная запись server_squad_promo_groups: %s",
+                    record
+                )
+                continue
+
+            try:
+                await db.execute(
+                    server_squad_promo_groups.insert().values(
+                        server_squad_id=server_id,
+                        promo_group_id=promo_id
+                    )
+                )
+                restored += 1
+            except IntegrityError:
+                logger.debug(
+                    "Запись server_squad_promo_groups (%s, %s) уже существует",
+                    server_id,
+                    promo_id
+                )
+            except Exception as e:
+                logger.error(
+                    "Ошибка при восстановлении связи server_squad_promo_groups (%s, %s): %s",
+                    server_id,
+                    promo_id,
+                    e
+                )
+                await db.rollback()
+                raise e
+
+        return restored
+
+    async def _restore_table_records(
+        self,
+        db: AsyncSession,
+        model,
+        table_name: str,
+        records: List[Dict[str, Any]],
+        clear_existing: bool
+    ) -> int:
+        restored_count = 0
+
+        for record_data in records:
+            try:
+                processed_data = self._process_record_data(record_data, model, table_name)
+
+                primary_key_col = self._get_primary_key_column(model)
+
+                if primary_key_col and primary_key_col in processed_data:
+                    existing_record = await db.execute(
+                        select(model).where(
+                            getattr(model, primary_key_col) == processed_data[primary_key_col]
+                        )
+                    )
+                    existing = existing_record.scalar_one_or_none()
+
+                    if existing and not clear_existing:
+                        for key, value in processed_data.items():
+                            if key != primary_key_col:
+                                setattr(existing, key, value)
+                    else:
+                        instance = model(**processed_data)
+                        db.add(instance)
+                else:
+                    instance = model(**processed_data)
+                    db.add(instance)
+
+                restored_count += 1
+
+            except Exception as e:
+                logger.error(f"Ошибка восстановления записи в {table_name}: {e}")
+                logger.error(f"Проблемные данные: {record_data}")
+                await db.rollback()
+                raise e
+
+        return restored_count
+
    async def _clear_database_tables(self, db: AsyncSession):
        tables_order = [
-            "subscription_servers", "sent_notifications", 
-            "user_messages", "broadcast_history", "subscription_conversions", 
-            "referral_earnings", "promocode_uses", "transactions", 
-            "yookassa_payments", "cryptobot_payments", "welcome_texts",
-            "subscriptions", "users", "promocodes", "server_squads", 
-            "squads", "service_rules", "system_settings", "monitoring_logs"
+            "server_squad_promo_groups",
+            "ticket_messages", "tickets", "support_audit_logs",
+            "advertising_campaign_registrations", "advertising_campaigns",
+            "subscription_servers", "sent_notifications",
+            "discount_offers", "user_messages", "broadcast_history", "subscription_conversions",
+            "referral_earnings", "promocode_uses",
+            "yookassa_payments", "cryptobot_payments",
+            "mulenpay_payments", "pal24_payments",
+            "transactions", "welcome_texts", "subscriptions",
+            "promocodes", "users", "promo_groups",
+            "server_squads", "squads", "service_rules",
+            "system_settings", "web_api_tokens", "monitoring_logs"
        ]
        
        for table_name in tables_order:
@@ -566,6 +737,57 @@ class BackupService:
            except Exception as e:
                logger.warning(f"⚠️ Не удалось очистить таблицу {table_name}: {e}")

+    async def _collect_file_snapshots(self) -> Dict[str, Dict[str, Any]]:
+        snapshots: Dict[str, Dict[str, Any]] = {}
+
+        app_config_path = settings.get_app_config_path()
+        if app_config_path:
+            path_obj = Path(app_config_path)
+            if path_obj.exists() and path_obj.is_file():
+                try:
+                    async with aiofiles.open(path_obj, 'r', encoding='utf-8') as f:
+                        content = await f.read()
+                    snapshots["app_config"] = {
+                        "path": str(path_obj),
+                        "content": content,
+                        "modified_at": datetime.fromtimestamp(
+                            path_obj.stat().st_mtime
+                        ).isoformat()
+                    }
+                    logger.info(
+                        "📁 Добавлен в бекап файл конфигурации: %s",
+                        path_obj
+                    )
+                except Exception as e:
+                    logger.error(
+                        "Ошибка чтения файла конфигурации %s: %s",
+                        path_obj,
+                        e
+                    )
+
+        return snapshots
+
+    async def _restore_file_snapshots(self, file_snapshots: Dict[str, Dict[str, Any]]) -> int:
+        restored_files = 0
+
+        if not file_snapshots:
+            return restored_files
+
+        app_config_snapshot = file_snapshots.get("app_config")
+        if app_config_snapshot:
+            target_path = Path(settings.get_app_config_path())
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+
+            try:
+                async with aiofiles.open(target_path, 'w', encoding='utf-8') as f:
+                    await f.write(app_config_snapshot.get("content", ""))
+                restored_files += 1
+                logger.info("📁 Файл app-config восстановлен по пути %s", target_path)
+            except Exception as e:
+                logger.error("Ошибка восстановления файла %s: %s", target_path, e)
+
+        return restored_files
+
    async def get_backup_list(self) -> List[Dict[str, Any]]:
        backups = []
        
@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from aiogram import Bot
+from aiogram.types import InlineKeyboardMarkup
+
+from app.database.database import AsyncSessionLocal
+from app.database.models import BroadcastHistory
+from app.handlers.admin.messages import (
+    create_broadcast_keyboard,
+    get_custom_users,
+    get_target_users,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+VALID_MEDIA_TYPES = {"photo", "video", "document"}
+
+
+@dataclass(slots=True)
+class BroadcastMediaConfig:
+    type: str
+    file_id: str
+    caption: Optional[str] = None
+
+
+@dataclass(slots=True)
+class BroadcastConfig:
+    target: str
+    message_text: str
+    selected_buttons: list[str]
+    media: Optional[BroadcastMediaConfig] = None
+    initiator_name: Optional[str] = None
+
+
+@dataclass(slots=True)
+class _BroadcastTask:
+    task: asyncio.Task
+    cancel_event: asyncio.Event
+
+
+class BroadcastService:
+    """Handles broadcast execution triggered from the admin web API."""
+
+    def __init__(self) -> None:
+        self._bot: Optional[Bot] = None
+        self._tasks: dict[int, _BroadcastTask] = {}
+        self._lock = asyncio.Lock()
+
+    def set_bot(self, bot: Bot) -> None:
+        self._bot = bot
+
+    def is_running(self, broadcast_id: int) -> bool:
+        task_entry = self._tasks.get(broadcast_id)
+        return bool(task_entry and not task_entry.task.done())
+
+    async def start_broadcast(self, broadcast_id: int, config: BroadcastConfig) -> None:
+        if self._bot is None:
+            logger.error("Невозможно запустить рассылку %s: бот не инициализирован", broadcast_id)
+            await self._mark_failed(broadcast_id)
+            return
+
+        cancel_event = asyncio.Event()
+
+        async with self._lock:
+            if broadcast_id in self._tasks and not self._tasks[broadcast_id].task.done():
+                logger.warning("Рассылка %s уже запущена", broadcast_id)
+                return
+
+            task = asyncio.create_task(
+                self._run_broadcast(broadcast_id, config, cancel_event),
+                name=f"broadcast-{broadcast_id}",
+            )
+            self._tasks[broadcast_id] = _BroadcastTask(task=task, cancel_event=cancel_event)
+            task.add_done_callback(lambda _: self._tasks.pop(broadcast_id, None))
+
+    async def request_stop(self, broadcast_id: int) -> bool:
+        async with self._lock:
+            task_entry = self._tasks.get(broadcast_id)
+            if not task_entry:
+                return False
+
+            task_entry.cancel_event.set()
+            return True
+
+    async def _run_broadcast(
+        self,
+        broadcast_id: int,
+        config: BroadcastConfig,
+        cancel_event: asyncio.Event,
+    ) -> None:
+        sent_count = 0
+        failed_count = 0
+
+        try:
+            if cancel_event.is_set():
+                await self._mark_cancelled(broadcast_id, sent_count, failed_count)
+                return
+
+            async with AsyncSessionLocal() as session:
+                broadcast = await session.get(BroadcastHistory, broadcast_id)
+                if not broadcast:
+                    logger.error("Запись рассылки %s не найдена в БД", broadcast_id)
+                    return
+
+                broadcast.status = "in_progress"
+                broadcast.sent_count = 0
+                broadcast.failed_count = 0
+                await session.commit()
+
+            recipients = await self._fetch_recipients(config.target)
+
+            async with AsyncSessionLocal() as session:
+                broadcast = await session.get(BroadcastHistory, broadcast_id)
+                if not broadcast:
+                    logger.error("Запись рассылки %s удалена до запуска", broadcast_id)
+                    return
+
+                broadcast.total_count = len(recipients)
+                await session.commit()
+
+            if cancel_event.is_set():
+                await self._mark_cancelled(broadcast_id, sent_count, failed_count)
+                return
+
+            if not recipients:
+                logger.info("Рассылка %s: получатели не найдены", broadcast_id)
+                await self._mark_finished(broadcast_id, sent_count, failed_count, cancelled=False)
+                return
+
+            keyboard = self._build_keyboard(config.selected_buttons)
+
+            for index, user in enumerate(recipients, start=1):
+                if cancel_event.is_set():
+                    await self._mark_cancelled(broadcast_id, sent_count, failed_count)
+                    return
+
+                telegram_id = getattr(user, "telegram_id", None)
+                if telegram_id is None:
+                    failed_count += 1
+                    continue
+
+                try:
+                    await self._deliver_message(telegram_id, config, keyboard)
+                    sent_count += 1
+                except Exception as exc:  # noqa: BLE001
+                    failed_count += 1
+                    logger.error(
+                        "Ошибка отправки рассылки %s пользователю %s: %s",
+                        broadcast_id,
+                        telegram_id,
+                        exc,
+                    )
+
+                if index % 20 == 0:
+                    await asyncio.sleep(1)
+
+            await self._mark_finished(broadcast_id, sent_count, failed_count, cancelled=False)
+
+        except asyncio.CancelledError:
+            await self._mark_cancelled(broadcast_id, sent_count, failed_count)
+            raise
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("Критическая ошибка при выполнении рассылки %s: %s", broadcast_id, exc)
+            await self._mark_failed(broadcast_id, sent_count, failed_count)
+
+    async def _fetch_recipients(self, target: str):
+        async with AsyncSessionLocal() as session:
+            if target.startswith("custom_"):
+                criteria = target[len("custom_"):]
+                return await get_custom_users(session, criteria)
+            return await get_target_users(session, target)
+
+    def _build_keyboard(self, selected_buttons: Optional[list[str]]) -> Optional[InlineKeyboardMarkup]:
+        if selected_buttons is None:
+            selected_buttons = []
+        return create_broadcast_keyboard(selected_buttons)
+
+    async def _deliver_message(
+        self,
+        telegram_id: int,
+        config: BroadcastConfig,
+        keyboard: Optional[InlineKeyboardMarkup],
+    ) -> None:
+        if not self._bot:
+            raise RuntimeError("Телеграм-бот не инициализирован")
+
+        if config.media and config.media.type in VALID_MEDIA_TYPES:
+            caption = config.media.caption or config.message_text
+            if config.media.type == "photo":
+                await self._bot.send_photo(
+                    chat_id=telegram_id,
+                    photo=config.media.file_id,
+                    caption=caption,
+                    reply_markup=keyboard,
+                )
+            elif config.media.type == "video":
+                await self._bot.send_video(
+                    chat_id=telegram_id,
+                    video=config.media.file_id,
+                    caption=caption,
+                    reply_markup=keyboard,
+                )
+            elif config.media.type == "document":
+                await self._bot.send_document(
+                    chat_id=telegram_id,
+                    document=config.media.file_id,
+                    caption=caption,
+                    reply_markup=keyboard,
+                )
+            return
+
+        await self._bot.send_message(
+            chat_id=telegram_id,
+            text=config.message_text,
+            reply_markup=keyboard,
+        )
+
+    async def _mark_finished(
+        self,
+        broadcast_id: int,
+        sent_count: int,
+        failed_count: int,
+        *,
+        cancelled: bool,
+    ) -> None:
+        async with AsyncSessionLocal() as session:
+            broadcast = await session.get(BroadcastHistory, broadcast_id)
+            if not broadcast:
+                return
+
+            broadcast.sent_count = sent_count
+            broadcast.failed_count = failed_count
+            broadcast.status = "cancelled" if cancelled else (
+                "completed" if failed_count == 0 else "partial"
+            )
+            broadcast.completed_at = datetime.utcnow()
+            await session.commit()
+
+    async def _mark_cancelled(
+        self,
+        broadcast_id: int,
+        sent_count: int,
+        failed_count: int,
+    ) -> None:
+        await self._mark_finished(
+            broadcast_id,
+            sent_count,
+            failed_count,
+            cancelled=True,
+        )
+
+    async def _mark_failed(
+        self,
+        broadcast_id: int,
+        sent_count: int = 0,
+        failed_count: int = 0,
+    ) -> None:
+        async with AsyncSessionLocal() as session:
+            broadcast = await session.get(BroadcastHistory, broadcast_id)
+            if not broadcast:
+                return
+
+            broadcast.sent_count = sent_count
+            broadcast.failed_count = failed_count or broadcast.failed_count
+            broadcast.status = "failed"
+            broadcast.completed_at = datetime.utcnow()
+            await session.commit()
+
+
+broadcast_service = BroadcastService()
+
@@ -0,0 +1,126 @@
+import hashlib
+import logging
+from typing import Optional, Dict, Any
+
+import aiohttp
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class MulenPayService:
+    """Интеграция с Mulen Pay API."""
+
+    def __init__(self) -> None:
+        self.api_key = settings.MULENPAY_API_KEY
+        self.shop_id = settings.MULENPAY_SHOP_ID
+        self.secret_key = settings.MULENPAY_SECRET_KEY
+        self.base_url = settings.MULENPAY_BASE_URL.rstrip("/")
+
+    @property
+    def is_configured(self) -> bool:
+        return bool(
+            settings.is_mulenpay_enabled()
+            and self.api_key
+            and self.shop_id
+            and self.secret_key
+        )
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        if not self.is_configured:
+            logger.error("MulenPay service is not configured")
+            return None
+
+        url = f"{self.base_url}{endpoint}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            timeout = aiohttp.ClientTimeout(total=30)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.request(
+                    method,
+                    url,
+                    headers=headers,
+                    json=json_data,
+                    params=params,
+                ) as response:
+                    data = await response.json(content_type=None)
+
+                    if response.status >= 400:
+                        logger.error(
+                            "MulenPay API error %s %s: %s", response.status, endpoint, data
+                        )
+                        return None
+
+                    return data
+        except aiohttp.ClientError as error:
+            logger.error("MulenPay API request error: %s", error)
+            return None
+        except Exception as error:  # pragma: no cover - safety
+            logger.error("Unexpected MulenPay error: %s", error, exc_info=True)
+            return None
+
+    @staticmethod
+    def _format_amount(amount_kopeks: int) -> str:
+        return f"{amount_kopeks / 100:.2f}"
+
+    def _build_signature(self, currency: str, amount_str: str) -> str:
+        raw_string = f"{currency}{amount_str}{self.shop_id}{self.secret_key}".encode()
+        return hashlib.sha1(raw_string).hexdigest()
+
+    async def create_payment(
+        self,
+        *,
+        amount_kopeks: int,
+        description: str,
+        uuid: str,
+        items: list,
+        language: str = "ru",
+        subscribe: Optional[str] = None,
+        hold_time: Optional[int] = None,
+        website_url: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        if not self.is_configured:
+            logger.error("MulenPay service is not configured")
+            return None
+
+        amount_str = self._format_amount(amount_kopeks)
+        currency = "rub"
+        payload = {
+            "currency": currency,
+            "amount": amount_str,
+            "uuid": uuid,
+            "shopId": self.shop_id,
+            "description": description,
+            "items": items,
+            "language": language,
+            "sign": self._build_signature(currency, amount_str),
+        }
+
+        if subscribe:
+            payload["subscribe"] = subscribe
+        if hold_time is not None:
+            payload["holdTime"] = hold_time
+        if website_url:
+            payload["website_url"] = website_url
+
+        response = await self._request("POST", "/v2/payments", json_data=payload)
+        if not response or not response.get("success"):
+            logger.error("Failed to create MulenPay payment: %s", response)
+            return None
+
+        return response
+
+    async def get_payment(self, payment_id: int) -> Optional[Dict[str, Any]]:
+        return await self._request("GET", f"/v2/payments/{payment_id}")
@@ -0,0 +1,257 @@
+import json
+import logging
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict
+
+from app.config import settings
+
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationSettingsService:
+    """Runtime-editable notification settings stored on disk."""
+
+    _storage_path: Path = Path("data/notification_settings.json")
+    _data: Dict[str, Dict[str, Any]] = {}
+    _loaded: bool = False
+
+    _DEFAULTS: Dict[str, Dict[str, Any]] = {
+        "trial_inactive_1h": {"enabled": True},
+        "trial_inactive_24h": {"enabled": True},
+        "trial_channel_unsubscribed": {"enabled": True},
+        "expired_1d": {"enabled": True},
+        "expired_second_wave": {
+            "enabled": True,
+            "discount_percent": 10,
+            "valid_hours": 24,
+        },
+        "expired_third_wave": {
+            "enabled": True,
+            "discount_percent": 20,
+            "valid_hours": 24,
+            "trigger_days": 5,
+        },
+    }
+
+    @classmethod
+    def _ensure_dir(cls) -> None:
+        try:
+            cls._storage_path.parent.mkdir(parents=True, exist_ok=True)
+        except Exception as exc:  # pragma: no cover - filesystem guard
+            logger.error("Failed to create notification settings dir: %s", exc)
+
+    @classmethod
+    def _load(cls) -> None:
+        if cls._loaded:
+            return
+
+        cls._ensure_dir()
+        try:
+            if cls._storage_path.exists():
+                raw = cls._storage_path.read_text(encoding="utf-8")
+                cls._data = json.loads(raw) if raw.strip() else {}
+            else:
+                cls._data = {}
+        except Exception as exc:
+            logger.error("Failed to load notification settings: %s", exc)
+            cls._data = {}
+
+        changed = cls._apply_defaults()
+        if changed:
+            cls._save()
+        cls._loaded = True
+
+    @classmethod
+    def _apply_defaults(cls) -> bool:
+        changed = False
+        for key, defaults in cls._DEFAULTS.items():
+            current = cls._data.get(key)
+            if not isinstance(current, dict):
+                cls._data[key] = deepcopy(defaults)
+                changed = True
+                continue
+
+            for def_key, def_value in defaults.items():
+                if def_key not in current:
+                    current[def_key] = def_value
+                    changed = True
+        return changed
+
+    @classmethod
+    def _save(cls) -> bool:
+        cls._ensure_dir()
+        try:
+            cls._storage_path.write_text(
+                json.dumps(cls._data, ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+            return True
+        except Exception as exc:
+            logger.error("Failed to save notification settings: %s", exc)
+            return False
+
+    @classmethod
+    def _get(cls, key: str) -> Dict[str, Any]:
+        cls._load()
+        value = cls._data.get(key)
+        if not isinstance(value, dict):
+            value = deepcopy(cls._DEFAULTS.get(key, {}))
+            cls._data[key] = value
+        return value
+
+    @classmethod
+    def get_config(cls) -> Dict[str, Dict[str, Any]]:
+        cls._load()
+        return deepcopy(cls._data)
+
+    @classmethod
+    def _set_field(cls, key: str, field: str, value: Any) -> bool:
+        cls._load()
+        section = cls._get(key)
+        section[field] = value
+        cls._data[key] = section
+        return cls._save()
+
+    @classmethod
+    def set_enabled(cls, key: str, enabled: bool) -> bool:
+        return cls._set_field(key, "enabled", bool(enabled))
+
+    @classmethod
+    def is_enabled(cls, key: str) -> bool:
+        return bool(cls._get(key).get("enabled", True))
+
+    # Trial inactivity helpers
+    @classmethod
+    def is_trial_inactive_1h_enabled(cls) -> bool:
+        return cls.is_enabled("trial_inactive_1h")
+
+    @classmethod
+    def set_trial_inactive_1h_enabled(cls, enabled: bool) -> bool:
+        return cls.set_enabled("trial_inactive_1h", enabled)
+
+    @classmethod
+    def is_trial_inactive_24h_enabled(cls) -> bool:
+        return cls.is_enabled("trial_inactive_24h")
+
+    @classmethod
+    def set_trial_inactive_24h_enabled(cls, enabled: bool) -> bool:
+        return cls.set_enabled("trial_inactive_24h", enabled)
+
+    @classmethod
+    def is_trial_channel_unsubscribed_enabled(cls) -> bool:
+        return cls.is_enabled("trial_channel_unsubscribed")
+
+    @classmethod
+    def set_trial_channel_unsubscribed_enabled(cls, enabled: bool) -> bool:
+        return cls.set_enabled("trial_channel_unsubscribed", enabled)
+
+    # Expired subscription notifications
+    @classmethod
+    def is_expired_1d_enabled(cls) -> bool:
+        return cls.is_enabled("expired_1d")
+
+    @classmethod
+    def set_expired_1d_enabled(cls, enabled: bool) -> bool:
+        return cls.set_enabled("expired_1d", enabled)
+
+    @classmethod
+    def is_second_wave_enabled(cls) -> bool:
+        return cls.is_enabled("expired_second_wave")
+
+    @classmethod
+    def set_second_wave_enabled(cls, enabled: bool) -> bool:
+        return cls.set_enabled("expired_second_wave", enabled)
+
+    @classmethod
+    def get_second_wave_discount_percent(cls) -> int:
+        value = cls._get("expired_second_wave").get("discount_percent", 10)
+        try:
+            return max(0, min(100, int(value)))
+        except (TypeError, ValueError):
+            return 10
+
+    @classmethod
+    def set_second_wave_discount_percent(cls, percent: int) -> bool:
+        try:
+            percent_int = max(0, min(100, int(percent)))
+        except (TypeError, ValueError):
+            return False
+        return cls._set_field("expired_second_wave", "discount_percent", percent_int)
+
+    @classmethod
+    def get_second_wave_valid_hours(cls) -> int:
+        value = cls._get("expired_second_wave").get("valid_hours", 24)
+        try:
+            return max(1, min(168, int(value)))
+        except (TypeError, ValueError):
+            return 24
+
+    @classmethod
+    def set_second_wave_valid_hours(cls, hours: int) -> bool:
+        try:
+            hours_int = max(1, min(168, int(hours)))
+        except (TypeError, ValueError):
+            return False
+        return cls._set_field("expired_second_wave", "valid_hours", hours_int)
+
+    @classmethod
+    def is_third_wave_enabled(cls) -> bool:
+        return cls.is_enabled("expired_third_wave")
+
+    @classmethod
+    def set_third_wave_enabled(cls, enabled: bool) -> bool:
+        return cls.set_enabled("expired_third_wave", enabled)
+
+    @classmethod
+    def get_third_wave_discount_percent(cls) -> int:
+        value = cls._get("expired_third_wave").get("discount_percent", 20)
+        try:
+            return max(0, min(100, int(value)))
+        except (TypeError, ValueError):
+            return 20
+
+    @classmethod
+    def set_third_wave_discount_percent(cls, percent: int) -> bool:
+        try:
+            percent_int = max(0, min(100, int(percent)))
+        except (TypeError, ValueError):
+            return False
+        return cls._set_field("expired_third_wave", "discount_percent", percent_int)
+
+    @classmethod
+    def get_third_wave_valid_hours(cls) -> int:
+        value = cls._get("expired_third_wave").get("valid_hours", 24)
+        try:
+            return max(1, min(168, int(value)))
+        except (TypeError, ValueError):
+            return 24
+
+    @classmethod
+    def set_third_wave_valid_hours(cls, hours: int) -> bool:
+        try:
+            hours_int = max(1, min(168, int(hours)))
+        except (TypeError, ValueError):
+            return False
+        return cls._set_field("expired_third_wave", "valid_hours", hours_int)
+
+    @classmethod
+    def get_third_wave_trigger_days(cls) -> int:
+        value = cls._get("expired_third_wave").get("trigger_days", 5)
+        try:
+            return max(2, min(60, int(value)))
+        except (TypeError, ValueError):
+            return 5
+
+    @classmethod
+    def set_third_wave_trigger_days(cls, days: int) -> bool:
+        try:
+            days_int = max(2, min(60, int(days)))
+        except (TypeError, ValueError):
+            return False
+        return cls._set_field("expired_third_wave", "trigger_days", days_int)
+
+    @classmethod
+    def are_notifications_globally_enabled(cls) -> bool:
+        return bool(getattr(settings, "ENABLE_NOTIFICATIONS", True))
@@ -0,0 +1,119 @@
+"""High level integration with PayPalych API."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+from app.config import settings
+from app.external.pal24_client import Pal24Client, Pal24APIError
+
+logger = logging.getLogger(__name__)
+
+
+class Pal24Service:
+    """Wrapper around :class:`Pal24Client` providing domain helpers."""
+
+    BILL_SUCCESS_STATES = {"SUCCESS", "OVERPAID"}
+    BILL_FAILED_STATES = {"FAIL", "CANCELLED"}
+    BILL_PENDING_STATES = {"NEW", "PROCESS", "UNDERPAID"}
+
+    def __init__(self, client: Optional[Pal24Client] = None) -> None:
+        self.client = client or Pal24Client()
+
+    @property
+    def is_configured(self) -> bool:
+        return self.client.is_configured and settings.is_pal24_enabled()
+
+    async def create_bill(
+        self,
+        *,
+        amount_kopeks: int,
+        user_id: int,
+        order_id: str,
+        description: str,
+        ttl_seconds: Optional[int] = None,
+        custom_payload: Optional[Dict[str, Any]] = None,
+        payer_email: Optional[str] = None,
+        payment_method: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        if not self.is_configured:
+            raise Pal24APIError("Pal24 service is not configured")
+
+        amount_decimal = Pal24Client.normalize_amount(amount_kopeks)
+        extra_payload: Dict[str, Any] = {
+            "custom": custom_payload or {},
+            "ttl": ttl_seconds,
+        }
+
+        if payer_email:
+            extra_payload["payer_email"] = payer_email
+        if payment_method:
+            extra_payload["payment_method"] = payment_method
+
+        filtered_payload = {k: v for k, v in extra_payload.items() if v not in (None, {})}
+
+        logger.info(
+            "Создаем Pal24 счет: user_id=%s, order_id=%s, amount=%s, ttl=%s",
+            user_id,
+            order_id,
+            amount_decimal,
+            ttl_seconds,
+        )
+
+        response = await self.client.create_bill(
+            amount=amount_decimal,
+            shop_id=settings.PAL24_SHOP_ID,
+            order_id=order_id,
+            description=description,
+            type_="normal",
+            **filtered_payload,
+        )
+
+        logger.info("Pal24 счет создан: %s", response)
+        return response
+
+    async def get_bill_status(self, bill_id: str) -> Dict[str, Any]:
+        logger.debug("Запрашиваем статус Pal24 счета %s", bill_id)
+        return await self.client.get_bill_status(bill_id)
+
+    async def get_payment_status(self, payment_id: str) -> Dict[str, Any]:
+        logger.debug("Запрашиваем статус Pal24 платежа %s", payment_id)
+        return await self.client.get_payment_status(payment_id)
+
+    @staticmethod
+    def parse_postback(payload: Dict[str, Any]) -> Dict[str, Any]:
+        required_fields = ["InvId", "OutSum", "Status", "SignatureValue"]
+        missing = [field for field in required_fields if field not in payload]
+        if missing:
+            raise Pal24APIError(f"Pal24 postback missing fields: {', '.join(missing)}")
+
+        inv_id = str(payload["InvId"])
+        out_sum = str(payload["OutSum"])
+        signature = str(payload["SignatureValue"])
+
+        if not Pal24Client.verify_signature(out_sum, inv_id, signature):
+            raise Pal24APIError("Pal24 postback signature mismatch")
+
+        logger.info(
+            "Получен Pal24 postback: InvId=%s, Status=%s, TrsId=%s",
+            inv_id,
+            payload.get("Status"),
+            payload.get("TrsId"),
+        )
+
+        return payload
+
+    @staticmethod
+    def convert_to_kopeks(amount: str) -> int:
+        decimal_amount = Decimal(str(amount))
+        return int((decimal_amount * Decimal("100")).quantize(Decimal("1")))
+
+    @staticmethod
+    def get_expiration(ttl_seconds: Optional[int]) -> Optional[datetime]:
+        if not ttl_seconds:
+            return None
+        return datetime.utcnow() + timedelta(seconds=ttl_seconds)
+
@@ -1,6 +1,8 @@
 import logging
 import hashlib
 import hmac
+import uuid
+from decimal import Decimal, InvalidOperation
 from typing import Optional, Dict, Any
 from datetime import datetime
 from aiogram import Bot
@@ -26,6 +28,24 @@ from app.services.subscription_checkout_service import (
    has_subscription_checkout_draft,
    should_offer_checkout_resume,
 )
+from app.services.mulenpay_service import MulenPayService
+from app.services.pal24_service import Pal24Service, Pal24APIError
+from app.database.crud.mulenpay import (
+    create_mulenpay_payment,
+    get_mulenpay_payment_by_local_id,
+    get_mulenpay_payment_by_uuid,
+    get_mulenpay_payment_by_mulen_id,
+    update_mulenpay_payment_status,
+    link_mulenpay_payment_to_transaction,
+)
+from app.database.crud.pal24 import (
+    create_pal24_payment,
+    get_pal24_payment_by_bill_id,
+    get_pal24_payment_by_id,
+    get_pal24_payment_by_order_id,
+    link_pal24_payment_to_transaction,
+    update_pal24_payment_status,
+)

 logger = logging.getLogger(__name__)

@@ -37,6 +57,8 @@ class PaymentService:
        self.yookassa_service = YooKassaService() if settings.is_yookassa_enabled() else None
        self.stars_service = TelegramStarsService(bot) if bot else None
        self.cryptobot_service = CryptoBotService() if settings.is_cryptobot_enabled() else None
+        self.mulenpay_service = MulenPayService() if settings.is_mulenpay_enabled() else None
+        self.pal24_service = Pal24Service() if settings.is_pal24_enabled() else None

    async def build_topup_success_keyboard(self, user) -> InlineKeyboardMarkup:
        texts = get_texts(user.language if user else "ru")
@@ -633,7 +655,7 @@ class PaymentService:
        description: str = "Пополнение баланса",
        payload: Optional[str] = None
    ) -> Optional[Dict[str, Any]]:
-        
+
        if not self.cryptobot_service:
            logger.error("CryptoBot сервис не инициализирован")
            return None
@@ -686,7 +708,709 @@ class PaymentService:
        except Exception as e:
            logger.error(f"Ошибка создания CryptoBot платежа: {e}")
            return None
-    
+
+    async def create_mulenpay_payment(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        amount_kopeks: int,
+        description: str,
+        language: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+
+        if not self.mulenpay_service:
+            logger.error("MulenPay сервис не инициализирован")
+            return None
+
+        if amount_kopeks < settings.MULENPAY_MIN_AMOUNT_KOPEKS:
+            logger.warning(
+                "Сумма MulenPay меньше минимальной: %s < %s",
+                amount_kopeks,
+                settings.MULENPAY_MIN_AMOUNT_KOPEKS,
+            )
+            return None
+
+        if amount_kopeks > settings.MULENPAY_MAX_AMOUNT_KOPEKS:
+            logger.warning(
+                "Сумма MulenPay больше максимальной: %s > %s",
+                amount_kopeks,
+                settings.MULENPAY_MAX_AMOUNT_KOPEKS,
+            )
+            return None
+
+        try:
+            payment_uuid = f"mulen_{user_id}_{uuid.uuid4().hex}"
+            amount_rubles = amount_kopeks / 100
+
+            items = [
+                {
+                    "description": description[:128],
+                    "quantity": 1,
+                    "price": round(amount_rubles, 2),
+                    "vat_code": settings.MULENPAY_VAT_CODE,
+                    "payment_subject": settings.MULENPAY_PAYMENT_SUBJECT,
+                    "payment_mode": settings.MULENPAY_PAYMENT_MODE,
+                }
+            ]
+
+            response = await self.mulenpay_service.create_payment(
+                amount_kopeks=amount_kopeks,
+                description=description,
+                uuid=payment_uuid,
+                items=items,
+                language=language or settings.MULENPAY_LANGUAGE,
+                website_url=settings.WEBHOOK_URL,
+            )
+
+            if not response:
+                logger.error("Ошибка создания MulenPay платежа")
+                return None
+
+            mulen_payment_id = response.get("id")
+            payment_url = response.get("paymentUrl")
+
+            metadata = {
+                "user_id": user_id,
+                "amount_kopeks": amount_kopeks,
+                "description": description,
+            }
+
+            local_payment = await create_mulenpay_payment(
+                db=db,
+                user_id=user_id,
+                amount_kopeks=amount_kopeks,
+                uuid=payment_uuid,
+                description=description,
+                payment_url=payment_url,
+                mulen_payment_id=mulen_payment_id,
+                currency="RUB",
+                status="created",
+                metadata=metadata,
+            )
+
+            logger.info(
+                "Создан MulenPay платеж %s на %s₽ для пользователя %s",
+                mulen_payment_id,
+                amount_rubles,
+                user_id,
+            )
+
+            return {
+                "local_payment_id": local_payment.id,
+                "mulen_payment_id": mulen_payment_id,
+                "payment_url": payment_url,
+                "amount_kopeks": amount_kopeks,
+                "uuid": payment_uuid,
+                "status": "created",
+            }
+
+        except Exception as e:
+            logger.error(f"Ошибка создания MulenPay платежа: {e}")
+            return None
+
+    async def create_pal24_payment(
+        self,
+        db: AsyncSession,
+        *,
+        user_id: int,
+        amount_kopeks: int,
+        description: str,
+        language: str,
+        ttl_seconds: Optional[int] = None,
+        payer_email: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+
+        if not self.pal24_service or not self.pal24_service.is_configured:
+            logger.error("Pal24 сервис не инициализирован")
+            return None
+
+        if amount_kopeks < settings.PAL24_MIN_AMOUNT_KOPEKS:
+            logger.warning(
+                "Сумма Pal24 меньше минимальной: %s < %s",
+                amount_kopeks,
+                settings.PAL24_MIN_AMOUNT_KOPEKS,
+            )
+            return None
+
+        if amount_kopeks > settings.PAL24_MAX_AMOUNT_KOPEKS:
+            logger.warning(
+                "Сумма Pal24 больше максимальной: %s > %s",
+                amount_kopeks,
+                settings.PAL24_MAX_AMOUNT_KOPEKS,
+            )
+            return None
+
+        order_id = f"pal24_{user_id}_{uuid.uuid4().hex}"
+
+        custom_payload = {
+            "user_id": user_id,
+            "amount_kopeks": amount_kopeks,
+            "language": language,
+        }
+
+        try:
+            response = await self.pal24_service.create_bill(
+                amount_kopeks=amount_kopeks,
+                user_id=user_id,
+                order_id=order_id,
+                description=description,
+                ttl_seconds=ttl_seconds,
+                custom_payload=custom_payload,
+                payer_email=payer_email,
+                payment_method="SBP",
+            )
+        except Pal24APIError as error:
+            logger.error("Ошибка Pal24 API при создании счета: %s", error)
+            return None
+
+        if not response.get("success", True):
+            logger.error("Pal24 вернул ошибку при создании счета: %s", response)
+            return None
+
+        bill_id = response.get("bill_id")
+        if not bill_id:
+            logger.error("Pal24 не вернул bill_id: %s", response)
+            return None
+
+        def _pick_url(*keys: str) -> Optional[str]:
+            for key in keys:
+                value = response.get(key)
+                if value:
+                    return str(value)
+            return None
+
+        transfer_url = _pick_url(
+            "transfer_url",
+            "transferUrl",
+            "transfer_link",
+            "transferLink",
+            "transfer",
+            "sbp_url",
+            "sbpUrl",
+            "sbp_link",
+            "sbpLink",
+        )
+        card_url = _pick_url(
+            "link_url",
+            "linkUrl",
+            "link",
+            "card_url",
+            "cardUrl",
+            "card_link",
+            "cardLink",
+            "payment_url",
+            "paymentUrl",
+            "url",
+        )
+        link_page_url = _pick_url(
+            "link_page_url",
+            "linkPageUrl",
+            "page_url",
+            "pageUrl",
+        )
+
+        primary_link = transfer_url or link_page_url or card_url
+        secondary_link = link_page_url or card_url or transfer_url
+
+        metadata_links = {
+            key: value
+            for key, value in {
+                "sbp": transfer_url,
+                "card": card_url,
+                "page": link_page_url,
+            }.items()
+            if value
+        }
+
+        payment = await create_pal24_payment(
+            db,
+            user_id=user_id,
+            bill_id=bill_id,
+            order_id=order_id,
+            amount_kopeks=amount_kopeks,
+            description=description,
+            status=response.get("status", "NEW"),
+            type_=response.get("type", "normal"),
+            currency=response.get("currency", "RUB"),
+            link_url=primary_link,
+            link_page_url=secondary_link,
+            ttl=ttl_seconds,
+            metadata={
+                "raw_response": response,
+                "language": language,
+                **({"links": metadata_links} if metadata_links else {}),
+            },
+        )
+
+        payment_info = {
+            "bill_id": bill_id,
+            "order_id": order_id,
+            "link_url": primary_link,
+            "link_page_url": secondary_link,
+            "local_payment_id": payment.id,
+            "amount_kopeks": amount_kopeks,
+            "sbp_url": transfer_url or primary_link,
+            "card_url": card_url,
+            "transfer_url": transfer_url,
+        }
+
+        logger.info(
+            "Создан Pal24 счет %s для пользователя %s на сумму %s",
+            bill_id,
+            user_id,
+            settings.format_price(amount_kopeks),
+        )
+
+        return payment_info
+
+    async def process_mulenpay_callback(self, db: AsyncSession, callback_data: dict) -> bool:
+        try:
+            uuid_value = callback_data.get("uuid")
+            payment_status = (callback_data.get("payment_status") or "").lower()
+            mulen_payment_id_raw = callback_data.get("id")
+            mulen_payment_id_int: Optional[int] = None
+            if mulen_payment_id_raw is not None:
+                try:
+                    mulen_payment_id_int = int(mulen_payment_id_raw)
+                except (TypeError, ValueError):
+                    mulen_payment_id_int = None
+            amount_value = callback_data.get("amount")
+
+            if not uuid_value and mulen_payment_id_raw is None:
+                logger.error("MulenPay callback без uuid и id")
+                return False
+
+            payment = None
+            if uuid_value:
+                payment = await get_mulenpay_payment_by_uuid(db, uuid_value)
+
+            if not payment and mulen_payment_id_int is not None:
+                payment = await get_mulenpay_payment_by_mulen_id(db, mulen_payment_id_int)
+
+            if not payment:
+                logger.error(
+                    "MulenPay платеж не найден (uuid=%s, id=%s)",
+                    uuid_value,
+                    mulen_payment_id_raw,
+                )
+                return False
+
+            if payment.transaction_id and payment.is_paid:
+                logger.info("MulenPay платеж %s уже обработан", payment.uuid)
+                return True
+
+            paid_at = datetime.utcnow()
+
+            if payment_status == "success":
+                try:
+                    amount_kopeks = int(Decimal(str(amount_value)) * 100)
+                except (InvalidOperation, TypeError):
+                    amount_kopeks = payment.amount_kopeks
+                    logger.warning(
+                        "Не удалось распарсить сумму MulenPay, используем значение из БД: %s",
+                        amount_value,
+                    )
+
+                if amount_kopeks != payment.amount_kopeks:
+                    logger.warning(
+                        "Несовпадение суммы MulenPay: callback=%s, ожидаемо=%s",
+                        amount_kopeks,
+                        payment.amount_kopeks,
+                    )
+
+                transaction = await create_transaction(
+                    db,
+                    user_id=payment.user_id,
+                    type=TransactionType.DEPOSIT,
+                    amount_kopeks=payment.amount_kopeks,
+                    description=f"Пополнение через Mulen Pay ({mulen_payment_id_raw})",
+                    payment_method=PaymentMethod.MULENPAY,
+                    external_id=(
+                        str(mulen_payment_id_int)
+                        if mulen_payment_id_int is not None
+                        else payment.uuid
+                    ),
+                    is_completed=True,
+                )
+
+                await link_mulenpay_payment_to_transaction(
+                    db,
+                    payment=payment,
+                    transaction_id=transaction.id,
+                )
+
+                user = await get_user_by_id(db, payment.user_id)
+                if not user:
+                    logger.error("Пользователь %s не найден для MulenPay платежа", payment.user_id)
+                    return False
+
+                old_balance = user.balance_kopeks
+                user.balance_kopeks += payment.amount_kopeks
+                user.updated_at = datetime.utcnow()
+
+                await db.commit()
+                await db.refresh(user)
+
+                try:
+                    from app.services.referral_service import process_referral_topup
+
+                    await process_referral_topup(db, user.id, payment.amount_kopeks, self.bot)
+                except Exception as referral_error:
+                    logger.error(
+                        "Ошибка обработки реферального пополнения MulenPay: %s",
+                        referral_error,
+                    )
+
+                await update_mulenpay_payment_status(
+                    db,
+                    payment=payment,
+                    status="success",
+                    is_paid=True,
+                    paid_at=paid_at,
+                    callback_payload=callback_data,
+                    mulen_payment_id=mulen_payment_id_int,
+                )
+
+                if self.bot:
+                    try:
+                        from app.services.admin_notification_service import AdminNotificationService
+
+                        notification_service = AdminNotificationService(self.bot)
+                        await notification_service.send_balance_topup_notification(
+                            db,
+                            user,
+                            transaction,
+                            old_balance,
+                        )
+                    except Exception as notify_error:
+                        logger.error(
+                            "Ошибка отправки админ уведомления MulenPay: %s",
+                            notify_error,
+                        )
+
+                if self.bot:
+                    try:
+                        keyboard = await self.build_topup_success_keyboard(user)
+                        await self.bot.send_message(
+                            user.telegram_id,
+                            (
+                                "✅ <b>Пополнение успешно!</b>\n\n"
+                                f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n"
+                                "🦊 Способ: Mulen Pay\n"
+                                f"🆔 Транзакция: {transaction.id}\n\n"
+                                "Баланс пополнен автоматически!"
+                            ),
+                            parse_mode="HTML",
+                            reply_markup=keyboard,
+                        )
+                    except Exception as user_notify_error:
+                        logger.error(
+                            "Ошибка отправки уведомления пользователю MulenPay: %s",
+                            user_notify_error,
+                        )
+
+                logger.info(
+                    "✅ Обработан MulenPay платеж %s для пользователя %s",
+                    payment.uuid,
+                    payment.user_id,
+                )
+                return True
+
+            if payment_status == "cancel":
+                await update_mulenpay_payment_status(
+                    db,
+                    payment=payment,
+                    status="canceled",
+                    callback_payload=callback_data,
+                    mulen_payment_id=mulen_payment_id_int,
+                )
+                logger.info("MulenPay платеж %s отменен", payment.uuid)
+                return True
+
+            await update_mulenpay_payment_status(
+                db,
+                payment=payment,
+                status=payment_status or "unknown",
+                callback_payload=callback_data,
+                mulen_payment_id=mulen_payment_id_int,
+            )
+            logger.info(
+                "Получен MulenPay callback со статусом %s для платежа %s",
+                payment_status,
+                payment.uuid,
+            )
+            return True
+
+        except Exception as error:
+            logger.error(f"Ошибка обработки MulenPay callback: {error}", exc_info=True)
+            return False
+
+    async def process_pal24_postback(self, db: AsyncSession, payload: Dict[str, Any]) -> bool:
+
+        if not self.pal24_service or not self.pal24_service.is_configured:
+            logger.error("Pal24 сервис не инициализирован")
+            return False
+
+        try:
+            order_id_raw = payload.get("InvId")
+            order_id = str(order_id_raw) if order_id_raw is not None else None
+            if not order_id:
+                logger.error("Pal24 postback без InvId")
+                return False
+
+            payment = await get_pal24_payment_by_order_id(db, order_id)
+            if not payment:
+                bill_id = payload.get("BillId")
+                if bill_id:
+                    payment = await get_pal24_payment_by_bill_id(db, str(bill_id))
+
+            if not payment:
+                logger.error("Pal24 платеж не найден для order_id=%s", order_id)
+                return False
+
+            if payment.transaction_id and payment.is_paid:
+                logger.info("Pal24 платеж %s уже обработан", payment.bill_id)
+                return True
+
+            status = str(payload.get("Status", "UNKNOWN")).upper()
+            payment_id = payload.get("TrsId")
+            balance_amount = payload.get("BalanceAmount")
+            balance_currency = payload.get("BalanceCurrency")
+            payer_account = payload.get("AccountNumber")
+            payment_method = payload.get("AccountType")
+
+            try:
+                amount_kopeks = Pal24Service.convert_to_kopeks(str(payload.get("OutSum")))
+            except Exception:
+                logger.warning("Не удалось распарсить сумму Pal24, используем сохраненное значение")
+                amount_kopeks = payment.amount_kopeks
+
+            if amount_kopeks != payment.amount_kopeks:
+                logger.warning(
+                    "Несовпадение суммы Pal24: callback=%s, ожидаемо=%s",
+                    amount_kopeks,
+                    payment.amount_kopeks,
+                )
+
+            is_success = status in Pal24Service.BILL_SUCCESS_STATES
+            is_failed = status in Pal24Service.BILL_FAILED_STATES
+
+            await update_pal24_payment_status(
+                db,
+                payment,
+                status=status,
+                is_active=not is_failed,
+                is_paid=is_success,
+                payment_id=str(payment_id) if payment_id else None,
+                payment_status=status,
+                payment_method=str(payment_method) if payment_method else None,
+                balance_amount=str(balance_amount) if balance_amount is not None else None,
+                balance_currency=str(balance_currency) if balance_currency is not None else None,
+                payer_account=str(payer_account) if payer_account is not None else None,
+                callback_payload=payload,
+            )
+
+            if not is_success:
+                logger.info(
+                    "Получен Pal24 статус %s для платежа %s (успех=%s)",
+                    status,
+                    payment.bill_id,
+                    is_success,
+                )
+                return True
+
+            user = await get_user_by_id(db, payment.user_id)
+            if not user:
+                logger.error("Пользователь %s не найден для Pal24 платежа", payment.user_id)
+                return False
+
+            transaction = await create_transaction(
+                db=db,
+                user_id=payment.user_id,
+                type=TransactionType.DEPOSIT,
+                amount_kopeks=payment.amount_kopeks,
+                description=f"Пополнение через Pal24 ({payment_id})",
+                payment_method=PaymentMethod.PAL24,
+                external_id=str(payment_id) if payment_id else payment.bill_id,
+                is_completed=True,
+            )
+
+            await link_pal24_payment_to_transaction(db, payment, transaction.id)
+
+            old_balance = user.balance_kopeks
+            user.balance_kopeks += payment.amount_kopeks
+            user.updated_at = datetime.utcnow()
+            await db.commit()
+            await db.refresh(user)
+
+            try:
+                from app.services.referral_service import process_referral_topup
+
+                await process_referral_topup(db, user.id, payment.amount_kopeks, self.bot)
+            except Exception as referral_error:
+                logger.error("Ошибка обработки реферального пополнения Pal24: %s", referral_error)
+
+            if self.bot:
+                try:
+                    from app.services.admin_notification_service import AdminNotificationService
+
+                    notification_service = AdminNotificationService(self.bot)
+                    await notification_service.send_balance_topup_notification(
+                        db,
+                        user,
+                        transaction,
+                        old_balance,
+                    )
+                except Exception as notify_error:
+                    logger.error("Ошибка отправки админ уведомления Pal24: %s", notify_error)
+
+            if self.bot:
+                try:
+                    keyboard = await self.build_topup_success_keyboard(user)
+                    await self.bot.send_message(
+                        user.telegram_id,
+                        (
+                            "✅ <b>Пополнение успешно!</b>\n\n"
+                            f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n"
+                            "🦊 Способ: PayPalych\n"
+                            f"🆔 Транзакция: {transaction.id}\n\n"
+                            "Баланс пополнен автоматически!"
+                        ),
+                        parse_mode="HTML",
+                        reply_markup=keyboard,
+                    )
+                except Exception as user_notify_error:
+                    logger.error("Ошибка отправки уведомления пользователю Pal24: %s", user_notify_error)
+
+            logger.info(
+                "✅ Обработан Pal24 платеж %s для пользователя %s",
+                payment.bill_id,
+                payment.user_id,
+            )
+
+            return True
+
+        except Exception as error:
+            logger.error("Ошибка обработки Pal24 postback: %s", error, exc_info=True)
+            return False
+
+    @staticmethod
+    def _map_mulenpay_status(status_code: Optional[int]) -> str:
+        mapping = {
+            0: "created",
+            1: "processing",
+            2: "canceled",
+            3: "success",
+            4: "error",
+            5: "hold",
+            6: "hold",
+        }
+        return mapping.get(status_code, "unknown")
+
+    async def get_mulenpay_payment_status(
+        self,
+        db: AsyncSession,
+        local_payment_id: int,
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            payment = await get_mulenpay_payment_by_local_id(db, local_payment_id)
+            if not payment:
+                return None
+
+            remote_status_code = None
+            remote_data = None
+
+            if (
+                self.mulenpay_service
+                and payment.mulen_payment_id is not None
+            ):
+                response = await self.mulenpay_service.get_payment(payment.mulen_payment_id)
+                if response and response.get("success"):
+                    remote_data = response.get("payment")
+                    if isinstance(remote_data, dict):
+                        remote_status_code = remote_data.get("status")
+                        mapped_status = self._map_mulenpay_status(remote_status_code)
+
+                        if mapped_status == "success" and not payment.is_paid:
+                            await self.process_mulenpay_callback(
+                                db,
+                                {
+                                    "uuid": payment.uuid,
+                                    "payment_status": "success",
+                                    "id": remote_data.get("id"),
+                                    "amount": remote_data.get("amount"),
+                                },
+                            )
+                            payment = await get_mulenpay_payment_by_local_id(
+                                db, local_payment_id
+                            )
+                        elif mapped_status and mapped_status != payment.status:
+                            await update_mulenpay_payment_status(
+                                db,
+                                payment=payment,
+                                status=mapped_status,
+                                mulen_payment_id=remote_data.get("id"),
+                            )
+                            payment = await get_mulenpay_payment_by_local_id(
+                                db, local_payment_id
+                            )
+
+            return {
+                "payment": payment,
+                "status": payment.status,
+                "is_paid": payment.is_paid,
+                "remote_status_code": remote_status_code,
+                "remote_data": remote_data,
+            }
+
+        except Exception as error:
+            logger.error(f"Ошибка получения статуса MulenPay: {error}", exc_info=True)
+            return None
+
+    async def get_pal24_payment_status(
+        self,
+        db: AsyncSession,
+        local_payment_id: int,
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            payment = await get_pal24_payment_by_id(db, local_payment_id)
+            if not payment:
+                return None
+
+            remote_status = None
+            remote_data = None
+
+            if self.pal24_service and payment.bill_id:
+                try:
+                    response = await self.pal24_service.get_bill_status(payment.bill_id)
+                    remote_data = response
+                    remote_status = (
+                        response.get("status")
+                        or response.get("bill", {}).get("status")
+                    )
+
+                    if remote_status and remote_status != payment.status:
+                        await update_pal24_payment_status(
+                            db,
+                            payment,
+                            status=str(remote_status).upper(),
+                        )
+                        payment = await get_pal24_payment_by_id(db, local_payment_id)
+                except Pal24APIError as error:
+                    logger.error("Ошибка Pal24 API при получении статуса: %s", error)
+
+            return {
+                "payment": payment,
+                "status": payment.status,
+                "is_paid": payment.is_paid,
+                "remote_status": remote_status,
+                "remote_data": remote_data,
+            }
+
+        except Exception as error:
+            logger.error("Ошибка получения статуса Pal24: %s", error, exc_info=True)
+            return None
+
    async def process_cryptobot_webhook(self, db: AsyncSession, webhook_data: dict) -> bool:
        try:
            from app.database.crud.cryptobot import (
@@ -0,0 +1,189 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from aiogram import Bot
+from aiogram.client.default import DefaultBotProperties
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.transaction import get_user_total_spent_kopeks
+from app.database.models import PromoGroup, User
+from app.services.admin_notification_service import AdminNotificationService
+
+logger = logging.getLogger(__name__)
+
+
+async def _notify_admins_about_auto_assignment(
+    db: AsyncSession,
+    user: User,
+    old_group: Optional[PromoGroup],
+    new_group: PromoGroup,
+    total_spent_kopeks: int,
+):
+    if not getattr(settings, "ADMIN_NOTIFICATIONS_ENABLED", False):
+        return
+
+    bot_token = getattr(settings, "BOT_TOKEN", None)
+    if not bot_token:
+        logger.debug("BOT_TOKEN не настроен — пропускаем уведомление о промогруппе")
+        return
+
+    bot = Bot(token=bot_token, default=DefaultBotProperties(parse_mode="HTML"))
+    try:
+        notification_service = AdminNotificationService(bot)
+        reason = (
+            f"Автоназначение за траты {settings.format_price(total_spent_kopeks)}"
+            if hasattr(settings, "format_price")
+            else f"Автоназначение за траты {total_spent_kopeks / 100:.2f}₽"
+        )
+        await notification_service.send_user_promo_group_change_notification(
+            db,
+            user,
+            old_group,
+            new_group,
+            reason=reason,
+            initiator=None,
+            automatic=True,
+        )
+    except Exception as exc:
+        logger.error(
+            "Ошибка отправки уведомления о автоназначении промогруппы пользователю %s: %s",
+            user.telegram_id,
+            exc,
+        )
+    finally:
+        try:
+            await bot.session.close()
+        except Exception:
+            pass
+
+
+async def _get_best_group_for_spending(
+    db: AsyncSession,
+    total_spent_kopeks: int,
+    min_threshold_kopeks: int = 0,
+) -> Optional[PromoGroup]:
+    if total_spent_kopeks <= 0:
+        return None
+
+    result = await db.execute(
+        select(PromoGroup)
+        .where(PromoGroup.auto_assign_total_spent_kopeks.is_not(None))
+        .where(PromoGroup.auto_assign_total_spent_kopeks > 0)
+        .order_by(PromoGroup.auto_assign_total_spent_kopeks.desc(), PromoGroup.id.desc())
+    )
+    groups = result.scalars().all()
+
+    for group in groups:
+        threshold = group.auto_assign_total_spent_kopeks or 0
+        if (
+            threshold
+            and total_spent_kopeks >= threshold
+            and threshold > min_threshold_kopeks
+        ):
+            return group
+
+    return None
+
+
+async def maybe_assign_promo_group_by_total_spent(
+    db: AsyncSession,
+    user_id: int,
+) -> Optional[PromoGroup]:
+    user = await db.get(User, user_id)
+    if not user:
+        logger.debug("Не удалось найти пользователя %s для автовыдачи промогруппы", user_id)
+        return None
+
+    old_group = None
+    if user.promo_group_id:
+        try:
+            await db.refresh(user, attribute_names=["promo_group"])
+        except Exception:
+            pass
+        old_group = getattr(user, "promo_group", None)
+
+    total_spent = await get_user_total_spent_kopeks(db, user_id)
+    if total_spent <= 0:
+        return None
+
+    previous_threshold = user.auto_promo_group_threshold_kopeks or 0
+
+    target_group = await _get_best_group_for_spending(
+        db,
+        total_spent,
+        min_threshold_kopeks=previous_threshold,
+    )
+    if not target_group:
+        return None
+
+    try:
+        previous_group_id = user.promo_group_id
+        target_threshold = target_group.auto_assign_total_spent_kopeks or 0
+
+        if target_threshold <= previous_threshold:
+            logger.debug(
+                "Порог промогруппы '%s' (%s) не превышает ранее назначенный (%s) для пользователя %s",
+                target_group.name,
+                target_threshold,
+                previous_threshold,
+                user.telegram_id,
+            )
+            return None
+
+        if user.auto_promo_group_assigned and target_group.id == previous_group_id:
+            logger.debug(
+                "Пользователь %s уже находится в актуальной промогруппе '%s', повторная выдача не требуется",
+                user.telegram_id,
+                target_group.name,
+            )
+            if target_threshold > previous_threshold:
+                user.auto_promo_group_threshold_kopeks = target_threshold
+                user.updated_at = datetime.utcnow()
+                await db.commit()
+                await db.refresh(user)
+            return target_group
+
+        user.auto_promo_group_assigned = True
+        user.auto_promo_group_threshold_kopeks = target_threshold
+        user.updated_at = datetime.utcnow()
+
+        if target_group.id != previous_group_id:
+            user.promo_group_id = target_group.id
+            user.promo_group = target_group
+            logger.info(
+                "🤖 Пользователь %s автоматически переведен в промогруппу '%s' за траты %s ₽",
+                user.telegram_id,
+                target_group.name,
+                total_spent / 100,
+            )
+        else:
+            logger.info(
+                "🤖 Пользователь %s уже находится в подходящей промогруппе '%s', отмечаем автоприсвоение",
+                user.telegram_id,
+                target_group.name,
+            )
+
+        await db.commit()
+        await db.refresh(user)
+
+        if target_group.id != previous_group_id:
+            await _notify_admins_about_auto_assignment(
+                db,
+                user,
+                old_group,
+                target_group,
+                total_spent,
+            )
+
+        return target_group
+    except Exception as exc:
+        logger.error(
+            "Ошибка при автоматическом назначении промогруппы пользователю %s: %s",
+            user_id,
+            exc,
+        )
+        await db.rollback()
+        return None
@@ -49,23 +49,34 @@ class PromoCodeService:
                return {"success": False, "error": "already_used_by_user"}
            
            result_description = await self._apply_promocode_effects(db, user, promocode)
-            
+
            if promocode.type == PromoCodeType.SUBSCRIPTION_DAYS.value and promocode.subscription_days > 0:
                from app.utils.user_utils import mark_user_as_had_paid_subscription
                await mark_user_as_had_paid_subscription(db, user)
-                
+
                logger.info(f"🎯 Пользователь {user.telegram_id} получил платную подписку через промокод {code}")
-            
+
            await create_promocode_use(db, promocode.id, user_id)
-            
+
            promocode.current_uses += 1
            await db.commit()
-            
+
            logger.info(f"✅ Пользователь {user.telegram_id} активировал промокод {code}")
-            
+
+            promocode_data = {
+                "code": promocode.code,
+                "type": promocode.type,
+                "balance_bonus_kopeks": promocode.balance_bonus_kopeks,
+                "subscription_days": promocode.subscription_days,
+                "max_uses": promocode.max_uses,
+                "current_uses": promocode.current_uses,
+                "valid_until": promocode.valid_until,
+            }
+
            return {
                "success": True,
-                "description": result_description
+                "description": result_description,
+                "promocode": promocode_data,
            }
            
        except Exception as e:
@@ -1,4 +1,5 @@
 import logging
+from contextlib import asynccontextmanager
 from typing import Dict, List, Any, Optional
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import delete
@@ -20,17 +21,56 @@ from app.database.models import (
 logger = logging.getLogger(__name__)


+class RemnaWaveConfigurationError(Exception):
+    """Raised when RemnaWave API configuration is missing."""
+
+
 class RemnaWaveService:
-    
+
    def __init__(self):
        auth_params = settings.get_remnawave_auth_params()
-        self.api = RemnaWaveAPI(
-            base_url=auth_params["base_url"],
-            api_key=auth_params["api_key"],
-            secret_key=auth_params["secret_key"],
-            username=auth_params["username"],
-            password=auth_params["password"]
-        )
+        base_url = (auth_params.get("base_url") or "").strip()
+        api_key = (auth_params.get("api_key") or "").strip()
+
+        self._config_error: Optional[str] = None
+
+        if not base_url:
+            self._config_error = "REMNAWAVE_API_URL не настроен"
+        elif not api_key:
+            self._config_error = "REMNAWAVE_API_KEY не настроен"
+
+        self.api: Optional[RemnaWaveAPI]
+        if 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")
+            )
+
+    @property
+    def is_configured(self) -> bool:
+        return self._config_error is None
+
+    @property
+    def configuration_error(self) -> Optional[str]:
+        return self._config_error
+
+    def _ensure_configured(self) -> None:
+        if not self.is_configured or self.api is None:
+            raise RemnaWaveConfigurationError(
+                self._config_error or "RemnaWave API не настроен"
+            )
+
+    @asynccontextmanager
+    async def get_api_client(self):
+        self._ensure_configured()
+        assert self.api is not None
+        async with self.api as api:
+            yield api

    def _parse_remnawave_date(self, date_str: str) -> datetime:
        if not date_str:
@@ -62,7 +102,7 @@ class RemnaWaveService:
    
    async def get_system_statistics(self) -> Dict[str, Any]:
            try:
-                async with self.api as api:
+                async with self.get_api_client() as api:
                    logger.info("Получение системной статистики RemnaWave...")
                
                    try:
@@ -255,7 +295,7 @@ class RemnaWaveService:
    async def get_all_nodes(self) -> List[Dict[str, Any]]:
        
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                nodes = await api.get_all_nodes()
                
                result = []
@@ -284,7 +324,7 @@ class RemnaWaveService:
    async def test_connection(self) -> bool:
        
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                stats = await api.get_system_stats()
                logger.info("✅ Соединение с Remnawave API работает")
                return True
@@ -295,7 +335,7 @@ class RemnaWaveService:
    
    async def get_node_details(self, node_uuid: str) -> Optional[Dict[str, Any]]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                node = await api.get_node_by_uuid(node_uuid)
                
                if not node:
@@ -321,7 +361,7 @@ class RemnaWaveService:
    
    async def manage_node(self, node_uuid: str, action: str) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                if action == "enable":
                    await api.enable_node(node_uuid)
                elif action == "disable":
@@ -340,7 +380,7 @@ class RemnaWaveService:
    
    async def restart_all_nodes(self) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                result = await api.restart_all_nodes()
                
                if result:
@@ -354,7 +394,7 @@ class RemnaWaveService:

    async def update_squad_inbounds(self, squad_uuid: str, inbound_uuids: List[str]) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                data = {
                    'uuid': squad_uuid,
                    'inbounds': inbound_uuids
@@ -368,7 +408,7 @@ class RemnaWaveService:
    async def get_all_squads(self) -> List[Dict[str, Any]]:
        
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                squads = await api.get_internal_squads()
                
                result = []
@@ -390,7 +430,7 @@ class RemnaWaveService:
    
    async def create_squad(self, name: str, inbounds: List[str]) -> Optional[str]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                squad = await api.create_internal_squad(name, inbounds)
                
                logger.info(f"✅ Создан новый сквад: {name}")
@@ -402,7 +442,7 @@ class RemnaWaveService:
    
    async def update_squad(self, uuid: str, name: str = None, inbounds: List[str] = None) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                await api.update_internal_squad(uuid, name, inbounds)
                
                logger.info(f"✅ Обновлен сквад {uuid}")
@@ -414,7 +454,7 @@ class RemnaWaveService:
    
    async def delete_squad(self, uuid: str) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                result = await api.delete_internal_squad(uuid)
                
                if result:
@@ -432,7 +472,7 @@ class RemnaWaveService:
            
            logger.info(f"🔄 Начинаем синхронизацию типа: {sync_type}")
            
-            async with self.api as api:
+            async with self.get_api_client() as api:
                panel_users = []
                start = 0
                size = 100 
@@ -458,6 +498,7 @@ class RemnaWaveService:
                            'usedTrafficBytes': user_obj.used_traffic_bytes,
                            'hwidDeviceLimit': user_obj.hwid_device_limit,
                            'subscriptionUrl': user_obj.subscription_url,
+                            'subscriptionCryptoLink': user_obj.happ_crypto_link,
                            'activeInternalSquads': user_obj.active_internal_squads
                        }
                        panel_users.append(user_dict)
@@ -549,7 +590,7 @@ class RemnaWaveService:
                            
                            if db_user.remnawave_uuid:
                                try:
-                                    async with self.api as api:
+                                    async with self.get_api_client() as api:
                                        devices_reset = await api.reset_user_devices(db_user.remnawave_uuid)
                                        if devices_reset:
                                            logger.info(f"🔧 Сброшены HWID устройства для пользователя {telegram_id}")
@@ -581,6 +622,7 @@ class RemnaWaveService:
                            subscription.autopay_enabled = False
                            subscription.remnawave_short_uuid = None
                            subscription.subscription_url = ""
+                            subscription.subscription_crypto_link = ""
                            
                            db_user.remnawave_uuid = None
                            
@@ -637,14 +679,18 @@ class RemnaWaveService:
            subscription_data = {
                'user_id': user.id,
                'status': status.value,
-                'is_trial': False, 
+                'is_trial': False,
                'end_date': expire_at,
                'traffic_limit_gb': traffic_limit_gb,
                'traffic_used_gb': traffic_used_gb,
                'device_limit': panel_user.get('hwidDeviceLimit', 1) or 1,
                'connected_squads': squad_uuids,
                'remnawave_short_uuid': panel_user.get('shortUuid'),
-                'subscription_url': panel_user.get('subscriptionUrl', '')
+                'subscription_url': panel_user.get('subscriptionUrl', ''),
+                'subscription_crypto_link': (
+                    panel_user.get('subscriptionCryptoLink')
+                    or (panel_user.get('happ') or {}).get('cryptoLink', '')
+                )
            }
        
            subscription = await create_subscription(db, **subscription_data)
@@ -667,7 +713,11 @@ class RemnaWaveService:
                    device_limit=1,
                    connected_squads=[],
                    remnawave_short_uuid=panel_user.get('shortUuid'),
-                    subscription_url=panel_user.get('subscriptionUrl', '')
+                    subscription_url=panel_user.get('subscriptionUrl', ''),
+                    subscription_crypto_link=(
+                        panel_user.get('subscriptionCryptoLink')
+                        or (panel_user.get('happ') or {}).get('cryptoLink', '')
+                    )
                )
                logger.info(f"✅ Создана базовая подписка для пользователя {user.telegram_id}")
            except Exception as basic_error:
@@ -733,6 +783,13 @@ class RemnaWaveService:
            panel_url = panel_user.get('subscriptionUrl', '')
            if not subscription.subscription_url or subscription.subscription_url != panel_url:
                subscription.subscription_url = panel_url
+
+            panel_crypto_link = (
+                panel_user.get('subscriptionCryptoLink')
+                or (panel_user.get('happ') or {}).get('cryptoLink', '')
+            )
+            if panel_crypto_link and subscription.subscription_crypto_link != panel_crypto_link:
+                subscription.subscription_crypto_link = panel_crypto_link
        
            active_squads = panel_user.get('activeInternalSquads', [])
            squad_uuids = []
@@ -763,7 +820,7 @@ class RemnaWaveService:
            
            users = await get_users_list(db, offset=0, limit=10000)
            
-            async with self.api as api:
+            async with self.get_api_client() as api:
                for user in users:
                    if not user.subscription:
                        continue
@@ -825,7 +882,7 @@ class RemnaWaveService:
    
    async def get_user_traffic_stats(self, telegram_id: int) -> Optional[Dict[str, Any]]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                users = await api.get_user_by_telegram_id(telegram_id)
                
                if not users:
@@ -848,17 +905,23 @@ class RemnaWaveService:
            return None
    
    async def test_api_connection(self) -> Dict[str, Any]:
+        if not self.is_configured:
+            return {
+                "status": "not_configured",
+                "message": self.configuration_error or "RemnaWave API не настроен",
+                "api_url": settings.REMNAWAVE_API_URL,
+            }
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                system_stats = await api.get_system_stats()
-                
+
                return {
                    "status": "connected",
                    "message": "Подключение успешно",
                    "api_url": settings.REMNAWAVE_API_URL,
                    "system_info": system_stats
                }
-                
+
        except RemnaWaveAPIError as e:
            return {
                "status": "error",
@@ -866,6 +929,12 @@ class RemnaWaveService:
                "status_code": e.status_code,
                "api_url": settings.REMNAWAVE_API_URL
            }
+        except RemnaWaveConfigurationError as e:
+            return {
+                "status": "not_configured",
+                "message": str(e),
+                "api_url": settings.REMNAWAVE_API_URL,
+            }
        except Exception as e:
            return {
                "status": "error",
@@ -875,7 +944,7 @@ class RemnaWaveService:
    
    async def get_nodes_realtime_usage(self) -> List[Dict[str, Any]]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                usage_data = await api.get_nodes_realtime_usage()
                return usage_data
                
@@ -885,7 +954,7 @@ class RemnaWaveService:

    async def get_squad_details(self, squad_uuid: str) -> Optional[Dict]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                squad = await api.get_internal_squad_by_uuid(squad_uuid)
                if squad:
                    return {
@@ -902,7 +971,7 @@ class RemnaWaveService:

    async def add_all_users_to_squad(self, squad_uuid: str) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                response = await api._make_request('POST', f'/api/internal-squads/{squad_uuid}/bulk-actions/add-users')
                return response.get('response', {}).get('eventSent', False)
        except Exception as e:
@@ -911,25 +980,16 @@ class RemnaWaveService:

    async def remove_all_users_from_squad(self, squad_uuid: str) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                response = await api._make_request('DELETE', f'/api/internal-squads/{squad_uuid}/bulk-actions/remove-users')
                return response.get('response', {}).get('eventSent', False)
        except Exception as e:
            logger.error(f"Error removing users from squad: {e}")
            return False

-    async def delete_squad(self, squad_uuid: str) -> bool:
-        try:
-            async with self.api as api:
-                response = await api.delete_internal_squad(squad_uuid)
-                return response
-        except Exception as e:
-            logger.error(f"Error deleting squad: {e}")
-            return False
-
    async def get_all_inbounds(self) -> List[Dict]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                response = await api._make_request('GET', '/api/config-profiles/inbounds')
                inbounds_data = response.get('response', {}).get('inbounds', [])
            
@@ -950,7 +1010,7 @@ class RemnaWaveService:

    async def rename_squad(self, squad_uuid: str, new_name: str) -> bool:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                data = {
                    'uuid': squad_uuid,
                    'name': new_name
@@ -961,18 +1021,9 @@ class RemnaWaveService:
            logger.error(f"Error renaming squad: {e}")
            return False

-    async def create_squad(self, name: str, inbound_uuids: List[str]) -> bool:
-        try:
-            async with self.api as api:
-                squad = await api.create_internal_squad(name, inbound_uuids)
-                return squad is not None
-        except Exception as e:
-            logger.error(f"Error creating squad: {e}")
-            return False
-
    async def get_node_user_usage_by_range(self, node_uuid: str, start_date, end_date) -> List[Dict[str, Any]]:
        try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                start_str = start_date.isoformat() + "Z"
                end_str = end_date.isoformat() + "Z"
                
@@ -1050,7 +1101,7 @@ class RemnaWaveService:
            
            if user.remnawave_uuid:
                try:
-                    async with self.api as api:
+                    async with self.get_api_client() as api:
                        devices_reset = await api.reset_user_devices(user.remnawave_uuid)
                        if devices_reset:
                            logger.info(f"🔧 Сброшены HWID устройства для {user.telegram_id}")
@@ -1113,6 +1164,7 @@ class RemnaWaveService:
                    user.subscription.autopay_days_before = 3
                    user.subscription.remnawave_short_uuid = None
                    user.subscription.subscription_url = ""
+                    user.subscription.subscription_crypto_link = ""
                    user.subscription.updated_at = datetime.utcnow()
                
                await db.commit()
@@ -1136,7 +1188,7 @@ class RemnaWaveService:
        
            logger.info("🧹 Начинаем усиленную очистку неактуальных подписок...")
        
-            async with self.api as api:
+            async with self.get_api_client() as api:
                panel_users_data = await api._make_request('GET', '/api/users')
                panel_users = panel_users_data['response']['users']
        
@@ -1200,7 +1252,7 @@ class RemnaWaveService:
        
            logger.info("🔄 Начинаем синхронизацию статусов подписок...")
        
-            async with self.api as api:
+            async with self.get_api_client() as api:
                panel_users_data = await api._make_request('GET', '/api/users')
                panel_users = panel_users_data['response']['users']
        
@@ -1290,11 +1342,12 @@ class RemnaWaveService:
                
                        if not subscription.remnawave_short_uuid and user.remnawave_uuid:
                            try:
-                                async with self.api as api:
+                                async with self.get_api_client() as api:
                                    rw_user = await api.get_user_by_uuid(user.remnawave_uuid)
                                    if rw_user:
                                        subscription.remnawave_short_uuid = rw_user.short_uuid
                                        subscription.subscription_url = rw_user.subscription_url
+                                        subscription.subscription_crypto_link = rw_user.happ_crypto_link
                                        logger.info(f"🔧 Восстановлены данные Remnawave для {user.telegram_id}")
                                        issues_fixed += 1
                            except Exception as rw_error:
@@ -1538,7 +1591,7 @@ class RemnaWaveService:
        try:
            start_time = datetime.utcnow()
                
-            async with self.api as api:
+            async with self.get_api_client() as api:
                try:
                    system_stats = await api.get_system_stats()
                    api_available = True
@@ -0,0 +1,378 @@
+import asyncio
+import logging
+from dataclasses import dataclass
+from datetime import date, datetime, time as datetime_time, timedelta, timezone
+from enum import Enum
+from typing import Optional, Tuple
+
+from zoneinfo import ZoneInfo
+
+from aiogram import Bot
+from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
+from sqlalchemy import func, select
+
+from app.config import settings
+from app.database.crud.subscription import get_subscriptions_statistics
+from app.database.database import AsyncSessionLocal
+from app.database.models import (
+    Subscription,
+    SubscriptionConversion,
+    Ticket,
+    TicketStatus,
+    Transaction,
+    TransactionType,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class ReportingServiceError(RuntimeError):
+    """Base error for the reporting service."""
+
+
+class ReportPeriod(Enum):
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    MONTHLY = "monthly"
+
+
+@dataclass(slots=True)
+class ReportPeriodRange:
+    start_msk: datetime
+    end_msk: datetime
+    label: str
+
+
+class ReportingService:
+    """Generates admin summary reports and can schedule daily delivery."""
+
+    def __init__(self) -> None:
+        self.bot: Optional[Bot] = None
+        self._task: Optional[asyncio.Task] = None
+        self._moscow_tz = ZoneInfo("Europe/Moscow")
+
+    def set_bot(self, bot: Bot) -> None:
+        self.bot = bot
+
+    def is_running(self) -> bool:
+        return self._task is not None and not self._task.done()
+
+    async def start(self) -> None:
+        await self.stop()
+
+        if not settings.ADMIN_REPORTS_ENABLED:
+            logger.info("Сервис отчетов отключен настройками")
+            return
+
+        if not self.bot:
+            logger.warning("Невозможно запустить сервис отчетов без экземпляра бота")
+            return
+
+        chat_id = settings.get_reports_chat_id()
+        if not chat_id:
+            logger.warning("Сервис отчетов не запущен: не указан чат для отправки отчетов")
+            return
+
+        send_time = settings.get_reports_send_time()
+        if not send_time:
+            logger.warning("Сервис отчетов не запущен: не указано время ежедневной отправки")
+            return
+
+        self._task = asyncio.create_task(self._auto_daily_loop(send_time))
+        logger.info(
+            "📊 Сервис отчетов запущен: ежедневная отправка в %s по МСК",
+            send_time.strftime("%H:%M"),
+        )
+
+    async def stop(self) -> None:
+        if self._task and not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        self._task = None
+
+    async def send_report(
+        self,
+        period: ReportPeriod,
+        *,
+        report_date: Optional[date] = None,
+        send_to_topic: bool = False,
+    ) -> str:
+        report_text = await self._build_report(period, report_date)
+
+        if send_to_topic:
+            await self._deliver_report(report_text)
+
+        return report_text
+
+    async def _auto_daily_loop(self, send_time: datetime_time) -> None:
+        try:
+            next_run_utc, report_date = self._calculate_next_run(send_time)
+
+            while True:
+                now_utc = datetime.now(timezone.utc)
+                delay = (next_run_utc - now_utc).total_seconds()
+
+                if delay > 0:
+                    await asyncio.sleep(delay)
+
+                try:
+                    await self.send_report(
+                        ReportPeriod.DAILY,
+                        report_date=report_date,
+                        send_to_topic=True,
+                    )
+                    logger.info(
+                        "📊 Автоматический отчет за %s отправлен",
+                        report_date.strftime("%d.%m.%Y"),
+                    )
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:  # noqa: BLE001
+                    logger.error("Ошибка автоматической отправки отчета: %s", exc)
+
+                next_run_utc, report_date = self._calculate_next_run(send_time)
+
+        except asyncio.CancelledError:
+            logger.info("Сервис отчетов остановлен")
+            raise
+        except Exception as exc:  # noqa: BLE001
+            logger.error("Критическая ошибка в сервисе отчетов: %s", exc)
+
+    def _calculate_next_run(
+        self,
+        send_time: datetime_time,
+    ) -> Tuple[datetime, date]:
+        now_msk = datetime.now(self._moscow_tz)
+        candidate = datetime.combine(now_msk.date(), send_time, tzinfo=self._moscow_tz)
+
+        if now_msk >= candidate:
+            candidate += timedelta(days=1)
+
+        report_date = (candidate - timedelta(days=1)).date()
+        return candidate.astimezone(timezone.utc), report_date
+
+    async def _deliver_report(self, report_text: str) -> None:
+        if not self.bot:
+            raise ReportingServiceError("Бот не инициализирован для отправки отчета")
+
+        chat_id = settings.get_reports_chat_id()
+        if not chat_id:
+            raise ReportingServiceError("Не задан чат для отправки отчета")
+
+        topic_id = settings.get_reports_topic_id()
+
+        try:
+            await self.bot.send_message(
+                chat_id=chat_id,
+                text=report_text,
+                message_thread_id=topic_id,
+            )
+        except (TelegramBadRequest, TelegramForbiddenError) as exc:
+            logger.error("Не удалось отправить отчет: %s", exc)
+            raise ReportingServiceError("Не удалось отправить отчет в чат") from exc
+
+    async def _build_report(
+        self,
+        period: ReportPeriod,
+        report_date: Optional[date],
+    ) -> str:
+        period_range = self._get_period_range(period, report_date)
+        start_utc = period_range.start_msk.astimezone(timezone.utc).replace(tzinfo=None)
+        end_utc = period_range.end_msk.astimezone(timezone.utc).replace(tzinfo=None)
+
+        async with AsyncSessionLocal() as session:
+            totals = await self._collect_current_totals(session)
+            period_stats = await self._collect_period_stats(session, start_utc, end_utc)
+
+        header = (
+            f"📊 <b>Отчет за {period_range.label}</b>"
+            if period == ReportPeriod.DAILY
+            else f"📊 <b>Отчет за период {period_range.label}</b>"
+        )
+
+        lines = [
+            header,
+            "",
+            "🎯 <b>Триалы</b>",
+            f"• Активных сейчас: {totals['active_trials']}",
+            f"• Новых за период: {period_stats['new_trials']}",
+            "",
+            "💎 <b>Платные подписки</b>",
+            f"• Активных сейчас: {totals['active_paid']}",
+            f"• Новых за период: {period_stats['new_paid_subscriptions']}",
+            "",
+            "🎟️ <b>Тикеты поддержки</b>",
+            f"• Активных сейчас: {totals['open_tickets']}",
+            f"• Новых за период: {period_stats['new_tickets']}",
+            "",
+            "💰 <b>Платежи</b>",
+            f"• Оплат подписок: {period_stats['subscription_payments_count']} на сумму "
+            f"{self._format_amount(period_stats['subscription_payments_amount'])}",
+            f"• Пополнений: {period_stats['deposits_count']} на сумму "
+            f"{self._format_amount(period_stats['deposits_amount'])}",
+            f"• Всего поступлений: {period_stats['total_payments_count']} на сумму "
+            f"{self._format_amount(period_stats['total_payments_amount'])}",
+        ]
+
+        return "\n".join(lines)
+
+    def _get_period_range(
+        self,
+        period: ReportPeriod,
+        report_date: Optional[date],
+    ) -> ReportPeriodRange:
+        now_msk = datetime.now(self._moscow_tz)
+
+        if period == ReportPeriod.DAILY:
+            target_date = report_date or (now_msk.date() - timedelta(days=1))
+            start = datetime.combine(target_date, datetime_time.min, tzinfo=self._moscow_tz)
+            end = start + timedelta(days=1)
+        elif period == ReportPeriod.WEEKLY:
+            end_date = report_date or now_msk.date()
+            start_date = end_date - timedelta(days=7)
+            start = datetime.combine(start_date, datetime_time.min, tzinfo=self._moscow_tz)
+            end = datetime.combine(end_date, datetime_time.min, tzinfo=self._moscow_tz)
+        elif period == ReportPeriod.MONTHLY:
+            end_date = report_date or now_msk.date()
+            start_date = end_date - timedelta(days=30)
+            start = datetime.combine(start_date, datetime_time.min, tzinfo=self._moscow_tz)
+            end = datetime.combine(end_date, datetime_time.min, tzinfo=self._moscow_tz)
+        else:  # pragma: no cover - defensive branch
+            raise ReportingServiceError(f"Неизвестный период отчета: {period}")
+
+        label = self._format_period_label(start, end)
+        return ReportPeriodRange(start, end, label)
+
+    async def _collect_current_totals(self, session) -> dict:
+        stats = await get_subscriptions_statistics(session)
+        open_tickets_result = await session.execute(
+            select(func.count(Ticket.id)).where(
+                Ticket.status.in_(
+                    [
+                        TicketStatus.OPEN.value,
+                        TicketStatus.ANSWERED.value,
+                        TicketStatus.PENDING.value,
+                    ]
+                )
+            )
+        )
+        open_tickets = int(open_tickets_result.scalar() or 0)
+        return {
+            "active_trials": stats.get("trial_subscriptions", 0) or 0,
+            "active_paid": stats.get("paid_subscriptions", 0) or 0,
+            "open_tickets": open_tickets,
+        }
+
+    async def _collect_period_stats(
+        self,
+        session,
+        start_utc: datetime,
+        end_utc: datetime,
+    ) -> dict:
+        new_trials_result = await session.execute(
+            select(func.count(Subscription.id)).where(
+                Subscription.created_at >= start_utc,
+                Subscription.created_at < end_utc,
+                Subscription.is_trial == True,  # noqa: E712
+            )
+        )
+        new_trials = int(new_trials_result.scalar() or 0)
+
+        direct_paid_result = await session.execute(
+            select(func.count(Subscription.id)).where(
+                Subscription.created_at >= start_utc,
+                Subscription.created_at < end_utc,
+                Subscription.is_trial == False,  # noqa: E712
+            )
+        )
+        direct_paid = int(direct_paid_result.scalar() or 0)
+
+        conversions_result = await session.execute(
+            select(func.count(SubscriptionConversion.id)).where(
+                SubscriptionConversion.converted_at >= start_utc,
+                SubscriptionConversion.converted_at < end_utc,
+            )
+        )
+        conversions_count = int(conversions_result.scalar() or 0)
+
+        subscription_payments_row = (
+            await session.execute(
+                select(
+                    func.count(Transaction.id),
+                    func.coalesce(func.sum(Transaction.amount_kopeks), 0),
+                ).where(
+                    Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                    Transaction.is_completed == True,  # noqa: E712
+                    Transaction.created_at >= start_utc,
+                    Transaction.created_at < end_utc,
+                )
+            )
+        ).one()
+
+        deposits_row = (
+            await session.execute(
+                select(
+                    func.count(Transaction.id),
+                    func.coalesce(func.sum(Transaction.amount_kopeks), 0),
+                ).where(
+                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.is_completed == True,  # noqa: E712
+                    Transaction.created_at >= start_utc,
+                    Transaction.created_at < end_utc,
+                )
+            )
+        ).one()
+
+        subscription_payments_count = int(subscription_payments_row[0] or 0)
+        subscription_payments_amount = int(subscription_payments_row[1] or 0)
+        deposits_count = int(deposits_row[0] or 0)
+        deposits_amount = int(deposits_row[1] or 0)
+
+        total_payments_count = subscription_payments_count + deposits_count
+        total_payments_amount = subscription_payments_amount + deposits_amount
+        new_tickets_result = await session.execute(
+            select(func.count(Ticket.id)).where(
+                Ticket.created_at >= start_utc,
+                Ticket.created_at < end_utc,
+            )
+        )
+        new_tickets = int(new_tickets_result.scalar() or 0)
+
+        return {
+            "new_trials": new_trials,
+            "new_paid_subscriptions": direct_paid + conversions_count,
+            "subscription_payments_count": subscription_payments_count,
+            "subscription_payments_amount": subscription_payments_amount,
+            "deposits_count": deposits_count,
+            "deposits_amount": deposits_amount,
+            "total_payments_count": total_payments_count,
+            "total_payments_amount": total_payments_amount,
+            "new_tickets": new_tickets,
+        }
+
+    def _format_period_label(self, start: datetime, end: datetime) -> str:
+        start_date = start.astimezone(self._moscow_tz).date()
+        end_boundary = (end - timedelta(seconds=1)).astimezone(self._moscow_tz)
+        end_date = end_boundary.date()
+
+        if start_date == end_date:
+            return start_date.strftime("%d.%m.%Y")
+
+        return (
+            f"{start_date.strftime('%d.%m.%Y')} - {end_date.strftime('%d.%m.%Y')}"
+        )
+
+    def _format_amount(self, amount_kopeks: int) -> str:
+        if not amount_kopeks:
+            return "0 ₽"
+
+        rubles = amount_kopeks / 100
+        return f"{rubles:,.2f} ₽".replace(",", " ")
+
+
+reporting_service = ReportingService()
+
@@ -49,4 +49,10 @@ def should_offer_checkout_resume(user: User, has_draft: bool) -> bool:
    if subscription is None:
        return True

-    return bool(getattr(subscription, "is_trial", False))
+    if getattr(subscription, "is_trial", False):
+        return True
+
+    if getattr(subscription, "actual_status", None) == "expired":
+        return True
+
+    return False
@@ -38,6 +38,26 @@ def _resolve_discount_percent(

    return 0

+
+def _resolve_addon_discount_percent(
+    user: Optional[User],
+    promo_group: Optional[PromoGroup],
+    category: str,
+    *,
+    period_days: Optional[int] = None,
+) -> int:
+    group = promo_group or (getattr(user, "promo_group", None) if user else None)
+
+    if group is not None and not getattr(group, "apply_discounts_to_addons", True):
+        return 0
+
+    return _resolve_discount_percent(
+        user,
+        promo_group,
+        category,
+        period_days=period_days,
+    )
+
 def get_traffic_reset_strategy():
    from app.config import settings
    strategy = settings.DEFAULT_TRAFFIC_RESET_STRATEGY.upper()
@@ -67,9 +87,12 @@ class SubscriptionService:
        )
    
    async def create_remnawave_user(
-        self, 
-        db: AsyncSession, 
-        subscription: Subscription
+        self,
+        db: AsyncSession,
+        subscription: Subscription,
+        *,
+        reset_traffic: bool = False,
+        reset_reason: Optional[str] = None,
    ) -> Optional[RemnaWaveUser]:
        
        try:
@@ -110,6 +133,14 @@ class SubscriptionService:
                        active_internal_squads=subscription.connected_squads
                    )
                    
+                    if reset_traffic:
+                        await self._reset_user_traffic(
+                            api,
+                            updated_user.uuid,
+                            user.telegram_id,
+                            reset_reason,
+                        )
+
                else:
                    logger.info(f"🆕 Создаем нового пользователя в панели для {user.telegram_id}")
                    username = f"user_{user.telegram_id}"
@@ -128,9 +159,18 @@ class SubscriptionService:
                        ),
                        active_internal_squads=subscription.connected_squads
                    )
-                
+
+                    if reset_traffic:
+                        await self._reset_user_traffic(
+                            api,
+                            updated_user.uuid,
+                            user.telegram_id,
+                            reset_reason,
+                        )
+
                subscription.remnawave_short_uuid = updated_user.short_uuid
-                subscription.subscription_url = updated_user.subscription_url 
+                subscription.subscription_url = updated_user.subscription_url
+                subscription.subscription_crypto_link = updated_user.happ_crypto_link
                user.remnawave_uuid = updated_user.uuid
                
                await db.commit()
@@ -151,7 +191,10 @@ class SubscriptionService:
    async def update_remnawave_user(
        self,
        db: AsyncSession,
-        subscription: Subscription
+        subscription: Subscription,
+        *,
+        reset_traffic: bool = False,
+        reset_reason: Optional[str] = None,
    ) -> Optional[RemnaWaveUser]:
        
        try:
@@ -189,7 +232,16 @@ class SubscriptionService:
                    active_internal_squads=subscription.connected_squads
                )
                
+                if reset_traffic:
+                    await self._reset_user_traffic(
+                        api,
+                        user.remnawave_uuid,
+                        user.telegram_id,
+                        reset_reason,
+                    )
+
                subscription.subscription_url = updated_user.subscription_url
+                subscription.subscription_crypto_link = updated_user.happ_crypto_link
                await db.commit()
                
                status_text = "активным" if is_actually_active else "истёкшим"
@@ -197,16 +249,37 @@ class SubscriptionService:
                strategy_name = settings.DEFAULT_TRAFFIC_RESET_STRATEGY
                logger.info(f"📊 Стратегия сброса трафика: {strategy_name}")
                return updated_user
-                
+
        except RemnaWaveAPIError as e:
            logger.error(f"Ошибка RemnaWave API: {e}")
            return None
        except Exception as e:
            logger.error(f"Ошибка обновления RemnaWave пользователя: {e}")
            return None
-    
+
+    async def _reset_user_traffic(
+        self,
+        api: RemnaWaveAPI,
+        user_uuid: str,
+        telegram_id: int,
+        reset_reason: Optional[str] = None,
+    ) -> None:
+        if not user_uuid:
+            return
+
+        try:
+            await api.reset_user_traffic(user_uuid)
+            reason_text = f" ({reset_reason})" if reset_reason else ""
+            logger.info(
+                f"🔄 Сброшен трафик RemnaWave для пользователя {telegram_id}{reason_text}"
+            )
+        except Exception as exc:
+            logger.warning(
+                f"⚠️ Не удалось сбросить трафик RemnaWave для пользователя {telegram_id}: {exc}"
+            )
+
    async def disable_remnawave_user(self, user_uuid: str) -> bool:
-        
+
        try:
            async with self.api as api:
                await api.disable_user(user_uuid)
@@ -233,6 +306,7 @@ class SubscriptionService:
                
                subscription.remnawave_short_uuid = updated_user.short_uuid
                subscription.subscription_url = updated_user.subscription_url
+                subscription.subscription_crypto_link = updated_user.happ_crypto_link
                await db.commit()
                
                logger.info(f"✅ Обновлена ссылка подписки для пользователя {user.telegram_id}")
@@ -299,7 +373,15 @@ class SubscriptionService:
        if settings.MAX_DEVICES_LIMIT > 0 and devices > settings.MAX_DEVICES_LIMIT:
            raise ValueError(f"Превышен максимальный лимит устройств: {settings.MAX_DEVICES_LIMIT}")
    
-        base_price = PERIOD_PRICES.get(period_days, 0)
+        base_price_original = PERIOD_PRICES.get(period_days, 0)
+        period_discount_percent = _resolve_discount_percent(
+            user,
+            promo_group,
+            "period",
+            period_days=period_days,
+        )
+        base_discount_total = base_price_original * period_discount_percent // 100
+        base_price = base_price_original - base_discount_total
        
        promo_group = promo_group or (user.promo_group if user else None)

@@ -353,7 +435,13 @@ class SubscriptionService:
        total_price = base_price + discounted_traffic_price + total_servers_price + discounted_devices_price

        logger.info(f"Расчет стоимости новой подписки:")
-        logger.info(f"   Период {period_days} дней: {base_price/100}₽")
+        base_log = f"   Период {period_days} дней: {base_price_original/100}₽"
+        if base_discount_total > 0:
+            base_log += (
+                f" → {base_price/100}₽"
+                f" (скидка {period_discount_percent}%: -{base_discount_total/100}₽)"
+            )
+        logger.info(base_log)
        if discounted_traffic_price > 0:
            message = f"   Трафик {traffic_gb} ГБ: {traffic_price/100}₽"
            if traffic_discount > 0:
@@ -391,14 +479,16 @@ class SubscriptionService:
        try:
            from app.config import PERIOD_PRICES

-            base_price = PERIOD_PRICES.get(period_days, 0)
+            base_price_original = PERIOD_PRICES.get(period_days, 0)

            if user is None:
                user = getattr(subscription, "user", None)
            promo_group = promo_group or (user.promo_group if user else None)

            servers_price, _ = await self.get_countries_price_by_uuids(
-                subscription.connected_squads, db
+                subscription.connected_squads,
+                db,
+                promo_group_id=promo_group.id if promo_group else None,
            )

            servers_discount_percent = _resolve_discount_percent(
@@ -430,6 +520,15 @@ class SubscriptionService:
            traffic_discount = traffic_price * traffic_discount_percent // 100
            discounted_traffic_price = traffic_price - traffic_discount

+            period_discount_percent = _resolve_discount_percent(
+                user,
+                promo_group,
+                "period",
+                period_days=period_days,
+            )
+            base_discount_total = base_price_original * period_discount_percent // 100
+            base_price = base_price_original - base_discount_total
+
            total_price = (
                base_price
                + discounted_servers_price
@@ -438,7 +537,13 @@ class SubscriptionService:
            )

            logger.info(f"💰 Расчет стоимости продления для подписки {subscription.id} (по текущим ценам):")
-            logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+            base_log = f"   📅 Период {period_days} дней: {base_price_original/100}₽"
+            if base_discount_total > 0:
+                base_log += (
+                    f" → {base_price/100}₽"
+                    f" (скидка {period_discount_percent}%: -{base_discount_total/100}₽)"
+                )
+            logger.info(base_log)
            if servers_price > 0:
                message = f"   🌍 Серверы ({len(subscription.connected_squads)}) по текущим ценам: {discounted_servers_price/100}₽"
                if servers_discount > 0:
@@ -503,6 +608,7 @@ class SubscriptionService:
                
                subscription.remnawave_short_uuid = None
                subscription.subscription_url = ""
+                subscription.subscription_crypto_link = ""
                subscription.connected_squads = []
                
                user.remnawave_uuid = None
@@ -518,9 +624,11 @@ class SubscriptionService:
            return False
    
    async def get_countries_price_by_uuids(
-        self, 
-        country_uuids: List[str], 
-        db: AsyncSession
+        self,
+        country_uuids: List[str],
+        db: AsyncSession,
+        *,
+        promo_group_id: Optional[int] = None,
    ) -> Tuple[int, List[int]]:
        try:
            from app.database.crud.server_squad import get_server_squad_by_uuid
@@ -530,7 +638,12 @@ class SubscriptionService:
            
            for country_uuid in country_uuids:
                server = await get_server_squad_by_uuid(db, country_uuid)
-                if server and server.is_available and not server.is_full:
+                is_allowed = True
+                if promo_group_id is not None and server:
+                    allowed_ids = {pg.id for pg in server.allowed_promo_groups}
+                    is_allowed = promo_group_id in allowed_ids
+
+                if server and server.is_available and not server.is_full and is_allowed:
                    price = server.price_kopeks
                    total_price += price
                    prices_list.append(price)
@@ -577,7 +690,15 @@ class SubscriptionService:
        
        months_in_period = calculate_months_from_days(period_days)
        
-        base_price = PERIOD_PRICES.get(period_days, 0)
+        base_price_original = PERIOD_PRICES.get(period_days, 0)
+        period_discount_percent = _resolve_discount_percent(
+            user,
+            promo_group,
+            "period",
+            period_days=period_days,
+        )
+        base_discount_total = base_price_original * period_discount_percent // 100
+        base_price = base_price_original - base_discount_total
        
        promo_group = promo_group or (user.promo_group if user else None)

@@ -637,7 +758,13 @@ class SubscriptionService:
        total_price = base_price + total_traffic_price + total_servers_price + total_devices_price

        logger.info(f"Расчет стоимости новой подписки на {period_days} дней ({months_in_period} мес):")
-        logger.info(f"   Период {period_days} дней: {base_price/100}₽")
+        base_log = f"   Период {period_days} дней: {base_price_original/100}₽"
+        if base_discount_total > 0:
+            base_log += (
+                f" → {base_price/100}₽"
+                f" (скидка {period_discount_percent}%: -{base_discount_total/100}₽)"
+            )
+        logger.info(base_log)
        if total_traffic_price > 0:
            message = (
                f"   Трафик {traffic_gb} ГБ: {traffic_price_per_month/100}₽/мес x {months_in_period} = {total_traffic_price/100}₽"
@@ -681,14 +808,16 @@ class SubscriptionService:

            months_in_period = calculate_months_from_days(period_days)

-            base_price = PERIOD_PRICES.get(period_days, 0)
+            base_price_original = PERIOD_PRICES.get(period_days, 0)

            if user is None:
                user = getattr(subscription, "user", None)
            promo_group = promo_group or (user.promo_group if user else None)

            servers_price_per_month, _ = await self.get_countries_price_by_uuids(
-                subscription.connected_squads, db
+                subscription.connected_squads,
+                db,
+                promo_group_id=promo_group.id if promo_group else None,
            )
            servers_discount_percent = _resolve_discount_percent(
                user,
@@ -723,10 +852,25 @@ class SubscriptionService:
            discounted_traffic_per_month = traffic_price_per_month - traffic_discount_per_month
            total_traffic_price = discounted_traffic_per_month * months_in_period

+            period_discount_percent = _resolve_discount_percent(
+                user,
+                promo_group,
+                "period",
+                period_days=period_days,
+            )
+            base_discount_total = base_price_original * period_discount_percent // 100
+            base_price = base_price_original - base_discount_total
+
            total_price = base_price + total_servers_price + total_devices_price + total_traffic_price

            logger.info(f"💰 Расчет стоимости продления подписки {subscription.id} на {period_days} дней ({months_in_period} мес):")
-            logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+            base_log = f"   📅 Период {period_days} дней: {base_price_original/100}₽"
+            if base_discount_total > 0:
+                base_log += (
+                    f" → {base_price/100}₽"
+                    f" (скидка {period_discount_percent}%: -{base_discount_total/100}₽)"
+                )
+            logger.info(base_log)
            if total_servers_price > 0:
                message = (
                    f"   🌍 Серверы: {servers_price_per_month/100}₽/мес x {months_in_period} = {total_servers_price/100}₽"
@@ -785,7 +929,7 @@ class SubscriptionService:

        if additional_traffic_gb > 0:
            traffic_price_per_month = settings.get_traffic_price(additional_traffic_gb)
-            traffic_discount_percent = _resolve_discount_percent(
+            traffic_discount_percent = _resolve_addon_discount_percent(
                user,
                promo_group,
                "traffic",
@@ -808,7 +952,7 @@ class SubscriptionService:

        if additional_devices > 0:
            devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
-            devices_discount_percent = _resolve_discount_percent(
+            devices_discount_percent = _resolve_addon_discount_percent(
                user,
                promo_group,
                "devices",
@@ -835,7 +979,7 @@ class SubscriptionService:
                server = await get_server_squad_by_id(db, server_id)
                if server and server.is_available:
                    server_price_per_month = server.price_kopeks
-                    servers_discount_percent = _resolve_discount_percent(
+                    servers_discount_percent = _resolve_addon_discount_percent(
                        user,
                        promo_group,
                        "servers",
@@ -110,3 +110,112 @@ class SupportSettingsService:
        return cls._save()


+    # Notifications & SLA
+    @classmethod
+    def get_admin_ticket_notifications_enabled(cls) -> bool:
+        cls._load()
+        if "admin_ticket_notifications_enabled" in cls._data:
+            return bool(cls._data["admin_ticket_notifications_enabled"])
+        # fallback to global admin notifications setting
+        return bool(settings.is_admin_notifications_enabled())
+
+    @classmethod
+    def set_admin_ticket_notifications_enabled(cls, enabled: bool) -> bool:
+        cls._load()
+        cls._data["admin_ticket_notifications_enabled"] = bool(enabled)
+        return cls._save()
+
+    @classmethod
+    def get_user_ticket_notifications_enabled(cls) -> bool:
+        cls._load()
+        if "user_ticket_notifications_enabled" in cls._data:
+            return bool(cls._data["user_ticket_notifications_enabled"])
+        # fallback to global enable notifications
+        return bool(getattr(settings, "ENABLE_NOTIFICATIONS", True))
+
+    @classmethod
+    def set_user_ticket_notifications_enabled(cls, enabled: bool) -> bool:
+        cls._load()
+        cls._data["user_ticket_notifications_enabled"] = bool(enabled)
+        return cls._save()
+
+    @classmethod
+    def get_sla_enabled(cls) -> bool:
+        cls._load()
+        if "ticket_sla_enabled" in cls._data:
+            return bool(cls._data["ticket_sla_enabled"])
+        return bool(getattr(settings, "SUPPORT_TICKET_SLA_ENABLED", True))
+
+    @classmethod
+    def set_sla_enabled(cls, enabled: bool) -> bool:
+        cls._load()
+        cls._data["ticket_sla_enabled"] = bool(enabled)
+        return cls._save()
+
+    @classmethod
+    def get_sla_minutes(cls) -> int:
+        cls._load()
+        minutes = cls._data.get("ticket_sla_minutes")
+        if isinstance(minutes, int) and minutes > 0:
+            return minutes
+        return int(getattr(settings, "SUPPORT_TICKET_SLA_MINUTES", 5))
+
+    @classmethod
+    def set_sla_minutes(cls, minutes: int) -> bool:
+        try:
+            minutes_int = int(minutes)
+        except Exception:
+            return False
+        if minutes_int <= 0:
+            return False
+        cls._load()
+        cls._data["ticket_sla_minutes"] = minutes_int
+        return cls._save()
+
+    # Moderators management
+    @classmethod
+    def get_moderators(cls) -> list[int]:
+        cls._load()
+        raw = cls._data.get("moderators") or []
+        moderators: list[int] = []
+        for item in raw:
+            try:
+                moderators.append(int(item))
+            except Exception:
+                continue
+        return moderators
+
+    @classmethod
+    def is_moderator(cls, telegram_id: int) -> bool:
+        try:
+            tid = int(telegram_id)
+        except Exception:
+            return False
+        return tid in cls.get_moderators()
+
+    @classmethod
+    def add_moderator(cls, telegram_id: int) -> bool:
+        try:
+            tid = int(telegram_id)
+        except Exception:
+            return False
+        cls._load()
+        moderators = set(cls.get_moderators())
+        moderators.add(tid)
+        cls._data["moderators"] = sorted(moderators)
+        return cls._save()
+
+    @classmethod
+    def remove_moderator(cls, telegram_id: int) -> bool:
+        try:
+            tid = int(telegram_id)
+        except Exception:
+            return False
+        cls._load()
+        moderators = set(cls.get_moderators())
+        if tid in moderators:
+            moderators.remove(tid)
+            cls._data["moderators"] = sorted(moderators)
+            return cls._save()
+        return True
+
@@ -0,0 +1,706 @@
+import hashlib
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple, Type, Union, get_args, get_origin
+
+from app.database.universal_migration import ensure_default_web_api_token
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import Settings, settings
+from app.database.crud.system_setting import (
+    delete_system_setting,
+    upsert_system_setting,
+)
+from app.database.database import AsyncSessionLocal
+from app.database.models import SystemSetting
+
+
+logger = logging.getLogger(__name__)
+
+
+def _title_from_key(key: str) -> str:
+    parts = key.split("_")
+    if not parts:
+        return key
+    return " ".join(part.capitalize() for part in parts)
+
+
+def _truncate(value: str, max_len: int = 60) -> str:
+    value = value.strip()
+    if len(value) <= max_len:
+        return value
+    return value[: max_len - 1] + "…"
+
+
+@dataclass(slots=True)
+class SettingDefinition:
+    key: str
+    category_key: str
+    category_label: str
+    python_type: Type[Any]
+    type_label: str
+    is_optional: bool
+
+    @property
+    def display_name(self) -> str:
+        return _title_from_key(self.key)
+
+
+@dataclass(slots=True)
+class ChoiceOption:
+    value: Any
+    label: str
+    description: Optional[str] = None
+
+
+class BotConfigurationService:
+    EXCLUDED_KEYS: set[str] = {"BOT_TOKEN", "ADMIN_IDS"}
+
+    CATEGORY_TITLES: Dict[str, str] = {
+        "SUPPORT": "💬 Ссылка на поддержку",
+        "LOCALIZATION": "🌍 Языковые настройки",
+        "MAINTENANCE": "🛠️ Режим обслуживания",
+        "CHANNEL": "📣 Обязательная подписка",
+        "ADMIN_NOTIFICATIONS": "🔔 Уведомления админам",
+        "ADMIN_REPORTS": "📊 Автоматические отчеты",
+        "TRIAL": "🎁 Триальная подписка",
+        "PAID_SUBSCRIPTION": "💰 Платные подписки",
+        "PERIODS": "📅 Периоды подписки",
+        "SUBSCRIPTION_PRICES": "💵 Цены за периоды",
+        "TRAFFIC": "🚦 Настройки трафика",
+        "TRAFFIC_PACKAGES": "📦 Пакеты трафика",
+        "DISCOUNTS": "🎯 Промо и скидки",
+        "PAYMENT": "⚙️ Общие настройки платежей",
+        "TELEGRAM": "⭐ Telegram Stars",
+        "CRYPTOBOT": "💎 CryptoBot",
+        "YOOKASSA": "💸 YooKassa",
+        "TRIBUTE": "🎁 Tribute",
+        "MULENPAY": "💰 MulenPay",
+        "PAL24": "🏦 Pal24/PayPalych",
+        "REMNAWAVE": "🔗 RemnaWave API",
+        "REFERRAL": "🤝 Реферальная система",
+        "AUTOPAY": "🔄 Автопродление",
+        "INTERFACE_BRANDING": "🖼️ Визуальные настройки",
+        "INTERFACE_SUBSCRIPTION": "🔗 Скрыть ссылку подписки",
+        "CONNECT_BUTTON": "🚀 Кнопка «Подключиться»",
+        "HAPP": "🅷 Happ настройки",
+        "SKIP": "⚡ Быстрый старт",
+        "ADDITIONAL": "📱 Приложения и DeepLinks",
+        "MINIAPP": "📱 Mini App",
+        "DATABASE": "🗄️ Режим БД",
+        "POSTGRES": "🐘 PostgreSQL",
+        "SQLITE": "💾 SQLite",
+        "REDIS": "🧠 Redis",
+        "MONITORING": "📈 Общий мониторинг",
+        "NOTIFICATIONS": "🔔 Уведомления пользователям",
+        "SERVER": "🖥️ Статус серверов",
+        "BACKUP": "💾 Система бэкапов",
+        "VERSION": "🔄 Обновления",
+        "LOG": "📝 Логирование",
+        "WEBHOOK": "🌐 Webhook",
+        "WEB_API": "🌐 Web API",
+        "DEBUG": "🔧 Режим разработки",
+    }
+
+    CATEGORY_KEY_OVERRIDES: Dict[str, str] = {
+        "DATABASE_URL": "DATABASE",
+        "DATABASE_MODE": "DATABASE",
+        "LOCALES_PATH": "DATABASE",
+        "DEFAULT_DEVICE_LIMIT": "PAID_SUBSCRIPTION",
+        "DEFAULT_TRAFFIC_LIMIT_GB": "PAID_SUBSCRIPTION",
+        "MAX_DEVICES_LIMIT": "PAID_SUBSCRIPTION",
+        "PRICE_PER_DEVICE": "PAID_SUBSCRIPTION",
+        "DEFAULT_TRAFFIC_RESET_STRATEGY": "TRAFFIC",
+        "RESET_TRAFFIC_ON_PAYMENT": "TRAFFIC",
+        "TRAFFIC_SELECTION_MODE": "TRAFFIC",
+        "FIXED_TRAFFIC_LIMIT_GB": "TRAFFIC",
+        "AVAILABLE_SUBSCRIPTION_PERIODS": "PERIODS",
+        "AVAILABLE_RENEWAL_PERIODS": "PERIODS",
+        "BASE_SUBSCRIPTION_PRICE": "SUBSCRIPTION_PRICES",
+        "PRICE_14_DAYS": "SUBSCRIPTION_PRICES",
+        "PRICE_30_DAYS": "SUBSCRIPTION_PRICES",
+        "PRICE_60_DAYS": "SUBSCRIPTION_PRICES",
+        "PRICE_90_DAYS": "SUBSCRIPTION_PRICES",
+        "PRICE_180_DAYS": "SUBSCRIPTION_PRICES",
+        "PRICE_360_DAYS": "SUBSCRIPTION_PRICES",
+        "PRICE_TRAFFIC_5GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_10GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_25GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_50GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_100GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_250GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_500GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_1000GB": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC_UNLIMITED": "TRAFFIC_PACKAGES",
+        "TRAFFIC_PACKAGES_CONFIG": "TRAFFIC_PACKAGES",
+        "BASE_PROMO_GROUP_PERIOD_DISCOUNTS_ENABLED": "DISCOUNTS",
+        "BASE_PROMO_GROUP_PERIOD_DISCOUNTS": "DISCOUNTS",
+        "REFERRED_USER_REWARD": "REFERRAL",
+        "DEFAULT_AUTOPAY_DAYS_BEFORE": "AUTOPAY",
+        "MIN_BALANCE_FOR_AUTOPAY_KOPEKS": "AUTOPAY",
+        "TRIAL_WARNING_HOURS": "NOTIFICATIONS",
+        "ENABLE_NOTIFICATIONS": "NOTIFICATIONS",
+        "NOTIFICATION_RETRY_ATTEMPTS": "NOTIFICATIONS",
+        "NOTIFICATION_CACHE_HOURS": "NOTIFICATIONS",
+        "MONITORING_LOGS_RETENTION_DAYS": "MONITORING",
+        "ENABLE_LOGO_MODE": "INTERFACE_BRANDING",
+        "LOGO_FILE": "INTERFACE_BRANDING",
+        "HIDE_SUBSCRIPTION_LINK": "INTERFACE_SUBSCRIPTION",
+        "CONNECT_BUTTON_MODE": "CONNECT_BUTTON",
+        "MINIAPP_CUSTOM_URL": "CONNECT_BUTTON",
+        "APP_CONFIG_PATH": "ADDITIONAL",
+        "ENABLE_DEEP_LINKS": "ADDITIONAL",
+        "APP_CONFIG_CACHE_TTL": "ADDITIONAL",
+        "DEFAULT_LANGUAGE": "LOCALIZATION",
+        "AVAILABLE_LANGUAGES": "LOCALIZATION",
+        "PAYMENT_SERVICE_NAME": "PAYMENT",
+        "PAYMENT_BALANCE_DESCRIPTION": "PAYMENT",
+        "PAYMENT_SUBSCRIPTION_DESCRIPTION": "PAYMENT",
+        "PAYMENT_BALANCE_TEMPLATE": "PAYMENT",
+        "PAYMENT_SUBSCRIPTION_TEMPLATE": "PAYMENT",
+        "INACTIVE_USER_DELETE_MONTHS": "MONITORING",
+        "LANGUAGE_SELECTION_ENABLED": "LOCALIZATION",
+    }
+
+    CATEGORY_PREFIX_OVERRIDES: Dict[str, str] = {
+        "SUPPORT_": "SUPPORT",
+        "ADMIN_NOTIFICATIONS": "ADMIN_NOTIFICATIONS",
+        "ADMIN_REPORTS": "ADMIN_REPORTS",
+        "CHANNEL_": "CHANNEL",
+        "POSTGRES_": "POSTGRES",
+        "SQLITE_": "SQLITE",
+        "REDIS_": "REDIS",
+        "REMNAWAVE": "REMNAWAVE",
+        "TRIAL_": "TRIAL",
+        "TRAFFIC_PACKAGES": "TRAFFIC_PACKAGES",
+        "PRICE_TRAFFIC": "TRAFFIC_PACKAGES",
+        "TRAFFIC_": "TRAFFIC",
+        "REFERRAL_": "REFERRAL",
+        "AUTOPAY_": "AUTOPAY",
+        "TELEGRAM_STARS": "TELEGRAM",
+        "TRIBUTE_": "TRIBUTE",
+        "YOOKASSA_": "YOOKASSA",
+        "CRYPTOBOT_": "CRYPTOBOT",
+        "MULENPAY_": "MULENPAY",
+        "PAL24_": "PAL24",
+        "PAYMENT_": "PAYMENT",
+        "CONNECT_BUTTON_HAPP": "HAPP",
+        "HAPP_": "HAPP",
+        "SKIP_": "SKIP",
+        "MINIAPP_": "MINIAPP",
+        "MONITORING_": "MONITORING",
+        "NOTIFICATION_": "NOTIFICATIONS",
+        "SERVER_STATUS": "SERVER",
+        "MAINTENANCE_": "MAINTENANCE",
+        "VERSION_CHECK": "VERSION",
+        "BACKUP_": "BACKUP",
+        "WEBHOOK_": "WEBHOOK",
+        "LOG_": "LOG",
+        "WEB_API_": "WEB_API",
+        "DEBUG": "DEBUG",
+    }
+
+    CHOICES: Dict[str, List[ChoiceOption]] = {
+        "DATABASE_MODE": [
+            ChoiceOption("auto", "🤖 Авто"),
+            ChoiceOption("postgresql", "🐘 PostgreSQL"),
+            ChoiceOption("sqlite", "💾 SQLite"),
+        ],
+        "REMNAWAVE_AUTH_TYPE": [
+            ChoiceOption("api_key", "🔑 API Key"),
+            ChoiceOption("basic_auth", "🧾 Basic Auth"),
+        ],
+        "REMNAWAVE_USER_DELETE_MODE": [
+            ChoiceOption("delete", "🗑 Удалять"),
+            ChoiceOption("disable", "🚫 Деактивировать"),
+        ],
+        "TRAFFIC_SELECTION_MODE": [
+            ChoiceOption("selectable", "📦 Выбор пакетов"),
+            ChoiceOption("fixed", "📏 Фиксированный лимит"),
+        ],
+        "DEFAULT_TRAFFIC_RESET_STRATEGY": [
+            ChoiceOption("NO_RESET", "♾️ Без сброса"),
+            ChoiceOption("DAY", "📅 Ежедневно"),
+            ChoiceOption("WEEK", "🗓 Еженедельно"),
+            ChoiceOption("MONTH", "📆 Ежемесячно"),
+        ],
+        "SUPPORT_SYSTEM_MODE": [
+            ChoiceOption("tickets", "🎫 Только тикеты"),
+            ChoiceOption("contact", "💬 Только контакт"),
+            ChoiceOption("both", "🔁 Оба варианта"),
+        ],
+        "CONNECT_BUTTON_MODE": [
+            ChoiceOption("guide", "📘 Гайд"),
+            ChoiceOption("miniapp_subscription", "🧾 Mini App подписка"),
+            ChoiceOption("miniapp_custom", "🧩 Mini App (ссылка)"),
+            ChoiceOption("link", "🔗 Прямая ссылка"),
+            ChoiceOption("happ_cryptolink", "🪙 Happ CryptoLink"),
+        ],
+        "SERVER_STATUS_MODE": [
+            ChoiceOption("disabled", "🚫 Отключено"),
+            ChoiceOption("external_link", "🌐 Внешняя ссылка"),
+            ChoiceOption("external_link_miniapp", "🧭 Mini App ссылка"),
+            ChoiceOption("xray", "📊 XRay Checker"),
+        ],
+        "YOOKASSA_PAYMENT_MODE": [
+            ChoiceOption("full_payment", "💳 Полная оплата"),
+            ChoiceOption("partial_payment", "🪙 Частичная оплата"),
+            ChoiceOption("advance", "💼 Аванс"),
+            ChoiceOption("full_prepayment", "📦 Полная предоплата"),
+            ChoiceOption("partial_prepayment", "📦 Частичная предоплата"),
+            ChoiceOption("credit", "💰 Кредит"),
+            ChoiceOption("credit_payment", "💸 Погашение кредита"),
+        ],
+        "YOOKASSA_PAYMENT_SUBJECT": [
+            ChoiceOption("commodity", "📦 Товар"),
+            ChoiceOption("excise", "🥃 Подакцизный товар"),
+            ChoiceOption("job", "🛠 Работа"),
+            ChoiceOption("service", "🧾 Услуга"),
+            ChoiceOption("gambling_bet", "🎲 Ставка"),
+            ChoiceOption("gambling_prize", "🏆 Выигрыш"),
+            ChoiceOption("lottery", "🎫 Лотерея"),
+            ChoiceOption("lottery_prize", "🎁 Приз лотереи"),
+            ChoiceOption("intellectual_activity", "🧠 Интеллектуальная деятельность"),
+            ChoiceOption("payment", "💱 Платеж"),
+            ChoiceOption("agent_commission", "🤝 Комиссия агента"),
+            ChoiceOption("composite", "🧩 Композитный"),
+            ChoiceOption("another", "📄 Другое"),
+        ],
+        "YOOKASSA_VAT_CODE": [
+            ChoiceOption(1, "1 — НДС не облагается"),
+            ChoiceOption(2, "2 — НДС 0%"),
+            ChoiceOption(3, "3 — НДС 10%"),
+            ChoiceOption(4, "4 — НДС 20%"),
+            ChoiceOption(5, "5 — НДС 10/110"),
+            ChoiceOption(6, "6 — НДС 20/120"),
+        ],
+        "MULENPAY_LANGUAGE": [
+            ChoiceOption("ru", "🇷🇺 Русский"),
+            ChoiceOption("en", "🇬🇧 Английский"),
+        ],
+        "LOG_LEVEL": [
+            ChoiceOption("DEBUG", "🐞 Debug"),
+            ChoiceOption("INFO", "ℹ️ Info"),
+            ChoiceOption("WARNING", "⚠️ Warning"),
+            ChoiceOption("ERROR", "❌ Error"),
+            ChoiceOption("CRITICAL", "🔥 Critical"),
+        ],
+    }
+
+    _definitions: Dict[str, SettingDefinition] = {}
+    _original_values: Dict[str, Any] = settings.model_dump()
+    _overrides_raw: Dict[str, Optional[str]] = {}
+    _callback_tokens: Dict[str, str] = {}
+    _token_to_key: Dict[str, str] = {}
+    _choice_tokens: Dict[str, Dict[Any, str]] = {}
+    _choice_token_lookup: Dict[str, Dict[str, Any]] = {}
+
+    @classmethod
+    def initialize_definitions(cls) -> None:
+        if cls._definitions:
+            return
+
+        for key, field in Settings.model_fields.items():
+            if key in cls.EXCLUDED_KEYS:
+                continue
+
+            annotation = field.annotation
+            python_type, is_optional = cls._normalize_type(annotation)
+            type_label = cls._type_to_label(python_type, is_optional)
+
+            category_key = cls._resolve_category_key(key)
+            category_label = cls.CATEGORY_TITLES.get(
+                category_key,
+                category_key.capitalize() if category_key else "Прочее",
+            )
+
+            cls._definitions[key] = SettingDefinition(
+                key=key,
+                category_key=category_key or "other",
+                category_label=category_label,
+                python_type=python_type,
+                type_label=type_label,
+                is_optional=is_optional,
+            )
+
+            cls._register_callback_token(key)
+            if key in cls.CHOICES:
+                cls._ensure_choice_tokens(key)
+
+
+    @classmethod
+    def _resolve_category_key(cls, key: str) -> str:
+        override = cls.CATEGORY_KEY_OVERRIDES.get(key)
+        if override:
+            return override
+
+        for prefix, category in sorted(
+            cls.CATEGORY_PREFIX_OVERRIDES.items(), key=lambda item: len(item[0]), reverse=True
+        ):
+            if key.startswith(prefix):
+                return category
+
+        if "_" not in key:
+            return key.upper()
+        prefix = key.split("_", 1)[0]
+        return prefix.upper()
+
+    @classmethod
+    def _normalize_type(cls, annotation: Any) -> Tuple[Type[Any], bool]:
+        if annotation is None:
+            return str, True
+
+        origin = get_origin(annotation)
+        if origin is Union:
+            args = [arg for arg in get_args(annotation) if arg is not type(None)]
+            if len(args) == 1:
+                nested_type, nested_optional = cls._normalize_type(args[0])
+                return nested_type, True
+            return str, True
+
+        if annotation in {int, float, bool, str}:
+            return annotation, False
+
+        if annotation in {Optional[int], Optional[float], Optional[bool], Optional[str]}:
+            nested = get_args(annotation)[0]
+            return nested, True
+
+        # Paths, lists, dicts и прочее будем хранить как строки
+        return str, False
+
+    @classmethod
+    def _type_to_label(cls, python_type: Type[Any], is_optional: bool) -> str:
+        base = {
+            bool: "bool",
+            int: "int",
+            float: "float",
+            str: "str",
+        }.get(python_type, "str")
+        return f"optional[{base}]" if is_optional else base
+
+    @classmethod
+    def get_categories(cls) -> List[Tuple[str, str, int]]:
+        cls.initialize_definitions()
+        categories: Dict[str, List[SettingDefinition]] = {}
+
+        for definition in cls._definitions.values():
+            categories.setdefault(definition.category_key, []).append(definition)
+
+        result: List[Tuple[str, str, int]] = []
+        for category_key, items in categories.items():
+            label = items[0].category_label
+            result.append((category_key, label, len(items)))
+
+        result.sort(key=lambda item: item[1])
+        return result
+
+    @classmethod
+    def get_settings_for_category(cls, category_key: str) -> List[SettingDefinition]:
+        cls.initialize_definitions()
+        filtered = [
+            definition
+            for definition in cls._definitions.values()
+            if definition.category_key == category_key
+        ]
+        filtered.sort(key=lambda definition: definition.key)
+        return filtered
+
+    @classmethod
+    def get_definition(cls, key: str) -> SettingDefinition:
+        cls.initialize_definitions()
+        return cls._definitions[key]
+
+    @classmethod
+    def has_override(cls, key: str) -> bool:
+        return key in cls._overrides_raw
+
+    @classmethod
+    def get_current_value(cls, key: str) -> Any:
+        return getattr(settings, key)
+
+    @classmethod
+    def get_original_value(cls, key: str) -> Any:
+        return cls._original_values.get(key)
+
+    @classmethod
+    def format_value(cls, value: Any) -> str:
+        if value is None:
+            return "—"
+        if isinstance(value, bool):
+            return "✅ Да" if value else "❌ Нет"
+        if isinstance(value, (int, float)):
+            return str(value)
+        if isinstance(value, (list, dict, tuple, set)):
+            try:
+                return json.dumps(value, ensure_ascii=False)
+            except Exception:
+                return str(value)
+        return str(value)
+
+    @classmethod
+    def format_value_for_list(cls, key: str) -> str:
+        value = cls.get_current_value(key)
+        formatted = cls.format_value(value)
+        if formatted == "—":
+            return formatted
+        return _truncate(formatted)
+
+    @classmethod
+    def get_choice_options(cls, key: str) -> List[ChoiceOption]:
+        cls.initialize_definitions()
+        return cls.CHOICES.get(key, [])
+
+    @classmethod
+    def has_choices(cls, key: str) -> bool:
+        return bool(cls.get_choice_options(key))
+
+    @classmethod
+    def get_callback_token(cls, key: str) -> str:
+        cls.initialize_definitions()
+        return cls._callback_tokens[key]
+
+    @classmethod
+    def resolve_callback_token(cls, token: str) -> str:
+        cls.initialize_definitions()
+        return cls._token_to_key[token]
+
+    @classmethod
+    def get_choice_token(cls, key: str, value: Any) -> Optional[str]:
+        cls.initialize_definitions()
+        cls._ensure_choice_tokens(key)
+        return cls._choice_tokens.get(key, {}).get(value)
+
+    @classmethod
+    def resolve_choice_token(cls, key: str, token: str) -> Any:
+        cls.initialize_definitions()
+        cls._ensure_choice_tokens(key)
+        return cls._choice_token_lookup.get(key, {})[token]
+
+    @classmethod
+    def _register_callback_token(cls, key: str) -> None:
+        if key in cls._callback_tokens:
+            return
+
+        base = hashlib.blake2s(key.encode("utf-8"), digest_size=6).hexdigest()
+        candidate = base
+        counter = 1
+        while candidate in cls._token_to_key and cls._token_to_key[candidate] != key:
+            suffix = cls._encode_base36(counter)
+            candidate = f"{base}{suffix}"[:16]
+            counter += 1
+
+        cls._callback_tokens[key] = candidate
+        cls._token_to_key[candidate] = key
+
+    @classmethod
+    def _ensure_choice_tokens(cls, key: str) -> None:
+        if key in cls._choice_tokens:
+            return
+
+        options = cls.CHOICES.get(key, [])
+        value_to_token: Dict[Any, str] = {}
+        token_to_value: Dict[str, Any] = {}
+
+        for index, option in enumerate(options):
+            token = cls._encode_base36(index)
+            value_to_token[option.value] = token
+            token_to_value[token] = option.value
+
+        cls._choice_tokens[key] = value_to_token
+        cls._choice_token_lookup[key] = token_to_value
+
+    @staticmethod
+    def _encode_base36(number: int) -> str:
+        if number < 0:
+            raise ValueError("number must be non-negative")
+        alphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
+        if number == 0:
+            return "0"
+        result = []
+        while number:
+            number, rem = divmod(number, 36)
+            result.append(alphabet[rem])
+        return "".join(reversed(result))
+
+    @classmethod
+    async def initialize(cls) -> None:
+        cls.initialize_definitions()
+
+        async with AsyncSessionLocal() as session:
+            result = await session.execute(select(SystemSetting))
+            rows = result.scalars().all()
+
+        overrides: Dict[str, Optional[str]] = {}
+        for row in rows:
+            if row.key in cls._definitions:
+                overrides[row.key] = row.value
+
+        for key, raw_value in overrides.items():
+            try:
+                parsed_value = cls.deserialize_value(key, raw_value)
+            except Exception as error:
+                logger.error("Не удалось применить настройку %s: %s", key, error)
+                continue
+
+            cls._overrides_raw[key] = raw_value
+            cls._apply_to_settings(key, parsed_value)
+
+        await cls._sync_default_web_api_token()
+
+    @classmethod
+    async def reload(cls) -> None:
+        cls._overrides_raw.clear()
+        await cls.initialize()
+
+    @classmethod
+    def deserialize_value(cls, key: str, raw_value: Optional[str]) -> Any:
+        if raw_value is None:
+            return None
+
+        definition = cls.get_definition(key)
+        python_type = definition.python_type
+
+        if python_type is bool:
+            value_lower = raw_value.strip().lower()
+            if value_lower in {"1", "true", "on", "yes", "да"}:
+                return True
+            if value_lower in {"0", "false", "off", "no", "нет"}:
+                return False
+            raise ValueError(f"Неверное булево значение: {raw_value}")
+
+        if python_type is int:
+            return int(raw_value)
+
+        if python_type is float:
+            return float(raw_value)
+
+        return raw_value
+
+    @classmethod
+    def serialize_value(cls, key: str, value: Any) -> Optional[str]:
+        if value is None:
+            return None
+
+        definition = cls.get_definition(key)
+        python_type = definition.python_type
+
+        if python_type is bool:
+            return "true" if value else "false"
+        if python_type in {int, float}:
+            return str(value)
+        return str(value)
+
+    @classmethod
+    def parse_user_value(cls, key: str, user_input: str) -> Any:
+        definition = cls.get_definition(key)
+        text = (user_input or "").strip()
+
+        if text.lower() in {"отмена", "cancel"}:
+            raise ValueError("Ввод отменен пользователем")
+
+        if definition.is_optional and text.lower() in {"none", "null", "пусто", ""}:
+            return None
+
+        python_type = definition.python_type
+
+        if python_type is bool:
+            lowered = text.lower()
+            if lowered in {"1", "true", "on", "yes", "да", "вкл", "enable", "enabled"}:
+                return True
+            if lowered in {"0", "false", "off", "no", "нет", "выкл", "disable", "disabled"}:
+                return False
+            raise ValueError("Введите 'true' или 'false' (или 'да'/'нет')")
+
+        if python_type is int:
+            parsed_value: Any = int(text)
+        elif python_type is float:
+            parsed_value = float(text.replace(",", "."))
+        else:
+            parsed_value = text
+
+        choices = cls.get_choice_options(key)
+        if choices:
+            allowed_values = {option.value for option in choices}
+            if python_type is str:
+                lowered_map = {
+                    str(option.value).lower(): option.value for option in choices
+                }
+                normalized = lowered_map.get(str(parsed_value).lower())
+                if normalized is not None:
+                    parsed_value = normalized
+                elif parsed_value not in allowed_values:
+                    readable = ", ".join(
+                        f"{option.label} ({cls.format_value(option.value)})" for option in choices
+                    )
+                    raise ValueError(f"Доступные значения: {readable}")
+            elif parsed_value not in allowed_values:
+                readable = ", ".join(
+                    f"{option.label} ({cls.format_value(option.value)})" for option in choices
+                )
+                raise ValueError(f"Доступные значения: {readable}")
+
+        return parsed_value
+
+    @classmethod
+    async def set_value(cls, db: AsyncSession, key: str, value: Any) -> None:
+        raw_value = cls.serialize_value(key, value)
+        await upsert_system_setting(db, key, raw_value)
+        cls._overrides_raw[key] = raw_value
+        cls._apply_to_settings(key, value)
+
+        if key in {"WEB_API_DEFAULT_TOKEN", "WEB_API_DEFAULT_TOKEN_NAME"}:
+            await cls._sync_default_web_api_token()
+
+    @classmethod
+    async def reset_value(cls, db: AsyncSession, key: str) -> None:
+        await delete_system_setting(db, key)
+        cls._overrides_raw.pop(key, None)
+        original = cls.get_original_value(key)
+        cls._apply_to_settings(key, original)
+
+        if key in {"WEB_API_DEFAULT_TOKEN", "WEB_API_DEFAULT_TOKEN_NAME"}:
+            await cls._sync_default_web_api_token()
+
+    @classmethod
+    def _apply_to_settings(cls, key: str, value: Any) -> None:
+        try:
+            setattr(settings, key, value)
+        except Exception as error:
+            logger.error("Не удалось применить значение %s=%s: %s", key, value, error)
+
+    @staticmethod
+    async def _sync_default_web_api_token() -> None:
+        default_token = (settings.WEB_API_DEFAULT_TOKEN or "").strip()
+        if not default_token:
+            return
+
+        success = await ensure_default_web_api_token()
+        if not success:
+            logger.warning(
+                "Не удалось синхронизировать бутстрап токен веб-API после обновления настроек",
+            )
+
+    @classmethod
+    def get_setting_summary(cls, key: str) -> Dict[str, Any]:
+        definition = cls.get_definition(key)
+        current = cls.get_current_value(key)
+        original = cls.get_original_value(key)
+        has_override = cls.has_override(key)
+
+        return {
+            "key": key,
+            "name": definition.display_name,
+            "current": cls.format_value(current),
+            "original": cls.format_value(original),
+            "type": definition.type_label,
+            "category_key": definition.category_key,
+            "category_label": definition.category_label,
+            "has_override": has_override,
+        }
+
+
+bot_configuration_service = BotConfigurationService
+
@@ -2,13 +2,14 @@ import logging
 from datetime import datetime, timedelta
 from typing import Optional, List, Dict, Any, Tuple
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import delete, select, update
+from sqlalchemy import delete, select, update, func
 from aiogram import Bot
 from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
 from app.database.crud.user import (
    get_user_by_id, get_user_by_telegram_id, get_users_list,
    get_users_count, get_users_statistics, get_inactive_users,
-    add_user_balance, subtract_user_balance, update_user, delete_user
+    add_user_balance, subtract_user_balance, update_user, delete_user,
+    get_users_spending_stats
 )
 from app.database.crud.promo_group import get_promo_group_by_id
 from app.database.crud.transaction import get_user_transactions_count
@@ -17,7 +18,9 @@ from app.database.models import (
    User, UserStatus, Subscription, Transaction, PromoCode, PromoCodeUse,
    ReferralEarning, SubscriptionServer, YooKassaPayment, BroadcastHistory,
    CryptoBotPayment, SubscriptionConversion, UserMessage, WelcomeText,
-    SentNotification, PromoGroup
+    SentNotification, PromoGroup, MulenPayPayment, Pal24Payment,
+    AdvertisingCampaign, AdvertisingCampaignRegistration, PaymentMethod,
+    TransactionType
 )
 from app.config import settings

@@ -140,20 +143,32 @@ class UserService:
                "has_next": False,
                "has_prev": False
            }
-    
+
    async def get_users_page(
        self,
        db: AsyncSession,
        page: int = 1,
        limit: int = 20,
        status: Optional[UserStatus] = None,
-        order_by_balance: bool = False
+        order_by_balance: bool = False,
+        order_by_traffic: bool = False,
+        order_by_last_activity: bool = False,
+        order_by_total_spent: bool = False,
+        order_by_purchase_count: bool = False
    ) -> Dict[str, Any]:
        try:
            offset = (page - 1) * limit
            
            users = await get_users_list(
-                db, offset=offset, limit=limit, status=status, order_by_balance=order_by_balance
+                db,
+                offset=offset,
+                limit=limit,
+                status=status,
+                order_by_balance=order_by_balance,
+                order_by_traffic=order_by_traffic,
+                order_by_last_activity=order_by_last_activity,
+                order_by_total_spent=order_by_total_spent,
+                order_by_purchase_count=order_by_purchase_count,
            )
            total_count = await get_users_count(db, status=status)
            
@@ -178,7 +193,110 @@ class UserService:
                "has_next": False,
                "has_prev": False
            }
-    
+
+    async def get_user_spending_stats_map(
+        self,
+        db: AsyncSession,
+        user_ids: List[int]
+    ) -> Dict[int, Dict[str, int]]:
+        try:
+            return await get_users_spending_stats(db, user_ids)
+        except Exception as e:
+            logger.error(f"Ошибка получения статистики трат пользователей: {e}")
+            return {}
+
+    async def get_users_by_campaign_page(
+        self,
+        db: AsyncSession,
+        page: int = 1,
+        limit: int = 20
+    ) -> Dict[str, Any]:
+        try:
+            offset = (page - 1) * limit
+
+            campaign_ranked = (
+                select(
+                    AdvertisingCampaignRegistration.user_id.label("user_id"),
+                    AdvertisingCampaignRegistration.campaign_id.label("campaign_id"),
+                    AdvertisingCampaignRegistration.created_at.label("created_at"),
+                    func.row_number()
+                    .over(
+                        partition_by=AdvertisingCampaignRegistration.user_id,
+                        order_by=AdvertisingCampaignRegistration.created_at.desc(),
+                    )
+                    .label("rn"),
+                )
+                .cte("campaign_ranked")
+            )
+
+            latest_campaign = (
+                select(
+                    campaign_ranked.c.user_id,
+                    campaign_ranked.c.campaign_id,
+                    campaign_ranked.c.created_at,
+                )
+                .where(campaign_ranked.c.rn == 1)
+                .subquery()
+            )
+
+            query = (
+                select(
+                    User,
+                    AdvertisingCampaign.name.label("campaign_name"),
+                    latest_campaign.c.created_at,
+                )
+                .join(latest_campaign, latest_campaign.c.user_id == User.id)
+                .join(
+                    AdvertisingCampaign,
+                    AdvertisingCampaign.id == latest_campaign.c.campaign_id,
+                )
+                .order_by(
+                    AdvertisingCampaign.name.asc(),
+                    latest_campaign.c.created_at.desc(),
+                )
+                .offset(offset)
+                .limit(limit)
+            )
+
+            result = await db.execute(query)
+            rows = result.all()
+
+            users = [row[0] for row in rows]
+            campaign_map = {
+                row[0].id: {
+                    "campaign_name": row[1],
+                    "registered_at": row[2],
+                }
+                for row in rows
+            }
+
+            total_stmt = select(func.count()).select_from(latest_campaign)
+            total_result = await db.execute(total_stmt)
+            total_count = total_result.scalar() or 0
+            total_pages = (total_count + limit - 1) // limit if total_count else 1
+
+            return {
+                "users": users,
+                "campaigns": campaign_map,
+                "current_page": page,
+                "total_pages": total_pages,
+                "total_count": total_count,
+                "has_next": page < total_pages,
+                "has_prev": page > 1,
+            }
+
+        except Exception as e:
+            logger.error(f"Ошибка получения пользователей по кампаниям: {e}")
+            return {
+                "users": [],
+                "campaigns": {},
+                "current_page": 1,
+                "total_pages": 1,
+                "total_count": 0,
+                "has_next": False,
+                "has_prev": False,
+            }
+
    async def update_user_balance(
        self,
        db: AsyncSession,
@@ -202,7 +320,14 @@ class UserService:
                logger.info(f"Админ {admin_id} пополнил баланс пользователя {user_id} на {amount_kopeks/100}₽")
                success = True
            else:
-                success = await subtract_user_balance(db, user, abs(amount_kopeks), description)
+                success = await subtract_user_balance(
+                    db,
+                    user,
+                    abs(amount_kopeks),
+                    description,
+                    create_transaction=True,
+                    payment_method=PaymentMethod.MANUAL,
+                )
                if success:
                    logger.info(f"Админ {admin_id} списал с баланса пользователя {user_id} {abs(amount_kopeks)/100}₽")

@@ -230,15 +355,17 @@ class UserService:
        db: AsyncSession,
        user_id: int,
        promo_group_id: int
-    ) -> Tuple[bool, Optional[User], Optional[PromoGroup]]:
+    ) -> Tuple[bool, Optional[User], Optional[PromoGroup], Optional[PromoGroup]]:
        try:
            user = await get_user_by_id(db, user_id)
            if not user:
-                return False, None, None
+                return False, None, None, None
+
+            old_group = user.promo_group

            promo_group = await get_promo_group_by_id(db, promo_group_id)
            if not promo_group:
-                return False, None, None
+                return False, None, None, old_group

            user.promo_group_id = promo_group.id
            user.promo_group = promo_group
@@ -253,12 +380,12 @@ class UserService:
                promo_group.name,
            )

-            return True, user, promo_group
+            return True, user, promo_group, old_group

        except Exception as e:
            await db.rollback()
            logger.error(f"Ошибка обновления промогруппы пользователя {user_id}: {e}")
-            return False, None, None
+            return False, None, None, None

    async def block_user(
        self,
@@ -359,7 +486,7 @@ class UserService:
                    
                    if delete_mode == "delete":
                        # Удаляем пользователя из панели Remnawave
-                        async with remnawave_service.api as api:
+                        async with remnawave_service.get_api_client() as api:
                            delete_success = await api.delete_user(user.remnawave_uuid)
                            if delete_success:
                                logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} удален из панели")
@@ -493,7 +620,7 @@ class UserService:
                    select(CryptoBotPayment).where(CryptoBotPayment.user_id == user_id)
                )
                cryptobot_payments = cryptobot_result.scalars().all()
-                
+
                if cryptobot_payments:
                    logger.info(f"🔄 Удаляем {len(cryptobot_payments)} CryptoBot платежей")
                    await db.execute(
@@ -508,7 +635,49 @@ class UserService:
                    await db.flush()
            except Exception as e:
                logger.error(f"❌ Ошибка удаления CryptoBot платежей: {e}")
-    
+
+            try:
+                mulenpay_result = await db.execute(
+                    select(MulenPayPayment).where(MulenPayPayment.user_id == user_id)
+                )
+                mulenpay_payments = mulenpay_result.scalars().all()
+
+                if mulenpay_payments:
+                    logger.info(f"🔄 Удаляем {len(mulenpay_payments)} MulenPay платежей")
+                    await db.execute(
+                        update(MulenPayPayment)
+                        .where(MulenPayPayment.user_id == user_id)
+                        .values(transaction_id=None)
+                    )
+                    await db.flush()
+                    await db.execute(
+                        delete(MulenPayPayment).where(MulenPayPayment.user_id == user_id)
+                    )
+                    await db.flush()
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления MulenPay платежей: {e}")
+
+            try:
+                pal24_result = await db.execute(
+                    select(Pal24Payment).where(Pal24Payment.user_id == user_id)
+                )
+                pal24_payments = pal24_result.scalars().all()
+
+                if pal24_payments:
+                    logger.info(f"🔄 Удаляем {len(pal24_payments)} Pal24 платежей")
+                    await db.execute(
+                        update(Pal24Payment)
+                        .where(Pal24Payment.user_id == user_id)
+                        .values(transaction_id=None)
+                    )
+                    await db.flush()
+                    await db.execute(
+                        delete(Pal24Payment).where(Pal24Payment.user_id == user_id)
+                    )
+                    await db.flush()
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления Pal24 платежей: {e}")
+
            try:
                transactions_result = await db.execute(
                    select(Transaction).where(Transaction.user_id == user_id)
@@ -589,7 +758,7 @@ class UserService:
                    select(BroadcastHistory).where(BroadcastHistory.admin_id == user_id)
                )
                broadcast_history = broadcast_history_result.scalars().all()
-                
+
                if broadcast_history:
                    logger.info(f"🔄 Удаляем {len(broadcast_history)} записей истории рассылок")
                    await db.execute(
@@ -598,6 +767,23 @@ class UserService:
                    await db.flush()
            except Exception as e:
                logger.error(f"❌ Ошибка удаления истории рассылок: {e}")
+
+            try:
+                campaigns_result = await db.execute(
+                    select(AdvertisingCampaign).where(AdvertisingCampaign.created_by == user_id)
+                )
+                campaigns = campaigns_result.scalars().all()
+
+                if campaigns:
+                    logger.info(f"🔄 Очищаем создателя у {len(campaigns)} рекламных кампаний")
+                    await db.execute(
+                        update(AdvertisingCampaign)
+                        .where(AdvertisingCampaign.created_by == user_id)
+                        .values(created_by=None)
+                    )
+                    await db.flush()
+            except Exception as e:
+                logger.error(f"❌ Ошибка обновления рекламных кампаний: {e}")
    
            try:
                if user.subscription:
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import secrets
+from datetime import datetime
+from typing import Optional, Tuple
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud import web_api_token as crud
+from app.database.models import WebApiToken
+from app.database.universal_migration import ensure_default_web_api_token
+from app.utils.security import generate_api_token, hash_api_token
+
+
+class WebApiTokenService:
+    """Сервис для управления токенами административного веб-API."""
+
+    def __init__(self):
+        self.algorithm = settings.WEB_API_TOKEN_HASH_ALGORITHM or "sha256"
+
+    def hash_token(self, token: str) -> str:
+        return hash_api_token(token, self.algorithm)  # type: ignore[arg-type]
+
+    async def authenticate(
+        self,
+        db: AsyncSession,
+        token_value: str,
+        *,
+        remote_ip: Optional[str] = None,
+    ) -> Optional[WebApiToken]:
+        normalized_value = token_value.strip()
+        if not normalized_value:
+            return None
+
+        async def _load_token(value: str) -> Optional[WebApiToken]:
+            token_hash = self.hash_token(value)
+            return await crud.get_token_by_hash(db, token_hash)
+
+        token = await _load_token(normalized_value)
+
+        if not token:
+            default_token = (settings.WEB_API_DEFAULT_TOKEN or "").strip()
+            if default_token and secrets.compare_digest(default_token, normalized_value):
+                await ensure_default_web_api_token()
+                token = await _load_token(default_token)
+
+        if not token or not token.is_active:
+            return None
+
+        if token.expires_at and token.expires_at < datetime.utcnow():
+            return None
+
+        token.last_used_at = datetime.utcnow()
+        if remote_ip:
+            token.last_used_ip = remote_ip
+        await db.flush()
+        return token
+
+    async def create_token(
+        self,
+        db: AsyncSession,
+        *,
+        name: str,
+        description: Optional[str] = None,
+        expires_at: Optional[datetime] = None,
+        created_by: Optional[str] = None,
+        token_value: Optional[str] = None,
+    ) -> Tuple[str, WebApiToken]:
+        plain_token = token_value or generate_api_token()
+        token_hash = self.hash_token(plain_token)
+
+        token = await crud.create_token(
+            db,
+            name=name,
+            token_hash=token_hash,
+            token_prefix=plain_token[:12],
+            description=description,
+            expires_at=expires_at,
+            created_by=created_by,
+        )
+
+        return plain_token, token
+
+    async def revoke_token(self, db: AsyncSession, token: WebApiToken) -> WebApiToken:
+        token.is_active = False
+        token.updated_at = datetime.utcnow()
+        await db.flush()
+        await db.refresh(token)
+        return token
+
+    async def activate_token(self, db: AsyncSession, token: WebApiToken) -> WebApiToken:
+        token.is_active = True
+        token.updated_at = datetime.utcnow()
+        await db.flush()
+        await db.refresh(token)
+        return token
+
+
+web_api_token_service = WebApiTokenService()
@@ -1,6 +1,7 @@
 from aiogram.fsm.state import State, StatesGroup

 class RegistrationStates(StatesGroup):
+    waiting_for_language = State()
    waiting_for_rules_accept = State()
    waiting_for_referral_code = State()

@@ -68,20 +69,26 @@ class AdminStates(StatesGroup):
    creating_promo_group_traffic_discount = State()
    creating_promo_group_server_discount = State()
    creating_promo_group_device_discount = State()
+    creating_promo_group_period_discount = State()
+    creating_promo_group_auto_assign = State()

+    editing_promo_group_menu = State()
    editing_promo_group_name = State()
    editing_promo_group_traffic_discount = State()
    editing_promo_group_server_discount = State()
    editing_promo_group_device_discount = State()
+    editing_promo_group_period_discount = State()
+    editing_promo_group_auto_assign = State()
    
    editing_squad_price = State()
    editing_traffic_price = State()
    editing_device_price = State()
    editing_user_devices = State()
    editing_user_traffic = State()
-    
+
    editing_rules_page = State()
-    
+    editing_notification_value = State()
+
    confirming_sync = State()

    editing_server_name = State()
@@ -89,6 +96,7 @@ class AdminStates(StatesGroup):
    editing_server_country = State()
    editing_server_limit = State()
    editing_server_description = State()
+    editing_server_promo_groups = State()
    
    creating_server_uuid = State()
    creating_server_name = State()
@@ -100,6 +108,11 @@ class AdminStates(StatesGroup):
    
    # Состояния для отслеживания источника перехода
    viewing_user_from_balance_list = State()
+    viewing_user_from_traffic_list = State()
+    viewing_user_from_last_activity_list = State()
+    viewing_user_from_spending_list = State()
+    viewing_user_from_purchases_list = State()
+    viewing_user_from_campaign_list = State()

 class SupportStates(StatesGroup):
    waiting_for_message = State()
@@ -116,6 +129,10 @@ class AdminTicketStates(StatesGroup):
 class SupportSettingsStates(StatesGroup):
    waiting_for_desc = State()

+
+class BotConfigStates(StatesGroup):
+    waiting_for_value = State()
+
 class AutoPayStates(StatesGroup):
    setting_autopay_days = State()
    confirming_autopay_toggle = State()
@@ -67,13 +67,28 @@ class CacheService:
    async def delete(self, key: str) -> bool:
        if not self._connected:
            return False
-        
+
        try:
            deleted = await self.redis_client.delete(key)
            return deleted > 0
        except Exception as e:
            logger.error(f"Ошибка удаления из кеша {key}: {e}")
            return False
+
+    async def delete_pattern(self, pattern: str) -> int:
+        if not self._connected:
+            return 0
+
+        try:
+            keys = await self.redis_client.keys(pattern)
+            if not keys:
+                return 0
+
+            deleted = await self.redis_client.delete(*keys)
+            return int(deleted)
+        except Exception as e:
+            logger.error(f"Ошибка удаления ключей по шаблону {pattern}: {e}")
+            return 0
    
    async def exists(self, key: str) -> bool:
        if not self._connected:
@@ -8,22 +8,28 @@ from app.states import RegistrationStates

 def is_registration_process(event: TelegramObject, current_state: Optional[str]) -> bool:
    registration_states = [
+        RegistrationStates.waiting_for_language.state,
        RegistrationStates.waiting_for_rules_accept.state,
        RegistrationStates.waiting_for_referral_code.state
    ]

    registration_callbacks = [
-        "rules_accept", 
-        "rules_decline", 
+        "rules_accept",
+        "rules_decline",
        "referral_skip"
    ]

+    language_select_prefix = "language_select:"
+
    if current_state in registration_states:
        return True
    
-    if (isinstance(event, CallbackQuery) 
-        and event.data 
-        and event.data in registration_callbacks):
+    if (isinstance(event, CallbackQuery)
+        and event.data
+        and (
+            event.data in registration_callbacks
+            or event.data.startswith(language_select_prefix)
+        )):
        return True
-    
-    return False
+
+    return False
@@ -28,7 +28,7 @@ def format_date(dt: Union[datetime, str], format_str: str = "%d.%m.%Y") -> str:
    return dt.strftime(format_str)


-def format_time_ago(dt: Union[datetime, str]) -> str:
+def format_time_ago(dt: Union[datetime, str], language: str = "ru") -> str:
    if isinstance(dt, str):
        if dt == "now" or dt == "":
            dt = datetime.now()
@@ -40,32 +40,51 @@ def format_time_ago(dt: Union[datetime, str]) -> str:
    
    now = datetime.utcnow()
    diff = now - dt
-    
+
+    language_code = (language or "ru").split("-")[0].lower()
+
    if diff.days > 0:
        if diff.days == 1:
-            return "вчера"
-        elif diff.days < 7:
-            return f"{diff.days} дн. назад"
-        elif diff.days < 30:
-            weeks = diff.days // 7
-            return f"{weeks} нед. назад"
-        elif diff.days < 365:
-            months = diff.days // 30
-            return f"{months} мес. назад"
-        else:
-            years = diff.days // 365
-            return f"{years} г. назад"
-    
-    elif diff.seconds > 3600:
-        hours = diff.seconds // 3600
-        return f"{hours} ч. назад"
-    
-    elif diff.seconds > 60:
-        minutes = diff.seconds // 60
-        return f"{minutes} мин. назад"
-    
-    else:
-        return "только что"
+            return "yesterday" if language_code == "en" else "вчера"
+        if diff.days < 7:
+            value = diff.days
+            if language_code == "en":
+                suffix = "day" if value == 1 else "days"
+                return f"{value} {suffix} ago"
+            return f"{value} дн. назад"
+        if diff.days < 30:
+            value = diff.days // 7
+            if language_code == "en":
+                suffix = "week" if value == 1 else "weeks"
+                return f"{value} {suffix} ago"
+            return f"{value} нед. назад"
+        if diff.days < 365:
+            value = diff.days // 30
+            if language_code == "en":
+                suffix = "month" if value == 1 else "months"
+                return f"{value} {suffix} ago"
+            return f"{value} мес. назад"
+        value = diff.days // 365
+        if language_code == "en":
+            suffix = "year" if value == 1 else "years"
+            return f"{value} {suffix} ago"
+        return f"{value} г. назад"
+
+    if diff.seconds > 3600:
+        value = diff.seconds // 3600
+        if language_code == "en":
+            suffix = "hour" if value == 1 else "hours"
+            return f"{value} {suffix} ago"
+        return f"{value} ч. назад"
+
+    if diff.seconds > 60:
+        value = diff.seconds // 60
+        if language_code == "en":
+            suffix = "minute" if value == 1 else "minutes"
+            return f"{value} {suffix} ago"
+        return f"{value} мин. назад"
+
+    return "just now" if language_code == "en" else "только что"

 def format_days_declension(days: int, language: str = "ru") -> str:
    if language != "ru":
@@ -27,6 +27,7 @@ async def _answer_with_photo(self: Message, text: str = None, **kwargs):
        pass
    if LOGO_PATH.exists():
        try:
+            # Отправляем caption как есть; при ошибке парсинга ниже сработает фоллбек
            return await self.answer_photo(FSInputFile(LOGO_PATH), caption=text, **kwargs)
        except Exception:
            # Фоллбек, если Telegram ругается на caption: отправим как текст
@@ -30,17 +30,35 @@ def get_available_payment_methods() -> List[Dict[str, str]]:
    if settings.TRIBUTE_ENABLED:
        methods.append({
            "id": "tribute",
-            "name": "Банковская карта", 
+            "name": "Банковская карта",
            "icon": "💳",
            "description": "через Tribute",
            "callback": "topup_tribute"
        })
-        
+
+    if settings.is_mulenpay_enabled():
+        methods.append({
+            "id": "mulenpay",
+            "name": "Банковская карта",
+            "icon": "💳",
+            "description": "через Mulen Pay",
+            "callback": "topup_mulenpay"
+        })
+
+    if settings.is_pal24_enabled():
+        methods.append({
+            "id": "pal24",
+            "name": "СБП",
+            "icon": "🏦",
+            "description": "через PayPalych",
+            "callback": "topup_pal24"
+        })
+
    if settings.is_cryptobot_enabled():
        methods.append({
            "id": "cryptobot",
            "name": "Криптовалюта",
-            "icon": "🪙", 
+            "icon": "🪙",
            "description": "через CryptoBot",
            "callback": "topup_cryptobot"
        })
@@ -112,6 +130,10 @@ def is_payment_method_available(method_id: str) -> bool:
        return settings.is_yookassa_enabled()
    elif method_id == "tribute":
        return settings.TRIBUTE_ENABLED
+    elif method_id == "mulenpay":
+        return settings.is_mulenpay_enabled()
+    elif method_id == "pal24":
+        return settings.is_pal24_enabled()
    elif method_id == "cryptobot":
        return settings.is_cryptobot_enabled()
    elif method_id == "support":
@@ -127,6 +149,8 @@ def get_payment_method_status() -> Dict[str, bool]:
        "stars": settings.TELEGRAM_STARS_ENABLED,
        "yookassa": settings.is_yookassa_enabled(),
        "tribute": settings.TRIBUTE_ENABLED,
+        "mulenpay": settings.is_mulenpay_enabled(),
+        "pal24": settings.is_pal24_enabled(),
        "cryptobot": settings.is_cryptobot_enabled(),
        "support": True
    }
@@ -139,9 +163,13 @@ def get_enabled_payment_methods_count() -> int:
    if settings.TELEGRAM_STARS_ENABLED:
        count += 1
    if settings.is_yookassa_enabled():
-        count += 1 
+        count += 1
    if settings.TRIBUTE_ENABLED:
        count += 1
+    if settings.is_mulenpay_enabled():
+        count += 1
+    if settings.is_pal24_enabled():
+        count += 1
    if settings.is_cryptobot_enabled():
        count += 1
    return count
@@ -1,5 +1,4 @@
 from datetime import datetime, timedelta
-from datetime import datetime
 from typing import Tuple
 import logging

@@ -51,6 +50,13 @@ def apply_percentage_discount(amount: int, percent: int) -> Tuple[int, int]:
    discount_value = amount * clamped_percent // 100
    discounted_amount = amount - discount_value

+    # Round the discounted price up to the nearest full ruble (100 kopeks)
+    # to avoid undercharging users because of fractional kopeks.
+    if discount_value >= 100 and discounted_amount % 100:
+        discounted_amount += 100 - (discounted_amount % 100)
+        discounted_amount = min(discounted_amount, amount)
+        discount_value = amount - discounted_amount
+
    logger.debug(
        "Применена скидка %s%%: %s → %s (скидка %s)",
        clamped_percent,
@@ -0,0 +1,28 @@
+"""Утилиты безопасности и генерации ключей."""
+from __future__ import annotations
+
+import hashlib
+import secrets
+from typing import Literal
+
+
+HashAlgorithm = Literal["sha256", "sha384", "sha512"]
+
+
+def hash_api_token(token: str, algorithm: HashAlgorithm = "sha256") -> str:
+    """Возвращает хеш токена в формате hex."""
+    normalized = (algorithm or "sha256").lower()
+    if normalized not in {"sha256", "sha384", "sha512"}:
+        raise ValueError(f"Unsupported hash algorithm: {algorithm}")
+
+    digest = getattr(hashlib, normalized)
+    return digest(token.encode("utf-8")).hexdigest()
+
+
+def generate_api_token(length: int = 48) -> str:
+    """Генерирует криптографически стойкий токен."""
+    length = max(24, min(length, 128))
+    return secrets.token_urlsafe(length)
+
+
+__all__ = ["hash_api_token", "generate_api_token", "HashAlgorithm"]
@@ -1,9 +1,11 @@
 import logging
 from datetime import datetime
 from typing import Optional
-from sqlalchemy import select, delete
+from urllib.parse import quote, urlparse, urlunparse
+from sqlalchemy import select, delete, func
 from sqlalchemy.ext.asyncio import AsyncSession
 from app.database.models import Subscription, User
+from app.config import settings

 logger = logging.getLogger(__name__)

@@ -93,5 +95,64 @@ async def cleanup_duplicate_subscriptions(db: AsyncSession) -> int:
    
    await db.commit()
    logger.info(f"🧹 Очищено {total_deleted} дублирующихся подписок")
-    
+
    return total_deleted
+
+
+def get_display_subscription_link(subscription: Optional[Subscription]) -> Optional[str]:
+    if not subscription:
+        return None
+
+    base_link = getattr(subscription, "subscription_url", None)
+
+    if settings.is_happ_cryptolink_mode():
+        crypto_link = getattr(subscription, "subscription_crypto_link", None)
+        return crypto_link or base_link
+
+    return base_link
+
+
+def get_happ_cryptolink_redirect_link(subscription_link: Optional[str]) -> Optional[str]:
+    if not subscription_link:
+        return None
+
+    template = settings.get_happ_cryptolink_redirect_template()
+    if not template:
+        return None
+
+    encoded_link = quote(subscription_link, safe="")
+    replacements = {
+        "{subscription_link}": encoded_link,
+        "{link}": encoded_link,
+        "{subscription_link_raw}": subscription_link,
+        "{link_raw}": subscription_link,
+    }
+
+    replaced = False
+    for placeholder, value in replacements.items():
+        if placeholder in template:
+            template = template.replace(placeholder, value)
+            replaced = True
+
+    if replaced:
+        return template
+
+    if template.endswith(("=", "?", "&")):
+        return f"{template}{encoded_link}"
+
+    return f"{template}{encoded_link}"
+
+
+def convert_subscription_link_to_happ_scheme(subscription_link: Optional[str]) -> Optional[str]:
+    if not subscription_link:
+        return None
+
+    parsed_link = urlparse(subscription_link)
+
+    if parsed_link.scheme.lower() == "happ":
+        return subscription_link
+
+    if not parsed_link.scheme:
+        return subscription_link
+
+    return urlunparse(parsed_link._replace(scheme="happ"))
@@ -0,0 +1,91 @@
+"""Utilities for validating Telegram WebApp initialization data."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Dict
+from urllib.parse import parse_qsl
+
+
+class TelegramWebAppAuthError(Exception):
+    """Raised when Telegram WebApp init data fails validation."""
+
+
+def parse_webapp_init_data(
+    init_data: str,
+    bot_token: str,
+    *,
+    max_age_seconds: int = 86400,
+) -> Dict[str, Any]:
+    """Validate and parse Telegram WebApp init data.
+
+    Args:
+        init_data: Raw init data string provided by Telegram WebApp.
+        bot_token: Bot token used to verify the signature.
+        max_age_seconds: Maximum allowed age for the payload. Defaults to 24 hours.
+
+    Returns:
+        Parsed init data as a dictionary.
+
+    Raises:
+        TelegramWebAppAuthError: If validation fails.
+    """
+
+    if not init_data:
+        raise TelegramWebAppAuthError("Missing init data")
+
+    if not bot_token:
+        raise TelegramWebAppAuthError("Bot token is not configured")
+
+    parsed_pairs = parse_qsl(init_data, strict_parsing=True, keep_blank_values=True)
+    data: Dict[str, Any] = {key: value for key, value in parsed_pairs}
+
+    received_hash = data.pop("hash", None)
+    if not received_hash:
+        raise TelegramWebAppAuthError("Missing init data signature")
+
+    data_check_string = "\n".join(
+        f"{key}={value}" for key, value in sorted(data.items())
+    )
+
+    secret_key = hmac.new(
+        key=b"WebAppData",
+        msg=bot_token.encode("utf-8"),
+        digestmod=hashlib.sha256,
+    ).digest()
+
+    computed_hash = hmac.new(
+        key=secret_key,
+        msg=data_check_string.encode("utf-8"),
+        digestmod=hashlib.sha256,
+    ).hexdigest()
+
+    if not hmac.compare_digest(computed_hash, received_hash):
+        raise TelegramWebAppAuthError("Invalid init data signature")
+
+    auth_date_raw = data.get("auth_date")
+    if auth_date_raw is not None:
+        try:
+            auth_date = int(auth_date_raw)
+        except (TypeError, ValueError):
+            raise TelegramWebAppAuthError("Invalid auth_date value") from None
+
+        if max_age_seconds and auth_date:
+            current_ts = int(time.time())
+            if current_ts - auth_date > max_age_seconds:
+                raise TelegramWebAppAuthError("Init data is too old")
+
+        data["auth_date"] = auth_date
+
+    user_payload = data.get("user")
+    if user_payload is not None:
+        try:
+            data["user"] = json.loads(user_payload)
+        except json.JSONDecodeError as error:
+            raise TelegramWebAppAuthError("Invalid user payload") from error
+
+    return data
+
@@ -189,7 +189,7 @@ async def get_detailed_referral_list(db: AsyncSession, user_id: int, limit: int
                    and_(
                        Transaction.user_id == referral.id,
                        Transaction.type == TransactionType.DEPOSIT.value,
-                        Transaction.is_completed == True
+                        Transaction.is_completed.is_(True)
                    )
                )
            )
@@ -143,6 +143,23 @@ def sanitize_html(text: str) -> str:
    return text


+def sanitize_telegram_name(name: Optional[str]) -> Optional[str]:
+    """Санитизация Telegram-имени для безопасной вставки в HTML и хранения.
+    Заменяет угловые скобки и амперсанд на безопасные визуальные аналоги.
+    """
+    if not name:
+        return name
+    try:
+        return (
+            name.replace('<', '‹')
+                .replace('>', '›')
+                .replace('&', '＆')
+                .strip()
+        )
+    except Exception:
+        return name
+
+
 def validate_device_count(count: Union[str, int]) -> Optional[int]:
    try:
        count_int = int(count)
@@ -0,0 +1,5 @@
+"""Пакет административного веб-API."""
+from .app import create_web_api_app
+from .server import WebAPIServer
+
+__all__ = ["create_web_api_app", "WebAPIServer"]
@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.config import settings
+
+from .middleware import RequestLoggingMiddleware
+from .routes import (
+    broadcasts,
+    backups,
+    campaigns,
+    config,
+    health,
+    promocodes,
+    miniapp,
+    promo_groups,
+    remnawave,
+    stats,
+    subscriptions,
+    tickets,
+    tokens,
+    transactions,
+    users,
+)
+
+
+OPENAPI_TAGS = [
+    {
+        "name": "health",
+        "description": "Мониторинг состояния административного API и связанных сервисов.",
+    },
+    {
+        "name": "stats",
+        "description": "Сводные показатели по пользователям, подпискам и платежам.",
+    },
+    {
+        "name": "settings",
+        "description": "Получение и изменение конфигурации бота из административной панели.",
+    },
+    {
+        "name": "users",
+        "description": "Управление пользователями, балансом и статусами подписок.",
+    },
+    {
+        "name": "subscriptions",
+        "description": "Создание, продление и настройка подписок бота.",
+    },
+    {
+        "name": "support",
+        "description": "Работа с тикетами поддержки, приоритетами и ограничениями на ответы.",
+    },
+    {
+        "name": "transactions",
+        "description": "История финансовых операций и пополнений баланса.",
+    },
+    {
+        "name": "promo-groups",
+        "description": "Создание и управление промо-группами и их участниками.",
+    },
+    {
+        "name": "auth",
+        "description": "Управление токенами доступа к административному API.",
+    },
+    {
+        "name": "remnawave",
+        "description": (
+            "Интеграция с RemnaWave: статус панели, управление нодами, сквадами и синхронизацией "
+            "данных между ботом и панелью."
+        ),
+    },
+    {
+        "name": "miniapp",
+        "description": "Endpoint для Telegram Mini App с информацией о подписке пользователя.",
+    },
+]
+
+
+def create_web_api_app() -> FastAPI:
+    docs_config = settings.get_web_api_docs_config()
+
+    app = FastAPI(
+        title=settings.WEB_API_TITLE,
+        version=settings.WEB_API_VERSION,
+        docs_url=docs_config.get("docs_url"),
+        redoc_url=docs_config.get("redoc_url"),
+        openapi_url=docs_config.get("openapi_url"),
+        openapi_tags=OPENAPI_TAGS,
+        swagger_ui_parameters={"persistAuthorization": True},
+    )
+
+    allowed_origins = settings.get_web_api_allowed_origins()
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"] if allowed_origins == ["*"] else allowed_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    if settings.WEB_API_REQUEST_LOGGING:
+        app.add_middleware(RequestLoggingMiddleware)
+
+    app.include_router(health.router)
+    app.include_router(stats.router, prefix="/stats", tags=["stats"])
+    app.include_router(config.router, prefix="/settings", tags=["settings"])
+    app.include_router(users.router, prefix="/users", tags=["users"])
+    app.include_router(subscriptions.router, prefix="/subscriptions", tags=["subscriptions"])
+    app.include_router(tickets.router, prefix="/tickets", tags=["support"])
+    app.include_router(transactions.router, prefix="/transactions", tags=["transactions"])
+    app.include_router(promo_groups.router, prefix="/promo-groups", tags=["promo-groups"])
+    app.include_router(promocodes.router, prefix="/promo-codes", tags=["promo-codes"])
+    app.include_router(broadcasts.router, prefix="/broadcasts", tags=["broadcasts"])
+    app.include_router(backups.router, prefix="/backups", tags=["backups"])
+    app.include_router(campaigns.router, prefix="/campaigns", tags=["campaigns"])
+    app.include_router(tokens.router, prefix="/tokens", tags=["auth"])
+    app.include_router(remnawave.router, prefix="/remnawave", tags=["remnawave"])
+    app.include_router(miniapp.router, prefix="/miniapp", tags=["miniapp"])
+
+    return app
@@ -0,0 +1 @@
+"""Background utilities for Web API."""
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import asyncio
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Optional
+
+from app.services.backup_service import backup_service
+
+
+@dataclass(slots=True)
+class BackupTaskState:
+    task_id: str
+    status: str = "queued"
+    message: Optional[str] = None
+    file_path: Optional[str] = None
+    created_by: Optional[int] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    updated_at: datetime = field(default_factory=datetime.utcnow)
+
+
+class BackupTaskManager:
+    def __init__(self) -> None:
+        self._tasks: dict[str, BackupTaskState] = {}
+        self._lock = asyncio.Lock()
+
+    async def enqueue(self, *, created_by: Optional[int]) -> BackupTaskState:
+        task_id = uuid.uuid4().hex
+        state = BackupTaskState(task_id=task_id, created_by=created_by)
+
+        async with self._lock:
+            self._tasks[task_id] = state
+
+        asyncio.create_task(self._run_task(state))
+        return state
+
+    async def _run_task(self, state: BackupTaskState) -> None:
+        state.status = "running"
+        state.updated_at = datetime.utcnow()
+
+        try:
+            success, message, file_path = await backup_service.create_backup(
+                created_by=state.created_by
+            )
+            state.message = message
+            state.file_path = file_path
+            state.status = "completed" if success else "failed"
+        except Exception as exc:  # noqa: BLE001
+            state.status = "failed"
+            state.message = f"Unexpected error: {exc}"
+        finally:
+            state.updated_at = datetime.utcnow()
+
+    async def get(self, task_id: str) -> Optional[BackupTaskState]:
+        async with self._lock:
+            return self._tasks.get(task_id)
+
+    async def list(self, *, active_only: bool = False) -> list[BackupTaskState]:
+        async with self._lock:
+            states = list(self._tasks.values())
+
+        if active_only:
+            return [
+                state
+                for state in states
+                if state.status in {"queued", "running"}
+            ]
+
+        return states
+
+
+backup_task_manager = BackupTaskManager()
@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import AsyncGenerator
+
+from fastapi import Depends, HTTPException, Request, Security, status
+from fastapi.security import APIKeyHeader
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.database import AsyncSessionLocal
+from app.database.models import WebApiToken
+from app.services.web_api_token_service import web_api_token_service
+
+
+api_key_header_scheme = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+
+async def require_api_token(
+    request: Request,
+    api_key_header: str | None = Security(api_key_header_scheme),
+    db: AsyncSession = Depends(get_db_session),
+) -> WebApiToken:
+    api_key = api_key_header
+
+    if not api_key:
+        authorization = request.headers.get("Authorization")
+        if authorization:
+            scheme, _, credentials = authorization.partition(" ")
+            if scheme.lower() == "bearer" and credentials:
+                api_key = credentials
+
+    if not api_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing API key",
+        )
+
+    token = await web_api_token_service.authenticate(
+        db,
+        api_key,
+        remote_ip=request.client.host if request.client else None,
+    )
+
+    if not token:
+        await db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired API key",
+        )
+
+    await db.commit()
+    return token
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+from time import monotonic
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+logger = logging.getLogger("web_api")
+
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    """Логирование входящих запросов в административный API."""
+
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        start = monotonic()
+        response: Response | None = None
+        try:
+            response = await call_next(request)
+            return response
+        finally:
+            duration_ms = (monotonic() - start) * 1000
+            status = response.status_code if response else "error"
+            logger.info(
+                "%s %s -> %s (%.2f ms)",
+                request.method,
+                request.url.path,
+                status,
+                duration_ms,
+            )
@@ -0,0 +1,27 @@
+from . import (
+    config,
+    health,
+    miniapp,
+    promo_groups,
+    remnawave,
+    stats,
+    subscriptions,
+    tickets,
+    tokens,
+    transactions,
+    users,
+)
+
+__all__ = [
+    "config",
+    "health",
+    "miniapp",
+    "promo_groups",
+    "remnawave",
+    "stats",
+    "subscriptions",
+    "tickets",
+    "tokens",
+    "transactions",
+    "users",
+]
@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Query, Security, status
+
+from app.services.backup_service import backup_service
+
+from ..background.backup_tasks import backup_task_manager
+from ..dependencies import require_api_token
+from ..schemas.backups import (
+    BackupCreateResponse,
+    BackupInfo,
+    BackupListResponse,
+    BackupStatusResponse,
+    BackupTaskInfo,
+    BackupTaskListResponse,
+)
+
+
+router = APIRouter()
+
+
+def _parse_datetime(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+
+    try:
+        if value.endswith("Z"):
+            value = value.replace("Z", "+00:00")
+        return datetime.fromisoformat(value)
+    except ValueError:
+        return None
+
+
+def _to_int(value: Any) -> Optional[int]:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _serialize_backup(raw: dict) -> BackupInfo:
+    timestamp = _parse_datetime(raw.get("timestamp"))
+    tables_count = _to_int(raw.get("tables_count"))
+    total_records = _to_int(raw.get("total_records"))
+    file_size_bytes = _to_int(raw.get("file_size_bytes")) or 0
+    file_size_mb = raw.get("file_size_mb")
+    try:
+        file_size_mb = float(file_size_mb)
+    except (TypeError, ValueError):
+        file_size_mb = round(file_size_bytes / 1024 / 1024, 2)
+
+    created_by = _to_int(raw.get("created_by"))
+
+    return BackupInfo(
+        filename=str(raw.get("filename")),
+        filepath=str(raw.get("filepath")),
+        timestamp=timestamp,
+        tables_count=tables_count,
+        total_records=total_records,
+        compressed=bool(raw.get("compressed", False)),
+        file_size_bytes=file_size_bytes,
+        file_size_mb=float(file_size_mb),
+        created_by=created_by,
+        database_type=raw.get("database_type"),
+        version=raw.get("version"),
+        error=raw.get("error"),
+    )
+
+
+@router.post(
+    "",
+    response_model=BackupCreateResponse,
+    status_code=status.HTTP_202_ACCEPTED,
+    summary="Запустить создание резервной копии",
+)
+async def create_backup_endpoint(
+    token: Any = Security(require_api_token),
+) -> BackupCreateResponse:
+    created_by = getattr(token, "id", None)
+    state = await backup_task_manager.enqueue(created_by=created_by)
+    return BackupCreateResponse(task_id=state.task_id, status=state.status)
+
+
+@router.get(
+    "",
+    response_model=BackupListResponse,
+    summary="Список резервных копий",
+)
+async def list_backups(
+    _: Any = Security(require_api_token),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> BackupListResponse:
+    backups = await backup_service.get_backup_list()
+    total = len(backups)
+
+    slice_backups = backups[offset : offset + limit]
+    items = [_serialize_backup(raw) for raw in slice_backups]
+
+    return BackupListResponse(
+        items=items,
+        total=total,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.get(
+    "/status/{task_id}",
+    response_model=BackupStatusResponse,
+    summary="Статус создания резервной копии",
+)
+async def get_backup_status(
+    task_id: str,
+    _: Any = Security(require_api_token),
+) -> BackupStatusResponse:
+    state = await backup_task_manager.get(task_id)
+    if not state:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Task not found")
+
+    return BackupStatusResponse(
+        task_id=state.task_id,
+        status=state.status,
+        message=state.message,
+        file_path=state.file_path,
+        created_by=state.created_by,
+        created_at=state.created_at,
+        updated_at=state.updated_at,
+    )
+
+
+@router.get(
+    "/tasks",
+    response_model=BackupTaskListResponse,
+    summary="Список фоновых задач бекапов",
+)
+async def list_backup_tasks(
+    _: Any = Security(require_api_token),
+    active_only: bool = Query(False, description="Вернуть только активные задачи"),
+) -> BackupTaskListResponse:
+    states = await backup_task_manager.list(active_only=active_only)
+
+    items = [
+        BackupTaskInfo(
+            task_id=state.task_id,
+            status=state.status,
+            message=state.message,
+            file_path=state.file_path,
+            created_by=state.created_by,
+            created_at=state.created_at,
+            updated_at=state.updated_at,
+        )
+        for state in states
+    ]
+
+    return BackupTaskListResponse(items=items, total=len(items))
@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import BroadcastHistory
+from app.services.broadcast_service import (
+    BroadcastConfig,
+    BroadcastMediaConfig,
+    broadcast_service,
+)
+
+from ..dependencies import get_db_session, require_api_token
+from ..schemas.broadcasts import (
+    BroadcastCreateRequest,
+    BroadcastListResponse,
+    BroadcastResponse,
+)
+
+
+router = APIRouter()
+
+
+def _serialize_broadcast(broadcast: BroadcastHistory) -> BroadcastResponse:
+    return BroadcastResponse(
+        id=broadcast.id,
+        target_type=broadcast.target_type,
+        message_text=broadcast.message_text,
+        has_media=broadcast.has_media,
+        media_type=broadcast.media_type,
+        media_file_id=broadcast.media_file_id,
+        media_caption=broadcast.media_caption,
+        total_count=broadcast.total_count,
+        sent_count=broadcast.sent_count,
+        failed_count=broadcast.failed_count,
+        status=broadcast.status,
+        admin_id=broadcast.admin_id,
+        admin_name=broadcast.admin_name,
+        created_at=broadcast.created_at,
+        completed_at=broadcast.completed_at,
+    )
+
+
+@router.post("", response_model=BroadcastResponse, status_code=status.HTTP_201_CREATED)
+async def create_broadcast(
+    payload: BroadcastCreateRequest,
+    token: Any = Depends(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> BroadcastResponse:
+    message_text = payload.message_text.strip()
+    if not message_text:
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, "Message text must not be empty")
+
+    media_payload = payload.media
+
+    broadcast = BroadcastHistory(
+        target_type=payload.target,
+        message_text=message_text,
+        has_media=media_payload is not None,
+        media_type=media_payload.type if media_payload else None,
+        media_file_id=media_payload.file_id if media_payload else None,
+        media_caption=media_payload.caption if media_payload else None,
+        total_count=0,
+        sent_count=0,
+        failed_count=0,
+        status="queued",
+        admin_id=None,
+        admin_name=getattr(token, "name", None) or getattr(token, "created_by", None),
+    )
+    db.add(broadcast)
+    await db.commit()
+    await db.refresh(broadcast)
+
+    media_config = None
+    if media_payload:
+        media_config = BroadcastMediaConfig(
+            type=media_payload.type,
+            file_id=media_payload.file_id,
+            caption=media_payload.caption or message_text,
+        )
+
+    config = BroadcastConfig(
+        target=payload.target,
+        message_text=message_text,
+        selected_buttons=payload.selected_buttons,
+        media=media_config,
+        initiator_name=getattr(token, "name", None) or getattr(token, "created_by", None),
+    )
+
+    await broadcast_service.start_broadcast(broadcast.id, config)
+    await db.refresh(broadcast)
+
+    return _serialize_broadcast(broadcast)
+
+
+@router.get("", response_model=BroadcastListResponse)
+async def list_broadcasts(
+    _: Any = Depends(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> BroadcastListResponse:
+    total = await db.scalar(select(func.count(BroadcastHistory.id))) or 0
+
+    result = await db.execute(
+        select(BroadcastHistory)
+        .order_by(BroadcastHistory.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+    broadcasts = result.scalars().all()
+
+    return BroadcastListResponse(
+        items=[_serialize_broadcast(item) for item in broadcasts],
+        total=int(total),
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.post("/{broadcast_id}/stop", response_model=BroadcastResponse)
+async def stop_broadcast(
+    broadcast_id: int,
+    _: Any = Depends(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> BroadcastResponse:
+    broadcast = await db.get(BroadcastHistory, broadcast_id)
+    if not broadcast:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Broadcast not found")
+
+    if broadcast.status not in {"queued", "in_progress", "cancelling"}:
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, "Broadcast is not running")
+
+    is_running = await broadcast_service.request_stop(broadcast_id)
+
+    if is_running:
+        broadcast.status = "cancelling"
+    else:
+        broadcast.status = "cancelled"
+        broadcast.completed_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(broadcast)
+
+    return _serialize_broadcast(broadcast)
@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Security, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.campaign import (
+    create_campaign,
+    delete_campaign,
+    get_campaign_by_id,
+    get_campaigns_count,
+    get_campaigns_list,
+    update_campaign,
+)
+
+from ..dependencies import get_db_session, require_api_token
+from ..schemas.campaigns import (
+    CampaignCreateRequest,
+    CampaignListResponse,
+    CampaignResponse,
+    CampaignUpdateRequest,
+)
+
+
+router = APIRouter()
+
+
+def _serialize_campaign(campaign) -> CampaignResponse:
+    registrations_attr = None
+    if isinstance(getattr(campaign, "__dict__", None), dict):
+        registrations_attr = campaign.__dict__.get("registrations")
+    registrations = registrations_attr or []
+    squads = list(campaign.subscription_squads or [])
+
+    return CampaignResponse(
+        id=campaign.id,
+        name=campaign.name,
+        start_parameter=campaign.start_parameter,
+        bonus_type=campaign.bonus_type,
+        balance_bonus_kopeks=campaign.balance_bonus_kopeks or 0,
+        balance_bonus_rubles=round((campaign.balance_bonus_kopeks or 0) / 100, 2),
+        subscription_duration_days=campaign.subscription_duration_days,
+        subscription_traffic_gb=campaign.subscription_traffic_gb,
+        subscription_device_limit=campaign.subscription_device_limit,
+        subscription_squads=squads,
+        is_active=campaign.is_active,
+        created_by=campaign.created_by,
+        created_at=campaign.created_at,
+        updated_at=campaign.updated_at,
+        registrations_count=len(registrations),
+    )
+
+
+@router.post(
+    "",
+    response_model=CampaignResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Создать рекламную кампанию",
+)
+async def create_campaign_endpoint(
+    payload: CampaignCreateRequest,
+    token: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> CampaignResponse:
+    created_by = getattr(token, "id", None)
+
+    try:
+        campaign = await create_campaign(
+            db,
+            name=payload.name,
+            start_parameter=payload.start_parameter,
+            bonus_type=payload.bonus_type,
+            created_by=created_by,
+            balance_bonus_kopeks=payload.balance_bonus_kopeks,
+            subscription_duration_days=payload.subscription_duration_days,
+            subscription_traffic_gb=payload.subscription_traffic_gb,
+            subscription_device_limit=payload.subscription_device_limit,
+            subscription_squads=payload.subscription_squads,
+            is_active=payload.is_active,
+        )
+    except IntegrityError as exc:  # duplicate start_parameter
+        await db.rollback()
+        raise HTTPException(
+            status.HTTP_400_BAD_REQUEST,
+            "Campaign with this start_parameter already exists",
+        ) from exc
+
+    return _serialize_campaign(campaign)
+
+
+@router.get(
+    "",
+    response_model=CampaignListResponse,
+    summary="Список рекламных кампаний",
+)
+async def list_campaigns(
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+    include_inactive: bool = Query(True, description="Включать неактивные кампании"),
+) -> CampaignListResponse:
+    total = await get_campaigns_count(db, is_active=None if include_inactive else True)
+    campaigns = await get_campaigns_list(
+        db,
+        offset=offset,
+        limit=limit,
+        include_inactive=include_inactive,
+    )
+
+    return CampaignListResponse(
+        items=[_serialize_campaign(campaign) for campaign in campaigns],
+        total=total,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.delete(
+    "/{campaign_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Удалить рекламную кампанию",
+)
+async def delete_campaign_endpoint(
+    campaign_id: int,
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+):
+    campaign = await get_campaign_by_id(db, campaign_id)
+    if not campaign:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Campaign not found")
+
+    await delete_campaign(db, campaign)
+    return None
+
+
+@router.patch(
+    "/{campaign_id}",
+    response_model=CampaignResponse,
+    summary="Обновить рекламную кампанию",
+)
+async def update_campaign_endpoint(
+    campaign_id: int,
+    payload: CampaignUpdateRequest,
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> CampaignResponse:
+    campaign = await get_campaign_by_id(db, campaign_id)
+    if not campaign:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Campaign not found")
+
+    update_fields = payload.dict(exclude_unset=True)
+    if not update_fields:
+        return _serialize_campaign(campaign)
+
+    try:
+        campaign = await update_campaign(db, campaign, **update_fields)
+    except IntegrityError as exc:
+        await db.rollback()
+        if "start_parameter" in str(exc.orig):
+            raise HTTPException(
+                status.HTTP_400_BAD_REQUEST,
+                "Campaign with this start_parameter already exists",
+            ) from exc
+        raise
+
+    return _serialize_campaign(campaign)
@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Security, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.system_settings_service import bot_configuration_service
+
+from ..dependencies import get_db_session, require_api_token
+from ..schemas.config import (
+    SettingCategoryRef,
+    SettingCategorySummary,
+    SettingChoice,
+    SettingDefinition,
+    SettingUpdateRequest,
+)
+
+router = APIRouter()
+
+
+def _coerce_value(key: str, value: Any) -> Any:
+    definition = bot_configuration_service.get_definition(key)
+
+    if value is None:
+        if definition.is_optional:
+            return None
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, "Value is required")
+
+    python_type = definition.python_type
+
+    try:
+        if python_type is bool:
+            if isinstance(value, bool):
+                normalized = value
+            elif isinstance(value, str):
+                lowered = value.strip().lower()
+                if lowered in {"true", "1", "yes", "on", "да"}:
+                    normalized = True
+                elif lowered in {"false", "0", "no", "off", "нет"}:
+                    normalized = False
+                else:
+                    raise ValueError("invalid bool")
+            else:
+                raise ValueError("invalid bool")
+
+        elif python_type is int:
+            normalized = int(value)
+        elif python_type is float:
+            normalized = float(value)
+        else:
+            normalized = str(value)
+    except ValueError:
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, "Invalid value type") from None
+
+    choices = bot_configuration_service.get_choice_options(key)
+    if choices:
+        allowed_values = {option.value for option in choices}
+        if normalized not in allowed_values:
+            readable = ", ".join(bot_configuration_service.format_value(opt.value) for opt in choices)
+            raise HTTPException(
+                status.HTTP_400_BAD_REQUEST,
+                detail=f"Value must be one of: {readable}",
+            )
+
+    return normalized
+
+
+def _serialize_definition(definition, include_choices: bool = True) -> SettingDefinition:
+    current = bot_configuration_service.get_current_value(definition.key)
+    original = bot_configuration_service.get_original_value(definition.key)
+    has_override = bot_configuration_service.has_override(definition.key)
+
+    choices: list[SettingChoice] = []
+    if include_choices:
+        choices = [
+            SettingChoice(
+                value=option.value,
+                label=option.label,
+                description=option.description,
+            )
+            for option in bot_configuration_service.get_choice_options(definition.key)
+        ]
+
+    return SettingDefinition(
+        key=definition.key,
+        name=definition.display_name,
+        category=SettingCategoryRef(
+            key=definition.category_key,
+            label=definition.category_label,
+        ),
+        type=definition.type_label,
+        is_optional=definition.is_optional,
+        current=current,
+        original=original,
+        has_override=has_override,
+        choices=choices,
+    )
+
+
+@router.get("/categories", response_model=list[SettingCategorySummary])
+async def list_categories(
+    _: object = Security(require_api_token),
+) -> list[SettingCategorySummary]:
+    categories = bot_configuration_service.get_categories()
+    return [
+        SettingCategorySummary(key=key, label=label, items=count)
+        for key, label, count in categories
+    ]
+
+
+@router.get("", response_model=list[SettingDefinition])
+async def list_settings(
+    _: object = Security(require_api_token),
+    category: Optional[str] = Query(default=None, alias="category_key"),
+) -> list[SettingDefinition]:
+    items: list[SettingDefinition] = []
+    if category:
+        definitions = bot_configuration_service.get_settings_for_category(category)
+        items.extend(_serialize_definition(defn) for defn in definitions)
+        return items
+
+    for category_key, _, _ in bot_configuration_service.get_categories():
+        definitions = bot_configuration_service.get_settings_for_category(category_key)
+        items.extend(_serialize_definition(defn) for defn in definitions)
+
+    return items
+
+
+@router.get("/{key}", response_model=SettingDefinition)
+async def get_setting(
+    key: str,
+    _: object = Security(require_api_token),
+) -> SettingDefinition:
+    try:
+        definition = bot_configuration_service.get_definition(key)
+    except KeyError as error:  # pragma: no cover - защита от некорректного ключа
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Setting not found") from error
+
+    return _serialize_definition(definition)
+
+
+@router.put("/{key}", response_model=SettingDefinition)
+async def update_setting(
+    key: str,
+    payload: SettingUpdateRequest,
+    _: object = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> SettingDefinition:
+    try:
+        definition = bot_configuration_service.get_definition(key)
+    except KeyError as error:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Setting not found") from error
+
+    value = _coerce_value(key, payload.value)
+    await bot_configuration_service.set_value(db, key, value)
+    await db.commit()
+
+    return _serialize_definition(definition)
+
+
+@router.delete("/{key}", response_model=SettingDefinition)
+async def reset_setting(
+    key: str,
+    _: object = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> SettingDefinition:
+    try:
+        definition = bot_configuration_service.get_definition(key)
+    except KeyError as error:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Setting not found") from error
+
+    await bot_configuration_service.reset_value(db, key)
+    await db.commit()
+    return _serialize_definition(definition)
@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Security
+
+from app.config import settings
+from app.services.version_service import version_service
+
+from ..dependencies import require_api_token
+from ..schemas.health import HealthCheckResponse, HealthFeatureFlags
+
+router = APIRouter()
+
+
+@router.get("/health", tags=["health"], response_model=HealthCheckResponse)
+async def health_check(_: object = Security(require_api_token)) -> HealthCheckResponse:
+    return HealthCheckResponse(
+        status="ok",
+        api_version=settings.WEB_API_VERSION,
+        bot_version=version_service.current_version,
+        features=HealthFeatureFlags(
+            monitoring=settings.MONITORING_INTERVAL > 0,
+            maintenance=True,
+            reporting=True,
+            webhooks=bool(settings.WEBHOOK_URL),
+        ),
+    )
@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.server_squad import get_server_squad_by_uuid
+from app.database.crud.user import get_user_by_telegram_id
+from app.database.models import Subscription, Transaction, User
+from app.services.remnawave_service import (
+    RemnaWaveConfigurationError,
+    RemnaWaveService,
+)
+from app.services.subscription_service import SubscriptionService
+from app.utils.subscription_utils import get_happ_cryptolink_redirect_link
+from app.utils.telegram_webapp import (
+    TelegramWebAppAuthError,
+    parse_webapp_init_data,
+)
+
+from ..dependencies import get_db_session
+from ..schemas.miniapp import (
+    MiniAppConnectedServer,
+    MiniAppDevice,
+    MiniAppPromoGroup,
+    MiniAppSubscriptionRequest,
+    MiniAppSubscriptionResponse,
+    MiniAppSubscriptionUser,
+    MiniAppTransaction,
+)
+
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def _format_gb(value: Optional[float]) -> float:
+    if value is None:
+        return 0.0
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _format_gb_label(value: float) -> str:
+    absolute = abs(value)
+    if absolute >= 100:
+        return f"{value:.0f} GB"
+    if absolute >= 10:
+        return f"{value:.1f} GB"
+    return f"{value:.2f} GB"
+
+
+def _format_limit_label(limit: Optional[int]) -> str:
+    if not limit:
+        return "Unlimited"
+    return f"{limit} GB"
+
+
+def _bytes_to_gb(bytes_value: Optional[int]) -> float:
+    if not bytes_value:
+        return 0.0
+    return round(bytes_value / (1024 ** 3), 2)
+
+
+def _status_label(status: str) -> str:
+    mapping = {
+        "active": "Active",
+        "trial": "Trial",
+        "expired": "Expired",
+        "disabled": "Disabled",
+    }
+    return mapping.get(status, status.title())
+
+
+def _parse_datetime_string(value: Optional[str]) -> Optional[str]:
+    if not value:
+        return None
+
+    try:
+        cleaned = value.strip()
+        if cleaned.endswith("Z"):
+            cleaned = f"{cleaned[:-1]}+00:00"
+        # Normalize duplicated timezone suffixes like +00:00+00:00
+        if "+00:00+00:00" in cleaned:
+            cleaned = cleaned.replace("+00:00+00:00", "+00:00")
+
+        datetime.fromisoformat(cleaned)
+        return cleaned
+    except Exception:  # pragma: no cover - defensive
+        return value
+
+
+async def _resolve_connected_servers(
+    db: AsyncSession,
+    squad_uuids: List[str],
+) -> List[MiniAppConnectedServer]:
+    if not squad_uuids:
+        return []
+
+    resolved: Dict[str, str] = {}
+    missing: List[str] = []
+
+    for squad_uuid in squad_uuids:
+        if squad_uuid in resolved:
+            continue
+        server = await get_server_squad_by_uuid(db, squad_uuid)
+        if server and server.display_name:
+            resolved[squad_uuid] = server.display_name
+        else:
+            missing.append(squad_uuid)
+
+    if missing:
+        try:
+            service = RemnaWaveService()
+            if service.is_configured:
+                squads = await service.get_all_squads()
+                for squad in squads:
+                    uuid = squad.get("uuid")
+                    name = squad.get("name")
+                    if uuid in missing and name:
+                        resolved[uuid] = name
+        except RemnaWaveConfigurationError:
+            logger.debug("RemnaWave is not configured; skipping server name enrichment")
+        except Exception as error:  # pragma: no cover - defensive logging
+            logger.warning("Failed to resolve server names from RemnaWave: %s", error)
+
+    connected_servers: List[MiniAppConnectedServer] = []
+    for squad_uuid in squad_uuids:
+        name = resolved.get(squad_uuid, squad_uuid)
+        connected_servers.append(MiniAppConnectedServer(uuid=squad_uuid, name=name))
+
+    return connected_servers
+
+
+async def _load_devices_info(user: User) -> Tuple[int, List[MiniAppDevice]]:
+    remnawave_uuid = getattr(user, "remnawave_uuid", None)
+    if not remnawave_uuid:
+        return 0, []
+
+    try:
+        service = RemnaWaveService()
+    except Exception as error:  # pragma: no cover - defensive logging
+        logger.warning("Failed to initialise RemnaWave service: %s", error)
+        return 0, []
+
+    if not service.is_configured:
+        return 0, []
+
+    try:
+        async with service.get_api_client() as api:
+            response = await api.get_user_devices(remnawave_uuid)
+    except RemnaWaveConfigurationError:
+        logger.debug("RemnaWave configuration missing while loading devices")
+        return 0, []
+    except Exception as error:  # pragma: no cover - defensive logging
+        logger.warning("Failed to load devices from RemnaWave: %s", error)
+        return 0, []
+
+    total_devices = int(response.get("total") or 0)
+    devices_payload = response.get("devices") or []
+
+    devices: List[MiniAppDevice] = []
+    for device in devices_payload:
+        platform = device.get("platform") or device.get("platformType")
+        model = device.get("deviceModel") or device.get("model") or device.get("name")
+        app_version = device.get("appVersion") or device.get("version")
+        last_seen_raw = (
+            device.get("updatedAt")
+            or device.get("lastSeen")
+            or device.get("lastActiveAt")
+            or device.get("createdAt")
+        )
+        last_ip = device.get("ip") or device.get("ipAddress")
+
+        devices.append(
+            MiniAppDevice(
+                platform=platform,
+                device_model=model,
+                app_version=app_version,
+                last_seen=_parse_datetime_string(last_seen_raw),
+                last_ip=last_ip,
+            )
+        )
+
+    if total_devices == 0:
+        total_devices = len(devices)
+
+    return total_devices, devices
+
+
+def _resolve_display_name(user_data: Dict[str, Any]) -> str:
+    username = user_data.get("username")
+    if username:
+        return username
+
+    first = user_data.get("first_name")
+    last = user_data.get("last_name")
+    parts = [part for part in [first, last] if part]
+    if parts:
+        return " ".join(parts)
+
+    telegram_id = user_data.get("telegram_id")
+    return f"User {telegram_id}" if telegram_id else "User"
+
+
+def _is_remnawave_configured() -> bool:
+    params = settings.get_remnawave_auth_params()
+    return bool(params.get("base_url") and params.get("api_key"))
+
+
+def _serialize_transaction(transaction: Transaction) -> MiniAppTransaction:
+    return MiniAppTransaction(
+        id=transaction.id,
+        type=transaction.type,
+        amount_kopeks=transaction.amount_kopeks,
+        amount_rubles=round(transaction.amount_kopeks / 100, 2),
+        description=transaction.description,
+        payment_method=transaction.payment_method,
+        external_id=transaction.external_id,
+        is_completed=transaction.is_completed,
+        created_at=transaction.created_at,
+        completed_at=transaction.completed_at,
+    )
+
+
+async def _load_subscription_links(
+    subscription: Subscription,
+) -> Dict[str, Any]:
+    if not subscription.remnawave_short_uuid or not _is_remnawave_configured():
+        return {}
+
+    try:
+        service = SubscriptionService()
+        info = await service.get_subscription_info(subscription.remnawave_short_uuid)
+    except Exception as error:  # pragma: no cover - defensive logging
+        logger.warning("Failed to load subscription info from RemnaWave: %s", error)
+        return {}
+
+    if not info:
+        return {}
+
+    payload: Dict[str, Any] = {
+        "links": list(info.links or []),
+        "ss_conf_links": dict(info.ss_conf_links or {}),
+        "subscription_url": info.subscription_url,
+        "happ": info.happ,
+        "happ_link": getattr(info, "happ_link", None),
+        "happ_crypto_link": getattr(info, "happ_crypto_link", None),
+    }
+
+    return payload
+
+
+@router.post("/subscription", response_model=MiniAppSubscriptionResponse)
+async def get_subscription_details(
+    payload: MiniAppSubscriptionRequest,
+    db: AsyncSession = Depends(get_db_session),
+) -> MiniAppSubscriptionResponse:
+    try:
+        webapp_data = parse_webapp_init_data(payload.init_data, settings.BOT_TOKEN)
+    except TelegramWebAppAuthError as error:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=str(error),
+        ) from error
+
+    telegram_user = webapp_data.get("user")
+    if not isinstance(telegram_user, dict) or "id" not in telegram_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid Telegram user payload",
+        )
+
+    try:
+        telegram_id = int(telegram_user["id"])
+    except (TypeError, ValueError):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid Telegram user identifier",
+        ) from None
+
+    user = await get_user_by_telegram_id(db, telegram_id)
+    purchase_url = (settings.MINIAPP_PURCHASE_URL or "").strip()
+    if not user or not user.subscription:
+        detail: Union[str, Dict[str, str]] = "Subscription not found"
+        if purchase_url:
+            detail = {
+                "message": "Subscription not found",
+                "purchase_url": purchase_url,
+            }
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=detail,
+        )
+
+    subscription = user.subscription
+    traffic_used = _format_gb(subscription.traffic_used_gb)
+    traffic_limit = subscription.traffic_limit_gb or 0
+    lifetime_used = _bytes_to_gb(getattr(user, "lifetime_used_traffic_bytes", 0))
+
+    status_actual = subscription.actual_status
+    links_payload = await _load_subscription_links(subscription)
+
+    subscription_url = links_payload.get("subscription_url") or subscription.subscription_url
+    subscription_crypto_link = (
+        links_payload.get("happ_crypto_link")
+        or subscription.subscription_crypto_link
+    )
+
+    happ_redirect_link = get_happ_cryptolink_redirect_link(subscription_crypto_link)
+
+    connected_squads: List[str] = list(subscription.connected_squads or [])
+    connected_servers = await _resolve_connected_servers(db, connected_squads)
+    devices_count, devices = await _load_devices_info(user)
+    links: List[str] = links_payload.get("links") or connected_squads
+    ss_conf_links: Dict[str, str] = links_payload.get("ss_conf_links") or {}
+
+    transactions_query = (
+        select(Transaction)
+        .where(Transaction.user_id == user.id)
+        .order_by(Transaction.created_at.desc())
+        .limit(10)
+    )
+    transactions_result = await db.execute(transactions_query)
+    transactions = list(transactions_result.scalars().all())
+
+    balance_currency = getattr(user, "balance_currency", None)
+    if isinstance(balance_currency, str):
+        balance_currency = balance_currency.upper()
+
+    promo_group = getattr(user, "promo_group", None)
+
+    response_user = MiniAppSubscriptionUser(
+        telegram_id=user.telegram_id,
+        username=user.username,
+        first_name=user.first_name,
+        last_name=user.last_name,
+        display_name=_resolve_display_name(
+            {
+                "username": user.username,
+                "first_name": user.first_name,
+                "last_name": user.last_name,
+                "telegram_id": user.telegram_id,
+            }
+        ),
+        language=user.language,
+        status=user.status,
+        subscription_status=subscription.status,
+        subscription_actual_status=status_actual,
+        status_label=_status_label(status_actual),
+        expires_at=subscription.end_date,
+        device_limit=subscription.device_limit,
+        traffic_used_gb=round(traffic_used, 2),
+        traffic_used_label=_format_gb_label(traffic_used),
+        traffic_limit_gb=traffic_limit,
+        traffic_limit_label=_format_limit_label(traffic_limit),
+        lifetime_used_traffic_gb=lifetime_used,
+        has_active_subscription=status_actual in {"active", "trial"},
+    )
+
+    return MiniAppSubscriptionResponse(
+        subscription_id=subscription.id,
+        remnawave_short_uuid=subscription.remnawave_short_uuid,
+        user=response_user,
+        subscription_url=subscription_url,
+        subscription_crypto_link=subscription_crypto_link,
+        subscription_purchase_url=purchase_url or None,
+        links=links,
+        ss_conf_links=ss_conf_links,
+        connected_squads=connected_squads,
+        connected_servers=connected_servers,
+        connected_devices_count=devices_count,
+        connected_devices=devices,
+        happ=links_payload.get("happ"),
+        happ_link=links_payload.get("happ_link"),
+        happ_crypto_link=links_payload.get("happ_crypto_link"),
+        happ_cryptolink_redirect_link=happ_redirect_link,
+        balance_kopeks=user.balance_kopeks,
+        balance_rubles=round(user.balance_rubles, 2),
+        balance_currency=balance_currency,
+        transactions=[_serialize_transaction(tx) for tx in transactions],
+        promo_group=MiniAppPromoGroup(id=promo_group.id, name=promo_group.name)
+        if promo_group
+        else None,
+        subscription_type="trial" if subscription.is_trial else "paid",
+        autopay_enabled=bool(subscription.autopay_enabled),
+        branding=settings.get_miniapp_branding(),
+    )
+
@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Response, Security, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.promo_group import (
+    count_promo_group_members,
+    count_promo_groups,
+    create_promo_group,
+    delete_promo_group,
+    get_promo_group_by_id,
+    get_promo_groups_with_counts,
+    update_promo_group,
+)
+from app.database.models import PromoGroup
+
+from ..dependencies import get_db_session, require_api_token
+from ..schemas.promo_groups import (
+    PromoGroupCreateRequest,
+    PromoGroupListResponse,
+    PromoGroupResponse,
+    PromoGroupUpdateRequest,
+)
+
+router = APIRouter()
+
+
+def _normalize_period_discounts(group: PromoGroup) -> dict[int, int]:
+    raw = group.period_discounts or {}
+    normalized: dict[int, int] = {}
+    if isinstance(raw, dict):
+        for key, value in raw.items():
+            try:
+                normalized[int(key)] = int(value)
+            except (TypeError, ValueError):
+                continue
+    return normalized
+
+
+def _serialize(group: PromoGroup, members_count: int = 0) -> PromoGroupResponse:
+    return PromoGroupResponse(
+        id=group.id,
+        name=group.name,
+        server_discount_percent=group.server_discount_percent,
+        traffic_discount_percent=group.traffic_discount_percent,
+        device_discount_percent=group.device_discount_percent,
+        period_discounts=_normalize_period_discounts(group),
+        auto_assign_total_spent_kopeks=group.auto_assign_total_spent_kopeks,
+        apply_discounts_to_addons=group.apply_discounts_to_addons,
+        is_default=group.is_default,
+        members_count=members_count,
+        created_at=group.created_at,
+        updated_at=group.updated_at,
+    )
+
+
+@router.get("", response_model=PromoGroupListResponse)
+async def list_promo_groups(
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> PromoGroupListResponse:
+    total = await count_promo_groups(db)
+    groups_with_counts = await get_promo_groups_with_counts(
+        db,
+        offset=offset,
+        limit=limit,
+    )
+
+    return PromoGroupListResponse(
+        items=[_serialize(group, members_count=count) for group, count in groups_with_counts],
+        total=total,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.get("/{group_id}", response_model=PromoGroupResponse)
+async def get_promo_group(
+    group_id: int,
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> PromoGroupResponse:
+    group = await get_promo_group_by_id(db, group_id)
+    if not group:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Promo group not found")
+
+    members_count = await count_promo_group_members(db, group_id)
+    return _serialize(group, members_count=members_count)
+
+
+@router.post("", response_model=PromoGroupResponse, status_code=status.HTTP_201_CREATED)
+async def create_promo_group_endpoint(
+    payload: PromoGroupCreateRequest,
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> PromoGroupResponse:
+    try:
+        group = await create_promo_group(
+            db,
+            name=payload.name,
+            server_discount_percent=payload.server_discount_percent,
+            traffic_discount_percent=payload.traffic_discount_percent,
+        device_discount_percent=payload.device_discount_percent,
+        period_discounts=payload.period_discounts,
+        auto_assign_total_spent_kopeks=payload.auto_assign_total_spent_kopeks,
+        apply_discounts_to_addons=payload.apply_discounts_to_addons,
+        is_default=payload.is_default,
+    )
+    except IntegrityError as exc:
+        await db.rollback()
+        raise HTTPException(
+            status.HTTP_400_BAD_REQUEST,
+            "Promo group with this name already exists",
+        ) from exc
+    return _serialize(group, members_count=0)
+
+
+@router.patch("/{group_id}", response_model=PromoGroupResponse)
+async def update_promo_group_endpoint(
+    group_id: int,
+    payload: PromoGroupUpdateRequest,
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> PromoGroupResponse:
+    group = await get_promo_group_by_id(db, group_id)
+    if not group:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Promo group not found")
+
+    try:
+        group = await update_promo_group(
+            db,
+            group,
+            name=payload.name,
+            server_discount_percent=payload.server_discount_percent,
+            traffic_discount_percent=payload.traffic_discount_percent,
+        device_discount_percent=payload.device_discount_percent,
+        period_discounts=payload.period_discounts,
+        auto_assign_total_spent_kopeks=payload.auto_assign_total_spent_kopeks,
+        apply_discounts_to_addons=payload.apply_discounts_to_addons,
+        is_default=payload.is_default,
+    )
+    except IntegrityError as exc:
+        await db.rollback()
+        raise HTTPException(
+            status.HTTP_400_BAD_REQUEST,
+            "Promo group with this name already exists",
+        ) from exc
+    members_count = await count_promo_group_members(db, group_id)
+    return _serialize(group, members_count=members_count)
+
+
+@router.delete("/{group_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_promo_group_endpoint(
+    group_id: int,
+    _: Any = Security(require_api_token),
+    db: AsyncSession = Depends(get_db_session),
+) -> Response:
+    group = await get_promo_group_by_id(db, group_id)
+    if not group:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Promo group not found")
+
+    success = await delete_promo_group(db, group)
+    if not success:
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, "Cannot delete default promo group")
+
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
--- a/Show More
+++ b/Show More