Update Dockerfile

Тест платежек в настройках конфигурации бота + перенос обязательных переменных ремны из env

.env.example

@@ -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 # Обязательна ли подписка на канал
@@ -221,7 +226,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 +237,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,11 +280,21 @@ 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=
 
+# Параметры режима 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 +312,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=
@@ -330,4 +374,4 @@ LOG_FILE=logs/bot.log
 # ===== РАЗРАБОТКА =====
 DEBUG=false
 WEBHOOK_URL=
-WEBHOOK_PATH=/webhook
+WEBHOOK_PATH=/webhook

.github/workflows/docker-hub.yml

@@ -36,15 +36,15 @@ jobs:
           TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:latest,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
           echo "🏷️ Собираем релизную версию: $VERSION"
         elif [[ $GITHUB_REF == refs/heads/main ]]; then
-          VERSION="v2.3.8-$(git rev-parse --short HEAD)"
+          VERSION="v2.4.0-$(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.0-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.0-pr-$(git rev-parse --short HEAD)"
           TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:pr-$(git rev-parse --short HEAD)"
           echo "🔀 Собираем PR версию: $VERSION"
         fi

.github/workflows/docker-registry.yml

@@ -49,13 +49,13 @@ jobs:
             VERSION=${GITHUB_REF#refs/tags/}
             echo "🏷️ Building release version: $VERSION"
           elif [[ $GITHUB_REF == refs/heads/main ]]; then
-            VERSION="v2.3.8-$(git rev-parse --short HEAD)"
+            VERSION="v2.4.0-$(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.0-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.0-pr-$(git rev-parse --short HEAD)"
             echo "🔀 Building PR version: $VERSION"
           fi
           echo "version=$VERSION" >> $GITHUB_OUTPUT

Dockerfile

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

README.md

@@ -35,7 +35,7 @@
 
 ### ⚡ **Полная автоматизация VPN бизнеса**
 - 🎯 **Готовое решение** - разверни за 5 минут, начни продавать сегодня
-- 💰 **Многоканальные платежи** - Telegram Stars + Tribute + CryptoBot + ЮKassa + P2P
+- 💰 **Многоканальные платежи** - Telegram Stars + Tribute + CryptoBot + ЮKassa + MulenPay + PayPalych + P2P
 - 🔄 **Автоматизация 99%** - от регистрации до продления подписок
 - 📊 **Детальная аналитика** - полная картина вашего бизнеса
 - 💬 **Уведомления в топики** об: Активация триала 💎 Покупка подписки 🔄 Конверсия из триала в платную ⏰ Продление подписки 💰 Пополнение баланса 🚧 Включении тех работ ♻️ Появлении новой версии бота
@@ -112,8 +112,8 @@ docker compose logs
 
 | Переменная | Описание | Пример |
 |------------|----------|--------|
-| `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 +248,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 +280,7 @@ POSTGRES_PASSWORD=secure_password_123
 
 # SQLite настройки (для локального запуска)
 SQLITE_PATH=./data/bot.db
+LOCALES_PATH=./locales
 
 # Redis
 REDIS_URL=redis://redis:6379/0
@@ -300,6 +307,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
@@ -437,6 +449,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 +466,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 +477,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,11 +520,21 @@ 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=
 
+# Параметры режима 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 +551,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
@@ -540,8 +615,6 @@ LOG_FILE=logs/bot.log
 DEBUG=false
 WEBHOOK_URL=
 WEBHOOK_PATH=/webhook
-
-
 ```
 
 </details>
@@ -573,6 +646,8 @@ WEBHOOK_PATH=/webhook
 - ⭐ Telegram Stars
 - 💳 Tribute
 - 💳 YooKassa (включая СБП и онлайн-чек)
+- 💳 MulenPay
+- 💳 PayPalych (Pal24)
 - 💰 CryptoBot (мультивалюта и срок жизни инвойсов)
 - 🎁 Реферальные и промо-бонусы
 - Детальная история транзакций и чеков
@@ -598,7 +673,7 @@ WEBHOOK_PATH=/webhook
 
 📊 **Мощная аналитика**
 - 👥 Детальная статистика пользователей и подписок
-- 💰 Анализ платежей по источникам (Stars, YooKassa, Tribute, CryptoBot)
+- 💰 Анализ платежей по источникам (Stars, YooKassa, Tribute, MulenPay, PayPalych, CryptoBot)
 - 🖥️ Мониторинг серверов Remnawave и статуса сквадов
 - 📈 Финансовые отчеты, конверсии и эффективность рекламных кампаний
 
@@ -891,6 +966,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 +1179,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 +1200,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 +1250,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"}` подтверждает корректную обработку вебхука.
+
 ---
 
 ## 💡 Использование

app/bot.py

@@ -38,6 +38,8 @@ from app.handlers.admin import (
     backup as admin_backup,
     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
 
@@ -139,6 +141,8 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     admin_backup.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 платежей")

app/config.py

@@ -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
@@ -56,7 +68,7 @@ class Settings(BaseSettings):
     TRIAL_DEVICE_LIMIT: int = 2
     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"
     MAX_DEVICES_LIMIT: int = 20
     
@@ -169,8 +181,41 @@ 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
+
     CONNECT_BUTTON_MODE: str = "guide"
     MINIAPP_CUSTOM_URL: 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"
@@ -221,6 +266,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 +280,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')
@@ -387,6 +441,32 @@ class Settings(BaseSettings):
     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
@@ -435,9 +515,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 +550,34 @@ 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 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
     
@@ -841,32 +964,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",

app/database/crud/discount_offer.py

@@ -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

app/database/crud/mulenpay.py

@@ -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

app/database/crud/pal24.py

@@ -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
+

app/database/crud/promo_group.py

@@ -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,6 +7,24 @@ 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__)
 
 
@@ -40,12 +58,26 @@ 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,
 ) -> 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
+    )
+
     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)),
+        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=False,
     )
 
@@ -54,11 +86,14 @@ async def create_promo_group(
     await db.refresh(promo_group)
 
     logger.info(
-        "Создана промогруппа '%s' с скидками (servers=%s%%, traffic=%s%%, devices=%s%%)",
+        "Создана промогруппа '%s' с скидками (servers=%s%%, traffic=%s%%, devices=%s%%, periods=%s) и порогом автоприсвоения %s₽, скидки на доп. услуги: %s",
         promo_group.name,
         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 +107,9 @@ 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,
 ) -> PromoGroup:
     if name is not None:
         group.name = name.strip()
@@ -81,6 +119,13 @@ 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)
 
     await db.commit()
     await db.refresh(group)

app/database/crud/server_squad.py

@@ -1,14 +1,22 @@
 import logging
-from typing import List, Optional, Tuple
+from typing import Iterable, List, Optional, Sequence, Tuple
+
 from sqlalchemy import select, and_, func, update, delete, text
 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
 
 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 +26,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 +58,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 +76,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 +89,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 +125,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(

app/database/crud/subscription.py

@@ -531,7 +531,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 +585,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 +965,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 +985,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)

app/database/crud/system_setting.py

@@ -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()
+

app/database/crud/ticket.py

@@ -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()
         

app/database/crud/transaction.py

@@ -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,47 @@ 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.in_(
+                    [
+                        TransactionType.DEPOSIT.value,
+                        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
 
 

app/database/crud/user.py

@@ -88,8 +88,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:

app/database/models.py

@@ -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:
@@ -622,6 +796,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 +840,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 +860,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 +906,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 +1030,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")

app/external/pal24_client.py

@@ -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
+

app/external/pal24_webhook.py

@@ -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
+

app/external/remnawave_api.py

@@ -58,6 +58,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 +94,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 +588,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 +620,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 +655,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
         )
 
 

app/external/webhook_server.py

@@ -1,3 +1,5 @@
+import hashlib
+import hmac
 import logging
 import json
 from typing import Optional
@@ -7,6 +9,8 @@ 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 +29,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 +73,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 +104,81 @@ 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 _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 = request.headers.get('X-MulenPay-Signature')
+        if signature:
+            expected_signature = hmac.new(
+                secret_key.encode('utf-8'),
+                raw_body,
+                hashlib.sha256,
+            ).hexdigest()
+
+            if hmac.compare_digest(signature.strip().lower(), expected_signature.lower()):
+                return True
+
+            logger.error("Неверная подпись Mulen Pay webhook")
+            return False
+
+        authorization_header = request.headers.get('Authorization')
+        if authorization_header and authorization_header.startswith('Bearer '):
+            token = authorization_header.split(' ', 1)[1].strip()
+            if hmac.compare_digest(token, secret_key):
+                return True
+
+            logger.error("Неверный Bearer токен Mulen Pay webhook")
+            return False
+
+        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)}")

app/handlers/admin/main.py

@@ -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__)
 
@@ -113,6 +117,115 @@ async def show_communications_submenu(
     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))
+    
+    from app.keyboards.admin import get_admin_support_submenu_keyboard
+    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="🎫 Тикеты поддержки", callback_data="admin_tickets")],
+            [InlineKeyboardButton(text="⬅️ Назад", callback_data="back_to_menu")]
+        ])
+    await callback.message.edit_text(
+        "🛟 **Поддержка**\n\n" + ("Доступ к тикетам." if is_moderator_only else "Управление тикетами и настройками поддержки:"),
+        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
+):
+    kb = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="🎫 Тикеты поддержки", callback_data="admin_tickets")],
+        [InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")]
+    ])
+    await callback.message.edit_text(
+        "🧑‍⚖️ <b>Модерация поддержки</b>\n\nДоступ к тикетам поддержки.",
+        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
+):
+    # 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 = ["🧾 <b>Аудит модераторов</b>", ""]
+    if not logs:
+        lines.append("Пока пусто")
+    else:
+        for log in logs:
+            role = "Модератор" if getattr(log, 'is_moderator', False) else "Админ"
+            ts = log.created_at.strftime('%d.%m.%Y %H:%M') if getattr(log, 'created_at', None) else ''
+            action_map = {
+                'close_ticket': 'Закрытие тикета',
+                'block_user_timed': 'Блокировка (время)',
+                'block_user_perm': 'Блокировка (навсегда)',
+                'unblock_user': 'Снятие блока',
+            }
+            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="⬅️ Назад", 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(
@@ -142,7 +255,7 @@ async def show_system_submenu(
     
     await callback.message.edit_text(
         "🛠️ **Системные функции**\n\n"
-        "Обновления, резервные копии и системные операции:",
+        "Отчеты, обновления, резервные копии и системные операции:",
         reply_markup=get_admin_system_submenu_keyboard(db_user.language),
         parse_mode="Markdown"
     )
@@ -285,6 +398,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 +416,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)
     

app/handlers/admin/monitoring.py

@@ -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,334 @@ 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))
+    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"• 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"{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 == "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):
@@ -52,6 +377,265 @@ 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_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",
+            "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 +950,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)

app/handlers/admin/remnawave.py

@@ -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()

app/handlers/admin/reports.py

@@ -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")
+

app/handlers/admin/servers.py

@@ -6,10 +6,17 @@ 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,
 )
+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 +24,111 @@ 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_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(
@@ -166,7 +278,7 @@ async def sync_servers_with_remnawave(
         
         created, updated, disabled = await sync_with_remnawave(db, squads)
         
-        await cache.delete("available_countries")
+        await cache.delete_pattern("available_countries*")
         
         text = f"""
 ✅ <b>Синхронизация завершена</b>
@@ -216,63 +328,16 @@ 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}
-
-<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"
     )
     await callback.answer()
@@ -296,65 +361,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 +440,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 +515,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 +588,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 +719,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 +865,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 +881,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 +1094,22 @@ 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(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 +1117,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_"))

app/handlers/admin/support_settings.py

@@ -7,6 +7,7 @@ from aiogram.fsm.context import FSMContext
 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,6 +21,10 @@ 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]] = []
 
@@ -40,8 +45,53 @@ def _get_support_settings_keyboard(language: str) -> types.InlineKeyboardMarkup:
         types.InlineKeyboardButton(text="📝 Изменить описание", callback_data="admin_support_edit_desc")
     ])
 
+    # Notifications block
     rows.append([
-        types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_communications")
+        types.InlineKeyboardButton(
+            text=("🔔 Админ-уведомления: Включены" if admin_notif else "🔕 Админ-уведомления: Отключены"),
+            callback_data="admin_support_toggle_admin_notifications"
+        )
+    ])
+    rows.append([
+        types.InlineKeyboardButton(
+            text=("🔔 Пользовательские уведомления: Включены" if user_notif else "🔕 Пользовательские уведомления: Отключены"),
+            callback_data="admin_support_toggle_user_notifications"
+        )
+    ])
+
+    # SLA block
+    rows.append([
+        types.InlineKeyboardButton(
+            text=("⏰ SLA: Включено" if sla_enabled else "⏹️ SLA: Отключено"),
+            callback_data="admin_support_toggle_sla"
+        )
+    ])
+    rows.append([
+        types.InlineKeyboardButton(
+            text=f"⏳ Время SLA: {sla_minutes} мин",
+            callback_data="admin_support_set_sla_minutes"
+        )
+    ])
+
+    # Moderators
+    moderators = SupportSettingsService.get_moderators()
+    mod_count = len(moderators)
+    rows.append([
+        types.InlineKeyboardButton(
+            text=f"🧑‍⚖️ Модераторы: {mod_count}", callback_data="admin_support_list_moderators"
+        )
+    ])
+    rows.append([
+        types.InlineKeyboardButton(
+            text="➕ Назначить модератора", callback_data="admin_support_add_moderator"
+        ),
+        types.InlineKeyboardButton(
+            text="➖ Удалить модератора", callback_data="admin_support_remove_moderator"
+        )
+    ])
+
+    rows.append([
+        types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_support")
     ])
 
     return types.InlineKeyboardMarkup(inline_keyboard=rows)
@@ -78,6 +128,175 @@ 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)
+
+
+from app.states import SupportSettingsStates
+
+@admin_required
+@error_handler
+async def start_set_sla_minutes(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    await callback.message.edit_text(
+        "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):",
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
+        )
+    )
+    await state.set_state(SupportSettingsStates.waiting_for_desc)  # temporary reuse replaced below
+    # we'll manage separate state below
+
+
+from aiogram.fsm.state import State, StatesGroup
+
+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):
+    await callback.message.edit_text(
+        "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):",
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", 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):
+    text = (message.text or "").strip()
+    try:
+        minutes = int(text)
+        if minutes <= 0 or minutes > 1440:
+            raise ValueError()
+    except Exception:
+        await message.answer("❌ Введите корректное число минут (1-1440)")
+        return
+    SupportSettingsService.set_sla_minutes(minutes)
+    await state.clear()
+    markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+    )
+    await message.answer("✅ Значение SLA сохранено", reply_markup=markup)
+
+
+@admin_required
+@error_handler
+async def start_add_moderator(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    await callback.message.edit_text(
+        "🧑‍⚖️ <b>Назначение модератора</b>\n\nОтправьте Telegram ID пользователя (число)",
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
+        )
+    )
+    await state.set_state(SupportAdvancedStates.waiting_for_moderator_id)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def handle_add_moderator(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    text = (message.text or "").strip()
+    try:
+        tid = int(text)
+    except Exception:
+        await message.answer("❌ Введите корректный Telegram ID (число)")
+        return
+    if SupportSettingsService.add_moderator(tid):
+        markup = types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        )
+        await message.answer(f"✅ Пользователь {tid} назначен модератором", reply_markup=markup)
+    else:
+        await message.answer("❌ Не удалось сохранить")
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def start_remove_moderator(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    await callback.message.edit_text(
+        "🧑‍⚖️ <b>Удаление модератора</b>\n\nОтправьте Telegram ID пользователя (число)",
+        parse_mode="HTML",
+        reply_markup=types.InlineKeyboardMarkup(
+            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", 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):
+    data = await state.get_data()
+    action = data.get("action", "add")
+    text = (message.text or "").strip()
+    try:
+        tid = int(text)
+    except Exception:
+        await message.answer("❌ Введите корректный Telegram ID (число)")
+        return
+    ok = False
+    if action == "remove_moderator":
+        ok = SupportSettingsService.remove_moderator(tid)
+        msg = "✅ Модератор удалён" if ok else "❌ Не удалось удалить"
+    else:
+        ok = SupportSettingsService.add_moderator(tid)
+        msg = "✅ Пользователь назначен модератором" if ok else "❌ Не удалось назначить"
+    await state.clear()
+    markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", 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):
+    moderators = SupportSettingsService.get_moderators()
+    if not moderators:
+        await callback.answer("Список пуст", show_alert=True)
+        return
+    text = "🧑‍⚖️ <b>Модераторы</b>\n\n" + "\n".join([f"• <code>{tid}</code>" for tid in moderators])
+    markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", 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):
@@ -177,9 +396,17 @@ async def send_desc_copy(callback: types.CallbackQuery, db_user: User, db: Async
     await callback.answer("Текст отправлен ниже")
 
 
-@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
+    if not may_delete:
+        texts = get_texts(db_user.language if db_user else 'ru')
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
     try:
         await callback.message.delete()
     finally:
@@ -196,6 +423,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)
 
 

app/handlers/admin/tickets.py

@@ -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
@@ -81,9 +90,33 @@ async def show_admin_tickets(
         })
     
     # Итоговые страницы уже посчитаны выше
-    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 +129,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])
@@ -158,9 +196,10 @@ 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
     )
     if has_photos:
         try:
@@ -168,24 +207,20 @@ async def view_admin_ticket(
         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 +230,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 +253,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 +432,42 @@ 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))
+                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={}
+                )
+            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 +495,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 +521,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 +552,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 +570,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 +595,76 @@ 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)
+            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 +673,44 @@ 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_", ""))
+            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={}
+            )
+        except Exception:
+            pass
         await view_admin_ticket(callback, db_user, db, state)
     else:
         await callback.answer("❌ Ошибка", show_alert=True)
@@ -546,10 +722,37 @@ 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))
+            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={}
+            )
+        except Exception:
+            pass
         await view_admin_ticket(callback, db_user, db, state)
     else:
         await callback.answer("❌ Ошибка", show_alert=True)
@@ -558,6 +761,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 +864,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_", ""))

app/handlers/admin/users.py

@@ -1988,7 +1988,7 @@ async def toggle_user_server(
         if user.remnawave_uuid:
             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=user.remnawave_uuid,
                         active_internal_squads=current_squads,
@@ -2332,7 +2332,7 @@ async def reset_user_devices(
             return
         
         remnawave_service = RemnaWaveService()
-        async with remnawave_service.api as api:
+        async with remnawave_service.get_api_client() as api:
             success = await api.reset_user_devices(user.remnawave_uuid)
         
         if success:
@@ -2372,7 +2372,7 @@ async def _update_user_devices(db: AsyncSession, user_id: int, devices: int, adm
         if user.remnawave_uuid:
             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=user.remnawave_uuid,
                         hwid_device_limit=devices,
@@ -2414,7 +2414,7 @@ async def _update_user_traffic(db: AsyncSession, user_id: int, traffic_gb: int,
                 from app.external.remnawave_api import TrafficLimitStrategy
                 
                 remnawave_service = RemnaWaveService()
-                async with remnawave_service.api as api:
+                async with remnawave_service.get_api_client() as api:
                     await api.update_user(
                         uuid=user.remnawave_uuid,
                         traffic_limit_bytes=traffic_gb * (1024**3) if traffic_gb > 0 else 0,
@@ -2873,7 +2873,7 @@ async def admin_buy_subscription_execute(
                 remnawave_service = RemnaWaveService()
                 
                 if target_user.remnawave_uuid:
-                    async with remnawave_service.api as api:
+                    async with remnawave_service.get_api_client() as api:
                         remnawave_user = await api.update_user(
                             uuid=target_user.remnawave_uuid,
                             status=UserStatus.ACTIVE if subscription.is_active else UserStatus.EXPIRED,
@@ -2890,7 +2890,7 @@ async def admin_buy_subscription_execute(
                         )
                 else:
                     username = f"user_{target_user.telegram_id}"
-                    async with remnawave_service.api as api:
+                    async with remnawave_service.get_api_client() as api:
                         remnawave_user = await api.create_user(
                             username=username,
                             expire_at=subscription.end_date,

app/handlers/balance.py

@@ -332,6 +332,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 +601,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 +846,241 @@ 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 or not payment_result.get("link_url"):
+            await message.answer(
+                texts.t(
+                    "PAL24_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+                )
+            )
+            await state.clear()
+            return
+
+        link_url = payment_result.get("link_url")
+        bill_id = payment_result.get("bill_id")
+        local_payment_id = payment_result.get("local_payment_id")
+
+        keyboard = types.InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    types.InlineKeyboardButton(
+                        text=texts.t("PAL24_PAY_BUTTON", "💳 Оплатить через PayPalych"),
+                        url=link_url,
+                    )
+                ],
+                [
+                    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")],
+            ]
+        )
+
+        message_template = texts.t(
+            "PAL24_PAYMENT_INSTRUCTIONS",
+            (
+                "💳 <b>Оплата через PayPalych</b>\n\n"
+                "💰 Сумма: {amount}\n"
+                "🆔 ID счета: {bill_id}\n\n"
+                "📱 <b>Инструкция:</b>\n"
+                "1. Нажмите кнопку ‘Оплатить через PayPalych’\n"
+                "2. Следуйте подсказкам платежной системы\n"
+                "3. Подтвердите перевод\n"
+                "4. Средства зачислятся автоматически\n\n"
+                "❓ Если возникнут проблемы, обратитесь в {support}"
+            ),
+        )
+
+        message_text = message_template.format(
+            amount=settings.format_price(amount_kopeks),
+            bill_id=bill_id,
+            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 +1136,122 @@ 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, ("❓", "Неизвестно"))
+
+        message_lines = [
+            "💳 Статус платежа PayPalych:\n\n",
+            f"🆔 ID счета: {payment.bill_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 {"NEW", "PROCESS"}:
+            message_lines.append("\n⏳ Платеж еще не завершен. Оплатите счет и проверьте статус позже.")
+            if payment.link_url:
+                message_lines.append(f"\n🔗 Ссылка на оплату: {payment.link_url}")
+        elif payment.status in {"FAIL", "UNDERPAID", "OVERPAID"}:
+            message_lines.append(
+                f"\n❌ Платеж не завершен корректно. Обратитесь в {settings.get_support_contact_display()}"
+            )
+
+        await callback.answer("".join(message_lines), show_alert=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 +1522,12 @@ 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
+                )
         else:
             await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
             return
@@ -1096,6 +1539,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 +1646,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 +1692,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 +1712,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|")
+    )

app/handlers/common.py

@@ -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)
+    )
     

app/handlers/menu.py

@@ -16,6 +16,7 @@ from app.services.subscription_checkout_service import (
     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__)
 
@@ -48,6 +49,7 @@ async def show_main_menu(
         keyboard=get_main_menu_keyboard(
             language=db_user.language,
             is_admin=settings.is_admin(db_user.telegram_id),
+                is_moderator=(not settings.is_admin(db_user.telegram_id) and SupportSettingsService.is_moderator(db_user.telegram_id)),
             has_had_paid_subscription=db_user.has_had_paid_subscription,
             has_active_subscription=has_active_subscription,
             subscription_is_active=subscription_is_active,
@@ -120,6 +122,7 @@ async def handle_back_to_menu(
         keyboard=get_main_menu_keyboard(
             language=db_user.language,
             is_admin=settings.is_admin(db_user.telegram_id),
+                is_moderator=(not settings.is_admin(db_user.telegram_id) and SupportSettingsService.is_moderator(db_user.telegram_id)),
             has_had_paid_subscription=db_user.has_had_paid_subscription,
             has_active_subscription=has_active_subscription,
             subscription_is_active=subscription_is_active,

app/handlers/stars_payments.py

@@ -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,

app/handlers/start.py

@@ -17,7 +17,7 @@ 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
 )
@@ -25,6 +25,7 @@ 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.subscription_service import SubscriptionService
 from app.utils.user_utils import generate_unique_referral_code
 from app.database.crud.user_message import get_random_active_message
 
@@ -591,7 +592,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 +699,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,
@@ -797,7 +816,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 +923,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,
@@ -1105,6 +1142,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,

app/handlers/tickets.py

@@ -374,12 +374,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 +405,19 @@ 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)
+    # Всегда используем фото-рендер с логотипом (утилита сама сделает фоллбек при необходимости)
+    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",
+    )
     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,20 @@ 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)
+    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",
+    )
     await callback.answer()
 
 
@@ -758,7 +760,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 +772,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
@@ -981,6 +989,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,

app/keyboards/admin.py

@@ -10,6 +10,7 @@ def get_admin_main_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     return InlineKeyboardMarkup(inline_keyboard=[
         [InlineKeyboardButton(text="👥 Юзеры/Подписки", callback_data="admin_submenu_users")],
         [InlineKeyboardButton(text="💰 Промокоды/Статистика", callback_data="admin_submenu_promo")],
+        [InlineKeyboardButton(text="🛟 Поддержка", callback_data="admin_submenu_support")],
         [InlineKeyboardButton(text="📨 Сообщения", callback_data="admin_submenu_communications")],
         [InlineKeyboardButton(text="⚙️ Настройки", callback_data="admin_submenu_settings")],
         [InlineKeyboardButton(text="🛠️ Система", callback_data="admin_submenu_system")],
@@ -61,15 +62,28 @@ def get_admin_communications_submenu_keyboard(language: str = "ru") -> InlineKey
         [
             InlineKeyboardButton(text=texts.ADMIN_MESSAGES, callback_data="admin_messages")
         ],
+        [
+            InlineKeyboardButton(text="👋 Приветственный текст", callback_data="welcome_text_panel"),
+            InlineKeyboardButton(text="📢 Сообщения в меню", callback_data="user_messages_panel")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_admin_support_submenu_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+
+    return InlineKeyboardMarkup(inline_keyboard=[
         [
             InlineKeyboardButton(text="🎫 Тикеты поддержки", callback_data="admin_tickets")
         ],
         [
-            InlineKeyboardButton(text="🛟 Настройки поддержки", callback_data="admin_support_settings")
+            InlineKeyboardButton(text="🧾 Аудит модераторов", callback_data="admin_support_audit")
         ],
         [
-            InlineKeyboardButton(text="👋 Приветственный текст", callback_data="welcome_text_panel"),
-            InlineKeyboardButton(text="📢 Сообщения в меню", callback_data="user_messages_panel")
+            InlineKeyboardButton(text="🛟 Настройки поддержки", callback_data="admin_support_settings")
         ],
         [
             InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
@@ -85,6 +99,15 @@ def get_admin_settings_submenu_keyboard(language: str = "ru") -> InlineKeyboardM
             InlineKeyboardButton(text=texts.ADMIN_REMNAWAVE, callback_data="admin_remnawave"),
             InlineKeyboardButton(text=texts.ADMIN_MONITORING, callback_data="admin_monitoring")
         ],
+        [
+            InlineKeyboardButton(text="🧩 Конфигурация бота", callback_data="admin_bot_config"),
+        ],
+        [
+            InlineKeyboardButton(
+                text=texts.t("ADMIN_MONITORING_SETTINGS", "⚙️ Настройки мониторинга"),
+                callback_data="admin_mon_settings"
+            )
+        ],
         [
             InlineKeyboardButton(text=texts.ADMIN_RULES, callback_data="admin_rules"),
             InlineKeyboardButton(text="🔧 Техработы", callback_data="maintenance_panel")
@@ -97,18 +120,36 @@ def get_admin_settings_submenu_keyboard(language: str = "ru") -> InlineKeyboardM
 
 def get_admin_system_submenu_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
-    
+
     return InlineKeyboardMarkup(inline_keyboard=[
         [
             InlineKeyboardButton(text="📄 Обновления", callback_data="admin_updates"),
             InlineKeyboardButton(text="🗄️ Бекапы", callback_data="backup_panel")
         ],
+        [InlineKeyboardButton(text=texts.t("ADMIN_REPORTS", "📊 Отчеты"), callback_data="admin_reports")],
         [
             InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
         ]
     ])
 
 
+def get_admin_reports_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="📆 За вчера", callback_data="admin_reports_daily")],
+        [InlineKeyboardButton(text="🗓️ За неделю", callback_data="admin_reports_weekly")],
+        [InlineKeyboardButton(text="📅 За месяц", callback_data="admin_reports_monthly")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")]
+    ])
+
+
+def get_admin_report_result_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text=texts.t("REPORT_CLOSE", "❌ Закрыть"), callback_data="admin_close_report")]
+    ])
+
+
 def get_admin_users_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     return InlineKeyboardMarkup(inline_keyboard=[
         [

app/keyboards/inline.py

@@ -8,7 +8,11 @@ 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__)
@@ -67,6 +71,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 +91,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 +117,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 +199,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")
@@ -198,10 +236,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 +386,36 @@ 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)
 
     if resume_callback:
-        keyboard.append([
-            InlineKeyboardButton(
-                text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
-                callback_data=resume_callback,
+        keyboard.inline_keyboard.insert(
+            0,
+            [
+                InlineKeyboardButton(
+                    text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
+                    callback_data=resume_callback,
+                )
+            ],
+        )
+
+    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 == "menu_balance"
+        ):
+            keyboard.inline_keyboard[-1][0] = InlineKeyboardButton(
+                text=last_row[0].text,
+                callback_data="back_to_menu",
             )
-        ])
 
-    keyboard.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
-
-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+    return keyboard
 
 
 def get_subscription_keyboard(
@@ -291,14 +430,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 +455,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 +513,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 +545,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 +778,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 +1123,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 +1159,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 +1176,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 +1193,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 +1235,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 +1322,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 +1338,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 +1358,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 +1467,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 +1549,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 +1801,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 +1830,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 +1845,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 +1908,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 = []
@@ -1713,7 +1975,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 +1984,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 +2007,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")

app/localization/locales/en.json

@@ -19,6 +19,16 @@
   "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,6 +47,7 @@
   "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_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",
@@ -126,7 +137,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.",
@@ -403,4 +423,5 @@
   "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."
+  
 }

app/localization/locales/ru.json

@@ -14,7 +14,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": "Промогруппы не найдены.",
@@ -55,6 +64,8 @@
   "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": "Включен - подписка продлится автоматически",
@@ -97,6 +108,16 @@
   "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": "✅ Продолжить",
@@ -121,6 +142,7 @@
   "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_SELECTED": "🌐 Язык интерфейса установлен: <b>Русский</b>",
   "LOADING": "⏳ Загрузка...",
@@ -403,4 +425,5 @@
   "PAYMENT_METHOD_SUPPORT_NAME": "🛠️ <b>Через поддержку</b>",
   "PAYMENT_METHOD_SUPPORT_DESCRIPTION": "другие способы",
   "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку."
+
 }

app/middlewares/auth.py

@@ -23,7 +23,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"

app/middlewares/channel_checker.py

@@ -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("🚫 Отправляем сообщение о необходимости подписки")

app/services/admin_notification_service.py

@@ -3,10 +3,11 @@ 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.models import User, Subscription, Transaction, TransactionType
 from app.database.crud.user import get_user_by_id
 
 logger = logging.getLogger(__name__)
@@ -215,7 +216,17 @@ class AdminNotificationService:
             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)
@@ -341,6 +352,8 @@ class AdminNotificationService:
             'telegram_stars': '⭐ Telegram Stars',
             'yookassa': '💳 YooKassa (карта)',
             'tribute': '💎 Tribute (карта)',
+            'mulenpay': '💳 Mulen Pay (карта)',
+            'pal24': '💳 PayPalych (карта)',
             'manual': '🛠️ Вручную (админ)',
             'balance': '💰 С баланса'
         }
@@ -818,7 +831,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)
 

app/services/backup_service.py

@@ -21,7 +21,9 @@ 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
 )
 
 logger = logging.getLogger(__name__)
@@ -61,29 +63,34 @@ 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,
             BroadcastHistory,
-            UserMessage,
-            
-            SentNotification, 
-            SubscriptionServer,  
+            AdvertisingCampaign,
+            AdvertisingCampaignRegistration,
+            Ticket,
+            TicketMessage,
+            SupportAuditLog,
         ]
-        
+
         if self._settings.include_logs:
             self.backup_models_ordered.append(MonitoringLog)
 
@@ -329,60 +336,47 @@ 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)
-                    
+
                     await db.commit()
                     
                     break
@@ -549,14 +543,64 @@ class BackupService:
                 return col.name
         return None
 
+    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"
+            "ticket_messages", "tickets", "support_audit_logs",
+            "advertising_campaign_registrations", "advertising_campaigns",
+            "subscription_servers", "sent_notifications",
+            "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", "monitoring_logs"
         ]
         
         for table_name in tables_order:

app/services/mulenpay_service.py

@@ -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}")

app/services/notification_settings_service.py

@@ -0,0 +1,249 @@
+import json
+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},
+        "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)
+
+    # 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))

app/services/pal24_service.py

@@ -0,0 +1,116 @@
+"""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,
+    ) -> 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
+
+        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)
+

app/services/payment_service.py

@@ -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,657 @@ 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,
+            )
+        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
+
+        link_url = response.get("link_url")
+        link_page_url = response.get("link_page_url")
+
+        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=link_url,
+            link_page_url=link_page_url,
+            ttl=ttl_seconds,
+            metadata={
+                "raw_response": response,
+                "language": language,
+            },
+        )
+
+        payment_info = {
+            "bill_id": bill_id,
+            "order_id": order_id,
+            "link_url": link_url or link_page_url,
+            "link_page_url": link_page_url,
+            "local_payment_id": payment.id,
+            "amount_kopeks": amount_kopeks,
+        }
+
+        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 (

app/services/promo_group_assignment.py

@@ -0,0 +1,123 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.transaction import get_user_total_spent_kopeks
+from app.database.models import PromoGroup, User
+
+logger = logging.getLogger(__name__)
+
+
+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
+
+    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)
+
+        return target_group
+    except Exception as exc:
+        logger.error(
+            "Ошибка при автоматическом назначении промогруппы пользователю %s: %s",
+            user_id,
+            exc,
+        )
+        await db.rollback()
+        return None

app/services/remnawave_service.py

@@ -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,7 +980,7 @@ 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:
@@ -920,7 +989,7 @@ class RemnaWaveService:
 
     async def delete_squad(self, squad_uuid: str) -> bool:
         try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                 response = await api.delete_internal_squad(squad_uuid)
                 return response
         except Exception as e:
@@ -929,7 +998,7 @@ class RemnaWaveService:
 
     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 +1019,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
@@ -963,7 +1032,7 @@ class RemnaWaveService:
 
     async def create_squad(self, name: str, inbound_uuids: List[str]) -> bool:
         try:
-            async with self.api as api:
+            async with self.get_api_client() as api:
                 squad = await api.create_internal_squad(name, inbound_uuids)
                 return squad is not None
         except Exception as e:
@@ -972,7 +1041,7 @@ class RemnaWaveService:
 
     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 +1119,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 +1182,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 +1206,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 +1270,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 +1360,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 +1609,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

app/services/reporting_service.py

@@ -0,0 +1,351 @@
+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,
+    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"• Оплат подписок: {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)
+        return {
+            "active_trials": stats.get("trial_subscriptions", 0) or 0,
+            "active_paid": stats.get("paid_subscriptions", 0) or 0,
+        }
+
+    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
+
+        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,
+        }
+
+    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()
+

app/services/subscription_checkout_service.py

@@ -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

app/services/subscription_service.py

@@ -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()
@@ -130,7 +150,8 @@ class SubscriptionService:
                     )
                 
                 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()
@@ -190,6 +211,7 @@ class SubscriptionService:
                 )
                 
                 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 "истёкшим"
@@ -233,6 +255,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 +322,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 +384,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 +428,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 +469,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 +486,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 +557,7 @@ class SubscriptionService:
                 
                 subscription.remnawave_short_uuid = None
                 subscription.subscription_url = ""
+                subscription.subscription_crypto_link = ""
                 subscription.connected_squads = []
                 
                 user.remnawave_uuid = None
@@ -518,9 +573,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 +587,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 +639,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 +707,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 +757,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 +801,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 +878,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 +901,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 +928,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",

app/services/support_settings_service.py

@@ -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
+

app/services/system_settings_service.py

@@ -0,0 +1,679 @@
+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 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": "Поддержка",
+        "ADMIN_NOTIFICATIONS": "Уведомления администраторов",
+        "ADMIN_REPORTS": "Автоотчеты",
+        "CHANNEL": "Обязательная подписка на канал",
+        "DATABASE": "База данных",
+        "POSTGRES": "PostgreSQL",
+        "SQLITE": "SQLite",
+        "REDIS": "Redis",
+        "REMNAWAVE": "Remnawave API",
+        "TRIAL": "Триал подписка",
+        "PAID_SUBSCRIPTION": "Платная подписка",
+        "SUBSCRIPTIONS_GLOBAL": "Глобальные параметры подписок",
+        "TRAFFIC": "Настройки трафика",
+        "PERIODS": "Периоды подписки",
+        "SUBSCRIPTION_PRICES": "Цены подписки",
+        "TRAFFIC_PACKAGES": "Пакеты трафика",
+        "DISCOUNTS": "Скидки промогрупп",
+        "REFERRAL": "Реферальная система",
+        "AUTOPAY": "Автопродление",
+        "TELEGRAM": "Telegram Stars",
+        "TRIBUTE": "Tribute",
+        "YOOKASSA": "YooKassa",
+        "CRYPTOBOT": "CryptoBot",
+        "MULENPAY": "MulenPay",
+        "PAL24": "PayPalych / Pal24",
+        "PAYMENT": "Описания платежей",
+        "INTERFACE_BRANDING": "Брендинг и логотип",
+        "INTERFACE_SUBSCRIPTION": "Блок подписки",
+        "CONNECT_BUTTON": "Кнопка «Подключиться»",
+        "HAPP": "Happ CryptoLink",
+        "SKIP": "Пропуски onboarding",
+        "MONITORING": "Мониторинг",
+        "NOTIFICATIONS": "Уведомления",
+        "SERVER": "Статус серверов",
+        "MAINTENANCE": "Технические работы",
+        "LOCALIZATION": "Локализация",
+        "ADDITIONAL": "Дополнительные настройки",
+        "BACKUP": "Бекапы",
+        "VERSION": "Проверка обновлений",
+        "LOG": "Логирование",
+        "WEBHOOK": "Вебхуки",
+        "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": "SUBSCRIPTIONS_GLOBAL",
+        "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",
+    }
+
+    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",
+        "MONITORING_": "MONITORING",
+        "NOTIFICATION_": "NOTIFICATIONS",
+        "SERVER_STATUS": "SERVER",
+        "MAINTENANCE_": "MAINTENANCE",
+        "VERSION_CHECK": "VERSION",
+        "BACKUP_": "BACKUP",
+        "WEBHOOK_": "WEBHOOK",
+        "LOG_": "LOG",
+        "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)
+
+    @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)
+
+    @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)
+
+    @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)
+
+    @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
+

app/services/user_service.py

@@ -17,7 +17,8 @@ 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
 )
 from app.config import settings
 
@@ -359,7 +360,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 +494,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 +509,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 +632,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 +641,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:

app/states.py

@@ -68,20 +68,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 +95,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()
@@ -116,6 +123,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()

app/utils/cache.py

@@ -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:

app/utils/payment_utils.py

@@ -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

app/utils/pricing_utils.py

@@ -1,5 +1,4 @@
 from datetime import datetime, timedelta
-from datetime import datetime
 from typing import Tuple
 import logging
 

app/utils/subscription_utils.py

@@ -1,9 +1,11 @@
 import logging
 from datetime import datetime
 from typing import Optional
-from sqlalchemy import select, delete
+from urllib.parse import quote
+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,49 @@ 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}"

locales/en.json

@@ -2,6 +2,7 @@
   "ADD_COUNTRIES_BUTTON": "🌐 Add countries",
   "ADMIN_MAIN_MENU": "🏠 Main menu",
   "ADMIN_CAMPAIGNS": "📣 Promotional campaigns",
+  "ADMIN_REPORTS": "📊 Reports",
   "AUTOPAY_BUTTON": "💳 Auto payment",
   "AUTOPAY_SET_DAYS_BUTTON": "⚙️ Configure days",
   "BACK": "⬅️ Back",
@@ -19,6 +20,16 @@
   "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,6 +48,7 @@
   "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_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",
@@ -56,6 +68,8 @@
   "PAGINATION_PREV": "⬅️",
   "PAYMENTS_TEMPORARILY_UNAVAILABLE": "⚠️ Payment methods are temporarily unavailable",
   "PAYMENT_CARD_TRIBUTE": "💳 Bank card (Tribute)",
+  "PAYMENT_CARD_MULENPAY": "💳 Bank card (Mulen Pay)",
+  "PAYMENT_CARD_PAL24": "💳 Bank card (PayPalych)",
   "PAYMENT_CARD_YOOKASSA": "💳 Bank card (YooKassa)",
   "PAYMENT_CRYPTOBOT": "🪙 Cryptocurrency (CryptoBot)",
   "PAYMENT_SBP_YOOKASSA": "🏦 Pay via SBP (YooKassa)",
@@ -63,6 +77,14 @@
   "PAYMENT_VIA_SUPPORT": "🛠️ Via support",
   "PAY_NOW_BUTTON": "💳 Pay",
   "PAY_WITH_COINS_BUTTON": "🪙 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.",
+  "MULENPAY_PAYMENT_ERROR": "❌ Failed to create Mulen Pay payment. Please try again later or contact support.",
+  "MULENPAY_PAY_BUTTON": "💳 Pay with Mulen Pay",
+  "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}",
+  "PAL24_TOPUP_PROMPT": "💳 <b>PayPalych payment</b>\n\nEnter an amount between 100 and 1,000,000 ₽.\nThe payment is processed by the secure PayPalych platform.",
+  "PAL24_PAYMENT_ERROR": "❌ Failed to create a PayPalych payment. Please try again later or contact support.",
+  "PAL24_PAY_BUTTON": "💳 Pay with PayPalych",
+  "PAL24_PAYMENT_INSTRUCTIONS": "💳 <b>PayPalych payment</b>\n\n💰 Amount: {amount}\n🆔 Invoice ID: {bill_id}\n\n📱 <b>How to pay:</b>\n1. Press ‘Pay with PayPalych’\n2. Follow the system prompts\n3. Confirm the transfer\n4. Funds will be credited automatically\n\n❓ Need help? Contact {support}",
   "PENDING_CANCEL_BUTTON": "⌛ Cancel",
   "POST_REGISTRATION_TRIAL_BUTTON": "🚀 Activate free trial 🚀",
   "REFERRAL_ANALYTICS_BUTTON": "📊 Analytics",
@@ -95,6 +117,7 @@
   "SUB_STATUS_TRIAL_TODAY": "🎁 Trial subscription\n⚠️ expires today!",
   "SUB_STATUS_TRIAL_TOMORROW": "🎁 Trial subscription\n⚠️ expires tomorrow!",
   "SUBSCRIPTION_ACTIVE": "✅ Active",
+  "SUBSCRIPTION_EXTEND": "💎 Extend subscription",
   "SUCCESS": "✅ Success",
   "REGISTRATION_COMPLETING": "✅ Completing registration...",
   "SWITCH_TRAFFIC_BUTTON": "🔄 Switch traffic",
@@ -117,6 +140,7 @@
   "ACCESS_DENIED": "❌ Access denied",
   "ADMIN_MESSAGES": "📨 Broadcasts",
   "ADMIN_MONITORING": "🔍 Monitoring",
+  "ADMIN_MONITORING_SETTINGS": "⚙️ Monitoring settings",
   "ADMIN_PANEL": "\n⚙️ <b>Administration panel</b>\n\nSelect a section to manage:\n",
   "ADMIN_PROMOCODES": "🎫 Promo codes",
   "ADMIN_REFERRALS": "🤝 Referral program",
@@ -126,13 +150,24 @@
   "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_GROUP_PERIOD_DISCOUNTS_HEADER": "⏳ Period discounts:",
   "ADMIN_PROMO_GROUPS_DEFAULT_LABEL": " (default)",
   "ADMIN_PROMO_GROUPS_MEMBERS_COUNT": "Members: {count}",
   "ADMIN_PROMO_GROUPS_EMPTY": "No promo groups found.",
   "CREATE_TICKET_BUTTON": "🎫 Create ticket",
   "MY_TICKETS_BUTTON": "📋 My tickets",
   "CONTACT_SUPPORT_BUTTON": "💬 Contact support",
+  "SUPPORT_BUTTON": "🆘 Support",
   "TICKET_PRIORITY_SELECT": "Select ticket priority:",
   "TICKET_PRIORITY_LOW": "🟢 Low",
   "TICKET_PRIORITY_NORMAL": "🟡 Normal",
@@ -178,6 +213,9 @@
   "MARK_AS_ANSWERED": "✅ Mark as answered",
   "TICKET_REPLY_NOTIFICATION": "🎫 Reply received for ticket #{ticket_id}\n\n{reply_preview}\n\nClick the button below to go to the ticket:",
   "CLOSE_NOTIFICATION": "❌ Close notification",
+  "REPORT_CLOSE": "❌ Close",
+  "REPORT_CLOSED": "✅ Report closed.",
+  "REPORT_CLOSE_ERROR": "❌ Failed to close the report.",
   "NOTIFICATION_CLOSED": "Notification closed.",
   "UNBLOCK": "✅ Unblock",
   "BLOCK_FOREVER": "🚫 Block permanently",
@@ -214,14 +252,30 @@
   "ADMIN_PROMO_GROUP_CREATE_TRAFFIC_PROMPT": "Enter traffic discount (0-100):",
   "ADMIN_PROMO_GROUP_CREATE_SERVERS_PROMPT": "Enter server discount (0-100):",
   "ADMIN_PROMO_GROUP_CREATE_DEVICES_PROMPT": "Enter device discount (0-100):",
+  "ADMIN_PROMO_GROUP_CREATE_PERIOD_PROMPT": "Enter subscription period discounts (e.g. 30:10, 90:15). Send 0 if none.",
   "ADMIN_PROMO_GROUP_INVALID_PERCENT": "Enter a number from 0 to 100.",
+  "ADMIN_PROMO_GROUP_INVALID_PERIOD_DISCOUNTS": "Enter period:discount pairs separated by commas, e.g. 30:10, 90:15, or 0.",
   "ADMIN_PROMO_GROUP_CREATED": "Promo group “{name}” created.",
   "ADMIN_PROMO_GROUP_CREATED_BACK_BUTTON": "↩️ Back to promo groups",
   "ADMIN_PROMO_GROUP_EDIT_NAME_PROMPT": "Enter a new name (current: {name}):",
-  "ADMIN_PROMO_GROUP_EDIT_TRAFFIC_PROMPT": "Enter new traffic discount (0-100):",
-  "ADMIN_PROMO_GROUP_EDIT_SERVERS_PROMPT": "Enter new server discount (0-100):",
-  "ADMIN_PROMO_GROUP_EDIT_DEVICES_PROMPT": "Enter new device discount (0-100):",
+  "ADMIN_PROMO_GROUP_EDIT_TRAFFIC_PROMPT": "Enter new traffic discount (0-100). Current value: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_SERVERS_PROMPT": "Enter new server discount (0-100). Current value: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_DEVICES_PROMPT": "Enter new device discount (0-100). Current value: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_PERIOD_PROMPT": "Enter new period discounts (current: {current}). Send 0 if none.",
   "ADMIN_PROMO_GROUP_UPDATED": "Promo group “{name}” updated.",
+  "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_EDIT_MENU_TITLE": "✏️ Promo group settings “{name}”",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_HINT": "Select a parameter to change:",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_NAME": "✏️ Rename",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_TRAFFIC": "🌐 Traffic discount",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_SERVERS": "🖥 Server discount",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_DEVICES": "📱 Device discount",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_PERIODS": "⏳ Period discounts",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_AUTO_ASSIGN": "🤖 Auto assignment by spending",
+  "ADMIN_PROMO_GROUP_CREATE_AUTO_ASSIGN_PROMPT": "Enter total spending (in ₽) required for automatic assignment. Send 0 to disable.",
+  "ADMIN_PROMO_GROUP_INVALID_AUTO_ASSIGN": "Enter a non-negative amount in rubles or 0 to disable.",
+  "ADMIN_PROMO_GROUP_EDIT_AUTO_ASSIGN_PROMPT": "Enter total spending (in ₽) for auto assignment. Current value: {current}.",
   "ADMIN_PROMO_GROUP_MEMBERS_TITLE": "👥 Members of {name}",
   "ADMIN_PROMO_GROUP_MEMBERS_EMPTY": "This group has no members yet.",
   "ADMIN_PROMO_GROUP_DELETE_FORBIDDEN": "The default promo group cannot be deleted.",
@@ -239,6 +293,7 @@
   "BALANCE_INFO": "\n💰 <b>Balance: {balance}</b>\n\nChoose an action:\n",
   "BALANCE_SUPPORT_REQUEST": "🛠️ Request via support",
   "BALANCE_TOP_UP": "💳 Top up",
+  "BALANCE_TOPUP": "💳 Top up balance",
   "CAMPAIGN_EXISTING_USER": "ℹ️ This promo link is available only to new users.",
   "CAMPAIGN_BONUS_BALANCE": "🎉 You received {amount} for registering via the \"{name}\" campaign!",
   "CAMPAIGN_BONUS_SUBSCRIPTION": "🎉 You’ve been granted a {days}-day subscription (traffic: {traffic}, devices: {devices}) from the \"{name}\" campaign!",
@@ -349,6 +404,7 @@
   "SUBSCRIPTION_CONNECT_LINK_PROMPT": "📱 Copy the link and add it to your VPN app",
   "SUBSCRIPTION_IMPORT_LINK_SECTION": "🔗 <b>Your import link for the VPN app:</b>\n<code>{subscription_url}</code>",
   "SUBSCRIPTION_IMPORT_INSTRUCTION_PROMPT": "📱 Tap the button below to get setup instructions for your device",
+  "SUBSCRIPTION_HAPP_LINK_PROMPT": "🔒 Subscription link is ready. Tap the \"Connect\" button below to open it in Happ.",
   "BACK_TO_MAIN_MENU_BUTTON": "⬅️ Back to main menu",
   "CUSTOM_MINIAPP_URL_NOT_SET": "⚠ Custom mini-app link is not configured",
   "SUBSCRIPTION_LINK_GENERATING_NOTICE": "{purchase_text}\n\nThe link is being generated, open the 'My subscription' section in a few seconds.",
@@ -360,6 +416,10 @@
   "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>",
+  "SUBSCRIPTION_HAPP_OPEN_TITLE": "🔗 <b>Connect via Happ</b>",
+  "SUBSCRIPTION_HAPP_OPEN_LINK": "<a href=\"{subscription_link}\">🔓 Open link in Happ</a>",
+  "SUBSCRIPTION_HAPP_OPEN_HINT": "💡 If the link doesn't open automatically, copy it manually: <code>{subscription_link}</code>",
+  "SUBSCRIPTION_HAPP_OPEN_BUTTON_HINT": "▶️ Tap the \"Connect\" button below to open Happ and add the subscription automatically.",
   "SUBSCRIPTION_DEVICE_LINK_TITLE": "🔗 <b>Subscription link:</b>",
   "SUBSCRIPTION_DEVICE_FEATURED_APP": "📋 <b>Recommended app:</b> {app_name}",
   "SUBSCRIPTION_DEVICE_STEP_INSTALL_TITLE": "<b>Step 1 - Install:</b>",
@@ -444,9 +504,31 @@
   "PAYMENT_METHOD_YOOKASSA_DESCRIPTION": "via YooKassa",
   "PAYMENT_METHOD_TRIBUTE_NAME": "💳 <b>Bank card</b>",
   "PAYMENT_METHOD_TRIBUTE_DESCRIPTION": "via Tribute",
+  "PAYMENT_METHOD_MULENPAY_NAME": "💳 <b>Bank card (Mulen Pay)</b>",
+  "PAYMENT_METHOD_MULENPAY_DESCRIPTION": "via Mulen Pay",
+  "PAYMENT_METHOD_PAL24_NAME": "💳 <b>Bank card (PayPalych)</b>",
+  "PAYMENT_METHOD_PAL24_DESCRIPTION": "via PayPalych",
   "PAYMENT_METHOD_CRYPTOBOT_NAME": "🪙 <b>Cryptocurrency</b>",
   "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.",
+  "TRIAL_INACTIVE_1H": "⏳ <b>An hour has passed and we haven't seen any traffic yet</b>\n\nOpen the connection guide and follow the steps. We're always ready to help!",
+  "TRIAL_INACTIVE_24H": "⏳ <b>A full day passed without activity</b>\n\nWe still don't see traffic from your test subscription. Use the guide or message support and we'll help you connect!",
+  "SUBSCRIPTION_EXPIRED_1D": "⛔ <b>Your subscription expired</b>\n\nAccess was disabled on {end_date}. Renew to return to the service.\n\n💎 Renewal price: {price}",
+  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>{percent}% discount on renewal</b>\n\nTap “Get discount” and we'll add {bonus} to your balance. The offer is valid until {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Personal {percent}% discount</b>\n\nIt's been {trigger_days} days without a subscription. Come back — tap “Get discount” and {bonus} will be credited. Offer valid until {expires_at}.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 Discount of {percent}% activated! {amount} credited to your balance.",
+  "DISCOUNT_CLAIM_ALREADY": "ℹ️ This discount has already been activated.",
+  "DISCOUNT_CLAIM_EXPIRED": "⚠️ The offer has expired.",
+  "DISCOUNT_CLAIM_NOT_FOUND": "❌ Offer not found.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Failed to credit the discount. Please try again later.",
+  "DISCOUNT_BONUS_DESCRIPTION": "Renewal discount bonus",
+  "NOTIFICATION_VALUE_INVALID": "❌ Invalid value, please enter a number.",
+  "NOTIFICATION_VALUE_UPDATED": "✅ Settings updated.",
+  "NOTIFY_PROMPT_SECOND_PERCENT": "Enter a new discount percentage for the 2-3 day reminder (0-100):",
+  "NOTIFY_PROMPT_SECOND_HOURS": "Enter the number of hours the discount is active (1-168):",
+  "NOTIFY_PROMPT_THIRD_PERCENT": "Enter a new discount percentage for the late offer (0-100):",
+  "NOTIFY_PROMPT_THIRD_HOURS": "Enter the number of hours the late discount is active (1-168):",
+  "NOTIFY_PROMPT_THIRD_DAYS": "After how many days without a subscription should we send the offer? (minimum 2):"
 }

locales/ru.json

@@ -5,6 +5,8 @@
   "ADMIN_CAMPAIGNS": "📣 Рекламные кампании",
   "ADMIN_MESSAGES": "📨 Рассылки",
   "ADMIN_MONITORING": "🔍 Мониторинг",
+  "ADMIN_MONITORING_SETTINGS": "⚙️ Настройки мониторинга",
+  "ADMIN_REPORTS": "📊 Отчеты",
   "ADMIN_PANEL": "\n⚙️ <b>Административная панель</b>\n\nВыберите раздел для управления:\n",
   "ADMIN_PROMOCODES": "🎫 Промокоды",
   "ADMIN_REFERRALS": "🤝 Партнерка",
@@ -14,13 +16,24 @@
   "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_GROUP_PERIOD_DISCOUNTS_HEADER": "⏳ Скидки по периодам:",
   "ADMIN_PROMO_GROUPS_DEFAULT_LABEL": " (базовая)",
   "ADMIN_PROMO_GROUPS_MEMBERS_COUNT": "Участников: {count}",
   "ADMIN_PROMO_GROUPS_EMPTY": "Промогруппы не найдены.",
   "CREATE_TICKET_BUTTON": "🎫 Создать тикет",
   "MY_TICKETS_BUTTON": "📋 Мои тикеты",
   "CONTACT_SUPPORT_BUTTON": "💬 Связаться с поддержкой",
+  "SUPPORT_BUTTON": "🆘 Поддержка",
   "TICKET_PRIORITY_SELECT": "Выберите приоритет тикета:",
   "TICKET_PRIORITY_LOW": "🟢 Низкий",
   "TICKET_PRIORITY_NORMAL": "🟡 Обычный",
@@ -30,7 +43,7 @@
   "TICKET_TITLE_INPUT": "Введите заголовок тикета:",
   "TICKET_TITLE_TOO_SHORT": "Заголовок должен содержать минимум 5 символов. Попробуйте еще раз:",
   "TICKET_TITLE_TOO_LONG": "Заголовок слишком длинный. Максимум 255 символов. Попробуйте еще раз:",
-  "TICKET_MESSAGE_INPUT": "Опишите проблему (до 500 символов) или отправьте фото без текста:",
+  "TICKET_MESSAGE_INPUT": "Опишите проблему (до 500 символов) или отправьте фото c подписью:",
   "TICKET_MESSAGE_TOO_SHORT": "Сообщение должно содержать минимум 10 символов. Попробуйте еще раз:",
   "TICKET_CREATED_SUCCESS": "✅ Тикет #{ticket_id} успешно создан!\n\nЗаголовок: {title}\n\nМы ответим вам в ближайшее время.",
   "VIEW_TICKET": "👁️ Посмотреть тикет",
@@ -66,9 +79,12 @@
   "MARK_AS_ANSWERED": "✅ Отметить как отвеченный",
   "TICKET_REPLY_NOTIFICATION": "🎫 Получен ответ по тикету #{ticket_id}\n\n{reply_preview}\n\nНажмите кнопку ниже, чтобы перейти к тикету:",
   "CLOSE_NOTIFICATION": "❌ Закрыть уведомление",
+  "REPORT_CLOSE": "❌ Закрыть",
+  "REPORT_CLOSED": "✅ Отчет закрыт.",
+  "REPORT_CLOSE_ERROR": "❌ Не удалось закрыть отчет.",
   "NOTIFICATION_CLOSED": "Уведомление закрыто.",
   "UNBLOCK": "✅ Разблокировать",
-  "BLOCK_FOREVER": "🚫 Блок навсегда",
+  "BLOCK_FOREVER": "🚫 Заблокировать",
   "BLOCK_BY_TIME": "⏳ Блокировка по времени",
   "ENTER_BLOCK_MINUTES": "Введите количество минут для блокировки пользователя (например, 15):",
   "TICKET_ATTACHMENTS": "📎 Вложения",
@@ -102,14 +118,30 @@
   "ADMIN_PROMO_GROUP_CREATE_TRAFFIC_PROMPT": "Введите скидку на трафик (0-100):",
   "ADMIN_PROMO_GROUP_CREATE_SERVERS_PROMPT": "Введите скидку на серверы (0-100):",
   "ADMIN_PROMO_GROUP_CREATE_DEVICES_PROMPT": "Введите скидку на устройства (0-100):",
+  "ADMIN_PROMO_GROUP_CREATE_PERIOD_PROMPT": "Введите скидки на периоды подписки (например, 30:10, 90:15). Отправьте 0, если без скидок.",
   "ADMIN_PROMO_GROUP_INVALID_PERCENT": "Введите число от 0 до 100.",
+  "ADMIN_PROMO_GROUP_INVALID_PERIOD_DISCOUNTS": "Введите пары период:скидка через запятую, например 30:10, 90:15, или 0.",
   "ADMIN_PROMO_GROUP_CREATED": "Промогруппа «{name}» создана.",
   "ADMIN_PROMO_GROUP_CREATED_BACK_BUTTON": "↩️ К промогруппам",
   "ADMIN_PROMO_GROUP_EDIT_NAME_PROMPT": "Введите новое название промогруппы (текущее: {name}):",
-  "ADMIN_PROMO_GROUP_EDIT_TRAFFIC_PROMPT": "Введите новую скидку на трафик (0-100):",
-  "ADMIN_PROMO_GROUP_EDIT_SERVERS_PROMPT": "Введите новую скидку на серверы (0-100):",
-  "ADMIN_PROMO_GROUP_EDIT_DEVICES_PROMPT": "Введите новую скидку на устройства (0-100):",
+  "ADMIN_PROMO_GROUP_EDIT_TRAFFIC_PROMPT": "Введите новую скидку на трафик (0-100). Текущее значение: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_SERVERS_PROMPT": "Введите новую скидку на серверы (0-100). Текущее значение: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_DEVICES_PROMPT": "Введите новую скидку на устройства (0-100). Текущее значение: {current}.",
+  "ADMIN_PROMO_GROUP_EDIT_PERIOD_PROMPT": "Введите новые скидки на периоды (текущие: {current}). Отправьте 0, если без скидок.",
   "ADMIN_PROMO_GROUP_UPDATED": "Промогруппа «{name}» обновлена.",
+  "ADMIN_PROMO_GROUP_AUTO_ASSIGN_DISABLED": "Автовыдача по суммарным тратам: отключена",
+  "ADMIN_PROMO_GROUP_AUTO_ASSIGN_LINE": "Автовыдача по суммарным тратам: от {amount} ₽",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_TITLE": "✏️ Настройки промогруппы «{name}»",
+  "ADMIN_PROMO_GROUP_EDIT_MENU_HINT": "Выберите параметр для изменения:",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_NAME": "✏️ Изменить название",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_TRAFFIC": "🌐 Скидка на трафик",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_SERVERS": "🖥 Скидка на серверы",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_DEVICES": "📱 Скидка на устройства",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_PERIODS": "⏳ Скидки по периодам",
+  "ADMIN_PROMO_GROUP_EDIT_FIELD_AUTO_ASSIGN": "🤖 Автовыдача по тратам",
+  "ADMIN_PROMO_GROUP_CREATE_AUTO_ASSIGN_PROMPT": "Введите сумму общих трат (в ₽) для автоматической выдачи этой группы. Отправьте 0, чтобы отключить.",
+  "ADMIN_PROMO_GROUP_INVALID_AUTO_ASSIGN": "Введите неотрицательное число в рублях или 0 для отключения.",
+  "ADMIN_PROMO_GROUP_EDIT_AUTO_ASSIGN_PROMPT": "Введите сумму общих трат (в ₽) для автовыдачи. Текущее значение: {current}.",
   "ADMIN_PROMO_GROUP_MEMBERS_TITLE": "👥 Участники группы {name}",
   "ADMIN_PROMO_GROUP_MEMBERS_EMPTY": "В этой группе пока нет участников.",
   "ADMIN_PROMO_GROUP_DELETE_FORBIDDEN": "Базовую промогруппу нельзя удалить.",
@@ -132,6 +164,7 @@
   "BALANCE_INFO": "\n💰 <b>Баланс: {balance}</b>\n\nВыберите действие:\n",
   "BALANCE_SUPPORT_REQUEST": "🛠️ Запрос через поддержку",
   "BALANCE_TOP_UP": "💳 Пополнить",
+  "BALANCE_TOPUP": "💳 Пополнить баланс",
   "CAMPAIGN_EXISTING_USER": "ℹ️ Эта рекламная ссылка доступна только новым пользователям.",
   "CAMPAIGN_BONUS_BALANCE": "🎉 Вы получили {amount} за регистрацию по кампании «{name}»!",
   "CAMPAIGN_BONUS_SUBSCRIPTION": "🎉 Вам выдана подписка на {days} д. (трафик: {traffic}, устройств: {devices}) по кампании «{name}»!",
@@ -159,6 +192,16 @@
   "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": "✅ Продолжить",
@@ -183,6 +226,7 @@
   "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_SELECTED": "🌐 Язык интерфейса установлен: <b>Русский</b>",
   "LOADING": "⏳ Загрузка...",
@@ -214,6 +258,8 @@
   "PAGINATION_PREV": "⬅️",
   "PAYMENTS_TEMPORARILY_UNAVAILABLE": "⚠️ Способы оплаты временно недоступны",
   "PAYMENT_CARD_TRIBUTE": "💳 Банковская карта (Tribute)",
+  "PAYMENT_CARD_MULENPAY": "💳 Банковская карта (Mulen Pay)",
+  "PAYMENT_CARD_PAL24": "💳 Банковская карта (PayPalych)",
   "PAYMENT_CARD_YOOKASSA": "💳 Банковская карта (YooKassa)",
   "PAYMENT_CRYPTOBOT": "🪙 Криптовалюта (CryptoBot)",
   "PAYMENT_SBP_YOOKASSA": "🏬 Оплатить по СБП (YooKassa)",
@@ -221,6 +267,14 @@
   "PAYMENT_VIA_SUPPORT": "🛠️ Через поддержку",
   "PAY_NOW_BUTTON": "💳 Оплатить",
   "PAY_WITH_COINS_BUTTON": "🪙 Оплатить",
+  "MULENPAY_TOPUP_PROMPT": "💳 <b>Оплата через Mulen Pay</b>\n\nВведите сумму для пополнения от 100 до 100 000 ₽.\nОплата происходит через защищенную платформу Mulen Pay.",
+  "MULENPAY_PAYMENT_ERROR": "❌ Ошибка создания платежа Mulen Pay. Попробуйте позже или обратитесь в поддержку.",
+  "MULENPAY_PAY_BUTTON": "💳 Оплатить через 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}",
+  "PAL24_TOPUP_PROMPT": "💳 <b>Оплата через PayPalych</b>\n\nВведите сумму для пополнения от 100 до 1 000 000 ₽.\nОплата проходит через защищенную платформу PayPalych.",
+  "PAL24_PAYMENT_ERROR": "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+  "PAL24_PAY_BUTTON": "💳 Оплатить через 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}",
   "PENDING_CANCEL_BUTTON": "⌛ Отмена",
   "PERIOD_14_DAYS": "📅 14 дней - {settings.format_price(settings.PRICE_14_DAYS)}",
   "PERIOD_180_DAYS": "📅 180 дней - {settings.format_price(settings.PRICE_180_DAYS)}",
@@ -265,6 +319,7 @@
   "SHOW_SUBSCRIPTION_LINK": "📋 Показать ссылку подписки",
   "SKIP_BUTTON": "⏭️ Пропустить",
   "SUBSCRIPTION_ACTIVE": "✅ Активна",
+  "SUBSCRIPTION_EXTEND": "💎 Продлить подписку",
   "SUBSCRIPTION_EXPIRED": "\n❌ <b>Подписка истекла</b>\n\nВаша подписка истекла. Для восстановления доступа продлите подписку.\n",
   "SUBSCRIPTION_EXPIRING": "\n⚠️ <b>Подписка истекает!</b>\n\nВаша подписка истекает через {days} дней.\n\nНе забудьте продлить подписку, чтобы не потерять доступ к серверам.\n",
   "SUBSCRIPTION_EXPIRING_PAID": "\n⚠️ <b>Подписка истекает через {days_text}!</b>\n\nВаша платная подписка истекает {end_date}.\n\n💳 <b>Автоплатеж:</b> {autopay_status}\n\n{action_text}\n",
@@ -349,6 +404,7 @@
   "SUBSCRIPTION_CONNECT_LINK_PROMPT": "📱 Скопируйте ссылку и добавьте в ваше VPN приложение",
   "SUBSCRIPTION_IMPORT_LINK_SECTION": "🔗 <b>Ваша ссылка для импорта в VPN приложение:</b>\n<code>{subscription_url}</code>",
   "SUBSCRIPTION_IMPORT_INSTRUCTION_PROMPT": "📱 Нажмите кнопку ниже, чтобы получить инструкцию по настройке VPN на вашем устройстве",
+  "SUBSCRIPTION_HAPP_LINK_PROMPT": "🔒 Ссылка на подписку создана. Нажмите кнопку \"Подключиться\" ниже, чтобы открыть её в Happ.",
   "BACK_TO_MAIN_MENU_BUTTON": "⬅️ В главное меню",
   "CUSTOM_MINIAPP_URL_NOT_SET": "⚠ Кастомная ссылка для мини-приложения не настроена",
   "SUBSCRIPTION_LINK_GENERATING_NOTICE": "{purchase_text}\n\nСсылка генерируется, перейдите в раздел 'Моя подписка' через несколько секунд.",
@@ -360,6 +416,10 @@
   "SUBSCRIPTION_LINK_UNAVAILABLE": "❌ Ссылка подписки недоступна",
   "SUBSCRIPTION_DEVICE_APPS_NOT_FOUND": "❌ Приложения для этого устройства не найдены",
   "SUBSCRIPTION_DEVICE_GUIDE_TITLE": "📱 <b>Настройка для {device_name}</b>",
+  "SUBSCRIPTION_HAPP_OPEN_TITLE": "🔗 <b>Подключение через Happ</b>",
+  "SUBSCRIPTION_HAPP_OPEN_LINK": "<a href=\"{subscription_link}\">🔓 Открыть ссылку в Happ</a>",
+  "SUBSCRIPTION_HAPP_OPEN_HINT": "💡 Если ссылка не открывается автоматически, скопируйте её вручную: <code>{subscription_link}</code>",
+  "SUBSCRIPTION_HAPP_OPEN_BUTTON_HINT": "▶️ Нажмите кнопку \"Подключиться\" ниже, чтобы открыть Happ и добавить подписку автоматически.",
   "SUBSCRIPTION_DEVICE_LINK_TITLE": "🔗 <b>Ссылка подписки:</b>",
   "SUBSCRIPTION_DEVICE_FEATURED_APP": "📋 <b>Рекомендуемое приложение:</b> {app_name}",
   "SUBSCRIPTION_DEVICE_STEP_INSTALL_TITLE": "<b>Шаг 1 - Установка:</b>",
@@ -444,9 +504,31 @@
   "PAYMENT_METHOD_YOOKASSA_DESCRIPTION": "через YooKassa",
   "PAYMENT_METHOD_TRIBUTE_NAME": "💳 <b>Банковская карта</b>",
   "PAYMENT_METHOD_TRIBUTE_DESCRIPTION": "через Tribute",
+  "PAYMENT_METHOD_MULENPAY_NAME": "💳 <b>Банковская карта (Mulen Pay)</b>",
+  "PAYMENT_METHOD_MULENPAY_DESCRIPTION": "через Mulen Pay",
+  "PAYMENT_METHOD_PAL24_NAME": "💳 <b>Банковская карта (PayPalych)</b>",
+  "PAYMENT_METHOD_PAL24_DESCRIPTION": "через PayPalych",
   "PAYMENT_METHOD_CRYPTOBOT_NAME": "🪙 <b>Криптовалюта</b>",
   "PAYMENT_METHOD_CRYPTOBOT_DESCRIPTION": "через CryptoBot",
   "PAYMENT_METHOD_SUPPORT_NAME": "🛠️ <b>Через поддержку</b>",
   "PAYMENT_METHOD_SUPPORT_DESCRIPTION": "другие способы",
-  "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку."
+  "PAYMENT_METHODS_UNAVAILABLE_ALERT": "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку.",
+  "TRIAL_INACTIVE_1H": "⏳ <b>Прошёл час, а подключение не выполнено</b>\n\nЕсли возникли сложности — откройте инструкцию и следуйте шагам. Мы всегда готовы помочь!",
+  "TRIAL_INACTIVE_24H": "⏳ <b>Прошли сутки с начала теста</b>\n\nМы не видим трафика по вашей подписке. Загляните в инструкцию или напишите в поддержку — поможем подключиться!",
+  "SUBSCRIPTION_EXPIRED_1D": "⛔ <b>Подписка закончилась</b>\n\nДоступ был отключён {end_date}. Продлите подписку, чтобы вернуть полный доступ.\n\n💎 Стоимость продления: {price}",
+  "SUBSCRIPTION_EXPIRED_SECOND_WAVE": "🔥 <b>Скидка {percent}% на продление</b>\n\nНажмите «Получить скидку», и мы начислим {bonus} на ваш баланс. Предложение действительно до {expires_at}.",
+  "SUBSCRIPTION_EXPIRED_THIRD_WAVE": "🎁 <b>Индивидуальная скидка {percent}%</b>\n\nПрошло {trigger_days} дней без подписки. Вернитесь — нажмите «Получить скидку», и {bonus} поступит на баланс. Предложение действительно до {expires_at}.",
+  "DISCOUNT_CLAIM_SUCCESS": "🎉 Скидка {percent}% активирована! На баланс начислено {amount}.",
+  "DISCOUNT_CLAIM_ALREADY": "ℹ️ Скидка уже была активирована ранее.",
+  "DISCOUNT_CLAIM_EXPIRED": "⚠️ Время действия предложения истекло.",
+  "DISCOUNT_CLAIM_NOT_FOUND": "❌ Предложение не найдено.",
+  "DISCOUNT_CLAIM_ERROR": "❌ Не удалось начислить скидку. Попробуйте позже.",
+  "DISCOUNT_BONUS_DESCRIPTION": "Скидка за продление подписки",
+  "NOTIFICATION_VALUE_INVALID": "❌ Некорректное значение, укажите число.",
+  "NOTIFICATION_VALUE_UPDATED": "✅ Настройки обновлены.",
+  "NOTIFY_PROMPT_SECOND_PERCENT": "Введите новый процент скидки для уведомления через 2-3 дня (0-100):",
+  "NOTIFY_PROMPT_SECOND_HOURS": "Введите количество часов действия скидки (1-168):",
+  "NOTIFY_PROMPT_THIRD_PERCENT": "Введите новый процент скидки для позднего предложения (0-100):",
+  "NOTIFY_PROMPT_THIRD_HOURS": "Введите количество часов действия скидки (1-168):",
+  "NOTIFY_PROMPT_THIRD_DAYS": "Через сколько дней после истечения отправлять предложение? (минимум 2):"
 }

main.py

@@ -16,9 +16,12 @@ from app.services.payment_service import PaymentService
 from app.services.version_service import version_service
 from app.external.webhook_server import WebhookServer
 from app.external.yookassa_webhook import start_yookassa_webhook_server
+from app.external.pal24_webhook import start_pal24_webhook_server, Pal24WebhookServer
 from app.database.universal_migration import run_universal_migration
 from app.services.backup_service import backup_service
+from app.services.reporting_service import reporting_service
 from app.localization.loader import ensure_locale_templates
+from app.services.system_settings_service import bot_configuration_service
 
 
 class GracefulExit:
@@ -55,6 +58,7 @@ async def main():
     
     webhook_server = None
     yookassa_server_task = None
+    pal24_server: Pal24WebhookServer | None = None
     monitoring_task = None
     maintenance_task = None
     version_check_task = None
@@ -82,6 +86,13 @@ async def main():
         else:
             logger.info("ℹ️ Миграция пропущена (SKIP_MIGRATION=true)")
         
+        logger.info("⚙️ Загрузка конфигурации из БД...")
+        try:
+            await bot_configuration_service.initialize()
+            logger.info("✅ Конфигурация загружена")
+        except Exception as error:
+            logger.error(f"❌ Не удалось загрузить конфигурацию: {error}")
+
         logger.info("🤖 Настройка бота...")
         bot, dp = await setup_bot()
         
@@ -109,15 +120,28 @@ async def main():
             logger.info("✅ Сервис бекапов инициализирован")
         except Exception as e:
             logger.error(f"❌ Ошибка инициализации сервиса бекапов: {e}")
-        
+
+        logger.info("📊 Инициализация сервиса отчетов...")
+        try:
+            reporting_service.set_bot(bot)
+            await reporting_service.start()
+        except Exception as e:
+            logger.error(f"❌ Ошибка запуска сервиса отчетов: {e}")
+
         payment_service = PaymentService(bot)
         
-        webhook_needed = settings.TRIBUTE_ENABLED or settings.is_cryptobot_enabled()
+        webhook_needed = (
+            settings.TRIBUTE_ENABLED
+            or settings.is_cryptobot_enabled()
+            or settings.is_mulenpay_enabled()
+        )
         
         if webhook_needed:
             enabled_services = []
             if settings.TRIBUTE_ENABLED:
                 enabled_services.append("Tribute")
+            if settings.is_mulenpay_enabled():
+                enabled_services.append("Mulen Pay")
             if settings.is_cryptobot_enabled():
                 enabled_services.append("CryptoBot")
             
@@ -134,7 +158,13 @@ async def main():
             )
         else:
             logger.info("ℹ️ YooKassa отключена, webhook сервер не запускается")
-        
+
+        if settings.is_pal24_enabled():
+            logger.info("💳 Запуск PayPalych webhook сервера...")
+            pal24_server = await start_pal24_webhook_server(payment_service)
+        else:
+            logger.info("ℹ️ PayPalych отключен, webhook сервер не запускается")
+
         logger.info("📊 Запуск службы мониторинга...")
         monitoring_task = asyncio.create_task(monitoring_service.start_monitoring())
         
@@ -160,14 +190,24 @@ async def main():
         if webhook_needed:
             if settings.TRIBUTE_ENABLED:
                 logger.info(f"   Tribute: {settings.WEBHOOK_URL}:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+            if settings.is_mulenpay_enabled():
+                logger.info(f"   Mulen Pay: {settings.WEBHOOK_URL}:{settings.TRIBUTE_WEBHOOK_PORT}{settings.MULENPAY_WEBHOOK_PATH}")
             if settings.is_cryptobot_enabled():
                 logger.info(f"   CryptoBot: {settings.WEBHOOK_URL}:{settings.TRIBUTE_WEBHOOK_PORT}{settings.CRYPTOBOT_WEBHOOK_PATH}")
         if settings.is_yookassa_enabled():
             logger.info(f"   YooKassa: {settings.WEBHOOK_URL}:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
+        if settings.is_pal24_enabled():
+            logger.info(
+                f"   PayPalych: {settings.WEBHOOK_URL}:{settings.PAL24_WEBHOOK_PORT}{settings.PAL24_WEBHOOK_PATH}"
+            )
         logger.info("📄 Активные фоновые сервисы:")
         logger.info(f"   Мониторинг: {'Включен' if monitoring_task else 'Отключен'}")
         logger.info(f"   Техработы: {'Включен' if maintenance_task else 'Отключен'}")
         logger.info(f"   Проверка версий: {'Включен' if version_check_task else 'Отключен'}")
+        logger.info(
+            "   Отчеты: %s",
+            "Включен" if reporting_service.is_running() else "Отключен",
+        )
         logger.info("=" * 50)
         
         try:
@@ -235,6 +275,10 @@ async def main():
                 await monitoring_task
             except asyncio.CancelledError:
                 pass
+
+        if pal24_server:
+            logger.info("ℹ️ Остановка PayPalych webhook сервера...")
+            await asyncio.get_running_loop().run_in_executor(None, pal24_server.stop)
         
         if maintenance_task and not maintenance_task.done():
             logger.info("ℹ️ Остановка службы техработ...")
@@ -253,6 +297,12 @@ async def main():
             except asyncio.CancelledError:
                 pass
 
+        logger.info("ℹ️ Остановка сервиса отчетов...")
+        try:
+            await reporting_service.stop()
+        except Exception as e:
+            logger.error(f"Ошибка остановки сервиса отчетов: {e}")
+
         logger.info("ℹ️ Остановка сервиса бекапов...")
         try:
             await backup_service.stop_auto_backup()

migrations/alembic/versions/4b6b0f58c8f9_add_period_discounts_to_promo_groups.py

@@ -0,0 +1,29 @@
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+revision: str = "4b6b0f58c8f9"
+down_revision: Union[str, None] = "1f5f3a3f5a4d"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    dialect = bind.dialect.name if bind else ""
+
+    op.add_column(
+        "promo_groups",
+        sa.Column("period_discounts", sa.JSON(), nullable=True),
+    )
+
+    if dialect == "postgresql":
+        op.execute("UPDATE promo_groups SET period_discounts = '{}'::jsonb WHERE period_discounts IS NULL")
+    else:
+        op.execute("UPDATE promo_groups SET period_discounts = '{}' WHERE period_discounts IS NULL")
+
+
+def downgrade() -> None:
+    op.drop_column("promo_groups", "period_discounts")

requirements.txt

@@ -32,3 +32,6 @@ qrcode[pil]==7.4.2
 packaging==23.2
 
 aiofiles==23.2.1
+
+# Вебхуки PayPalych (Flask)
+Flask==3.1.0