Merge pull request #2832 from BEDOLAGA-DEV/release-please--branches--main

chore(main): release 3.43.1

.env.example

@@ -13,6 +13,11 @@ SUPPORT_USERNAME=@support
 # Имя пользователя бота (опционально, автоопределяется)
 # BOT_USERNAME=
 
+# ===== SOCKS5 ПРОКСИ =====
+# URL SOCKS5 прокси-сервера для маршрутизации трафика бота к Telegram API
+# Формат: socks5://user:password@host:port или socks5://host:port
+# PROXY_URL=socks5://127.0.0.1:1080
+
 # ===== СИСТЕМА ПОДДЕРЖКИ =====
 # Включить меню поддержки в интерфейсе
 SUPPORT_MENU_ENABLED=true
@@ -194,6 +199,9 @@ REMNAWAVE_WEBHOOK_PATH=/remnawave-webhook
 # Сгенерируйте: openssl rand -hex 32
 # ВАЖНО: этот же секрет указывается в панели Remnawave при создании вебхука
 REMNAWAVE_WEBHOOK_SECRET=
+# Уведомления администраторам о потере/восстановлении связи с нодами
+# false = не отправлять события node.connection_lost / node.connection_restored
+REMNAWAVE_WEBHOOK_NOTIFY_NODE_CONNECTION_STATUS=true
 
 # ===== УВЕДОМЛЕНИЯ ОТ ВЕБХУКОВ (что получают пользователи) =====
 # Глобальный переключатель уведомлений пользователям от вебхуков
@@ -369,6 +377,8 @@ REFERRAL_MINIMUM_TOPUP_KOPEKS=10000
 REFERRAL_FIRST_TOPUP_BONUS_KOPEKS=10000
 REFERRAL_INVITER_BONUS_KOPEKS=10000
 REFERRAL_COMMISSION_PERCENT=25
+# Макс. кол-во платежей реферала, с которых начисляется комиссия (0 = без лимита)
+REFERRAL_MAX_COMMISSION_PAYMENTS=0
 # Показывать раздел партнёрки в кабинете
 REFERRAL_PARTNER_SECTION_VISIBLE=true
 
@@ -489,11 +499,11 @@ YOOKASSA_WEBHOOK_PORT=8082
 YOOKASSA_MIN_AMOUNT_KOPEKS=5000
 YOOKASSA_MAX_AMOUNT_KOPEKS=1000000
 
-# Быстрый выбор суммы пополнения через YooKassa
-YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED=true
+# Рекуррентные платежи YooKassa (автосохранение карты для автоплатежей)
+YOOKASSA_RECURRENT_ENABLED=false
+# true = карта сохраняется обязательно, false = пользователь решает (чекбокс на стороне YooKassa)
+YOOKASSA_RECURRENT_REQUIRED=true
 
-# Отключить отображение кнопок выбора суммы пополнения (оставить только ввод вручную)
-DISABLE_TOPUP_BUTTONS=false
 # Отключить пополнение баланса через поддержку
 SUPPORT_TOPUP_ENABLED=true
 
@@ -512,6 +522,7 @@ NALOGO_STORAGE_PATH=./nalogo_tokens.json  # Путь к файлу с токен
 NALOGO_QUEUE_CHECK_INTERVAL=300           # Интервал проверки очереди чеков (секунды)
 NALOGO_QUEUE_RECEIPT_DELAY=3              # Задержка между отправкой чеков (секунды)
 NALOGO_QUEUE_MAX_ATTEMPTS=10              # Максимум попыток отправки одного чека
+# NALOGO_PROXY_URL=socks5://127.0.0.1:1080  # SOCKS прокси для nalog.ru (если не задан — используется PROXY_URL)
 
 # ===== НАСТРОЙКИ ОПИСАНИЙ ПЛАТЕЖЕЙ =====
 # Эти настройки позволяют изменить описания платежей,
@@ -655,6 +666,20 @@ KASSA_AI_WEBHOOK_PORT=8089
 # Способ оплаты: 44 = СБП (QR), 36 = Карты РФ, 43 = SberPay
 KASSA_AI_PAYMENT_SYSTEM_ID=44
 
+# ===== RIOPAY (api.riopay.online) =====
+RIOPAY_ENABLED=false
+RIOPAY_API_TOKEN=
+# Ключ для HMAC-SHA512 верификации вебхуков (если не указан, используется RIOPAY_API_TOKEN)
+RIOPAY_WEBHOOK_SECRET=
+RIOPAY_DISPLAY_NAME=RioPay
+RIOPAY_CURRENCY=RUB
+RIOPAY_MIN_AMOUNT_KOPEKS=10000
+RIOPAY_MAX_AMOUNT_KOPEKS=100000000
+RIOPAY_WEBHOOK_PATH=/riopay-webhook
+# URL для редиректа после оплаты (опционально)
+RIOPAY_SUCCESS_URL=
+RIOPAY_FAIL_URL=
+
 # ===== WATA =====
 WATA_ENABLED=false
 WATA_BASE_URL=https://api.wata.pro

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "3.27.0"
+  ".": "3.43.1"
 }

CHANGELOG.md

@@ -1,5 +1,643 @@
 # Changelog
 
+## [3.43.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.43.0...v3.43.1) (2026-03-31)
+
+
+### Bug Fixes
+
+* prevent MissingGreenlet on subscription.tariff lazy load in webhook handlers ([72170b3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/72170b35f5d2af56aa7dcb579a70ecf6af2da3f6))
+* use subscription-level remnawave_uuid in multi-tariff mode for sync and detail pages ([0c284b9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0c284b9e9941b516170fc68a3f63551096cb5a7b))
+
+
+### Documentation
+
+* add Platega partnership to README, highlight partner payment providers ([312cc72](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/312cc728a9321fe9ac90cf1f5201e38465f67f16))
+
+## [3.43.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.42.0...v3.43.0) (2026-03-29)
+
+
+### New Features
+
+* add Remnawave panel 2.7.0 API support ([565c083](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/565c08366bdc1d3dcaba89a8522360e1e4d8c2d8))
+* add SeverPay support to cabinet balance top-up ([092b9f6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/092b9f63b24e8129a8e6f9ac0040f19a35514295))
+* add subscription_id to admin sync endpoints for multi-tariff ([54a19a9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/54a19a9c50d58affd1cd8bc897e360318744e28d))
+* add tariff identification to all notifications for multi-tariff mode ([7dd67e3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7dd67e36b3a8a408239ec53d0ae2cc230dfd726c))
+* add tariff_id to promo codes for trial subscription type ([63e4296](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/63e4296197d7943914267f503782e46befc151d4))
+* **api:** expose email field in UserResponse ([23d1830](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/23d1830644be6ab71da629465604cbb296fa7c02))
+* DELETE /subscriptions/:id for expired/disabled subscriptions ([c27f144](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c27f144b76ad392c5d6909f8f62cb2b065515eed))
+* expose MULTI_TARIFF_ENABLED and MAX_ACTIVE_SUBSCRIPTIONS in admin settings ([2628012](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2628012097893ec93cfcb2b8fe190183cfe53a3b))
+* expose per-inbound traffic breakdown in nodes realtime API ([5d173c8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5d173c806af1e3c31854ae92b194016984cfd80e))
+* include countryEmoji and providerName in realtime metrics ([b59c581](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b59c581e916e4f6511514463e149a03cc4fb6f8f))
+* multi-subscription support ([1099c52](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1099c5224c07b4ddc17397b0200f64f22fbf8520))
+* multi-subscription support (1 user = N subscriptions) ([335be66](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/335be66980bfefae9d39e8f549fb4df1780ce3d0))
+* return is_daily and is_daily_paused in subscription list API ([4dd8170](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4dd81702ceb5ee9ff46af16249d0dd145da2e3b6))
+* support email/OAuth users in referral editing and add remove endpoints ([7f60196](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7f60196033fa48f093edd06da8f2162936c76162))
+* trial lifecycle + purchase-options filter for multi-tariff ([048d208](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/048d208bc1aa188c16fc4e01de836e9f1553b561))
+* wheel subscription picker for multi-tariff mode ([24edfb6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/24edfb6c3f83726aff0a7b4566da5762ceb10d72))
+
+
+### Bug Fixes
+
+* accept subscription_id from query param in renew endpoint (consistent with other endpoints) ([824d54b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/824d54b7dc97a7a4df8a7f34e078e3ff018df442))
+* account linking broken in multi-tariff mode (MULTI_TARIFF_ENABLED=true) ([2c12a47](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2c12a4773c8b0614a06acaf5bcef2784cc211a5a))
+* account merge no longer nulls transferred subscriptions' remnawave_uuid ([b0273dc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b0273dc8aeecbbdd3a72c41c885492026f0aea58))
+* add missing ADMIN_PAYMENTS localization keys for ru and en ([4f76f53](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4f76f53d55588387251b80de6ac878589299817e))
+* add period_days validation and zero-price guard to tariff purchase ([cefdfc5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cefdfc54cc8baea3b4e36740d6913b74a8072b6a))
+* add redirect_slashes=False to prevent HTTP 307 redirects on subscription endpoints ([f7f8ea8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f7f8ea87cfd5b182e7e395a9aa95c37bd40e165c))
+* add selectinload for GuestPurchase.user/tariff in gift activation ([84357a1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/84357a1e8715cb176191eace7d019544175822f4))
+* add tariff identification to remaining notification gaps ([cddb8d6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cddb8d63326e2849d674de64b2da508103d5922f))
+* add_traffic handler passes FSM state to resolve_subscription for multi-tariff context ([684f286](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/684f286fcd9d2c29b1c02d5fc7c9ebf5631f4878))
+* address remaining review issues in device limit patch ([9726145](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/972614511fb10d2cad91e0b8a52cac4c634fc6d7))
+* address review issues in device limit patch ([34aec03](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/34aec0323bd78ff159c9e84bdcf584051b3b0fd4))
+* admin handlers use _resolve_admin_subscription + per-subscription UUID ([147ef6b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/147ef6b22b9518fc806939aba435f81121828641))
+* admin panel per-subscription UUID in multi-tariff mode ([56fffc2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/56fffc241572ec1d59370bfdb01945877e34e5a0))
+* admin server/devices/traffic buttons pass subscription_id in multi-tariff ([9a27e6d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9a27e6db3110e171a9cac02728a21cd4a002e9b1))
+* admin tariff purchase now creates separate RemnaWave user per tariff ([95ba739](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/95ba73995820ac5c154226a370979437809d3f8c))
+* assign promo group from tariff on guest purchase ([da11ec6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/da11ec6f946e6a439111c31c6e5387dab4167303))
+* async tariff loading in promocode serialization ([3bec662](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3bec6620b67f0dfe7926a030ee98ef0f08e5673e))
+* auto-purchase processes each autopay subscription independently ([f89e326](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f89e326a19f37ec2189fe01814cd3a4cf69c4d02))
+* back button in subscriptions list uses correct callback ([382e29d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/382e29d3dd20cca8f231e444181703bf72c45c86))
+* back buttons in devices/traffic return to subscription detail in multi-tariff ([319941d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/319941d33a43552c09ba5fb95e1a165dd1603999))
+* block classic subscription renewal/autopay when tariff mode enabled ([cd6913c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cd6913cb849ccefe2b36de786068890c8117b1d8))
+* block legacy subscription renewal bypass in tariff mode ([78209c8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/78209c862320ef030134ac7e77c57229b5701cfd))
+* cabinet admin create subscription now creates new RemnaWave user in multi-tariff mode ([31c67d1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/31c67d15657d88df24ba490e0d47a9c3104883af))
+* cabinet purchase_tariff — handle IntegrityError with compensating refund ([1bc2581](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1bc2581669ecc3b47b12283c7fb6988bbe34cb28))
+* cabinet routes use smart subscription fallback + per-subscription UUID ([f83ff26](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f83ff26332c8057f5cbb1725f1d5db74e23af9bf))
+* centralize trial cleanup in CRUD + shared subscription resolver for bot ([355fef8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/355fef846e786b638fdcf8823fc077ace89e8615))
+* comprehensive multi-subscription audit fixes across routes, handlers, and services ([d071269](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d071269b8c4df08f91b3a94e09d3a37686082f8a))
+* comprehensive tariff switch/extend/back button fixes for multi-tariff ([e42bddb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e42bddb868414aec8df55c071adab63a88b30696))
+* contest prize applies to best non-daily subscription in multi-tariff ([d2bbeb8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d2bbeb8624ca1320b38a300de0417f64747a6286))
+* daily tariff switch uses _resolve_subscription instead of searching by new tariff_id ([4e12ab3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4e12ab3458c1c73ed4ffe62ca8688ff917a64e4c))
+* delete subscription from RemnaWave panel + prevent phantom webhook notifications ([a12ffb1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a12ffb1d6c30bc2d73888f5c352c12fc3d0fd95c))
+* device limit decrease, HWID pagination, tariff max enforcement ([931eeb3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/931eeb35689532a892e14bc76a05fea1a8f2cec3))
+* devices button shows menu with buy + manage options in multi-tariff ([f925efb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f925efbfb47de8dc8e5932eab629ee6beb7c61e2))
+* disable redirect_slashes globally to prevent HTTP 307 on subscription endpoints ([06feb3f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/06feb3fff589616b6cf78a2cdf6ba5c33cca7794))
+* distinguish cabinet gift notifications from landing page ([48eaa6b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/48eaa6b0724a3f881d144abc723fa8373ee9a67f))
+* eligibility and display use best non-daily subscription in multi-tariff ([76ba19d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/76ba19da175553597599fcbcc8513221078e01f6))
+* fix MiniApp renewal options 500 error for legacy subscriptions ([aa36549](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aa36549bb3bc1e04362750b7eecee23f9ba99d88))
+* gift code activation and multi-tariff subscription sync ([f93c51a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f93c51a6773e706a6fc6f9b6016868e181400762))
+* harden node info display against injection and type errors ([6d167d2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6d167d292266a660f0d6fd906db3cdea84e8c9cf))
+* harden webhook signature verification across all payment providers ([8295880](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/82958801b5179ff5703e6d11b3b0b30f74581eeb))
+* import Subscription in wheel_service to fix NameError ([34bb87c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/34bb87c7baf34b4d9c0c09a6b3fe2b76378d9a66))
+* improve UX for legacy users migrating to tariff mode ([f6f330d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f6f330db4a2e6aa5d14a616b9fd2365577f928a1))
+* load buyer relationship before gift notification, clean up recipient logic ([adb39c6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/adb39c6ef46507966482cdceed8ba03e861285ee))
+* multi-subscription support for promocodes, contests, phantom merge ([6d468e9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6d468e9adacc8c111cdb5145dc048f7eea6e93e4))
+* multi-subscription UUID resolution and ownership validation ([d87fb47](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d87fb47e886eebb3a1e75b1dae1982230f7bac72))
+* multi-tariff code review — 13 critical/high bugs fixed across 14 files ([5724906](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/57249065178900a8626181556119464c7d55fd74))
+* multi-tariff MEDIUM/LOW batch — 20 issues across 17 files ([94ed282](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/94ed282381fcc71efdef8b55c2e566b2fcd92c2c))
+* multi-tariff Stage 2 critical fixes — panel sync, guest purchase, cart isolation ([4259ba1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4259ba1cb57020314f478d7efc78c915fce9e9b6))
+* multi-tariff Stage 2 HIGH fixes — 18 issues across 12 files ([c6bedc6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c6bedc6a061cd6ff2010f1345d6bae42e4282fbd))
+* multi-tariff Stage 3 critical fixes — panel sync UUID, admin grant, wheel ([49db5f5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/49db5f5eedb452aac7b12739ce735abb8c3b99d2))
+* multi-tariff Stage 3 HIGH fixes — phantom, cart, yookassa, auto-extend ([aa7e461](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aa7e461c4451fc477ac9a1714c8e2243fe12ba49))
+* multi-tariff Stage 4 critical fixes — keyboards, guest purchase, monitoring, tariff deletion ([a49e52c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a49e52cc92819b10d1d4afc823cf98b534a84a0f))
+* multi-tariff Stage 5 fixes — auth sync, notifications, cart, race guard ([948e479](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/948e4791f49a0626100af8ada29da8b605392566))
+* multi-tariff sync auto-links legacy user-level UUIDs to subscriptions ([dbe247b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/dbe247ba6f8cea2ccb845ceb1cfd87d76d47dc52))
+* notifications include tariff name for multi-subscription clarity ([05d1ae0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/05d1ae0560f63627c17b629d476088ce21398863))
+* parse_bytes now handles IEC units (GiB, MiB, KiB) from API ([1471320](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/147132060659e828b005160003d5bff1a565e280))
+* pass FSM state to _resolve_subscription across all subscription handlers ([90fb0a2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/90fb0a21e227d46ed5624051d8185a1e026b0806))
+* pass sub_id to show_devices_page to fix NameError in multi-tariff ([59d4b35](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/59d4b353a6456fc40682239df441b23bc8d63f6d))
+* persist referral to Redis on /start to prevent loss when user opens miniapp ([6d9bd99](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6d9bd9915cda01d819b4c3db02115777c8cb7500))
+* post-payment keyboard checks all subscriptions instead of LIMIT 1 ([25b853d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/25b853d629f9581a9f7871142751dcb2b1e73d3a))
+* prevent sync from overwriting wrong subscription traffic in multi-tariff mode ([78a7eaf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/78a7eafcb65a175dd8f5ded304138ebd8c47acd8))
+* prevent sync/from-panel cross-subscription data mismatch ([960aa44](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/960aa44b007b454f94403cedf98033c9a2c60dec))
+* promocode system broken in multi-tariff mode ([3cbe09d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3cbe09ddd54bec6568b49fbd2ed961649160d21f))
+* re-fetch subscription after lock_user_for_pricing to prevent selectinload reset ([71082f4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/71082f436c6a49409b84e84a367e6059abea850e))
+* remnawave service uses per-subscription UUID throughout multi-tariff ([afd7b6d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/afd7b6d7ec777fd380b43c77da55d3114ff837d7))
+* RemnaWave sync finds user by Subscription.remnawave_uuid in multi-tariff ([c3c2b81](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c3c2b8137b5b8e656b0368742e55a99c4d6a3ec3))
+* remove unused imports and variables after rebase ([b6cf361](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b6cf361737653f7601515126b2e2d073a8a5ca0f))
+* remove user.subscription setter - use local variable instead ([2f88b07](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f88b07f05cb568c6a6f0bde9c7b7e91d4309d66))
+* remove UUID fallback override in admin_tariffs + restore promo on IntegrityError ([a232d21](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a232d21edd9714082a7943f9e23db4241f188d66))
+* rename refresh('subscription') to refresh('subscriptions') in all files ([e99f3d9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e99f3d9a374b1ab32bbefd8be2036aa185e50f5c))
+* renewal handlers use _resolve_subscription + store subscription_id in FSM ([87bf65c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/87bf65c8097d270a139402ab5e976b6215735c99))
+* renewal status check, int() safety, daily charge atomicity ([58d899a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/58d899aab89ff41ef86a2c578613a59720fdab31))
+* renumber multi-subscription migrations to avoid conflicts with dev ([5a7b3d5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5a7b3d59627f61b3afc7d23ec08d00d9c07c7f10))
+* resolve MissingGreenlet error on article detail view ([004dac5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/004dac5b7ef76b2b1e98e0ab0f62d9fe7fcbd12b))
+* services use smart subscription selection + per-subscription UUID ([0866c2e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0866c2ea4b3183dc63e5ea88391d83dd03f30428))
+* set is_daily_paused=True when admin cancels/disables daily subscription to prevent auto-resume ([d04f2fc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d04f2fc718d11a4766627fda83bdee3abf7f15ea))
+* show all subscriptions in main menu for multi-tariff mode ([e39c358](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e39c358d5caf00674c8d148757b66d46b15485c2))
+* show subscription picker for traffic/connect buttons with multiple subs ([a39e355](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a39e3554d8b91eac676cf4e3b4cfe6a0dd9caa82))
+* suppress empty reward alerts and clean up referral notifications ([e3d8d21](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e3d8d21b662761dca1ffe5938e3ce4d72275be84))
+* tariff purchase shows purchased tariffs and blocks re-buying in multi-tariff ([9644135](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9644135dd7a1c1e951274a73a56ec75fd715fe62))
+* tariff_purchase next() fallbacks use None instead of active_subs[0] in multi-tariff ([72d5bae](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/72d5bae531ae04a36fbc44a6803de7f17020f846))
+* test access promo applies to all active subscriptions in multi-tariff ([181ef15](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/181ef1501b31837585958f89631c1aa36b1872a2))
+* transliterate Cyrillic slugs instead of stripping to 'untitled' ([c805cfd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c805cfd6d8335f147991458e42fa8a19121a5126))
+* trial promo extends existing subscription with same tariff ([b8662b8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b8662b8bf6c341f391a25940dea928a043396f04))
+* trial reset in multi-tariff only deletes trial subscriptions, keeps paid ([424fff4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/424fff4ac29e697268eeb57d5b5bacd498c691e8))
+* trial subscription lifecycle — autopay, cleanup on purchase, bonus days ([344852b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/344852b85223b49fc52f1401d63b198e1a8412c5))
+* use '/' instead of empty path in subscription sub-routers ([07ebc43](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/07ebc435cf2544c31e0c55bb543775ffcd252e01))
+* use empty path instead of '/' for multi-tariff list endpoint to avoid 404 ([c8ecec4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c8ecec47a0af59911407d8d5a9d6df3f2afc3fb8))
+* UUID check in servers/tariff_switch, start.py refresh, delegation state passing ([bd46b4c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bd46b4cf6dcd7cd65a42456d741b957a22aa7863))
+* UUID warnings, phantom merge, yookassa validation, contest prize notification ([fe03b58](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fe03b587db96eb365a718e21a0177dd6e6e6a480))
+* validate_and_clean_subscription uses per-subscription UUID in multi-tariff mode, not user-level UUID ([18f31c5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/18f31c565c7c0217ebd2348389466c16dc17fc3f))
+* web API routes use multi-subscription resolution for operations ([a1623d9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a1623d94b119025f59263749eaa727bc910dc467))
+
+
+### Refactoring
+
+* remove dead multi-tariff check in guest purchase activation ([34b5a9a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/34b5a9ab3a0eab8561ddd6930b59b817bc2ef9b4))
+* update remnawave API integration for v2.7.0 ([173cc37](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/173cc374bb8391359d8f54569565f18a82fc28eb))
+
+
+### Documentation
+
+* add Stage 3+4 audit results to multi-tariff review ([6dc5879](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6dc5879ffa7edb77166291fbda9e03fbe532bc2d))
+* update multi-tariff review with Stage 2 full audit results ([40d2ec6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/40d2ec67189064b41774292029a397fde2a1c863))
+
+## [3.42.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.41.0...v3.42.0) (2026-03-23)
+
+
+### New Features
+
+* add managed news categories and tags with DB-backed CRUD ([51392d1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/51392d1918d8e2e94645acfb3a11b8e16776a5d5))
+* add media upload/delete API for news articles ([a0d40ad](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a0d40ad432d858ebfe75485a9597d32e847d5746))
+* add news articles module with admin CRUD and public API ([b932403](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b93240393f739f1243bbbfdd4298b90974b8fa87))
+* enforce single featured news article — unfeature others on toggle/create/update ([b5853ec](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b5853ec3b6769655f8d19914e51fd078ec9edccc))
+* show Platega payment methods inline on main screen ([#2720](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/issues/2720)) ([334db53](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/334db53868ae2f9206fdde97fa575e953a83cbcf))
+
+
+### Bug Fixes
+
+* add explicit File(...) to UploadFile param to fix 422 on media upload ([89bfdc8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/89bfdc8ed6bfba48cfcb61083240d5e6e870f49b))
+* add Literal type to SavedMedia and close orphaned PIL Image objects ([ce554cb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ce554cb2a8e606b6060dbf63463e64087a3a7539))
+* add user ID to payment descriptions for all providers and fix tuple bug ([2f19c76](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f19c76357fe7de1636d65968cb13f784ee47c31))
+* catch DecompressionBombError, hoist MP4 brands to module level ([172924d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/172924df0e1248b27d3f18f6acf23cf115040941))
+* comprehensive html.escape() for all user/admin data in Telegram HTML messages ([9de3490](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9de34900a2a9047ab275c0bbf16fd314eb49a3ec))
+* comprehensive security hardening across payment and API layers ([8175bc8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8175bc8bfe56dc564a0783c45226451b695bdbd6))
+* correctly price unlimited traffic (0 GB) in classic subscription mode ([aec04f0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aec04f0085bd9c566bd033b8bb628389ff22bdf6))
+* create uploads subdirectories in Dockerfile for correct permissions ([5ed3780](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5ed3780f830023f7b1940dc96256fd38e3c86f4b))
+* media upload security hardening from 6-agent review ([165d25e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/165d25ef5fc02eecf7c6d703072b6adbe88bfd98))
+* news module security hardening, perf optimizations, bug fixes ([2b91808](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2b91808b0c72381cfb2f4e36eaff69e9102a32ee))
+* phantom user merge on claim failure, referral assignment, account merge hardening ([fad77f8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fad77f8c80a8fdecb0512f0ff91e5ae6d78ec8f3))
+* register categories/tags/media routers before news to avoid route conflict ([d9cda3a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d9cda3a6d67c6249397e3778c1aefc6bdb6d9e4f))
+* reject HEIC as MP4, close UploadFile, narrow exception handling ([7ff73e8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7ff73e8492343be5ed77fad5eea7e730621eac76))
+* remove future annotations breaking UploadFile, harden media URL generation ([0225fa1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0225fa155b7d4f3d1c6572a68651c206b1820db0))
+* replace asyncio.gather with sequential queries on shared session ([3e69efe](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3e69efe5891bbe8869a7feb2320185e14d83dd73))
+* respect per-channel disable_on_leave settings in monitoring service ([958ec48](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/958ec489a2a1d01d19cb6e60f52fb2be56295104))
+* respect X-Forwarded-Proto in media URL generation to prevent mixed content ([fd41009](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fd410096ea7e541d8443ec4336bfd72de63d03d9))
+* restore connected_squads and admin notification on daily subscription resume ([89341ba](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/89341baa6243496d3b24c501e227ed156676c052))
+* simplify 0046 migration downgrade to just drop_table ([015c2da](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/015c2da297e4250ebfa50e32b3c1468c9a2143f3))
+* suppress harmless TelegramBadRequest errors and fix discount promo display ([0fe3c21](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0fe3c217f752ced2e3c3f56b4ab5b4c898ba2d8e))
+* use IF EXISTS in downgrade for FK indexes ([76b1f9b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/76b1f9b036e276646546aa4c89a3fe1d2ee58a40))
+* validate FK existence, add FK indexes, expand video brand whitelist ([f0cdd5d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f0cdd5dc904926b55be390798a71a5427a20949b))
+* validate period_days against tariff in purchase-tariff and auto-purchase ([4660ca5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4660ca5756f5f1ef8033f9202d68612d570ddb1a))
+
+
+### Refactoring
+
+* extract phantom service, replace lightweight merge with execute_merge ([6658af6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6658af6268c10db170e3eaabc75f857e5c664c3c))
+* simplify referral invite text to single template ([cbe630c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cbe630cab0973d7d71dd72603b114807b237ac84))
+
+## [3.41.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.40.0...v3.41.0) (2026-03-22)
+
+
+### New Features
+
+* add subscription status to referral network graph nodes ([de91d32](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/de91d3282ffa15c0cec60c0d62871d39e7ee4c05))
+* add total subscription revenue to referral network stats ([2bdb764](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2bdb7643f8fd142e99caee0fe989348161377348))
+
+
+### Bug Fixes
+
+* add abs() to all remaining subscription payment sum queries ([1eb4e18](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1eb4e18c1776b2265a48e0b923a0ca4ee057d912))
+* add missing total_subscription_revenue_kopeks in scoped graph early return ([bcc761f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bcc761f9d3f673bd2b404adf817762058d8e0df4))
+* consider subscription status field in network graph ([454dc93](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/454dc9321bb9405c5ff0ff559ae4ced15533f3af))
+* superadmin role managed exclusively via env config ([e0bedc8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e0bedc8e780a2f91509517110639773e90bb6125))
+* treat expired and limited subscription statuses as inactive in referral network graph ([5ed2f0c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5ed2f0c95842a43ab57220dc05ca346748bd6adb))
+* use abs() for subscription payment amounts in referral network ([056c13b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/056c13bc23e6737f44bbcb802a66b643349f75a9))
+
+
+### Refactoring
+
+* extract _compute_subscription_status shared helper ([8b8f1b9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8b8f1b91f37f829528f785a40e3a9cb98c85e043))
+
+## [3.40.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.39.0...v3.40.0) (2026-03-22)
+
+
+### New Features
+
+* allow inactive tariffs for trial subscription activation ([cce3b0c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cce3b0c13bcbf0b567bd4dcf2670973382e7cab0))
+* custom broadcast buttons and fix home button to use bot menu ([13ea376](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/13ea3768b516337c4e0320120bc60a9acb27a16b))
+
+
+### Bug Fixes
+
+* accept stale Telegram initData to prevent MiniApp auth failures ([4c2cb63](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4c2cb63cf9f71fb392c3723a99e88ca3d02b127d))
+* daily subscription pause not persisting in cabinet and miniapp ([d3c9940](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d3c994083e3b054d02d4911172968c914724d051))
+* handle spurious user.deleted webhooks — preserve active subscriptions and prevent orphaned panel users ([9eab802](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9eab80200006e576967204b52f90bf9866875917))
+* prevent MESSAGE_TOO_LONG in promo groups list ([c307278](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c30727823169159b4b6b61f54897b209ced8dfd2))
+* referral system — self-referral protection, race condition fix, deleted user re-registration ([ed5a92a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ed5a92ab966dac54c15217050eae87f4b05eed62))
+* sanitize email dots in RemnaWave username generation ([6c20858](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6c208581d936f5ab7d6b978baafd50881b8ce9f1))
+* send DISABLED instead of EXPIRED status to RemnaWave API ([79cfcbc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/79cfcbcece3938f2daa83206f96ec1bffd0857e0))
+
+## [3.39.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.38.0...v3.39.0) (2026-03-21)
+
+
+### New Features
+
+* add NaloGO fiscal receipts for code-only gift purchases ([90209eb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/90209ebef1a872665e622124a1898d52eff398e7))
+
+
+### Bug Fixes
+
+* add NaloGO fiscal receipt creation for landing page purchases ([4244962](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/424496233773b4cee4e389a1172e95208b3afeaf))
+* manual admin top-ups missing from sales statistics ([ab43e74](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ab43e74ab7484f8d3517f91e366ea395e1944b99))
+* skip non-JSON payload rows in cryptobot payment index and query ([ba79d03](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ba79d03e389afed972296fe2bc05104aa6b883f3))
+
+## [3.38.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.37.0...v3.38.0) (2026-03-21)
+
+
+### New Features
+
+* add SOCKS proxy support for nalogo (tax service) module ([3c5bf4f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3c5bf4fa22d1cdf144269f4e6ab32a4523c8f1f3))
+
+
+### Bug Fixes
+
+* add diagnostic payload logging in create_user error path ([4990ddf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4990ddf9e46495b65fc3638ea8d6bed0cbe6b857))
+* retry Remnawave API calls without externalSquadUuid on A039 FK violation ([de00612](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/de006129657ce3dac2b1f2fc0ab1b91e23e44241))
+* sanitize proxy credentials in all nalogo error paths ([3bf3105](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3bf31055e71ff64e6a6d94486bb7f7775ac7dc91))
+
+## [3.37.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.36.1...v3.37.0) (2026-03-21)
+
+
+### New Features
+
+* add SOCKS5 proxy support for Telegram API traffic ([82b6a8b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/82b6a8bf707736541b58637b0fc9a84b0c403a6c))
+* broadcast caption validation + landing daily created stats ([d400cd7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d400cd7b49cb18edf8545a5af54009561610218a))
+* expose cabinet_email/password vars in subscription delivered template admin UI ([f82a713](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f82a713110c90494e41f2de9910f5dc60a06962e))
+* include cabinet credentials in subscription delivered email ([fedcf25](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fedcf2569a153ac40699dd5b402208ac86db0fc3))
+* show both bot and cabinet referral links everywhere ([67da390](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/67da3903715e97c0d84d0018efdd74b085ee8720))
+
+
+### Bug Fixes
+
+* default payment_method to BALANCE for bot subscription payments ([226d3f2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/226d3f2766bb0842e5a4aefb1458a9e40389108e))
+* derive income_today from revenue_chart to ensure consistency ([1882909](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1882909b3e60f4959921ae085e909bc91c0756b3))
+* include landing page revenue in dashboard statistics ([c6c1599](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c6c1599e14a8c7033dfa399ff3f2c3ee6d156598))
+* include SUBSCRIPTION_PAYMENT in dashboard revenue ([5f71eaa](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5f71eaa92604faa2c6928994bd32a9c6c8ae7ae5))
+* include SUBSCRIPTION_PAYMENT in dashboard revenue calculations ([13dba5a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/13dba5a303604f8d39e85d1382a4d36225f957ac))
+* include SUBSCRIPTION_PAYMENT in dashboard revenue calculations ([d7f91c8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d7f91c83584384ef5d0fc90a28debc722b2db79f))
+* include SUBSCRIPTION_PAYMENT in recent payments today/week totals ([6982d27](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6982d27378d0dbe5c7b37d1491e6c9d0461dffc8))
+* include SUBSCRIPTION_PAYMENT in sales summary and deposits stats ([27ef752](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/27ef75214e73211a68d541f5375ca14275ea86e9))
+* increase landing purchase rate limit from 5 to 30 req/min ([801921f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/801921ff74107daccc17e49a0335c7b133268280))
+* narrow exception handling and fix session leak in gift.py ([3875335](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3875335cd7083115043d22f8726f0d33a225cd10))
+* prevent bootstrap from reactivating revoked superadmin roles ([9dd6b54](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9dd6b54c6e963d2a842d4ac48c9a463014306ed7))
+* prevent double balance credit on concurrent Platega webhooks ([0e1296e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0e1296e0ea291ee661aa82508d5eb8049ce23cac))
+* prevent double-payment TOCTOU race in all payment providers ([82c79c1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/82c79c130601736cd149350f761dcceacfb7c2db))
+* resolve EmailService stale SMTP config causing NoneType crash on from_email ([2a72dea](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2a72deadd6ac3baea15a8d4ee414d763c16690b0))
+* resolve remaining TOCTOU issues in RioPay, SeverPay and restore paid_at ([afefcc9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/afefcc9c07a80ecf65871bc2d0fbcfe13ffc24fd))
+
+
+### Refactoring
+
+* centralize Bot instantiation via create_bot() factory ([0a53b85](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0a53b85b8a3193f67e148c0f2bde246cc92f010c))
+
+## [3.36.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.36.0...v3.36.1) (2026-03-20)
+
+
+### Bug Fixes
+
+* handle duplicate admin roles in RBAC bootstrap ([877b1cd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/877b1cde11c462c0cf5692119ca09944476a2fb6))
+* make migration 0042 idempotent for retry_count column ([5faf701](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5faf7015ac043f44366fd2a5e00be19eab76b945))
+
+## [3.36.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.35.0...v3.36.0) (2026-03-20)
+
+
+### New Features
+
+* add media attachment support for admin ticket replies ([69bb399](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/69bb399b63d6e1d761cc5518e6272917fc5a6ae7))
+* add multi-provider recovery, retry_count, amount verification, and indexes ([3d78974](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3d78974af70b360449d9cf634e09a79821cdc7c0))
+* add partner → campaign edges to referral network graph ([01132a7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/01132a7bc77b07eaaaf876c05d639bfed83e5324))
+* add referral network graph visualization admin API ([c08c903](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c08c903e8f94f3730872b19de904ce166ba35b98))
+* add scoped referral network graph with scope selector API ([df086b0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/df086b09c75a9157cdc558fb610b617a2d49deaf))
+* multi-select scope for referral network graph API ([6a4ce3d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6a4ce3dd38dc3cf2e9db08322093bfd0b84f1e1c))
+
+
+### Bug Fixes
+
+* address review findings for guest purchase recovery ([57c5c67](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/57c5c679eef987e9bacee1a9d420ac3c0ff69ff7))
+* address review findings for multi-provider recovery ([79c110f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/79c110ff41659ff225164c13690bafc859212d05))
+* allow repeated auto-assignment of promo groups on each purchase ([4a002b7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4a002b7db1bfa8fd1149b0e3dfa469e8912a0e3b))
+* correct revenue calculations in referral network ([c8f4cca](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c8f4cca34053713eb2793bbb82e74cbb9a6f893c))
+* improve referral network query correctness and cleanup ([ac9fcd8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ac9fcd8d30dd64fdc7363e689e9ffaf03700976e))
+* prevent duplicate promo groups during auto-assignment after purchase ([da7a9cc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/da7a9cc3c5fd771b932a2bfd154400f6f923a4d1))
+* prevent guest purchases from getting stuck in PENDING/FAILED status ([2781236](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2781236011942e794949544b9c5422aa8679e5eb))
+* prevent premature commits in promocode promo group operations ([8b26680](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8b2668087b4831c08474846b20591b2158d607fc))
+* propagate exceptions from get_primary_user_promo_group ([3ec9e71](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3ec9e71de7d8d40e969f9ea738455445d04d983a))
+* use 'kassa_ai' base model name for guest metadata patch ([182667e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/182667ecb86f9bbbe87d640865dcbcaadf9e72f6))
+* use base model name for KassaAI guest metadata patch ([b6d4373](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b6d43739337cd2e2cfd61ac33398eb6def5b28b6))
+
+
+### Performance
+
+* add covering indexes for referral network queries ([b5471b7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b5471b7720213c217fc452dc1234a7d3c53447d5))
+
+## [3.35.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.34.1...v3.35.0) (2026-03-18)
+
+
+### New Features
+
+* add user_email to admin payments API response ([7101555](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7101555da0722d1eacd97f40b6b8c8c3a2327a0c))
+* include manual admin top-ups in sales statistics revenue ([b80eeea](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b80eeea089568c60c20b1ae165b8dbe887bbe378))
+* раздельные топики для админских уведомлений ([e15b18f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e15b18fb41b180e7dd3d65f2f058667be321fe85))
+
+
+### Bug Fixes
+
+* fix Platega and CryptoBot webhook verification ([b40a812](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b40a812f3aa0596bf6c5105008451dd8a17b103f))
+* handle None autopay_days_before in autopayment processing ([f1d4534](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f1d45343e941594d69f71e822ecc9b3a7062f4bf))
+* remove forced white background from custom email template overrides ([cb61014](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cb61014d9c5a89e3aeafb191f1b9826ca1cbf338))
+* undefined currency variable in RioPay payment creation ([5b33534](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5b3353433bc524e3e51f2ae87d26bd162bd9f97b))
+
+## [3.34.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.34.0...v3.34.1) (2026-03-18)
+
+
+### Bug Fixes
+
+* add null check for subscription in execute_change_devices ([5081deb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5081debee7625954bd7b82f66e09dd58e08e8822))
+* correct CryptoBot webhook signature verification and auto-fill topup amount from cart ([d7ad9d7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d7ad9d70330b6ef5599f7a9409cdd16657d61b85))
+* correct RioPay API header case and remove undocumented fields ([1a87d43](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1a87d438fe127a0b62bd6ee59887212869a3cb17))
+* disable quick amount buttons in balance topup ([d0eab3f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d0eab3f7aacf0249ca244f168c96044347c918e3))
+* reset device limit to new tariff base on tariff switch ([aec01ce](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aec01ce0d4a36da5ddd07b56ca4bd5de04735a0b))
+* sync crypto link from happ.cryptoLink in webhook handlers ([0ceff44](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0ceff44c30cf11466c4cbe51b520558c51c4af4a))
+
+
+### Refactoring
+
+* remove quick amount buttons feature entirely ([136f29c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/136f29c1eb63778b2b329ed5bf72ab06a4531d0b))
+
+
+### Documentation
+
+* add bot preview screenshot to README ([d7931a2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d7931a2afaf272aae74453f2bb6d493593895f67))
+* add cabinet preview screenshot to README ([b032c8f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b032c8f35435ddd592df04d6352097580f5e9837))
+* add icons and list all 14+1 payment providers ([1306c24](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1306c24fa36fd3e812c5bec551a0aca450ca7d2c))
+* add Redis to tech stack ([c14d7ab](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c14d7ab0af2e5dd4f35213b323a97eedcc99af0e))
+* add Redis to tech stack ([e12cc9f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e12cc9f248764104d538db1daaede9ddd8b77b2d))
+* add WATA partnership block to payments section ([31bdf8a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/31bdf8a0aeba53fcec40358d0a38b8480130a346))
+* increase logo size to 800px ([22e7f15](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/22e7f150b30c35b0419e7923e94c5ebc92c4b61a))
+* redesign README — concise feature showcase, link to docs ([38deb70](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/38deb70f8118d371e36ac92a4417bdb543635fc9))
+* replace header logo with new artwork ([6888822](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/688882237fe3019bb78d5e1d7ad54faf4cd69c09))
+* WATA partnership block with logo and table card ([8d5a002](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8d5a0029964ba52b40e03ebfe8ab6f4146d3aca9))
+
+## [3.34.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.33.0...v3.34.0) (2026-03-18)
+
+
+### New Features
+
+* добавлен SeverPay в админ-панель и настройки кабинета ([06a00e3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/06a00e367c303b5426008f38a20393ec4f2e07cd))
+* добавлена интеграция SeverPay для пополнения баланса ([abaf279](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/abaf279533d31994a8a70346627c962b43000c64))
+* поиск платежей в админ-панели с фильтрами и статистикой ([1804c28](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1804c28f0551fbe52883fc36fc4cfcd60d2d6bd6))
+
+
+### Bug Fixes
+
+* remove contains_eager conflicting with selectinload on user relationship ([fddf8ef](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fddf8ef5ebc8e5176a75a10e92d59165bdabf2e1))
+* добавлен импорт MAX_ALL_TIME_DAYS в admin_payments routes ([ad26832](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ad268329be45bdd665ce4a6f142e9762a78e55b5))
+* добавлены RioPay и SeverPay в REAL_PAYMENT_METHODS ([f967c29](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f967c29bd7cfe8a66e7e0f492573bb7521fcda22))
+
+## [3.33.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.4...v3.33.0) (2026-03-17)
+
+
+### New Features
+
+* add SBP and Card sub-options for KassaAI payment method ([5b722c5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5b722c521036befcbbaf6192215f651c2ec9c4fb))
+* add SBP and Card sub-options to kassa_ai payment method ([04419fd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/04419fdff7dc244eb2c9553ea1501e2de454010b))
+* deep link авторизация в кабинете при блокировке oauth.telegram.org ([322d457](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/322d45765220c854e36ae0b4b862a96d36ae3be8))
+* добавлена поддержка RioPay в кабинете ([3d1fbc7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3d1fbc70f8add81d4a3561d63dcd46f385bcc6f1))
+* добавлена поддержка RioPay для лендингов и подарков ([04f4e6b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/04f4e6bf6e9031ef8512a07ab36355111c524319))
+
+
+### Bug Fixes
+
+* add back button to payment amount validation errors ([20eff61](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/20eff6170fb752051022a14fa9d927d59ff1d602))
+* add sync_squads=True to admin tariff change handler ([3f0b24c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3f0b24c1ec82ebfb6fdbc801ed6b493ea09c9a2f))
+* deep link auth security and reliability fixes ([099391e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/099391eb5f24319703f12ae2cb72d93b26164d99))
+* enforce promo group authorization on country/server selection ([641da94](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/641da949a907ade7b870e1a5385fdb71f9e524af))
+* merge phantom users into active accounts on /start ([77f1a76](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/77f1a764d59d68236899ec59c884907d3666d3dd))
+* MissingGreenlet crash after subscription purchase in cabinet ([a80a85c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a80a85c2a489f397efb4ffb5bd77655420a49adb))
+* MissingGreenlet crash after subscription purchase in cabinet ([1cc687a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1cc687ac15ecdf12928e5ce448514c09b6628f65))
+* MissingGreenlet при изменении количества устройств на CLASSIC подписках ([826accb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/826accba519f23a687fcc3d387f727fd31d2a88c))
+* protect external squads from deletion during server sync ([b563796](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b563796091e83edcc8dfbd6222648b5346f39a9c))
+* review findings — db.commit, isinstance guard, constants, ACTIVE check ([72b5305](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/72b5305b870ae9ecdb2672549b9c153dd8b3f7bc))
+* sub-method enabled check, guest payment provider, silent FSM return ([603b9a1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/603b9a1f4610a5b288d6fba78c98474c439529aa))
+* **subscription:** remove stale extend promo state fields causing NameError ([20a6fa1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/20a6fa1bcf362455623f43838f4ffaaf98b33e76))
+* swap Caddy auth headers — api_key to Authorization, caddy_token to X-Api-Key ([038c34e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/038c34e52a863d0c5c6993ea785587ba7e0bc61d))
+* sync squads to Remnawave panel on tariff purchase/switch ([c34fdd1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c34fdd10a0a22a85a4e29cbf44da2ac5d4a643b3))
+* защита внешних сквадов от удаления при синхронизации серверов ([f84885c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f84885cc8aa0c9a70f916076e987284f1f9c3479))
+* исправлен расчёт конверсии в статистике продаж ([3089c17](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3089c1704b54323b4c2a151d40a5b395a427c658))
+* исправлены проблемы RioPay интеграции после ревью ([4abb8cb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4abb8cb1a3f21089697199261bcc37e6f6a5c623))
+* миграция Tribute webhook с deprecated user_id на trb_user_id ([9419941](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/94199413c283167edd829b337cf9bec0a5414a54))
+* скрыть плашку верификации email при выключенной верификации ([4966e39](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4966e39eb9b92967ef92c92ae434ca6cdea80c84))
+
+
+### Refactoring
+
+* deduplicate KassaAI handlers with config dict and shared helpers ([e4bb043](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e4bb0430fb9cc4f55013767ceda6d1c214bd80a6))
+* move KASSA_AI_SUB_METHODS to service layer, add early enabled checks ([cda2392](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cda239241122ae1dd02a252b3eadc47453c0c48b))
+
+## [3.32.4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.3...v3.32.4) (2026-03-16)
+
+
+### Bug Fixes
+
+* лог полного payload при ошибке PATCH /api/users для диагностики A039 ([8d7f0ee](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8d7f0eea0fecd9e66bf199bd2c288e073f1354c0))
+* не пересылать activeInternalSquads в рутинных обновлениях RemnaWave (A039) ([4aaf0dd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4aaf0ddd25527ec23fa6a479ac3826d6b6266761))
+* не пересылать externalSquadUuid в рутинных обновлениях RemnaWave ([3d68db0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3d68db0a51fac55640d44be784c832875ca2da17))
+* расширен лог PATCH /api/users payload для диагностики A039 ([db2f0c9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/db2f0c93f2974410e744411fb9111c6de1f0f0be))
+* режим «Контакт и тикеты» возвращает support_type='both' вместо 'tickets' ([2f33e55](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f33e5514469f2686c4b35e2105f4188a41d4145))
+* реферальный бонус инвайтера — сумма вместо максимума, защита флага первого пополнения ([e1bcb1b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e1bcb1ba910ef3a79dec5fa974ae8e6c09494aa7))
+* сохранение user_id до rollback чтобы избежать MissingGreenlet при lazy load ([3f8e899](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3f8e8993b2949b5a5e04b1d8a468ef7dc1170e08))
+* убрана отправка externalSquadUuid=null в RemnaWave API и исправлен ложный лог синхронизации рулетки ([f80912e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f80912e444ab5706c809e689ca5ed2a38da118d0))
+* уведомление об истечении подписки теперь учитывает autopay_enabled пользователя ([c0b282a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c0b282a189a2b761c68fc70886edd91d9c807ff6))
+* устранена отправка externalSquadUuid=null в RemnaWave API (A039) и исправлен reduce_devices ([e453521](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e4535210982351413cb82483000fe441e7b7300a))
+
+
+### Refactoring
+
+* централизация всех расчётов цен в PricingEngine ([8d3cd50](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8d3cd500980f4f640cb1ba493150f1f20e8bd58c))
+
+## [3.32.3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.2...v3.32.3) (2026-03-14)
+
+
+### Bug Fixes
+
+* campaign registration, revenue calculation, backup restore, autopay errors, referral links ([7648707](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7648707ca26d6cd2703b50b0fe8c4697e6155784))
+* implement case-insensitive email checks in authentication and user retrieval ([7e466ef](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7e466ef464ce918d885bd6297d1e605a633fd43e))
+* implement case-insensitive email checks in authentication and user retrieval ([ebee834](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ebee8348ca338b9be5f044537e5e2b4740dc6441))
+* **payment:** prioritize saved cart after topup over expired auto-extend ([28321df](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/28321df4d274269536efebcf3da870f2e7d07d90))
+* refresh CLASSIC_PERIOD_PRICES when admin changes PRICE_*_DAYS or SALES_MODE ([6adf70b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6adf70b2da6e2250cc8e909dbb497b355302e72f))
+
+## [3.32.2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.1...v3.32.2) (2026-03-13)
+
+
+### Bug Fixes
+
+* add nested selectinload and referrer eager loading to prevent MissingGreenlet ([3306e02](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3306e029021c396e13774a205225beece4fbbcfb))
+* add selectinload to user lock queries to prevent MissingGreenlet ([5442f28](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5442f288d4c6c3973dd92ac141172a9f0e53a28f))
+* silence PARTICIPANT_ID_INVALID error in channel subscription check ([14dceaa](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/14dceaa39ff9faa1c9205483653014a1c5ac73fb))
+
+## [3.32.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.0...v3.32.1) (2026-03-13)
+
+
+### Bug Fixes
+
+* invalid ISO date format in node usage stats API call ([69a38da](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/69a38dad259bd05f4658e1014ce0bd73fc2e2ac5))
+* platega webhook ID fallback for SBP and card payments ([aa3459b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aa3459b8463ce0a54b7709aa3547b2337064fa26))
+* resolve MissingGreenlet in switch_tariff endpoint ([4d695be](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4d695be7d51adda40fa72c00c349fb0e1ec4acd2))
+
+## [3.32.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.31.0...v3.32.0) (2026-03-13)
+
+
+### New Features
+
+* add _calculate_servers_price (fixed fallback) and _calculate_traffic_price ([88369ee](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/88369eec5047e733d26d2450a74abd0d600b2e1b))
+* add CLASSIC_PERIOD_PRICES to config ([c3bb63f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c3bb63ffed6e0b684c322aa51d70ab7e71c8eb6b))
+* add LIMITED subscription status and preserve extra devices on tariff switch ([8f43452](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8f434525eb14618e3c3e26261d443b1632c111bb))
+* add RenewalPricing dataclass and PricingEngine discount methods ([83ca51c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/83ca51cd5b040e747c6db904dde0f3a5c59f480f))
+* implement calculate_renewal_price with tariff and classic modes ([02e5401](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/02e5401327786c9dfe5ae7d4c89624c9455aa53e))
+
+
+### Bug Fixes
+
+* add missing settings import in admin_users tariff switch ([b2ee6c7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b2ee6c766a1fb0c9a701684a6349b970d12f5e2e))
+* add per-category discounts and months multiplier to classic mode ([1660b24](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1660b24f9844374bbd156f9202a8e1550a6beb49))
+* add period_days whitelist validation and type annotations ([18e2e78](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/18e2e7841a6d614263e7c87db5964916ec869a9d))
+* address 6-agent review findings for PricingEngine ([c9f2dff](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c9f2dffabf6369df360c5f9ad7a12c0415026310))
+* address review findings from 5-agent audit ([08bea70](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/08bea704ded78102dce29deac8da95c4e4b9d815))
+* atomicity refactor, review fixes, and DELETED recovery logging ([ba54819](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ba54819f9cd7f60914dd472b68885683f435db4e))
+* change None assignment to [] + add "or []" guards at all 5 call sites. ([a5fbd74](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a5fbd7400f828824c5baa520bdaf06023b4caf70))
+* downgrade known-harmless RemnaWave 400s to warning level ([0419781](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/04197817fede058dc4688dce2f9877f0fc2a7f7f))
+* guard rollback on commit flag, add flush to promo_offer_log ([b7775b7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b7775b72dc7a1b3d18f179c2f247fe9f47023347))
+* handle legacy telegram_id in YooKassa webhook recovery metadata ([815a1d9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/815a1d9136f39b932d4b369aec9d67034d6785d9))
+* harden remnawave API error handling and YooKassa user cross-validation ([585baaf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/585baaf63c9f535e5311a32085d0187d8c854001))
+* harden YooKassa webhook recovery user lookup ([d35ee58](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d35ee58aa6f3edc6a9e8ab43025569262acf64a2))
+* payment providers — lock_user_for_update + commit=False atomicity ([b4ef52c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b4ef52caa4b324eded8e6c6cb715a09ad59140c1))
+* prevent balance loss on auto-purchase for DISABLED subscriptions and fix WATA expiration ([266340a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/266340aad195995f208ed82fc11e0909d34898f4))
+* pricing audit — display/charge parity, race conditions, balance locks ([ae99358](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ae99358ae9f35a25370ab127d98a0b630a08e3f2))
+* resolve merge conflict with dev (accept calc_device_limit_on_tariff_switch) ([ba049ca](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ba049ca017e004c25f8738f01b2d5f329a35bb5e))
+* user deletion FK error + connected_squads None TypeError ([a5fbd74](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a5fbd7400f828824c5baa520bdaf06023b4caf70))
+
+
+### Refactoring
+
+* add typed breakdowns + module-level singleton to PricingEngine ([b551def](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b551def3402e2bf762406fb0b374360958231bb3))
+* extract shared formatting helpers into app/utils/formatting.py ([5e9a462](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5e9a462261e46ee649de481266a821fd6793bf2e))
+* make finalize() accept both old and new pricing types ([3efa24b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3efa24bab3a2bd1d31103b134e502c10af8e41e1))
+* migrate admin user price calculation to PricingEngine ([49c0f3f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/49c0f3fc10d27092961601cf7f6a780fb56885fa))
+* migrate all callers to pricing_engine singleton + fix miniapp discount ([e24b911](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e24b911283bf4cbee7b18d3e49c935217e4a2863))
+* migrate bot renewal display to PricingEngine ([ce82c2c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ce82c2c00988542ac73dc9d2e811711ea9cefebe))
+* migrate bot renewal execute to PricingEngine ([acf27a1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/acf27a102308d38676b2ccaef78016b56a80935d))
+* migrate cabinet renewal display + execute to PricingEngine ([28fc36d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/28fc36dca41b626430baf823274561269023ac59))
+* migrate cart auto-purchase to PricingEngine (fresh calc) ([bd2e93a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bd2e93a6a5076341b104f7dba2b7fc5fdb587e66))
+* migrate menu.py renewal pricing to PricingEngine ([652b6da](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/652b6dabde014d19075f13198dd06e5fb8bef380))
+* migrate miniapp renewal display + execute to PricingEngine ([cb43aca](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cb43acab3194bbf9b6e2c04ca0254ba5b2571b2d))
+* migrate recurrent and monitoring services to PricingEngine ([978f68e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/978f68e7be42b0faf92d9ac5bc0bbaa2022ac95b))
+* migrate remaining callers to PricingEngine + cleanup dead CRUD ([75dbd2b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/75dbd2b4fcc8ab14ac44d915bf55b10406544bb1))
+* migrate try_auto_extend_expired to PricingEngine ([e6ebc67](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e6ebc6722d826d291156e6bff3bf86000b32b783))
+* remove dead pricing code and fix miniapp classic mode ([c9a9816](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c9a9816daa15a4534a3990822543eeefe1a1631b))
+* unify first-purchase discount algorithm with PricingEngine ([fe4e6ac](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fe4e6acb5391d0797ea01281eeb2e2ea59a0070f))
+
+## [3.31.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.30.0...v3.31.0) (2026-03-12)
+
+
+### New Features
+
+* add show_in_gift toggle for tariffs in admin panel ([cb5126a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cb5126aff8c15938a59ea9c4f8e605b250b05dbc))
+* add sync-squads endpoint for bulk updating subscription squads in Remnawave ([b1e2146](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b1e2146254255586b5be9bd894ac4d113a0a8cf5))
+* auto-sync squads to Remnawave when admin updates tariff ([076290e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/076290e0c1d81b610a7653d6b64ed218e0f124b4))
+* referral links now point to web cabinet instead of bot ([12ae871](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/12ae871653399bc4ccd23b6394878e814ce9cd75))
+
+
+### Bug Fixes
+
+* add post_update=True to User.referrals self-referential relationship ([9957259](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/995725988150f31d193631120a4692e88fa4dd57))
+* add Telegram Stars payment support for gift subscriptions ([5424d8c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5424d8c31484873b0adc0bc980abdc51ee81325b))
+* correct skipped_count in sync-squads circuit breaker and simplify ternary ([8a362db](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8a362db7833b5b7793b5b52345d227cb84cbc39e))
+* preserve purchased devices when admin changes user tariff ([bf72f24](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bf72f241d81e4432f50a61ec3bb829d18c92955d))
+* prevent account takeover via auto_login_token, ensure promo group on all purchase paths ([b3f3eba](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b3f3eba5756404df9ed0f12d8048244ca536f7d3))
+* reactivate subscription after traffic top-up when status is EXPIRED ([8b35428](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8b354280558a5f28d1b99eae55ccd21a4af6a07b))
+* update promo group via M2M table so admin changes persist ([68bc8eb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/68bc8eb57c792059d2be8a8fff6bba3254d3773d))
+
+
+### Refactoring
+
+* remove estimated price from balance, simplify server sync, fix HTML injection ([a798f11](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a798f1143eebf52e18254bddd610f7f14a0c4056))
+
+## [3.30.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.29.0...v3.30.0) (2026-03-11)
+
+
+### New Features
+
+* add gifts section to admin user detail API ([bca8bab](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bca8bab4336b2583da9be8c642985e6a0151e33d))
+* add promo group and promo offer discounts to gift subscriptions ([2fd0f6a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2fd0f6aa4eb62f704208c1e56a6542d3967e7867))
+
+
+### Bug Fixes
+
+* record transactions for free tariff switches and admin tariff changes ([864a4ed](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/864a4ed7005195ff3be3a8bb2e7666bc5a7f3e4e))
+* reset subscription for paid users, trial-to-paid tariff conversion, gift purchase MissingGreenlet ([e67b8e4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e67b8e448e5396ee6daa8c6278bb5a0b313dda74))
+* use keyword args for Path.mkdir in asyncio.to_thread ([2879996](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/287999645506a49b6693a184757598e1cdceb4d8))
+
+## [3.29.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.28.1...v3.29.0) (2026-03-10)
+
+
+### New Features
+
+* gift subscription code-only purchase + activation via deep link ([5ffce17](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5ffce175dcb8aebf22cf536bfa032c66da284600))
+* prevent self-activation of gift codes ([b30c73c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b30c73c300019646ea4a0d7e1bf758464ee58f0f))
+
+
+### Bug Fixes
+
+* 3 bugs — notification type, referral with channel sub, BOT_USERNAME ([3c96c2a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3c96c2affd5a803311e3c0c9a0f844d2217f387a))
+* 3 critical issues from second-round review ([a90d2d9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a90d2d936793daaadf116cf314b736a9ebfb7c3b))
+* add minimum 8-char length check for gift token in bot deep link ([8a8337f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8a8337f538c3fcaf84b84c34b7a1e38a4ce9d580))
+* address review findings from 6-agent audit ([5c34656](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5c3465647639d6f07432bc3d725bba9396af6c45))
+* code-only gifts skip fulfillment in gateway webhook + retry service ([05bcac5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/05bcac502efb1b4298a1c6be91bba5d7c057b9f0))
+* panel sync now updates end_date in both directions ([def594b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/def594bbb55ef45d3df81524bd8841de73a07340))
+* pass full token to svc_activate instead of truncated prefix ([38c6adf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/38c6adfdb4d4fc786bf6ca34a5d54025126130c0))
+* refresh user subscription after gift activation in /start ([363ccce](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/363ccce56d3e61554ca49d725322a79b05bc65d3))
+* remove begin_nested that breaks activate_purchase transaction ([0005d59](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0005d59da1e58c38561c8346db89d8475a25d7df))
+* stars rate rounding + device/traffic purchase stats ([641ff86](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/641ff86bf6f1ac1f22146f4344beda05759869fc))
+* support prefix-based gift code lookup for activation ([4fb72ae](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4fb72ae6e3bc65d93ab84b594b4ff5b4856c5357))
+
+
+### Refactoring
+
+* deduplicate gift activation in start.py ([769d3a0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/769d3a0b309fb6be1c3175cd66a0df7cb6e2fb67))
+* rename GIFTCODE_ start parameter prefix to GIFT_ ([42b6c80](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/42b6c80a48ad0100d5ddbbe99a096ebb7b292f08))
+
+## [3.28.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.28.0...v3.28.1) (2026-03-10)
+
+
+### Bug Fixes
+
+* migrate pricing to days-based proration, fix promo revenue leaks, fix admin panel bugs ([fcdeff1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fcdeff1ee5155c88c634e12a703159c221d66af5))
+
+## [3.28.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.27.0...v3.28.0) (2026-03-09)
+
+
+### New Features
+
+* add cabinet gift subscription API routes and schemas ([6a61b09](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6a61b095755885ff8973eb9ac4422740d07e0306))
+* add cabinet menu layout editor with row arrangement, custom URL buttons, and drag-and-drop reordering ([dd8d7f6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/dd8d7f69203490553d15dcdad6dda28fab02d593))
+* add CABINET_GIFT_ENABLED branding toggle ([759bfe1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/759bfe1bdb3a3d3f917334fd32d0ea2f5be5d1f0))
+* add open_in setting for custom buttons (external browser / webapp) ([497a8ee](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/497a8ee5b528cf80d7042a7eec62369b6a327339))
+* add source and buyer_user_id fields to GuestPurchase model ([0936d4a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0936d4a7f651a1fcef8c2f86818320af3764b423))
+* implement gateway payment for gifts, persist recipient warning ([cd04f3b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cd04f3b622444f45e2edf4a92da581f3d1f79b67))
+
+
+### Bug Fixes
+
+* enforce HTTPS for webapp mode, deduplicate keyboard builder, fix long line ([69dbd6a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/69dbd6a2df4cf5e0dd7156ca0f3beb53c4a061af))
+* harden gift subscription feature after multi-agent review ([6a4140e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6a4140e3e203beb20cc56aa9c65dfed70f0a12d7))
+* loyalty tiers current status based on spending, not assigned group ([b815abf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b815abf2b11e32eb658f9a8a63ae902bc0db46f4))
+* negate GIFT_PAYMENT amounts and remove dead code ([f80b058](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f80b0583804f27c322a4eb27f0613163ca1f97e9))
+* normalize threshold 0→NULL in create_promo_group for consistency ([b9089e6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b9089e693f823e3b8618d08329ccba559592dfa3))
+* payment gateway issues — YooKassa polling, PAL24 card 500 ([95a32e8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/95a32e8574320eeba9276e44551a2f1207ae1e8b))
+* support Telegram OIDC id_token in account linking endpoint ([680c22c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/680c22c0179253d24f7f89e115a283dac92f9a49))
+
 ## [3.27.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.26.0...v3.27.0) (2026-03-09)
 
 

CONTRIBUTING.md

@@ -197,28 +197,17 @@ async def create_subscription(
 ### Документация кода
 
 ```python
-async def calculate_subscription_price(
-    period_days: int,
-    traffic_gb: int,
-    devices_count: int,
-    servers_count: int
-) -> int:
-    """
-    Рассчитывает стоимость подписки.
-    
-    Args:
-        period_days: Период подписки в днях
-        traffic_gb: Лимит трафика в ГБ (0 = безлимит)
-        devices_count: Количество устройств
-        servers_count: Количество серверов
-        
-    Returns:
-        Стоимость в копейках
-        
-    Raises:
-        ValueError: Если переданы некорректные параметры
-    """
-    # implementation
+from app.services.pricing_engine import PricingEngine
+
+pricing = PricingEngine.calculate_renewal_price(
+    subscription=subscription,
+    period_days=30,
+    user=user,
+)
+# pricing.final_total — стоимость в копейках
+# pricing.original_total — цена до скидок
+# pricing.promo_group_discount — скидка промогруппы
+# pricing.promo_offer_discount — скидка промо-оффера
 ```
 
 ### Обработка ошибок
@@ -341,20 +330,18 @@ python main.py
 ### Тестирование компонентов
 
 ```python
-# tests/test_subscription_service.py
+# tests/services/test_pricing_engine.py
 import pytest
-from app.services.subscription_service import SubscriptionService
+from app.services.pricing_engine import PricingEngine
 
-@pytest.mark.asyncio
-async def test_calculate_price():
-    price = await SubscriptionService.calculate_subscription_price(
+def test_calculate_renewal_price():
+    pricing = PricingEngine.calculate_renewal_price(
+        subscription=mock_subscription,
         period_days=30,
-        traffic_gb=100,
-        devices_count=3,
-        servers_count=1
+        user=mock_user,
     )
-    assert price > 0
-    assert isinstance(price, int)
+    assert pricing.final_total > 0
+    assert isinstance(pricing.final_total, int)
 ```
 
 ### Integration тесты

Dockerfile

@@ -19,7 +19,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 
 FROM python:3.13-slim
 
-ARG VERSION="v3.27.0" # x-release-please-version
+ARG VERSION="v3.43.1" # x-release-please-version
 ARG BUILD_DATE
 ARG VCS_REF
 
@@ -33,7 +33,8 @@ WORKDIR /app
 
 COPY --chown=app:app . .
 
-RUN mkdir -p logs data && chown app:app logs data
+RUN mkdir -p logs data uploads/images uploads/videos uploads/thumbnails && \
+    chown -R app:app logs data uploads
 
 USER app
 

app/bot.py

@@ -67,6 +67,7 @@ from app.middlewares.blacklist import BlacklistMiddleware
 from app.middlewares.button_stats import ButtonStatsMiddleware
 from app.middlewares.chat_type_filter import ChatTypeFilterMiddleware
 from app.middlewares.context_binding import ContextVarsMiddleware
+from app.middlewares.display_name_restriction import DisplayNameRestrictionMiddleware
 from app.middlewares.global_error import GlobalErrorMiddleware
 from app.middlewares.logging import LoggingMiddleware
 from app.middlewares.maintenance import MaintenanceMiddleware
@@ -96,10 +97,21 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     except Exception as e:
         logger.warning('Кеш не инициализирован', error=e)
 
-    from aiogram.client.default import DefaultBotProperties
-    from aiogram.enums import ParseMode
+    from app.bot_factory import create_bot
 
-    bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    bot = create_bot()
+
+    proxy_url = settings.get_proxy_url()
+    nalogo_proxy_url = settings.get_nalogo_proxy_url()
+
+    if proxy_url or nalogo_proxy_url:
+        from app.utils.proxy import mask_proxy_url
+
+        if proxy_url:
+            logger.info('Proxy configured', proxy_url=mask_proxy_url(proxy_url))
+        if nalogo_proxy_url:
+            source = 'NALOGO_PROXY_URL' if settings.NALOGO_PROXY_URL else 'PROXY_URL (fallback)'
+            logger.info('Nalogo proxy configured', proxy_url=mask_proxy_url(nalogo_proxy_url), source=source)
 
     maintenance_service.set_bot(bot)
     logger.info('Бот установлен в maintenance_service')
@@ -122,11 +134,11 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     chat_type_filter = ChatTypeFilterMiddleware()
     dp.message.middleware(chat_type_filter)
     dp.callback_query.middleware(chat_type_filter)
+    dp.message.middleware(LoggingMiddleware())
+    dp.callback_query.middleware(LoggingMiddleware())
     dp.message.middleware(GlobalErrorMiddleware())
     dp.callback_query.middleware(GlobalErrorMiddleware())
     dp.pre_checkout_query.middleware(GlobalErrorMiddleware())
-    dp.message.middleware(LoggingMiddleware())
-    dp.callback_query.middleware(LoggingMiddleware())
     dp.message.middleware(MaintenanceMiddleware())
     dp.callback_query.middleware(MaintenanceMiddleware())
     blacklist_middleware = BlacklistMiddleware()
@@ -151,8 +163,12 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     dp.message.middleware(AuthMiddleware())
     dp.callback_query.middleware(AuthMiddleware())
     dp.pre_checkout_query.middleware(AuthMiddleware())
+    display_name_restriction = DisplayNameRestrictionMiddleware()
+    dp.message.middleware(display_name_restriction)
+    dp.callback_query.middleware(display_name_restriction)
     dp.message.middleware(SubscriptionStatusMiddleware())
     dp.callback_query.middleware(SubscriptionStatusMiddleware())
+    dp.pre_checkout_query.middleware(SubscriptionStatusMiddleware())
     start.register_handlers(dp)
     menu.register_handlers(dp)
     subscription.register_handlers(dp)
@@ -248,7 +264,7 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     elif settings.is_cabinet_mode():
         logger.info('🏠 Режим Cabinet активен, базовый URL', MINIAPP_CUSTOM_URL=settings.MINIAPP_CUSTOM_URL)
 
-    # Load per-section button styles cache
+    # Load per-section button styles cache and menu layout cache
     if settings.is_cabinet_mode():
         try:
             from app.utils.button_styles_cache import load_button_styles_cache
@@ -257,6 +273,13 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
         except Exception as e:
             logger.warning('Failed to load button styles cache', error=e)
 
+        try:
+            from app.utils.menu_layout_cache import load_menu_layout_cache
+
+            await load_menu_layout_cache()
+        except Exception as e:
+            logger.warning('Failed to load menu layout cache', error=e)
+
     logger.info('Бот успешно настроен')
 
     return bot, dp

app/bot_factory.py

@@ -0,0 +1,20 @@
+"""Factory for creating Bot instances with proxy support."""
+
+from aiogram import Bot
+from aiogram.client.default import DefaultBotProperties
+from aiogram.enums import ParseMode
+
+from app.config import settings
+
+
+def create_bot(token: str | None = None, **kwargs) -> Bot:
+    """Create a Bot instance with SOCKS5 proxy session if PROXY_URL is configured."""
+    proxy_url = settings.get_proxy_url()
+    session = None
+    if proxy_url:
+        from aiogram.client.session.aiohttp import AiohttpSession
+
+        session = AiohttpSession(proxy=proxy_url)
+
+    kwargs.setdefault('default', DefaultBotProperties(parse_mode=ParseMode.HTML))
+    return Bot(token=token or settings.BOT_TOKEN, session=session, **kwargs)

app/cabinet/auth/telegram_auth.py

@@ -49,7 +49,17 @@ def validate_telegram_login_widget(data: dict[str, Any], max_age_seconds: int =
         auth_time = datetime.fromtimestamp(int(auth_date), tz=UTC)
         age = (datetime.now(UTC) - auth_time).total_seconds()
         if age > max_age_seconds or age < -_MAX_CLOCK_SKEW_SECONDS:
+            logger.warning(
+                'Telegram widget auth rejected: too old',
+                age_hours=round(age / 3600, 1),
+                max_age_hours=round(max_age_seconds / 3600, 1),
+            )
             return False
+        if age > 86400:
+            logger.info(
+                'Telegram widget auth accepted with stale auth_date',
+                age_hours=round(age / 3600, 1),
+            )
     except (ValueError, TypeError, OSError):
         return False
 
@@ -96,7 +106,17 @@ def validate_telegram_init_data(init_data: str, max_age_seconds: int = 86400) ->
             auth_time = datetime.fromtimestamp(int(auth_date), tz=UTC)
             age = (datetime.now(UTC) - auth_time).total_seconds()
             if age > max_age_seconds or age < -_MAX_CLOCK_SKEW_SECONDS:
+                logger.warning(
+                    'Telegram initData rejected: too old',
+                    age_hours=round(age / 3600, 1),
+                    max_age_hours=round(max_age_seconds / 3600, 1),
+                )
                 return None
+            if age > 86400:
+                logger.info(
+                    'Telegram initData accepted with stale auth_date (Telegram caching bug)',
+                    age_hours=round(age / 3600, 1),
+                )
         except (ValueError, TypeError, OSError):
             return None
 

app/cabinet/routes/__init__.py

@@ -12,6 +12,11 @@ from .admin_campaigns import router as admin_campaigns_router
 from .admin_channels import router as admin_channels_router
 from .admin_email_templates import router as admin_email_templates_router
 from .admin_landings import router as admin_landings_router
+from .admin_menu_layout import router as admin_menu_layout_router
+from .admin_news import router as admin_news_router
+from .admin_news_categories import router as admin_news_categories_router
+from .admin_news_media import router as admin_news_media_router
+from .admin_news_tags import router as admin_news_tags_router
 from .admin_partners import router as admin_partners_router
 from .admin_payment_methods import router as admin_payment_methods_router
 from .admin_payments import router as admin_payments_router
@@ -19,6 +24,7 @@ from .admin_pinned_messages import router as admin_pinned_messages_router
 from .admin_policies import router as admin_policies_router
 from .admin_promo_offers import router as admin_promo_offers_router
 from .admin_promocodes import promo_groups_router as admin_promo_groups_router, router as admin_promocodes_router
+from .admin_referral_network import router as admin_referral_network_router
 from .admin_remnawave import router as admin_remnawave_router
 from .admin_roles import router as admin_roles_router
 from .admin_sales_stats import router as admin_sales_stats_router
@@ -36,9 +42,11 @@ from .auth import router as auth_router
 from .balance import router as balance_router
 from .branding import router as branding_router
 from .contests import router as contests_router
+from .gift import router as gift_router
 from .info import router as info_router
 from .landing import router as landing_router
 from .media import router as media_router
+from .news import router as news_router
 from .notifications import router as notifications_router
 from .oauth import router as oauth_router
 from .partner_application import router as partner_application_router
@@ -47,6 +55,7 @@ from .promo import router as promo_router
 from .promocode import router as promocode_router
 from .referral import router as referral_router
 from .subscription import router as subscription_router
+from .subscription_modules.multi_tariff import router as multi_tariff_subscription_router
 from .ticket_notifications import (
     admin_router as admin_ticket_notifications_router,
     router as ticket_notifications_router,
@@ -58,7 +67,7 @@ from .withdrawal import router as withdrawal_router
 
 
 # Main cabinet router
-router = APIRouter(prefix='/cabinet', tags=['Cabinet'])
+router = APIRouter(prefix='/cabinet', tags=['Cabinet'], redirect_slashes=False)
 
 # Include all sub-routers
 router.include_router(auth_router)
@@ -66,6 +75,7 @@ router.include_router(oauth_router)
 router.include_router(account_linking_router)
 router.include_router(merge_router)
 router.include_router(subscription_router)
+router.include_router(multi_tariff_subscription_router)
 router.include_router(balance_router)
 router.include_router(referral_router)
 router.include_router(partner_application_router)
@@ -82,10 +92,14 @@ router.include_router(info_router)
 router.include_router(branding_router)
 router.include_router(landing_router)
 router.include_router(media_router)
+router.include_router(news_router)
 
 # Wheel routes
 router.include_router(wheel_router)
 
+# Gift routes
+router.include_router(gift_router)
+
 # Admin routes (notifications router MUST be before tickets router to avoid route conflict)
 router.include_router(admin_ticket_notifications_router)
 router.include_router(admin_tickets_router)
@@ -94,6 +108,7 @@ router.include_router(admin_wheel_router)
 router.include_router(admin_tariffs_router)
 router.include_router(admin_servers_router)
 router.include_router(admin_stats_router)
+router.include_router(admin_referral_network_router)
 router.include_router(admin_sales_stats_router)
 router.include_router(admin_ban_system_router)
 router.include_router(admin_broadcasts_router)
@@ -113,11 +128,18 @@ router.include_router(admin_updates_router)
 router.include_router(admin_traffic_router)
 router.include_router(admin_pinned_messages_router)
 router.include_router(admin_button_styles_router)
+router.include_router(admin_menu_layout_router)
 router.include_router(admin_channels_router)
 router.include_router(admin_apps_router)
 router.include_router(admin_roles_router)
 router.include_router(admin_policies_router)
 router.include_router(admin_audit_log_router)
+# Categories/tags/media routers MUST be before the main news router
+# to avoid /admin/news/{article_id} catching /admin/news/categories etc.
+router.include_router(admin_news_categories_router)
+router.include_router(admin_news_tags_router)
+router.include_router(admin_news_media_router)
+router.include_router(admin_news_router)
 
 # WebSocket route
 router.include_router(websocket_router)

app/cabinet/routes/account_linking.py

@@ -5,6 +5,7 @@ Router 1 (`router`): JWT-protected endpoints for linking/unlinking OAuth provide
 Router 2 (`merge_router`): Public endpoints for merge preview and execution.
 """
 
+import hashlib
 from datetime import UTC, datetime
 from typing import Literal, NotRequired, TypedDict
 
@@ -14,6 +15,8 @@ from pydantic import BaseModel, Field, model_validator
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.config import settings
+from app.database.crud.system_setting import get_setting_value
 from app.database.crud.user import (
     OAUTH_PROVIDER_COLUMNS,
     clear_user_oauth_provider_id,
@@ -24,7 +27,7 @@ from app.database.crud.user import (
 )
 from app.database.models import User
 from app.services.account_merge_service import compute_auth_methods, execute_merge, get_merge_preview
-from app.utils.cache import RateLimitCache
+from app.utils.cache import RateLimitCache, TokenReplayCache
 
 from ..auth.merge_service import (
     MERGE_TOKEN_TTL_SECONDS,
@@ -38,7 +41,11 @@ from ..auth.oauth_providers import (
     get_provider,
     validate_oauth_state,
 )
-from ..auth.telegram_auth import validate_telegram_init_data, validate_telegram_login_widget
+from ..auth.telegram_auth import (
+    validate_telegram_init_data,
+    validate_telegram_login_widget,
+    validate_telegram_oidc_token,
+)
 from ..dependencies import get_cabinet_db, get_current_cabinet_user
 from ..ip_utils import get_client_ip
 from ..schemas.auth import UserResponse
@@ -70,8 +77,6 @@ class OAuthStateData(TypedDict):
 
 def _get_active_providers() -> list[str]:
     """Вернуть список активных провайдеров аутентификации (только включённые)."""
-    from app.config import settings
-
     providers: list[str] = ['telegram']
     if settings.is_cabinet_email_auth_enabled():
         providers.append('email')
@@ -117,10 +122,12 @@ class UnlinkResponse(BaseModel):
 
 
 class LinkTelegramRequest(BaseModel):
-    """Request for linking Telegram account. Supply EITHER init_data OR widget fields."""
+    """Request for linking Telegram account. Supply EITHER init_data, id_token, OR widget fields."""
 
     # Mini App: Telegram WebApp initData
     init_data: str | None = Field(None, max_length=4096, description='Telegram WebApp initData string')
+    # OIDC: id_token from Telegram Login popup
+    id_token: str | None = Field(None, max_length=4096, description='Telegram OIDC id_token (JWT)')
     # Login Widget fields
     id: int | None = Field(None, description='Telegram user ID from Login Widget')
     first_name: str | None = Field(None, max_length=256, description="User's first name")
@@ -133,11 +140,13 @@ class LinkTelegramRequest(BaseModel):
     @model_validator(mode='after')
     def check_exclusive(self) -> 'LinkTelegramRequest':
         has_init = self.init_data is not None
+        has_oidc = self.id_token is not None
         has_widget = self.id is not None or self.hash is not None or self.auth_date is not None
-        if has_init and has_widget:
-            raise ValueError('Provide either init_data or Login Widget fields, not both')
-        if not has_init and not has_widget:
-            raise ValueError('Provide either init_data or Login Widget fields (id, auth_date, hash)')
+        modes = sum([has_init, has_oidc, has_widget])
+        if modes > 1:
+            raise ValueError('Provide exactly one of: init_data, id_token, or Login Widget fields')
+        if modes == 0:
+            raise ValueError('Provide one of: init_data, id_token, or Login Widget fields (id, auth_date, hash)')
         if has_widget and not (self.id is not None and self.auth_date is not None and self.hash is not None):
             raise ValueError('Login Widget mode requires id, auth_date, and hash fields')
         return self
@@ -449,10 +458,20 @@ async def unlink_provider(
 @router.post('/link/telegram', response_model=LinkCallbackResponse)
 async def link_telegram(
     request: LinkTelegramRequest,
+    raw_request: Request,
     user: User = Depends(get_current_cabinet_user),
     db: AsyncSession = Depends(get_cabinet_db),
 ) -> LinkCallbackResponse:
-    """Link Telegram account via WebApp initData or Login Widget."""
+    """Link Telegram account via WebApp initData, OIDC id_token, or Login Widget."""
+    # Rate limit
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'link_telegram', limit=10, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
     # 1. Already has Telegram linked?
     if user.telegram_id:
         raise HTTPException(
@@ -468,7 +487,8 @@ async def link_telegram(
 
     if request.init_data:
         # Mini App flow: validate initData
-        user_data = validate_telegram_init_data(request.init_data)
+        # Generous max_age: Telegram Desktop/iOS cache initData with stale auth_date
+        user_data = validate_telegram_init_data(request.init_data, max_age_seconds=86400 * 30)
         if not user_data or not user_data.get('id'):
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
@@ -478,6 +498,53 @@ async def link_telegram(
         telegram_username = user_data.get('username')
         telegram_first_name = user_data.get('first_name')
         telegram_last_name = user_data.get('last_name')
+    elif request.id_token:
+        # OIDC flow: validate id_token via JWKS
+        oidc_enabled_val = await get_setting_value(db, 'TELEGRAM_OIDC_ENABLED')
+        oidc_client_id_val = await get_setting_value(db, 'TELEGRAM_OIDC_CLIENT_ID')
+        oidc_client_id = oidc_client_id_val or settings.TELEGRAM_OIDC_CLIENT_ID
+        oidc_enabled = (
+            oidc_enabled_val.lower() == 'true' if oidc_enabled_val is not None else settings.TELEGRAM_OIDC_ENABLED
+        ) and bool(oidc_client_id)
+
+        if not oidc_enabled:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Telegram OIDC is not configured',
+            )
+
+        claims = await validate_telegram_oidc_token(request.id_token, oidc_client_id)
+        if not claims:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail='Invalid or expired Telegram OIDC token',
+            )
+
+        # Replay detection
+        token_hash = hashlib.sha256(request.id_token.encode()).hexdigest()
+        token_ttl = max(int(claims.get('exp', 0) - datetime.now(UTC).timestamp()), 60)
+        if await TokenReplayCache.is_token_replayed(token_hash, ttl=min(token_ttl, 600)):
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail='Invalid or expired Telegram OIDC token',
+            )
+
+        try:
+            telegram_id = int(claims.get('id', claims.get('sub', 0)))
+        except (ValueError, TypeError) as exc:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail='Invalid user ID in OIDC claims',
+            ) from exc
+        if not telegram_id:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail='Missing user ID in OIDC claims',
+            )
+
+        telegram_username = claims.get('preferred_username')
+        telegram_first_name = claims.get('name', claims.get('given_name', ''))
+        telegram_last_name = claims.get('family_name')
     elif request.id is not None and request.hash is not None and request.auth_date is not None:
         # Login Widget flow: validate widget hash
         widget_data = {
@@ -494,7 +561,8 @@ async def link_telegram(
         if request.photo_url is not None:
             widget_data['photo_url'] = request.photo_url
 
-        if not validate_telegram_login_widget(widget_data):
+        # Generous max_age: Telegram caches auth data with stale auth_date
+        if not validate_telegram_login_widget(widget_data, max_age_seconds=86400 * 30):
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail='Invalid or expired Telegram Login Widget data',
@@ -506,7 +574,7 @@ async def link_telegram(
     else:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail='Provide either init_data (Mini App) or Login Widget fields (id, auth_date, hash)',
+            detail='Provide init_data (Mini App), id_token (OIDC), or Login Widget fields (id, auth_date, hash)',
         )
 
     # 3. Check if telegram_id is linked to ANOTHER user

app/cabinet/routes/admin_broadcasts.py

@@ -411,6 +411,13 @@ async def create_broadcast(
 
     media_payload = request.media
 
+    # Validate caption length for media messages (Telegram limit: 1024 chars)
+    if media_payload and len(message_text) > 1024:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f'Текст слишком длинный для сообщения с медиа. Максимум 1024 символов, сейчас {len(message_text)}. Сократите текст или уберите медиафайл.',
+        )
+
     # Create broadcast record
     broadcast = BroadcastHistory(
         target_type=request.target,
@@ -446,6 +453,7 @@ async def create_broadcast(
         selected_buttons=request.selected_buttons,
         media=media_config,
         initiator_name=admin.username or f'Admin #{admin.id}',
+        custom_buttons=[btn.model_dump() for btn in request.custom_buttons] if request.custom_buttons else None,
     )
 
     # Start broadcast
@@ -644,6 +652,7 @@ async def create_combined_broadcast(
             selected_buttons=request.selected_buttons,
             media=media_config,
             initiator_name=admin_name,
+            custom_buttons=[btn.model_dump() for btn in request.custom_buttons] if request.custom_buttons else None,
         )
 
         await broadcast_service.start_broadcast(broadcast.id, telegram_config)

app/cabinet/routes/admin_email_templates.py

@@ -312,7 +312,7 @@ TEMPLATE_TYPES = [
             'zh': '通过落地页成功付款后发送给买家的邮件',
             'ua': 'Лист покупцю після успішної оплати через лендінг',
         },
-        'context_vars': ['tariff_name', 'period_days', 'cabinet_url'],
+        'context_vars': ['tariff_name', 'period_days', 'cabinet_url', 'cabinet_email', 'cabinet_password'],
     },
     {
         'type': 'guest_activation_required',
@@ -425,6 +425,8 @@ SAMPLE_CONTEXTS: dict[str, dict[str, Any]] = {
         'tariff_name': 'Premium',
         'period_days': 30,
         'cabinet_url': 'https://example.com/cabinet',
+        'cabinet_email': 'user@example.com',
+        'cabinet_password': 'SecurePass123',
     },
     'guest_activation_required': {
         'tariff_name': 'Premium',
@@ -670,8 +672,8 @@ async def preview_template(
     language = data.language if data.language in AVAILABLE_LANGUAGES else 'ru'
 
     if data.body_html:
-        # Preview custom content wrapped in base template
-        rendered_html = templates_instance._get_base_template(data.body_html, language)
+        # Preview custom content — auto-detects styled vs simple HTML
+        rendered_html = templates_instance._wrap_override_template(data.body_html, language)
         subject = data.subject or notification_type
     else:
         # Preview default template

app/cabinet/routes/admin_landings.py

@@ -483,6 +483,7 @@ class OrderRequest(BaseModel):
 
 class LandingDailyStat(BaseModel):
     date: str  # YYYY-MM-DD
+    created: int = 0
     purchases: int
     revenue_kopeks: int
     gifts: int
@@ -844,17 +845,35 @@ async def get_landing_stats(
     )
     daily_rows = {str(r.day): r for r in daily_result.all()}
 
+    # Created per day (all statuses, by created_at)
+    day_created_utc = func.date(func.timezone('UTC', GuestPurchase.created_at))
+    created_result = await db.execute(
+        select(
+            day_created_utc.label('day'),
+            func.count(GuestPurchase.id).label('created'),
+        )
+        .where(
+            GuestPurchase.landing_id == landing_id,
+            GuestPurchase.created_at >= cutoff,
+        )
+        .group_by(day_created_utc)
+        .order_by(day_created_utc)
+    )
+    created_rows = {str(r.day): r.created for r in created_result.all()}
+
     # Fill missing days with zeros
     today = now.date()
     daily_stats: list[LandingDailyStat] = []
     for i in range(_STATS_PERIOD_DAYS, -1, -1):
         day = today - timedelta(days=i)
         day_str = day.isoformat()
+        day_created = created_rows.get(day_str, 0)
         if day_str in daily_rows:
             r = daily_rows[day_str]
             daily_stats.append(
                 LandingDailyStat(
                     date=day_str,
+                    created=day_created,
                     purchases=r.purchases,
                     revenue_kopeks=r.revenue_kopeks,
                     gifts=r.gifts,
@@ -864,6 +883,7 @@ async def get_landing_stats(
             daily_stats.append(
                 LandingDailyStat(
                     date=day_str,
+                    created=day_created,
                     purchases=0,
                     revenue_kopeks=0,
                     gifts=0,
@@ -897,7 +917,7 @@ async def get_landing_stats(
     ]
 
     return LandingStatsResponse(
-        total_purchases=total_successful,
+        total_purchases=total_created,
         total_revenue_kopeks=total_revenue_kopeks,
         total_gifts=total_gifts,
         total_regular=total_regular,

app/cabinet/routes/admin_menu_layout.py

@@ -0,0 +1,398 @@
+"""Admin routes for cabinet menu layout configuration (rows + custom URL buttons).
+
+Serves a MERGED view combining ``CABINET_MENU_LAYOUT`` (row arrangement, custom buttons)
+and ``CABINET_BUTTON_STYLES`` (per-section style/emoji/enabled/labels) to the frontend.
+On save, splits the payload back into two SystemSetting keys.
+"""
+
+import json
+import re
+from typing import Literal
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.utils.button_styles_cache import (
+    ALLOWED_STYLE_VALUES,
+    BOT_LOCALES,
+    BUTTON_STYLES_KEY,
+    DEFAULT_BUTTON_STYLES,
+    get_cached_button_styles,
+    load_button_styles_cache,
+)
+from app.utils.menu_layout_cache import (
+    BUILTIN_SECTIONS,
+    DEFAULT_MENU_LAYOUT,
+    MENU_LAYOUT_KEY,
+    VALID_CUSTOM_BUTTON_STYLES,
+    get_cached_menu_layout,
+    load_menu_layout_cache,
+)
+
+from ..dependencies import get_cabinet_db, require_permission
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/menu-layout', tags=['Admin Menu Layout'])
+
+# ---- Constants ---------------------------------------------------------------
+
+MAX_ROWS = 20
+MAX_BUTTONS_PER_ROW = 3
+MAX_LABEL_LENGTH = 100
+URL_PATTERN = re.compile(r'^https?://')
+
+
+# ---- Schemas -----------------------------------------------------------------
+
+
+class ButtonConfig(BaseModel):
+    """Configuration for a single button (built-in or custom URL)."""
+
+    id: str = Field(max_length=100)
+    type: Literal['builtin', 'custom']
+    style: str = Field(default='primary', max_length=20)
+    icon_custom_emoji_id: str = Field(default='', max_length=100)
+    enabled: bool = True
+    labels: dict[str, str] = Field(default_factory=dict, max_length=10)
+    url: str | None = Field(default=None, max_length=2048)
+    open_in: Literal['external', 'webapp'] = 'external'
+
+
+class RowConfig(BaseModel):
+    """Configuration for a single row of buttons."""
+
+    id: str = Field(max_length=100)
+    max_per_row: int = Field(default=2, ge=1, le=3)
+    buttons: list[ButtonConfig] = Field(default_factory=list, max_length=MAX_BUTTONS_PER_ROW)
+
+
+class MenuConfigResponse(BaseModel):
+    """Full merged menu configuration returned to the frontend."""
+
+    rows: list[RowConfig]
+
+
+class MenuConfigUpdateRequest(BaseModel):
+    """Full menu configuration submitted by the frontend."""
+
+    rows: list[RowConfig] = Field(max_length=MAX_ROWS)
+
+
+# ---- Helpers -----------------------------------------------------------------
+
+
+async def _get_setting_value(db: AsyncSession, key: str) -> str | None:
+    from sqlalchemy import select
+
+    from app.database.models import SystemSetting
+
+    result = await db.execute(select(SystemSetting).where(SystemSetting.key == key))
+    setting = result.scalar_one_or_none()
+    return setting.value if setting else None
+
+
+async def _upsert_setting(db: AsyncSession, key: str, value: str) -> None:
+    """Insert or update a SystemSetting without committing."""
+    from sqlalchemy import select
+
+    from app.database.models import SystemSetting
+
+    result = await db.execute(select(SystemSetting).where(SystemSetting.key == key))
+    setting = result.scalar_one_or_none()
+    if setting:
+        setting.value = value
+    else:
+        setting = SystemSetting(key=key, value=value)
+        db.add(setting)
+
+
+def _build_merged_response(
+    layout: dict[str, object],
+    button_styles: dict[str, dict],
+) -> MenuConfigResponse:
+    """Merge layout rows with button_styles into a unified response.
+
+    Built-in buttons get style/emoji/enabled/labels from ``button_styles``.
+    Custom URL buttons get all config from layout's ``custom_buttons``.
+    """
+    custom_buttons: dict[str, dict] = layout.get('custom_buttons', {})
+
+    # Collect row entries sorted numerically (row_1, row_2, ..., row_10, ...)
+    row_keys = sorted(
+        (k for k in layout if k.startswith('row_')),
+        key=lambda k: int(k.split('_', 1)[1]) if k.split('_', 1)[1].isdigit() else 0,
+    )
+
+    rows: list[RowConfig] = []
+    for row_key in row_keys:
+        row_data = layout[row_key]
+        if not isinstance(row_data, dict):
+            continue
+
+        raw_buttons: list[str] = row_data.get('buttons', [])
+        max_per_row: int = row_data.get('max_per_row', 2)
+        row_id: str = row_data.get('id', row_key)
+
+        merged_buttons: list[ButtonConfig] = []
+        for btn_id in raw_buttons:
+            if btn_id in BUILTIN_SECTIONS:
+                # Built-in: pull style data from button_styles cache
+                style_cfg = button_styles.get(btn_id, {})
+                merged_buttons.append(
+                    ButtonConfig(
+                        id=btn_id,
+                        type='builtin',
+                        style=style_cfg.get('style', 'primary'),
+                        icon_custom_emoji_id=style_cfg.get('icon_custom_emoji_id', ''),
+                        enabled=style_cfg.get('enabled', True),
+                        labels=style_cfg.get('labels', {}),
+                    ),
+                )
+            elif btn_id.startswith('custom_') and btn_id in custom_buttons:
+                # Custom URL button: pull config from layout's custom_buttons
+                cb = custom_buttons[btn_id]
+                merged_buttons.append(
+                    ButtonConfig(
+                        id=btn_id,
+                        type='custom',
+                        style=cb.get('style', 'primary'),
+                        icon_custom_emoji_id=cb.get('icon_custom_emoji_id', ''),
+                        enabled=cb.get('enabled', True),
+                        labels=cb.get('labels', {}),
+                        url=cb.get('url'),
+                        open_in=cb.get('open_in', 'external'),
+                    ),
+                )
+
+        rows.append(
+            RowConfig(
+                id=row_id,
+                max_per_row=max_per_row,
+                buttons=merged_buttons,
+            ),
+        )
+
+    return MenuConfigResponse(rows=rows)
+
+
+def _split_update(
+    rows: list[RowConfig],
+) -> tuple[dict[str, object], dict[str, dict]]:
+    """Split a flat list of RowConfig back into layout_data and button_styles_updates.
+
+    Returns:
+        (layout_data, button_styles_updates)
+        - layout_data: rows + custom_buttons for ``CABINET_MENU_LAYOUT``
+        - button_styles_updates: ``{section: {style, icon_custom_emoji_id, enabled, labels}}``
+          for built-in sections only
+    """
+    layout_data: dict[str, object] = {}
+    custom_buttons: dict[str, dict] = {}
+    button_styles_updates: dict[str, dict] = {}
+
+    for idx, row in enumerate(rows, start=1):
+        row_key = f'row_{idx}'
+        button_ids: list[str] = []
+
+        for btn in row.buttons:
+            button_ids.append(btn.id)
+
+            if btn.type == 'builtin' and btn.id in BUILTIN_SECTIONS:
+                button_styles_updates[btn.id] = {
+                    'style': btn.style,
+                    'icon_custom_emoji_id': btn.icon_custom_emoji_id,
+                    'enabled': btn.enabled,
+                    'labels': btn.labels,
+                }
+            elif btn.type == 'custom' and btn.id.startswith('custom_'):
+                custom_buttons[btn.id] = {
+                    'id': btn.id,
+                    'url': btn.url or '',
+                    'style': btn.style,
+                    'icon_custom_emoji_id': btn.icon_custom_emoji_id,
+                    'enabled': btn.enabled,
+                    'labels': btn.labels,
+                    'open_in': btn.open_in,
+                }
+
+        layout_data[row_key] = {
+            'id': row.id or row_key,
+            'buttons': button_ids,
+            'max_per_row': row.max_per_row,
+        }
+
+    layout_data['custom_buttons'] = custom_buttons
+    return layout_data, button_styles_updates
+
+
+def _validate_update_payload(rows: list[RowConfig]) -> None:
+    """Validate the full update payload. Raises HTTPException on failure."""
+    if len(rows) > MAX_ROWS:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f'Too many rows: {len(rows)}. Maximum allowed: {MAX_ROWS}.',
+        )
+
+    # Check for duplicate button IDs across all rows
+    seen_ids: set[str] = set()
+    for row in rows:
+        for btn in row.buttons:
+            if btn.id in seen_ids:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f'Duplicate button ID: "{btn.id}". Each button can only appear once.',
+                )
+            seen_ids.add(btn.id)
+
+    for row in rows:
+        if len(row.buttons) > MAX_BUTTONS_PER_ROW:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Row "{row.id}" has {len(row.buttons)} buttons. Maximum per row: {MAX_BUTTONS_PER_ROW}.',
+            )
+
+        for btn in row.buttons:
+            # Validate button type consistency
+            if btn.type == 'builtin' and btn.id not in BUILTIN_SECTIONS:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f'Unknown built-in section: "{btn.id}".',
+                )
+
+            if btn.type == 'custom' and not btn.id.startswith('custom_'):
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f'Custom button id must start with "custom_": "{btn.id}".',
+                )
+
+            # Validate URL for custom buttons
+            if btn.type == 'custom':
+                if not btn.url or not URL_PATTERN.match(btn.url):
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f'Custom button "{btn.id}" must have a URL starting with http:// or https://.',
+                    )
+                if btn.open_in == 'webapp' and not btn.url.startswith('https://'):
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f'Custom button "{btn.id}" with webapp mode requires an https:// URL.',
+                    )
+
+            # Validate style
+            all_allowed = ALLOWED_STYLE_VALUES | VALID_CUSTOM_BUTTON_STYLES
+            if btn.style not in all_allowed:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f'Invalid style "{btn.style}" for button "{btn.id}". '
+                    f'Allowed: {", ".join(sorted(all_allowed))}.',
+                )
+
+            # Validate labels
+            for locale_key, label_val in btn.labels.items():
+                if locale_key not in BOT_LOCALES:
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f'Invalid locale "{locale_key}" for button "{btn.id}". '
+                        f'Allowed: {", ".join(BOT_LOCALES)}.',
+                    )
+                if not isinstance(label_val, str):
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f'Label value for locale "{locale_key}" must be a string.',
+                    )
+                if len(label_val.strip()) > MAX_LABEL_LENGTH:
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f'Label for locale "{locale_key}" on button "{btn.id}" '
+                        f'exceeds {MAX_LABEL_LENGTH} characters.',
+                    )
+
+
+# ---- Routes ------------------------------------------------------------------
+
+
+@router.get('', response_model=MenuConfigResponse)
+async def get_menu_layout(
+    _admin: User = Depends(require_permission('settings:read')),
+):
+    """Return merged menu layout config (rows + button styles). Admin only."""
+    layout = get_cached_menu_layout()
+    button_styles = get_cached_button_styles()
+    return _build_merged_response(layout, button_styles)
+
+
+@router.put('', response_model=MenuConfigResponse)
+async def update_menu_layout(
+    payload: MenuConfigUpdateRequest,
+    admin: User = Depends(require_permission('settings:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Save full menu layout config. Splits into layout + button styles. Admin only."""
+    _validate_update_payload(payload.rows)
+
+    layout_data, button_styles_updates = _split_update(payload.rows)
+
+    # Save layout to CABINET_MENU_LAYOUT (without committing)
+    await _upsert_setting(db, MENU_LAYOUT_KEY, json.dumps(layout_data))
+
+    # Merge button styles updates with existing styles (don't overwrite sections not in request)
+    if button_styles_updates:
+        raw = await _get_setting_value(db, BUTTON_STYLES_KEY)
+        current_styles: dict[str, dict] = {}
+        if raw:
+            try:
+                current_styles = json.loads(raw)
+            except (json.JSONDecodeError, TypeError):
+                current_styles = {}
+
+        for section, updates in button_styles_updates.items():
+            current_styles[section] = updates
+
+        await _upsert_setting(db, BUTTON_STYLES_KEY, json.dumps(current_styles))
+
+    # Single atomic commit for both settings
+    await db.commit()
+
+    # Refresh caches after commit
+    await load_button_styles_cache()
+    await load_menu_layout_cache()
+
+    logger.info(
+        'Admin updated menu layout',
+        telegram_id=admin.telegram_id,
+        rows_count=len(payload.rows),
+        custom_buttons_count=len(layout_data.get('custom_buttons', {})),
+    )
+
+    # Return merged response from fresh caches
+    layout = get_cached_menu_layout()
+    button_styles = get_cached_button_styles()
+    return _build_merged_response(layout, button_styles)
+
+
+@router.post('/reset', response_model=MenuConfigResponse)
+async def reset_menu_layout(
+    admin: User = Depends(require_permission('settings:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Reset menu layout AND button styles to defaults. Admin only."""
+    await _upsert_setting(db, MENU_LAYOUT_KEY, json.dumps(DEFAULT_MENU_LAYOUT))
+    await _upsert_setting(db, BUTTON_STYLES_KEY, json.dumps(DEFAULT_BUTTON_STYLES))
+
+    # Single atomic commit for both settings
+    await db.commit()
+
+    # Refresh caches after commit
+    await load_button_styles_cache()
+    await load_menu_layout_cache()
+
+    logger.info('Admin reset menu layout and button styles to defaults', telegram_id=admin.telegram_id)
+
+    layout = get_cached_menu_layout()
+    button_styles = get_cached_button_styles()
+    return _build_merged_response(layout, button_styles)

app/cabinet/routes/admin_news.py

@@ -0,0 +1,343 @@
+"""Admin routes for managing news articles in cabinet."""
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news import (
+    create_news_article,
+    delete_news_article,
+    get_all_news,
+    get_all_news_count,
+    get_news_article_by_id,
+    unfeature_all_news,
+    update_news_article,
+)
+from app.database.crud.news_categories import get_category_by_id
+from app.database.crud.news_tags import get_tag_by_id
+from app.database.models import NewsArticle, User
+
+from ..dependencies import get_cabinet_db, require_permission
+from ..schemas.news import (
+    NewsArticleListItem,
+    NewsArticleResponse,
+    NewsCreateRequest,
+    NewsListResponse,
+    NewsToggleResponse,
+    NewsUpdateRequest,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/news', tags=['Cabinet Admin News'])
+
+
+def _article_to_detail(article: NewsArticle) -> dict[str, Any]:
+    """Convert NewsArticle ORM instance to full detail dict.
+
+    Expects the ``author`` relationship to be eagerly loaded.
+    """
+    author_name: str | None = None
+    if article.author:
+        author_name = article.author.first_name or article.author.username or f'#{article.author.id}'
+
+    return {
+        'id': article.id,
+        'title': article.title,
+        'slug': article.slug,
+        'content': article.content,
+        'excerpt': article.excerpt,
+        'category': article.category,
+        'category_color': article.category_color,
+        'tag': article.tag,
+        'category_id': article.category_id,
+        'tag_id': article.tag_id,
+        'featured_image_url': article.featured_image_url,
+        'is_published': article.is_published,
+        'is_featured': article.is_featured,
+        'published_at': article.published_at,
+        'read_time_minutes': article.read_time_minutes,
+        'views_count': article.views_count,
+        'author_name': author_name,
+        'created_at': article.created_at,
+        'updated_at': article.updated_at,
+    }
+
+
+@router.get('', response_model=NewsListResponse)
+async def list_all_news(
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> NewsListResponse:
+    """Get all news articles (admin view, includes unpublished)."""
+    try:
+        articles = await get_all_news(db, limit=limit, offset=offset)
+        total = await get_all_news_count(db)
+
+        items = [NewsArticleListItem.model_validate(a) for a in articles]
+
+        return NewsListResponse(items=items, total=total)
+    except HTTPException:
+        raise
+    except Exception:
+        logger.exception('Failed to list all news')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to load news articles',
+        )
+
+
+@router.get('/{article_id}', response_model=NewsArticleResponse)
+async def get_article_detail(
+    article_id: int,
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Get a single news article by ID (admin view)."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    return NewsArticleResponse(**_article_to_detail(article))
+
+
+@router.post('', response_model=NewsArticleResponse, status_code=status.HTTP_201_CREATED)
+async def create_article(
+    request: NewsCreateRequest,
+    admin: User = Depends(require_permission('news:create')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Create a new news article."""
+    try:
+        # Resolve category from FK -- sync legacy string fields from the managed entity
+        category_name = request.category
+        category_color = request.category_color
+        if request.category_id is not None:
+            cat = await get_category_by_id(db, request.category_id)
+            if not cat:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Category with id={request.category_id} not found',
+                )
+            category_name = cat.name
+            category_color = cat.color
+
+        # Resolve tag from FK -- sync legacy string field from the managed entity
+        tag_name = request.tag
+        if request.tag_id is not None:
+            tag_obj = await get_tag_by_id(db, request.tag_id)
+            if not tag_obj:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Tag with id={request.tag_id} not found',
+                )
+            tag_name = tag_obj.name
+
+        if request.is_featured:
+            await unfeature_all_news(db)
+        article = await create_news_article(
+            db,
+            title=request.title,
+            slug=request.slug,
+            content=request.content,
+            excerpt=request.excerpt,
+            category=category_name,
+            category_color=category_color,
+            tag=tag_name,
+            category_id=request.category_id,
+            tag_id=request.tag_id,
+            featured_image_url=request.featured_image_url,
+            is_published=request.is_published,
+            is_featured=request.is_featured,
+            read_time_minutes=request.read_time_minutes,
+            created_by=admin.id,
+        )
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='An article with this slug already exists',
+        )
+    except Exception:
+        logger.exception('Failed to create news article')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to create article',
+        )
+
+    # Reload with author relationship
+    article = await get_news_article_by_id(db, article.id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to reload article after creation',
+        )
+    return NewsArticleResponse(**_article_to_detail(article))
+
+
+@router.put('/{article_id}', response_model=NewsArticleResponse)
+async def update_article(
+    article_id: int,
+    request: NewsUpdateRequest,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Update an existing news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    try:
+        update_data = request.model_dump(exclude_unset=True)
+
+        # Resolve category from FK -- sync legacy string fields from the managed entity
+        if 'category_id' in update_data and update_data['category_id'] is not None:
+            cat = await get_category_by_id(db, update_data['category_id'])
+            if not cat:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Category with id={update_data["category_id"]} not found',
+                )
+            update_data['category'] = cat.name
+            update_data['category_color'] = cat.color
+
+        # Resolve tag from FK -- sync legacy string field from the managed entity
+        if 'tag_id' in update_data and update_data['tag_id'] is not None:
+            tag_obj = await get_tag_by_id(db, update_data['tag_id'])
+            if not tag_obj:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Tag with id={update_data["tag_id"]} not found',
+                )
+            update_data['tag'] = tag_obj.name
+
+        if update_data.get('is_featured'):
+            await unfeature_all_news(db)
+        article = await update_news_article(db, article, **update_data)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='An article with this slug already exists',
+        )
+    except Exception:
+        logger.exception('Failed to update news article', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to update article',
+        )
+
+    # Reload with author relationship (update used bulk UPDATE, author not populated)
+    article = await get_news_article_by_id(db, article.id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to reload article after update',
+        )
+    return NewsArticleResponse(**_article_to_detail(article))
+
+
+@router.delete('/{article_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def remove_article(
+    article_id: int,
+    admin: User = Depends(require_permission('news:delete')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> None:
+    """Delete a news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    try:
+        await delete_news_article(db, article)
+    except Exception:
+        logger.exception('Failed to delete news article', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to delete article',
+        )
+
+
+@router.post('/{article_id}/publish', response_model=NewsToggleResponse)
+async def toggle_publish(
+    article_id: int,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsToggleResponse:
+    """Toggle the published status of a news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    new_published = not article.is_published
+
+    update_kwargs: dict[str, Any] = {'is_published': new_published}
+    # Auto-set published_at on first publish
+    if new_published and article.published_at is None:
+        update_kwargs['published_at'] = datetime.now(UTC)
+
+    try:
+        article = await update_news_article(db, article, **update_kwargs)
+        return NewsToggleResponse(
+            id=article.id,
+            is_published=article.is_published,
+            is_featured=article.is_featured,
+            published_at=article.published_at,
+        )
+    except Exception:
+        logger.exception('Failed to toggle publish', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to toggle publish status',
+        )
+
+
+@router.post('/{article_id}/feature', response_model=NewsToggleResponse)
+async def toggle_featured(
+    article_id: int,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsToggleResponse:
+    """Toggle the featured status of a news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    try:
+        new_featured = not article.is_featured
+        # Only one article can be featured at a time — unfeature all others first
+        if new_featured:
+            await unfeature_all_news(db)
+        article = await update_news_article(db, article, is_featured=new_featured)
+        return NewsToggleResponse(
+            id=article.id,
+            is_published=article.is_published,
+            is_featured=article.is_featured,
+            published_at=article.published_at,
+        )
+    except Exception:
+        logger.exception('Failed to toggle featured', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to toggle featured status',
+        )

app/cabinet/routes/admin_news_categories.py

@@ -0,0 +1,90 @@
+"""Admin routes for managing news categories."""
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news_categories import (
+    create_category,
+    delete_category,
+    get_all_categories,
+    get_category_by_id,
+    update_category,
+)
+from app.database.models import User
+
+from ..dependencies import get_cabinet_db, require_permission
+from ..schemas.news_categories import NewsCategoryCreate, NewsCategoryResponse, NewsCategoryUpdate
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/news/categories', tags=['Cabinet Admin News Categories'])
+
+
+@router.get('', response_model=list[NewsCategoryResponse])
+async def list_categories(
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> list[NewsCategoryResponse]:
+    """Get all news categories."""
+    categories = await get_all_categories(db)
+    return [NewsCategoryResponse.model_validate(c) for c in categories]
+
+
+@router.post('', response_model=NewsCategoryResponse, status_code=status.HTTP_201_CREATED)
+async def create_new_category(
+    request: NewsCategoryCreate,
+    admin: User = Depends(require_permission('news:create')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsCategoryResponse:
+    """Create a new news category."""
+    try:
+        category = await create_category(db, name=request.name, color=request.color)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Category already exists',
+        )
+    return NewsCategoryResponse.model_validate(category)
+
+
+@router.put('/{category_id}', response_model=NewsCategoryResponse)
+async def update_existing_category(
+    category_id: int,
+    request: NewsCategoryUpdate,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsCategoryResponse:
+    """Update an existing news category."""
+    category = await get_category_by_id(db, category_id)
+    if not category:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Category not found',
+        )
+    try:
+        category = await update_category(db, category, **request.model_dump(exclude_unset=True))
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Category name already exists',
+        )
+    return NewsCategoryResponse.model_validate(category)
+
+
+@router.delete('/{category_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def remove_category(
+    category_id: int,
+    admin: User = Depends(require_permission('news:delete')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> None:
+    """Delete a news category. Articles using it will have category_id set to NULL."""
+    category = await get_category_by_id(db, category_id)
+    if not category:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Category not found',
+        )
+    await delete_category(db, category)

app/cabinet/routes/admin_news_media.py

@@ -0,0 +1,157 @@
+"""Admin routes for managing news article media (images/videos)."""
+
+import asyncio
+import re
+
+import structlog
+from fastapi import APIRouter, Depends, File, HTTPException, Request, UploadFile, status
+from PIL import Image as PILImage
+
+from app.config import settings
+from app.database.models import User
+from app.services.news_media_service import (
+    SavedMedia,
+    delete_media_file,
+    detect_file_type,
+    ensure_upload_dirs,
+    save_image,
+    save_video,
+)
+
+from ..dependencies import require_permission
+from ..schemas.news_media import NewsMediaUploadResponse
+
+
+logger = structlog.get_logger(__name__)
+
+_BYTES_PER_MB = 1024 * 1024
+
+# Only allow UUID-hex filenames with expected extensions (path traversal defense-in-depth).
+# thumb_ prefix is NOT allowed — thumbnails are cleaned up automatically when the main file is deleted.
+_SAFE_FILENAME_RE = re.compile(r'^[0-9a-f]{32}\.(jpg|mp4|webm)$')
+
+router = APIRouter(prefix='/admin/news/media', tags=['Cabinet Admin News Media'])
+
+
+_ALLOWED_SCHEMES = frozenset({'http', 'https'})
+
+
+def _build_media_url(request: Request, relative_path: str) -> str:
+    """Build a full URL for a media file, respecting reverse proxy headers."""
+    proto = request.headers.get('X-Forwarded-Proto', request.url.scheme).split(',')[0].strip()
+    if proto not in _ALLOWED_SCHEMES:
+        proto = 'https'
+    host = request.headers.get('X-Forwarded-Host', request.headers.get('Host', request.url.netloc))
+    host = host.split(',')[0].strip()
+    return f'{proto}://{host}/uploads/{relative_path}'
+
+
+def _build_response(request: Request, saved: SavedMedia) -> NewsMediaUploadResponse:
+    """Convert SavedMedia to API response with full URLs."""
+    thumbnail_url = _build_media_url(request, saved.thumbnail_path) if saved.thumbnail_path else None
+
+    return NewsMediaUploadResponse(
+        url=_build_media_url(request, saved.relative_path),
+        thumbnail_url=thumbnail_url,
+        media_type=saved.media_type,
+        filename=saved.filename,
+        size_bytes=saved.size_bytes,
+        width=saved.width,
+        height=saved.height,
+    )
+
+
+@router.post('/upload', response_model=NewsMediaUploadResponse, status_code=status.HTTP_201_CREATED)
+async def upload_media(
+    request: Request,
+    file: UploadFile = File(...),
+    admin: User = Depends(require_permission('news:edit')),
+) -> NewsMediaUploadResponse:
+    """Upload an image or video for a news article."""
+    # Read with a hard budget to prevent memory exhaustion from huge uploads.
+    # Read slightly over the max allowed size so we can detect oversized files.
+    absolute_max_bytes = settings.MEDIA_MAX_VIDEO_SIZE_MB * _BYTES_PER_MB + 1
+    data = await file.read(absolute_max_bytes)
+    await file.close()
+    if not data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Empty file',
+        )
+
+    if len(data) >= absolute_max_bytes:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f'File too large. Absolute maximum: {settings.MEDIA_MAX_VIDEO_SIZE_MB} MB',
+        )
+
+    # Detect type from magic bytes
+    try:
+        media_type, _ext = detect_file_type(data)
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            detail='Unsupported file type. Allowed: JPEG, PNG, WebP, MP4, WebM',
+        ) from None
+
+    # Enforce per-type size limits
+    max_size_mb = settings.MEDIA_MAX_IMAGE_SIZE_MB if media_type == 'image' else settings.MEDIA_MAX_VIDEO_SIZE_MB
+    if len(data) > max_size_mb * _BYTES_PER_MB:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f'File too large. Maximum size for {media_type}: {max_size_mb} MB',
+        )
+
+    upload_path = settings.get_media_upload_path()
+    await asyncio.to_thread(ensure_upload_dirs, upload_path)
+
+    try:
+        if media_type == 'image':
+            saved = await save_image(
+                data,
+                upload_path,
+                max_dim=settings.MEDIA_IMAGE_MAX_DIMENSION,
+                quality=settings.MEDIA_JPEG_QUALITY,
+            )
+        else:
+            saved = await save_video(data, upload_path)
+    except (ValueError, OSError, PILImage.DecompressionBombError) as exc:
+        logger.warning('Failed to save uploaded media', media_type=media_type, error=str(exc))
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail='Failed to process uploaded file',
+        ) from None
+
+    logger.info(
+        'Media uploaded',
+        filename=saved.filename,
+        media_type=saved.media_type,
+        size_bytes=saved.size_bytes,
+        admin_id=admin.id,
+    )
+
+    return _build_response(request, saved)
+
+
+@router.delete('/{filename}', status_code=status.HTTP_204_NO_CONTENT)
+async def delete_media(
+    filename: str,
+    admin: User = Depends(require_permission('news:delete')),
+) -> None:
+    """Delete a previously uploaded media file."""
+    if not _SAFE_FILENAME_RE.match(filename):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid filename',
+        )
+
+    upload_path = settings.get_media_upload_path()
+
+    deleted = await asyncio.to_thread(delete_media_file, filename, upload_path)
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='File not found',
+        )
+
+    logger.info('Media deleted', filename=filename, admin_id=admin.id)

app/cabinet/routes/admin_news_tags.py

@@ -0,0 +1,90 @@
+"""Admin routes for managing news tags."""
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news_tags import (
+    create_tag,
+    delete_tag,
+    get_all_tags,
+    get_tag_by_id,
+    update_tag,
+)
+from app.database.models import User
+
+from ..dependencies import get_cabinet_db, require_permission
+from ..schemas.news_tags import NewsTagCreate, NewsTagResponse, NewsTagUpdate
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/news/tags', tags=['Cabinet Admin News Tags'])
+
+
+@router.get('', response_model=list[NewsTagResponse])
+async def list_tags(
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> list[NewsTagResponse]:
+    """Get all news tags."""
+    tags = await get_all_tags(db)
+    return [NewsTagResponse.model_validate(t) for t in tags]
+
+
+@router.post('', response_model=NewsTagResponse, status_code=status.HTTP_201_CREATED)
+async def create_new_tag(
+    request: NewsTagCreate,
+    admin: User = Depends(require_permission('news:create')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsTagResponse:
+    """Create a new news tag."""
+    try:
+        tag = await create_tag(db, name=request.name, color=request.color)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Tag already exists',
+        )
+    return NewsTagResponse.model_validate(tag)
+
+
+@router.put('/{tag_id}', response_model=NewsTagResponse)
+async def update_existing_tag(
+    tag_id: int,
+    request: NewsTagUpdate,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsTagResponse:
+    """Update an existing news tag."""
+    tag = await get_tag_by_id(db, tag_id)
+    if not tag:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tag not found',
+        )
+    try:
+        tag = await update_tag(db, tag, **request.model_dump(exclude_unset=True))
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Tag name already exists',
+        )
+    return NewsTagResponse.model_validate(tag)
+
+
+@router.delete('/{tag_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def remove_tag(
+    tag_id: int,
+    admin: User = Depends(require_permission('news:delete')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> None:
+    """Delete a news tag. Articles using it will have tag_id set to NULL."""
+    tag = await get_tag_by_id(db, tag_id)
+    if not tag:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tag not found',
+        )
+    await delete_tag(db, tag)

app/cabinet/routes/admin_partners.py

@@ -85,6 +85,7 @@ async def update_partner_settings(
     admin: User = Depends(require_permission('partners:settings')),
 ):
     """Update partner system settings."""
+    import asyncio
     from pathlib import Path
 
     # Update in-memory settings
@@ -104,8 +105,8 @@ async def update_partner_settings(
     # Persist to .env file
     try:
         env_file = Path('.env')
-        if env_file.exists():
-            lines = env_file.read_text().splitlines()
+        if await asyncio.to_thread(env_file.exists):
+            lines = (await asyncio.to_thread(env_file.read_text)).splitlines()
             updates: dict[str, str] = {}
 
             if request.withdrawal_enabled is not None:
@@ -143,7 +144,7 @@ async def update_partner_settings(
                 if key not in updated_keys:
                     new_lines.append(f'{key}={value}')
 
-            env_file.write_text('\n'.join(new_lines) + '\n')
+            await asyncio.to_thread(env_file.write_text, '\n'.join(new_lines) + '\n')
             logger.info('Updated partner settings in .env file', admin_id=admin.id)
     except Exception as e:
         logger.warning('Failed to update .env file', error=e)
@@ -226,8 +227,7 @@ async def approve_application(
 
     # Notify user about approval
     try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
         from app.config import settings
         from app.services.notification_delivery_service import notification_delivery_service
 
@@ -239,7 +239,7 @@ async def approve_application(
                 tg_message = (
                     f'✅ Ваша заявка на партнёрство одобрена!\nКомиссия: {request.commission_percent}%{comment_text}'
                 )
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                 try:
                     await notification_delivery_service.notify_partner_approved(
                         user=user,
@@ -279,8 +279,7 @@ async def reject_application(
 
     # Notify user about rejection
     try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
         from app.config import settings
         from app.services.notification_delivery_service import notification_delivery_service
 
@@ -290,7 +289,7 @@ async def reject_application(
             if user:
                 comment_text = f'\nПричина: {request.comment}' if request.comment else ''
                 tg_message = f'❌ Ваша заявка на партнёрство отклонена.{comment_text}'
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                 try:
                     await notification_delivery_service.notify_partner_rejected(
                         user=user,

app/cabinet/routes/admin_payments.py

@@ -1,18 +1,23 @@
 """Admin routes for payment verification in cabinet."""
 
 import math
-from datetime import datetime
+from datetime import UTC, datetime, timedelta
 
 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.models import PaymentMethod, User
+from app.services.payment_search_service import (
+    MAX_ALL_TIME_DAYS,
+    PeriodPreset,
+    SearchParams,
+    StatusFilter,
+    search_payments,
+    search_payments_stats,
+)
 from app.services.payment_service import PaymentService
 from app.services.payment_verification_service import (
     SUPPORTED_MANUAL_CHECK_METHODS,
@@ -54,6 +59,7 @@ class PendingPaymentResponse(BaseModel):
     user_id: int | None = None
     user_telegram_id: int | None = None
     user_username: str | None = None
+    user_email: str | None = None
 
     class Config:
         from_attributes = True
@@ -87,6 +93,16 @@ class PaymentsStatsResponse(BaseModel):
     by_method: dict
 
 
+class SearchStatsResponse(BaseModel):
+    """Statistics for payment search results."""
+
+    total: int
+    pending: int
+    paid: int
+    cancelled: int
+    by_method: dict
+
+
 # ============ Helper functions ============
 
 
@@ -210,7 +226,7 @@ def _is_checkable(record: PendingPayment) -> bool:
     if record.method == PaymentMethod.YOOKASSA:
         return status_str in {'pending', 'waiting_for_capture'}
     if record.method == PaymentMethod.CRYPTOBOT:
-        return status_str in {'active'}
+        return status_str == 'active'
     if record.method == PaymentMethod.CLOUDPAYMENTS:
         return status_str in {'pending', 'authorized'}
     if record.method == PaymentMethod.FREEKASSA:
@@ -241,6 +257,8 @@ def _get_payment_url(record: PendingPayment) -> str | None:
     elif record.method == PaymentMethod.CLOUDPAYMENTS or record.method == PaymentMethod.FREEKASSA:
         payment_url = getattr(payment, 'payment_url', None) or payment_url
 
+    if payment_url and not payment_url.startswith(('https://', 'http://')):
+        return None
     return payment_url
 
 
@@ -265,6 +283,7 @@ def _record_to_response(record: PendingPayment) -> PendingPaymentResponse:
         user_id=record.user.id if record.user else None,
         user_telegram_id=record.user.telegram_id if record.user else None,
         user_username=record.user.username if record.user else None,
+        user_email=record.user.email if record.user else None,
     )
 
 
@@ -329,6 +348,140 @@ async def get_payments_stats(
     )
 
 
+@router.get('/search', response_model=PendingPaymentListResponse)
+async def search_payments_endpoint(
+    search: str | None = Query(
+        None, max_length=256, description='Search query (invoice, @username, telegram_id, email)'
+    ),
+    status_filter: str = Query('all', description='Status filter: all, pending, paid, cancelled'),
+    method_filter: str | None = Query(None, description='Filter by payment method'),
+    period: str = Query('24h', description='Period preset: 24h, 7d, 30d, all'),
+    date_from: datetime | None = Query(None, description='Custom range start (ISO 8601)'),
+    date_to: datetime | None = Query(None, description='Custom range end (ISO 8601)'),
+    page: int = Query(1, ge=1, description='Page number'),
+    per_page: int = Query(20, ge=1, le=100, description='Items per page'),
+    admin: User = Depends(require_permission('payments:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Search payments across all providers with filters."""
+    try:
+        parsed_status = StatusFilter(status_filter)
+    except ValueError:
+        parsed_status = StatusFilter.ALL
+
+    try:
+        parsed_period = PeriodPreset(period)
+    except ValueError:
+        parsed_period = PeriodPreset.H24
+
+    parsed_method: PaymentMethod | None = None
+    if method_filter:
+        try:
+            parsed_method = PaymentMethod(method_filter)
+        except ValueError:
+            pass
+
+    # Ensure custom dates are timezone-aware
+    if date_from is not None and date_from.tzinfo is None:
+        date_from = date_from.replace(tzinfo=UTC)
+    if date_to is not None and date_to.tzinfo is None:
+        date_to = date_to.replace(tzinfo=UTC)
+
+    # Clamp custom dates to safety limit
+    min_allowed = datetime.now(UTC) - timedelta(days=MAX_ALL_TIME_DAYS)
+    if date_from is not None and date_from < min_allowed:
+        date_from = min_allowed
+    if date_from is not None and date_to is not None and date_from > date_to:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail='date_from must be before date_to')
+
+    params = SearchParams(
+        search=search.strip() if search else None,
+        status_filter=parsed_status,
+        method_filter=parsed_method,
+        period=parsed_period,
+        date_from=date_from,
+        date_to=date_to,
+        page=page,
+        per_page=per_page,
+    )
+
+    page_items, total = await search_payments(db, params)
+    pages = math.ceil(total / per_page) if total > 0 else 1
+    items = [_record_to_response(p) for p in page_items]
+
+    return PendingPaymentListResponse(
+        items=items,
+        total=total,
+        page=page,
+        per_page=per_page,
+        pages=pages,
+    )
+
+
+@router.get('/search/stats', response_model=SearchStatsResponse)
+async def search_payments_stats_endpoint(
+    search: str | None = Query(
+        None, max_length=256, description='Search query (invoice, @username, telegram_id, email)'
+    ),
+    status_filter: str = Query('all', description='Status filter: all, pending, paid, cancelled'),
+    method_filter: str | None = Query(None, description='Filter by payment method'),
+    period: str = Query('24h', description='Period preset: 24h, 7d, 30d, all'),
+    date_from: datetime | None = Query(None, description='Custom range start (ISO 8601)'),
+    date_to: datetime | None = Query(None, description='Custom range end (ISO 8601)'),
+    admin: User = Depends(require_permission('payments:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get aggregated statistics for payment search results."""
+    try:
+        parsed_status = StatusFilter(status_filter)
+    except ValueError:
+        parsed_status = StatusFilter.ALL
+
+    try:
+        parsed_period = PeriodPreset(period)
+    except ValueError:
+        parsed_period = PeriodPreset.H24
+
+    parsed_method: PaymentMethod | None = None
+    if method_filter:
+        try:
+            parsed_method = PaymentMethod(method_filter)
+        except ValueError:
+            pass
+
+    # Ensure custom dates are timezone-aware
+    if date_from is not None and date_from.tzinfo is None:
+        date_from = date_from.replace(tzinfo=UTC)
+    if date_to is not None and date_to.tzinfo is None:
+        date_to = date_to.replace(tzinfo=UTC)
+
+    # Clamp custom dates to safety limit
+    min_allowed = datetime.now(UTC) - timedelta(days=MAX_ALL_TIME_DAYS)
+    if date_from is not None and date_from < min_allowed:
+        date_from = min_allowed
+    if date_from is not None and date_to is not None and date_from > date_to:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail='date_from must be before date_to')
+
+    params = SearchParams(
+        search=search.strip() if search else None,
+        status_filter=parsed_status,
+        method_filter=parsed_method,
+        period=parsed_period,
+        date_from=date_from,
+        date_to=date_to,
+    )
+
+    stats = await search_payments_stats(db, params)
+
+    return SearchStatsResponse(
+        total=stats.total,
+        pending=stats.pending,
+        paid=stats.paid,
+        cancelled=stats.cancelled,
+        by_method=stats.by_method or {},
+    )
+
+
 @router.get('/{method}/{payment_id}', response_model=PendingPaymentResponse)
 async def get_pending_payment_details(
     method: str,
@@ -342,7 +495,7 @@ async def get_pending_payment_details(
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f'Invalid payment method: {method}',
+            detail='Invalid payment method',
         )
 
     record = await get_payment_record(db, payment_method, payment_id)
@@ -369,7 +522,7 @@ async def check_payment_status(
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f'Invalid payment method: {method}',
+            detail='Invalid payment method',
         )
 
     # Get current record
@@ -394,7 +547,7 @@ async def check_payment_status(
     old_is_paid = record.is_paid
 
     # Run manual check
-    bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    bot = create_bot()
     try:
         payment_service = PaymentService(bot=bot)
         updated = await run_manual_check(db, payment_method, payment_id, payment_service)

app/cabinet/routes/admin_pinned_messages.py

@@ -5,13 +5,11 @@ from datetime import UTC, datetime
 
 import structlog
 from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.models import PinnedMessage, User
 from app.services.pinned_message_service import (
     broadcast_pinned_message,
@@ -77,10 +75,7 @@ _cached_bot: Bot | None = None
 def _get_bot() -> Bot:
     global _cached_bot
     if _cached_bot is None:
-        _cached_bot = Bot(
-            token=settings.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-        )
+        _cached_bot = create_bot()
     return _cached_bot
 
 

app/cabinet/routes/admin_promo_offers.py

@@ -8,15 +8,13 @@ from typing import Any
 
 import structlog
 from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from pydantic import BaseModel, Field
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.crud.discount_offer import (
     count_discount_offers,
     list_discount_offers,
@@ -369,10 +367,7 @@ async def list_offers(
 
 def _get_bot() -> Bot:
     """Create bot instance for sending notifications."""
-    return Bot(
-        token=settings.BOT_TOKEN,
-        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-    )
+    return create_bot()
 
 
 def _build_default_promo_message(

app/cabinet/routes/admin_promocodes.py

@@ -28,6 +28,7 @@ from app.database.crud.promocode import (
     get_promocodes_list,
     update_promocode,
 )
+from app.database.crud.tariff import get_tariff_by_id
 from app.database.models import PromoCode, PromoCodeType, PromoCodeUse, PromoGroup, User
 
 from ..dependencies import get_cabinet_db, require_permission
@@ -55,6 +56,8 @@ class PromoCodeResponse(BaseModel):
     valid_from: datetime
     valid_until: datetime | None = None
     promo_group_id: int | None = None
+    tariff_id: int | None = None
+    tariff_name: str | None = None
     created_by: int | None = None
     created_at: datetime
     updated_at: datetime
@@ -93,6 +96,7 @@ class PromoCodeCreateRequest(BaseModel):
     is_active: bool = True
     first_purchase_only: bool = False
     promo_group_id: int | None = None
+    tariff_id: int | None = None
 
 
 class PromoCodeUpdateRequest(BaseModel):
@@ -106,6 +110,7 @@ class PromoCodeUpdateRequest(BaseModel):
     is_active: bool | None = None
     first_purchase_only: bool | None = None
     promo_group_id: int | None = None
+    tariff_id: int | None = None
 
 
 # ============== PromoGroup Schemas ==============
@@ -168,7 +173,12 @@ def _normalize_datetime(value: datetime | None) -> datetime | None:
     return value
 
 
-def _serialize_promocode(promocode: PromoCode) -> PromoCodeResponse:
+async def _serialize_promocode(db: AsyncSession, promocode: PromoCode) -> PromoCodeResponse:
+    tariff_name = None
+    if promocode.tariff_id:
+        tariff = await get_tariff_by_id(db, promocode.tariff_id)
+        tariff_name = tariff.name if tariff else None
+
     promo_type = PromoCodeType(promocode.type)
     return PromoCodeResponse(
         id=promocode.id,
@@ -186,6 +196,8 @@ def _serialize_promocode(promocode: PromoCode) -> PromoCodeResponse:
         valid_from=promocode.valid_from,
         valid_until=promocode.valid_until,
         promo_group_id=promocode.promo_group_id,
+        tariff_id=promocode.tariff_id,
+        tariff_name=tariff_name,
         created_by=promocode.created_by,
         created_at=promocode.created_at,
         updated_at=promocode.updated_at,
@@ -315,8 +327,9 @@ async def list_promocodes(
     total = await get_promocodes_count(db, is_active=is_active) or 0
     promocodes = await get_promocodes_list(db, offset=offset, limit=limit, is_active=is_active)
 
+    serialized = [await _serialize_promocode(db, p) for p in promocodes]
     return PromoCodeListResponse(
-        items=[_serialize_promocode(promocode) for promocode in promocodes],
+        items=serialized,
         total=int(total),
         limit=limit,
         offset=offset,
@@ -335,7 +348,7 @@ async def get_promocode(
         raise HTTPException(status.HTTP_404_NOT_FOUND, 'Promo code not found')
 
     stats = await get_promocode_statistics(db, promocode_id)
-    base = _serialize_promocode(promocode)
+    base = await _serialize_promocode(db, promocode)
     recent_uses = [_serialize_recent_use(use) for use in stats.get('recent_uses', [])]
 
     return PromoCodeDetailResponse(
@@ -388,11 +401,13 @@ async def create_promocode_endpoint(
         update_fields['first_purchase_only'] = payload.first_purchase_only
     if payload.promo_group_id is not None:
         update_fields['promo_group_id'] = payload.promo_group_id
+    if payload.tariff_id is not None:
+        update_fields['tariff_id'] = payload.tariff_id
 
     if update_fields:
         promocode = await update_promocode(db, promocode, **update_fields)
 
-    return _serialize_promocode(promocode)
+    return await _serialize_promocode(db, promocode)
 
 
 @router.patch('/{promocode_id}', response_model=PromoCodeResponse)
@@ -446,11 +461,14 @@ async def update_promocode_endpoint(
     if payload.promo_group_id is not None:
         updates['promo_group_id'] = payload.promo_group_id
 
+    if payload.tariff_id is not None:
+        updates['tariff_id'] = payload.tariff_id if payload.tariff_id != 0 else None
+
     if not updates:
-        return _serialize_promocode(promocode)
+        return await _serialize_promocode(db, promocode)
 
     promocode = await update_promocode(db, promocode, **updates)
-    return _serialize_promocode(promocode)
+    return await _serialize_promocode(db, promocode)
 
 
 @router.delete(
@@ -489,44 +507,63 @@ async def admin_deactivate_discount_promocode(
     admin: User = Depends(require_permission('promocodes:edit')),
     db: AsyncSession = Depends(get_cabinet_db),
 ) -> DeactivateDiscountResponse:
-    """Admin: deactivate a user's active discount promo code."""
+    """Admin: deactivate a user's active discount (promo code or promo offer)."""
     from app.database.crud.user import get_user_by_id as get_user
 
     target_user = await get_user(db, user_id)
     if not target_user:
         raise HTTPException(status.HTTP_404_NOT_FOUND, 'User not found')
 
-    from app.services.promocode_service import PromoCodeService
+    current_discount = getattr(target_user, 'promo_offer_discount_percent', 0) or 0
+    source = getattr(target_user, 'promo_offer_discount_source', None)
 
-    service = PromoCodeService()
-    result = await service.deactivate_discount_promocode(
-        db=db,
-        user_id=user_id,
-        admin_initiated=True,
-    )
+    if current_discount <= 0:
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, 'User has no active discount')
 
-    if result['success']:
-        return DeactivateDiscountResponse(
-            success=True,
-            message=f'Discount promo code deactivated for user {user_id}',
-            deactivated_code=result.get('deactivated_code'),
-            discount_percent=result.get('discount_percent', 0),
+    # If source is a promo code, use the service to properly rollback usage
+    if source and source.startswith('promocode:'):
+        from app.services.promocode_service import PromoCodeService
+
+        service = PromoCodeService()
+        result = await service.deactivate_discount_promocode(
+            db=db,
             user_id=user_id,
+            admin_initiated=True,
         )
 
-    error_messages = {
-        'user_not_found': 'User not found',
-        'no_active_discount_promocode': 'User has no active discount from a promo code',
-        'discount_already_expired': 'Discount has already expired (cleaned up)',
-        'server_error': 'Server error occurred',
-    }
+        if result['success']:
+            return DeactivateDiscountResponse(
+                success=True,
+                message=f'Discount promo code deactivated for user {user_id}',
+                deactivated_code=result.get('deactivated_code'),
+                discount_percent=result.get('discount_percent', 0),
+                user_id=user_id,
+            )
 
-    error_code = result.get('error', 'server_error')
-    error_message = error_messages.get(error_code, 'Failed to deactivate promo code')
+        error_messages = {
+            'user_not_found': 'User not found',
+            'no_active_discount_promocode': 'User has no active discount from a promo code',
+            'discount_already_expired': 'Discount has already expired (cleaned up)',
+            'server_error': 'Server error occurred',
+        }
 
-    raise HTTPException(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        detail=error_message,
+        error_code = result.get('error', 'server_error')
+        raise HTTPException(status.HTTP_400_BAD_REQUEST, error_messages.get(error_code, 'Failed to deactivate'))
+
+    # For non-promocode offers (admin offers, etc.) — just clear the fields
+    old_percent = target_user.promo_offer_discount_percent
+    target_user.promo_offer_discount_percent = 0
+    target_user.promo_offer_discount_source = None
+    target_user.promo_offer_discount_expires_at = None
+    target_user.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    return DeactivateDiscountResponse(
+        success=True,
+        message=f'Promo offer deactivated for user {user_id}',
+        deactivated_code=None,
+        discount_percent=old_percent,
+        user_id=user_id,
     )
 
 

app/cabinet/routes/admin_remnawave.py

@@ -5,6 +5,7 @@ from typing import Any
 
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.database.crud.server_squad import (
@@ -129,22 +130,22 @@ def _serialize_node(node_data: dict[str, Any]) -> NodeInfo:
         is_disabled=bool(node_data.get('is_disabled')),
         is_node_online=bool(node_data.get('is_node_online')),
         is_xray_running=bool(node_data.get('is_xray_running')),
-        users_online=node_data.get('users_online'),
+        users_online=node_data.get('users_online', 0),
         traffic_used_bytes=node_data.get('traffic_used_bytes'),
         traffic_limit_bytes=node_data.get('traffic_limit_bytes'),
         last_status_change=_parse_datetime(node_data.get('last_status_change')),
         last_status_message=node_data.get('last_status_message'),
-        xray_uptime=node_data.get('xray_uptime'),
+        xray_uptime=node_data.get('xray_uptime', 0) or 0,
         is_traffic_tracking_active=bool(node_data.get('is_traffic_tracking_active', False)),
         traffic_reset_day=node_data.get('traffic_reset_day'),
         notify_percent=node_data.get('notify_percent'),
         consumption_multiplier=float(node_data.get('consumption_multiplier', 1.0)),
-        cpu_count=node_data.get('cpu_count'),
-        cpu_model=node_data.get('cpu_model'),
-        total_ram=node_data.get('total_ram'),
         created_at=_parse_datetime(node_data.get('created_at')),
         updated_at=_parse_datetime(node_data.get('updated_at')),
         provider_uuid=node_data.get('provider_uuid'),
+        versions=node_data.get('versions'),
+        system=node_data.get('system'),
+        active_plugin_uuid=node_data.get('active_plugin_uuid'),
     )
 
 
@@ -208,11 +209,9 @@ async def get_system_statistics(
         users_by_status=stats.get('users_by_status', {}),
         server_info=ServerInfo(
             cpu_cores=server_data.get('cpu_cores', 0),
-            cpu_physical_cores=server_data.get('cpu_physical_cores', 0),
             memory_total=server_data.get('memory_total', 0),
             memory_used=server_data.get('memory_used', 0),
             memory_free=server_data.get('memory_free', 0),
-            memory_available=server_data.get('memory_available', 0),
             uptime_seconds=server_data.get('uptime_seconds', 0),
         ),
         bandwidth=Bandwidth(
@@ -397,15 +396,21 @@ async def perform_node_action(
     )
 
 
+class RestartAllNodesPayload(BaseModel):
+    force_restart: bool = False
+
+
 @router.post('/nodes/restart-all', response_model=NodeActionResponse)
 async def restart_all_nodes(
+    payload: RestartAllNodesPayload | None = None,
     admin: User = Depends(require_permission('remnawave:manage')),
 ) -> NodeActionResponse:
     """Restart all nodes."""
     service = _get_service()
     _ensure_configured(service)
 
-    success = await service.restart_all_nodes()
+    force = payload.force_restart if payload else False
+    success = await service.restart_all_nodes(force_restart=force)
 
     if success:
         logger.info('Admin restarted all nodes', telegram_id=admin.telegram_id)

app/cabinet/routes/admin_roles.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 from datetime import datetime
 
+import sqlalchemy as sa
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel, Field
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.database.crud.rbac import AdminRoleCRUD, UserRoleCRUD
+from app.database.crud.rbac import SUPERADMIN_LEVEL, AdminRoleCRUD, UserRoleCRUD
 from app.database.models import User
 from app.services.permission_service import PERMISSION_REGISTRY, get_all_permissions
 
@@ -129,21 +130,26 @@ async def _role_to_response(db: AsyncSession, role) -> RoleResponse:
 
 
 async def _get_admin_level(db: AsyncSession, admin: User) -> int:
-    """Get the maximum role level of the current admin.
+    """Get the effective management level of the current admin.
 
-    Legacy config-based admins (ADMIN_IDS) get superadmin level (999+1=1000)
-    so they can manage all roles including level 999.
+    Superadmin-tier users (DB level 999 or legacy ADMIN_IDS) are promoted to
+    level 1000 so they can manage peer Superadmins.  Without this, the ``>=``
+    hierarchy guard would block 999-vs-999 operations.
     """
     from app.config import settings
 
     _perms, _names, max_level = await UserRoleCRUD.get_user_permissions(db, admin.id)
 
+    # DB-assigned Superadmins can manage peers
+    if max_level >= SUPERADMIN_LEVEL:
+        max_level = SUPERADMIN_LEVEL + 1
+
     # Legacy config-based admins always get the highest level
     if settings.is_admin(
         telegram_id=admin.telegram_id,
         email=admin.email if admin.email_verified else None,
     ):
-        max_level = max(max_level, 1000)
+        max_level = max(max_level, SUPERADMIN_LEVEL + 1)
 
     return max_level
 
@@ -339,6 +345,15 @@ async def update_role(
 
     update_data = payload.model_dump(exclude_unset=True)
 
+    # System roles: only permissions can be extended, block is_active/level changes
+    if role.is_system:
+        blocked = {'is_active', 'level'} & update_data.keys()
+        if blocked:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f'Cannot change {", ".join(sorted(blocked))} on a system role',
+            )
+
     # Validate level change
     if 'level' in update_data and update_data['level'] >= admin_level:
         raise HTTPException(
@@ -426,6 +441,14 @@ async def assign_role(
             detail='Role not found',
         )
 
+    # Superadmin role is managed exclusively via ADMIN_IDS/ADMIN_EMAILS env config
+    if role.level >= SUPERADMIN_LEVEL:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Superadmin role is managed via ADMIN_IDS/ADMIN_EMAILS environment variables. '
+            'Add the user there and restart the bot.',
+        )
+
     admin_level = await _get_admin_level(db, admin)
 
     # Cannot assign a role with level >= own level
@@ -483,13 +506,11 @@ async def revoke_role(
     admin: User = Depends(require_permission('roles:assign')),
     db: AsyncSession = Depends(get_cabinet_db),
 ):
-    """Revoke a role assignment. Cannot remove the last superadmin."""
-    from sqlalchemy import select as sa_select
-
+    """Revoke a role assignment. Superadmin roles are managed via env config."""
     from app.database.models import UserRole
 
-    # Load the assignment to check hierarchy
-    result = await db.execute(sa_select(UserRole).where(UserRole.id == assignment_id))
+    # Lock the assignment row (FOR UPDATE held until commit)
+    result = await db.execute(sa.select(UserRole).where(UserRole.id == assignment_id).with_for_update())
     user_role = result.scalar_one_or_none()
     if not user_role:
         raise HTTPException(
@@ -504,6 +525,14 @@ async def revoke_role(
             detail='Associated role not found',
         )
 
+    # Superadmin role is managed exclusively via env config
+    if role.level >= SUPERADMIN_LEVEL:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Superadmin role is managed via ADMIN_IDS/ADMIN_EMAILS environment variables. '
+            'Remove the user from env and restart the bot.',
+        )
+
     admin_level = await _get_admin_level(db, admin)
 
     # Cannot revoke a role at or above own level
@@ -513,23 +542,9 @@ async def revoke_role(
             detail='Cannot revoke a role at or above your own level',
         )
 
-    # Protect last superadmin (level 999)
-    superadmin_level = 999
-    if role.level == superadmin_level:
-        superadmin_count = await UserRoleCRUD.get_superadmin_count(db)
-        if superadmin_count <= 1:
-            raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail='Cannot remove the last superadmin',
-            )
-
-    revoked = await UserRoleCRUD.revoke_role(db, assignment_id)
-    if not revoked:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail='Failed to revoke role',
-        )
-
+    # Revoke directly on the locked object (avoid CRUD re-fetch without FOR UPDATE)
+    user_role.is_active = False
+    await db.flush()
     await db.commit()
 
     logger.info(
@@ -539,4 +554,5 @@ async def revoke_role(
         target_user_id=user_role.user_id,
         role_name=role.name,
     )
+
     return {'message': 'Role revoked', 'assignment_id': assignment_id}

app/cabinet/routes/admin_sales_stats.py

@@ -10,6 +10,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.database.crud.transaction import REAL_PAYMENT_METHODS
 from app.database.models import (
+    PaymentMethod,
     Subscription,
     SubscriptionConversion,
     SubscriptionStatus,
@@ -87,6 +88,7 @@ class SalesSummary(BaseModel):
     """Summary stats for the top cards."""
 
     total_revenue_kopeks: int
+    manual_topup_kopeks: int
     active_subscriptions: int
     active_trials: int
     new_trials: int
@@ -110,11 +112,11 @@ async def get_sales_summary(
     try:
         period_start, period_end = _parse_period(days, start_date, end_date)
 
-        # Total revenue (deposits with real payment methods)
+        # Total revenue (deposits + direct subscription payments with real payment methods)
         revenue_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                 and_(
-                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
                     Transaction.is_completed == True,
                     Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
                     Transaction.created_at >= period_start,
@@ -124,6 +126,20 @@ async def get_sales_summary(
         )
         total_revenue = revenue_result.scalar() or 0
 
+        # Manual top-ups by admins
+        manual_topup_result = await db.execute(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
+                and_(
+                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.is_completed == True,
+                    Transaction.payment_method == PaymentMethod.MANUAL.value,
+                    Transaction.created_at >= period_start,
+                    Transaction.created_at <= period_end,
+                )
+            )
+        )
+        manual_topup = manual_topup_result.scalar() or 0
+
         # Consolidated subscription counts: active paid, active trial, new trials in period
         sub_counts_result = await db.execute(
             select(
@@ -170,6 +186,7 @@ async def get_sales_summary(
         new_trials = row.new_trials or 0
 
         # Trial-to-paid conversion in period
+        # Method 1: SubscriptionConversion records (only created by some purchase flows)
         conversions_result = await db.execute(
             select(func.count(SubscriptionConversion.id)).where(
                 and_(
@@ -178,9 +195,29 @@ async def get_sales_summary(
                 )
             )
         )
-        conversions = conversions_result.scalar() or 0
-        # Cap at 100%: conversions from previous periods can exceed current new_trials
-        conversion_rate = min(round((conversions / new_trials * 100), 1), 100.0) if new_trials > 0 else 0.0
+        conversion_records = conversions_result.scalar() or 0
+
+        # Method 2: Users registered in period who have paid (catches all purchase flows)
+        converted_users_result = await db.execute(
+            select(func.count(User.id)).where(
+                and_(
+                    User.created_at >= period_start,
+                    User.created_at <= period_end,
+                    User.has_had_paid_subscription.is_(True),
+                )
+            )
+        )
+        converted_users = converted_users_result.scalar() or 0
+
+        # Use the higher count to catch conversions from all purchase flows
+        conversions = max(conversion_records, converted_users)
+
+        # new_trials only counts REMAINING trials (is_trial=True), but converted users
+        # had is_trial flipped to False. Add conversions back to get total trial starters.
+        total_trial_starters = new_trials + conversions
+        conversion_rate = (
+            min(round((conversions / total_trial_starters * 100), 1), 100.0) if total_trial_starters > 0 else 0.0
+        )
 
         # Renewals count
         renewals_subquery = (
@@ -209,7 +246,7 @@ async def get_sales_summary(
 
         # Add-on revenue
         addon_revenue_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                 and_(
                     Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
                     Transaction.is_completed == True,
@@ -219,10 +256,11 @@ async def get_sales_summary(
                 )
             )
         )
-        addon_revenue = abs(addon_revenue_result.scalar() or 0)
+        addon_revenue = addon_revenue_result.scalar() or 0
 
         return SalesSummary(
-            total_revenue_kopeks=total_revenue,
+            total_revenue_kopeks=total_revenue + manual_topup,
+            manual_topup_kopeks=manual_topup,
             active_subscriptions=active_subs,
             active_trials=active_trials,
             new_trials=new_trials,
@@ -290,6 +328,7 @@ async def get_trials_stats(
         )
         total_trials = total_result.scalar() or 0
 
+        # Conversion: SubscriptionConversion records + fallback to has_had_paid_subscription
         conversions_result = await db.execute(
             select(func.count(SubscriptionConversion.id)).where(
                 and_(
@@ -298,9 +337,25 @@ async def get_trials_stats(
                 )
             )
         )
-        conversions = conversions_result.scalar() or 0
-        # Cap at 100%: conversions from previous periods can exceed current period trials
-        conversion_rate = min(round((conversions / total_trials * 100), 1), 100.0) if total_trials > 0 else 0.0
+        conversion_records = conversions_result.scalar() or 0
+
+        converted_users_result = await db.execute(
+            select(func.count(User.id)).where(
+                and_(
+                    User.created_at >= period_start,
+                    User.created_at <= period_end,
+                    User.has_had_paid_subscription.is_(True),
+                )
+            )
+        )
+        converted_users = converted_users_result.scalar() or 0
+        conversions = max(conversion_records, converted_users)
+
+        # total_trials only counts remaining is_trial=True; add conversions for total starters
+        total_trial_starters = total_trials + conversions
+        conversion_rate = (
+            min(round((conversions / total_trial_starters * 100), 1), 100.0) if total_trial_starters > 0 else 0.0
+        )
 
         avg_duration_result = await db.execute(
             select(func.avg(SubscriptionConversion.trial_duration_days)).where(
@@ -1022,10 +1077,11 @@ async def get_deposits_stats(
     try:
         period_start, period_end = _parse_period(days, start_date, end_date)
 
+        methods_with_manual = [*REAL_PAYMENT_METHODS, PaymentMethod.MANUAL.value]
         base_filter = and_(
-            Transaction.type == TransactionType.DEPOSIT.value,
+            Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
             Transaction.is_completed == True,
-            Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
+            Transaction.payment_method.in_(methods_with_manual),
             Transaction.created_at >= period_start,
             Transaction.created_at <= period_end,
         )
@@ -1033,7 +1089,7 @@ async def get_deposits_stats(
         totals_result = await db.execute(
             select(
                 func.count(Transaction.id).label('count'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
             ).where(base_filter)
         )
         totals = totals_result.one()
@@ -1045,11 +1101,11 @@ async def get_deposits_stats(
             select(
                 Transaction.payment_method.label('method'),
                 func.count(Transaction.id).label('count'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
             )
             .where(base_filter)
             .group_by(Transaction.payment_method)
-            .order_by(func.sum(Transaction.amount_kopeks).desc())
+            .order_by(func.sum(func.abs(Transaction.amount_kopeks)).desc())
         )
         by_method = [
             DepositByMethodItem(method=row.method or 'unknown', count=row.count, amount_kopeks=row.amount)
@@ -1060,7 +1116,7 @@ async def get_deposits_stats(
             select(
                 func.date(Transaction.created_at).label('date'),
                 func.count(Transaction.id).label('count'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
             )
             .where(base_filter)
             .group_by(func.date(Transaction.created_at))
@@ -1076,12 +1132,12 @@ async def get_deposits_stats(
         ]
 
         # Daily deposits grouped by payment method
-        # base_filter already excludes NULLs via .in_(REAL_PAYMENT_METHODS), no coalesce needed
+        # base_filter already excludes NULLs via .in_(methods_with_manual), no coalesce needed
         daily_by_method_query = await db.execute(
             select(
                 func.date(Transaction.created_at).label('date'),
                 Transaction.payment_method.label('method'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
             )
             .where(base_filter)
             .group_by(func.date(Transaction.created_at), Transaction.payment_method)

app/cabinet/routes/admin_stats.py

@@ -3,6 +3,7 @@
 import sys
 import time
 from datetime import UTC, datetime, timedelta
+from typing import Any
 
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
@@ -13,7 +14,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.database.crud.campaign import get_campaign_statistics, get_campaigns_count, get_campaigns_list
 from app.database.crud.server_squad import get_server_statistics
 from app.database.crud.subscription import get_subscriptions_statistics
-from app.database.crud.transaction import get_revenue_by_period, get_transactions_statistics
+from app.database.crud.transaction import REAL_PAYMENT_METHODS, get_revenue_by_period, get_transactions_statistics
 from app.database.models import (
     ReferralEarning,
     Subscription,
@@ -49,15 +50,11 @@ class NodeStatus(BaseModel):
     is_disabled: bool
     users_online: int
     traffic_used_bytes: int | None = None
-    uptime: str | None = None
-    xray_version: str | None = None
-    node_version: str | None = None
     last_status_message: str | None = None
-    xray_uptime: str | None = None
+    xray_uptime: int = 0
     is_xray_running: bool | None = None
-    cpu_count: int | None = None
-    cpu_model: str | None = None
-    total_ram: str | None = None
+    versions: dict[str, str] | None = None
+    system: dict[str, Any] | None = None
     country_code: str | None = None
 
 
@@ -275,6 +272,14 @@ async def get_dashboard_stats(
         # Get tariff statistics
         tariff_stats = await _get_tariff_stats(db)
 
+        # Derive income_today from revenue_chart to ensure consistency with chart
+        today_str = now.date().isoformat()
+        income_today_from_chart = sum(
+            item.get('amount_kopeks', 0) for item in revenue_data if str(item.get('date', '')) == today_str
+        )
+        # Use chart-derived value if available, otherwise fall back to trans_stats
+        income_today_kopeks = income_today_from_chart or trans_stats.get('today', {}).get('income_kopeks', 0)
+
         # Build response
         return DashboardStats(
             nodes=nodes_data,
@@ -290,8 +295,8 @@ async def get_dashboard_stats(
                 trial_to_paid_conversion=sub_stats.get('trial_to_paid_conversion', 0.0),
             ),
             financial=FinancialStats(
-                income_today_kopeks=trans_stats.get('today', {}).get('income_kopeks', 0),
-                income_today_rubles=trans_stats.get('today', {}).get('income_kopeks', 0) / 100,
+                income_today_kopeks=income_today_kopeks,
+                income_today_rubles=income_today_kopeks / 100,
                 income_month_kopeks=trans_stats.get('totals', {}).get('income_kopeks', 0),
                 income_month_rubles=trans_stats.get('totals', {}).get('income_kopeks', 0) / 100,
                 income_total_kopeks=all_time_stats.get('totals', {}).get('income_kopeks', 0),
@@ -461,15 +466,11 @@ async def _get_nodes_overview() -> NodesOverview:
                 is_disabled=n.get('is_disabled', False),
                 users_online=n.get('users_online', 0) or 0,
                 traffic_used_bytes=n.get('traffic_used_bytes'),
-                uptime=n.get('uptime'),
-                xray_version=n.get('xray_version'),
-                node_version=n.get('node_version'),
                 last_status_message=n.get('last_status_message'),
-                xray_uptime=n.get('xray_uptime'),
+                xray_uptime=n.get('xray_uptime', 0) or 0,
                 is_xray_running=n.get('is_xray_running'),
-                cpu_count=n.get('cpu_count'),
-                cpu_model=n.get('cpu_model'),
-                total_ram=n.get('total_ram'),
+                versions=n.get('versions'),
+                system=n.get('system'),
                 country_code=n.get('country_code'),
             )
             for n in nodes
@@ -926,22 +927,24 @@ async def get_recent_payments(
         total_count = total_count_result.scalar() or 0
 
         today_total_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                 and_(
-                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
                     Transaction.is_completed == True,
                     Transaction.created_at >= today_start,
+                    Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
                 )
             )
         )
         total_today = today_total_result.scalar() or 0
 
         week_total_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                 and_(
-                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
                     Transaction.is_completed == True,
                     Transaction.created_at >= week_ago,
+                    Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
                 )
             )
         )

app/cabinet/routes/admin_tariffs.py

@@ -1,10 +1,14 @@
 """Admin routes for managing tariffs in cabinet."""
 
+import asyncio
+
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy import func, select
+from sqlalchemy import and_, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import joinedload
 
+from app.config import settings
 from app.database.crud.server_squad import get_all_server_squads
 from app.database.crud.tariff import (
     create_tariff,
@@ -17,7 +21,7 @@ from app.database.crud.tariff import (
     set_tariff_promo_groups,
     update_tariff,
 )
-from app.database.models import PromoGroup, Subscription, Tariff, Transaction, TransactionType, User
+from app.database.models import PromoGroup, Subscription, SubscriptionStatus, Tariff, Transaction, TransactionType, User
 
 from ..dependencies import get_cabinet_db, require_permission
 from ..schemas.tariffs import (
@@ -26,6 +30,7 @@ from ..schemas.tariffs import (
     PromoGroupInfo,
     ServerInfo,
     ServerTrafficLimit,
+    SyncSquadsResponse,
     TariffCreateRequest,
     TariffDetailResponse,
     TariffListItem,
@@ -127,6 +132,7 @@ async def list_tariffs(
                 is_daily=tariff.is_daily,
                 daily_price_kopeks=tariff.daily_price_kopeks,
                 allow_traffic_topup=tariff.allow_traffic_topup,
+                show_in_gift=tariff.show_in_gift,
                 traffic_limit_gb=tariff.traffic_limit_gb,
                 device_limit=tariff.device_limit,
                 tier_level=tariff.tier_level,
@@ -265,6 +271,8 @@ async def get_tariff(
         traffic_reset_mode=tariff.traffic_reset_mode,
         # Внешний сквад
         external_squad_uuid=tariff.external_squad_uuid,
+        # Показывать в подарках
+        show_in_gift=tariff.show_in_gift,
         created_at=tariff.created_at,
         updated_at=tariff.updated_at,
     )
@@ -303,7 +311,7 @@ async def create_new_tariff(
         period_prices=period_prices_dict,
         allowed_squads=request.allowed_squads,
         server_traffic_limits=server_limits_dict,
-        promo_group_ids=request.promo_group_ids if request.promo_group_ids else None,
+        promo_group_ids=request.promo_group_ids or None,
         # Произвольное количество дней
         custom_days_enabled=request.custom_days_enabled,
         price_per_day_kopeks=request.price_per_day_kopeks,
@@ -321,6 +329,8 @@ async def create_new_tariff(
         traffic_reset_mode=request.traffic_reset_mode,
         # Внешний сквад
         external_squad_uuid=request.external_squad_uuid,
+        # Показывать в подарках
+        show_in_gift=request.show_in_gift,
     )
 
     logger.info('Admin created tariff', admin_id=admin.id, tariff_id=tariff.id, tariff_name=tariff.name)
@@ -347,6 +357,10 @@ async def update_existing_tariff(
             detail='Tariff not found',
         )
 
+    # Capture old values for change detection
+    old_squads = list(tariff.allowed_squads) if tariff.allowed_squads else []
+    old_external_squad = tariff.external_squad_uuid
+
     # Build updates dict
     updates = {}
     if request.name is not None:
@@ -413,6 +427,9 @@ async def update_existing_tariff(
     # Внешний сквад (None допускается для сброса)
     if 'external_squad_uuid' in request.model_fields_set:
         updates['external_squad_uuid'] = request.external_squad_uuid
+    # Показывать в подарках
+    if request.show_in_gift is not None:
+        updates['show_in_gift'] = request.show_in_gift
 
     if updates:
         await update_tariff(db, tariff, **updates)
@@ -426,6 +443,18 @@ async def update_existing_tariff(
     # Перезагружаем периоды из БД для синхронизации с ботом
     await load_period_prices_from_db(db)
 
+    # Auto-sync squads to active subscriptions in Remnawave when squads changed
+    new_squads = tariff.allowed_squads or []
+    squads_changed = request.allowed_squads is not None and sorted(old_squads) != sorted(new_squads)
+    ext_squad_changed = (
+        'external_squad_uuid' in request.model_fields_set and tariff.external_squad_uuid != old_external_squad
+    )
+    if squads_changed or ext_squad_changed:
+        asyncio.create_task(
+            _background_sync_squads(tariff_id, admin.id),
+            name=f'sync-squads-tariff-{tariff_id}',
+        )
+
     return await get_tariff(tariff_id, admin, db)
 
 
@@ -586,3 +615,225 @@ async def get_tariff_stats(
         revenue_kopeks=revenue_kopeks,
         revenue_rubles=revenue_kopeks / 100,
     )
+
+
+async def _background_sync_squads(tariff_id: int, admin_id: int) -> None:
+    """Run squad sync in background with its own DB session (fire-and-forget)."""
+    from app.database.database import AsyncSessionLocal
+    from app.services.remnawave_service import RemnaWaveService
+
+    try:
+        async with AsyncSessionLocal() as db:
+            tariff = await get_tariff_by_id(db, tariff_id)
+            if not tariff:
+                return
+
+            result = await db.execute(
+                select(Subscription)
+                .join(User, Subscription.user_id == User.id)
+                .options(joinedload(Subscription.user))
+                .where(
+                    and_(
+                        Subscription.tariff_id == tariff_id,
+                        Subscription.status.in_([SubscriptionStatus.ACTIVE.value, SubscriptionStatus.TRIAL.value]),
+                        User.remnawave_uuid.isnot(None),
+                    )
+                )
+            )
+            subscriptions = list(result.unique().scalars().all())
+
+            if not subscriptions:
+                return
+
+            new_squads = tariff.allowed_squads or []
+            ext_squad_uuid = tariff.external_squad_uuid
+
+            service = RemnaWaveService()
+            updated = 0
+            failed = 0
+
+            async with service.get_api_client() as api:
+                semaphore = asyncio.Semaphore(5)
+
+                async def _sync_one(sub: Subscription) -> None:
+                    nonlocal updated, failed
+                    remnawave_uuid = (
+                        getattr(sub, 'remnawave_uuid', None)
+                        if settings.is_multi_tariff_enabled()
+                        else (sub.user.remnawave_uuid if sub.user else None)
+                    )
+                    if not remnawave_uuid:
+                        return
+                    async with semaphore:
+                        try:
+                            await api.update_user(
+                                uuid=remnawave_uuid,
+                                active_internal_squads=new_squads,
+                                external_squad_uuid=ext_squad_uuid,
+                            )
+                            sub.connected_squads = new_squads
+                            updated += 1
+                        except Exception as e:
+                            failed += 1
+                            logger.warning(
+                                'Background sync: failed to sync squads for user',
+                                user_id=sub.user_id,
+                                error=str(e),
+                            )
+
+                await asyncio.gather(*[_sync_one(sub) for sub in subscriptions])
+
+            await db.commit()
+            logger.info(
+                'Background squad sync completed after tariff update',
+                admin_id=admin_id,
+                tariff_id=tariff_id,
+                tariff_name=tariff.name,
+                total=len(subscriptions),
+                updated=updated,
+                failed=failed,
+            )
+    except Exception:
+        logger.exception('Background squad sync failed', tariff_id=tariff_id)
+
+
+_SYNC_SQUADS_CONCURRENCY = 5
+_SYNC_SQUADS_MAX_CONSECUTIVE_FAILURES = 10
+
+
+@router.post('/{tariff_id}/sync-squads', response_model=SyncSquadsResponse)
+async def sync_tariff_squads(
+    tariff_id: int,
+    admin: User = Depends(require_permission('tariffs:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Sync squads from tariff to all active/trial subscriptions in Remnawave panel.
+
+    Updates connected_squads and external_squad_uuid for every active or trial
+    subscription linked to this tariff.  Only users that have a remnawave_uuid
+    (i.e. already exist in the panel) are touched.
+    """
+    tariff = await get_tariff_by_id(db, tariff_id)
+    if not tariff:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tariff not found',
+        )
+
+    # Fetch active + trial subscriptions for this tariff whose users exist in Remnawave
+    result = await db.execute(
+        select(Subscription)
+        .join(User, Subscription.user_id == User.id)
+        .options(joinedload(Subscription.user))
+        .where(
+            and_(
+                Subscription.tariff_id == tariff_id,
+                Subscription.status.in_([SubscriptionStatus.ACTIVE.value, SubscriptionStatus.TRIAL.value]),
+                User.remnawave_uuid.isnot(None),
+            )
+        )
+    )
+    subscriptions = list(result.unique().scalars().all())
+
+    if not subscriptions:
+        return SyncSquadsResponse(
+            tariff_id=tariff_id,
+            tariff_name=tariff.name,
+            total_subscriptions=0,
+            updated_count=0,
+            failed_count=0,
+            skipped_count=0,
+        )
+
+    new_squads = tariff.allowed_squads or []
+    # None means "clear external squad" — intentional when tariff has none
+    ext_squad_uuid = tariff.external_squad_uuid
+
+    # Sync to Remnawave panel with concurrency limit and circuit breaker
+    from app.services.remnawave_service import RemnaWaveService
+
+    service = RemnaWaveService()
+    updated_count = 0
+    failed_count = 0
+    skipped_count = 0
+    consecutive_failures = 0
+    errors: list[str] = []
+    aborted = False
+
+    async with service.get_api_client() as api:
+        semaphore = asyncio.Semaphore(_SYNC_SQUADS_CONCURRENCY)
+
+        async def _sync_one(sub: Subscription) -> str:
+            # Counter mutations are safe: no `await` between read-modify-write
+            # and the check within each branch (single-threaded asyncio event loop).
+            nonlocal updated_count, failed_count, skipped_count, consecutive_failures, aborted
+
+            if aborted:
+                skipped_count += 1
+                return 'skipped'
+
+            remnawave_uuid = (
+                getattr(sub, 'remnawave_uuid', None)
+                if settings.is_multi_tariff_enabled()
+                else (sub.user.remnawave_uuid if sub.user else None)
+            )
+            if not remnawave_uuid:
+                skipped_count += 1
+                return 'skipped'
+
+            async with semaphore:
+                if aborted:
+                    skipped_count += 1
+                    return 'skipped'
+
+                try:
+                    await api.update_user(
+                        uuid=remnawave_uuid,
+                        active_internal_squads=new_squads,
+                        external_squad_uuid=ext_squad_uuid,
+                    )
+                    # Update local DB only on successful API call
+                    sub.connected_squads = new_squads
+                    updated_count += 1
+                    consecutive_failures = 0
+                    return 'ok'
+                except Exception as e:
+                    failed_count += 1
+                    consecutive_failures += 1
+                    errors.append(f'user_id={sub.user_id}: sync failed')
+                    logger.warning(
+                        'Failed to sync squads for user in Remnawave',
+                        user_id=sub.user_id,
+                        remnawave_uuid=remnawave_uuid,
+                        error=str(e),
+                    )
+                    if consecutive_failures >= _SYNC_SQUADS_MAX_CONSECUTIVE_FAILURES:
+                        aborted = True
+                        errors.append(f'Aborted after {_SYNC_SQUADS_MAX_CONSECUTIVE_FAILURES} consecutive failures')
+                    return 'error'
+
+        await asyncio.gather(*[_sync_one(sub) for sub in subscriptions])
+
+    # Commit local DB changes only for successfully synced subscriptions
+    await db.commit()
+
+    logger.info(
+        'Admin synced squads for tariff',
+        admin_id=admin.id,
+        tariff_id=tariff_id,
+        tariff_name=tariff.name,
+        total=len(subscriptions),
+        updated=updated_count,
+        failed=failed_count,
+        skipped=skipped_count,
+    )
+
+    return SyncSquadsResponse(
+        tariff_id=tariff_id,
+        tariff_name=tariff.name,
+        total_subscriptions=len(subscriptions),
+        updated_count=updated_count,
+        failed_count=failed_count,
+        skipped_count=skipped_count,
+        errors=errors[:20],
+    )

app/cabinet/routes/admin_tickets.py

@@ -5,7 +5,7 @@ from datetime import UTC, datetime
 
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, Query, status
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from sqlalchemy import desc, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
@@ -90,6 +90,19 @@ class AdminReplyRequest(BaseModel):
     """Admin reply to ticket."""
 
     message: str = Field(..., min_length=1, max_length=4000, description='Reply message')
+    media_type: str | None = Field(None, description='Media type: photo, video, or document')
+    media_file_id: str | None = Field(None, max_length=255, description='Telegram file_id from media upload')
+    media_caption: str | None = Field(None, max_length=1000, description='Caption for media')
+
+    @model_validator(mode='after')
+    def validate_media_fields(self) -> 'AdminReplyRequest':
+        if self.media_file_id and not self.media_type:
+            raise ValueError('media_type is required when media_file_id is provided')
+        if self.media_type and not self.media_file_id:
+            raise ValueError('media_file_id is required when media_type is provided')
+        if self.media_type and self.media_type not in {'photo', 'video', 'document'}:
+            raise ValueError('media_type must be one of: photo, video, document')
+        return self
 
 
 class AdminStatusUpdateRequest(BaseModel):
@@ -246,6 +259,7 @@ async def update_ticket_settings(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Update ticket system settings."""
+    import asyncio
     from pathlib import Path
 
     from app.services.support_settings_service import SupportSettingsService
@@ -280,8 +294,8 @@ async def update_ticket_settings(
     # Try to persist to .env file
     try:
         env_file = Path('.env')
-        if env_file.exists():
-            lines = env_file.read_text().splitlines()
+        if await asyncio.to_thread(env_file.exists):
+            lines = (await asyncio.to_thread(env_file.read_text)).splitlines()
             updates = {}
 
             if request.sla_enabled is not None:
@@ -314,7 +328,7 @@ async def update_ticket_settings(
                 if key not in updated_keys:
                     new_lines.append(f'{key}={value}')
 
-            env_file.write_text('\n'.join(new_lines) + '\n')
+            await asyncio.to_thread(env_file.write_text, '\n'.join(new_lines) + '\n')
             logger.info('Updated ticket settings in .env file')
     except Exception as e:
         logger.warning('Failed to update .env file', error=e)
@@ -442,11 +456,16 @@ async def reply_to_ticket(
         )
 
     # Create admin message
+    has_media = bool(request.media_file_id)
     message = TicketMessage(
         ticket_id=ticket.id,
         user_id=ticket.user_id,
         message_text=request.message,
         is_from_admin=True,
+        has_media=has_media,
+        media_type=request.media_type if has_media else None,
+        media_file_id=request.media_file_id if has_media else None,
+        media_caption=request.media_caption if has_media else None,
         created_at=datetime.now(UTC),
     )
     db.add(message)
@@ -460,14 +479,9 @@ async def reply_to_ticket(
 
     # Try to notify user via Telegram
     try:
-        from aiogram import Bot
-        from aiogram.client.default import DefaultBotProperties
-        from aiogram.enums import ParseMode
+        from app.bot_factory import create_bot
 
-        bot = Bot(
-            token=settings.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-        )
+        bot = create_bot()
         try:
             from app.handlers.admin.tickets import notify_user_about_ticket_reply
 

app/cabinet/routes/admin_traffic.py

@@ -7,16 +7,13 @@ import time
 from datetime import UTC, datetime, timedelta
 
 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from aiogram.types import BufferedInputFile
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy import and_, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 
-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.models import Subscription, Transaction, TransactionType, User
 from app.services.remnawave_service import RemnaWaveService
 
@@ -24,6 +21,8 @@ from ..dependencies import get_cabinet_db, require_permission
 from ..schemas.traffic import (
     ExportCsvRequest,
     ExportCsvResponse,
+    SubscriptionEnrichmentInfo,
+    SubscriptionTrafficInfo,
     TrafficEnrichmentResponse,
     TrafficNodeInfo,
     TrafficUsageResponse,
@@ -159,15 +158,42 @@ def _compute_date_range(period_days: int) -> tuple[str, str]:
 
 
 async def _load_user_map(db: AsyncSession) -> dict[str, User]:
-    """Load all users with remnawave_uuid, eagerly loading subscription + tariff."""
-    stmt = (
+    """Load all users with remnawave_uuid, eagerly loading subscription + tariff.
+
+    In multi-tariff mode UUIDs live on Subscription rows, not on User.
+    Both sources are merged so the caller gets a complete uuid → User map.
+    """
+    from app.config import settings
+
+    # Build user map from both user-level and subscription-level UUIDs
+    user_map: dict[str, User] = {}
+
+    # Legacy: user-level UUIDs
+    stmt_users = (
         select(User)
         .where(User.remnawave_uuid.isnot(None))
-        .options(selectinload(User.subscription).selectinload(Subscription.tariff))
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
     )
-    result = await db.execute(stmt)
-    users = result.scalars().all()
-    return {u.remnawave_uuid: u for u in users if u.remnawave_uuid}
+    result_users = await db.execute(stmt_users)
+    users = result_users.scalars().all()
+    for u in users:
+        if u.remnawave_uuid:
+            user_map[u.remnawave_uuid] = u
+
+    # Multi-tariff: subscription-level UUIDs
+    if settings.is_multi_tariff_enabled():
+        stmt_subs = (
+            select(Subscription)
+            .where(Subscription.remnawave_uuid.isnot(None))
+            .options(selectinload(Subscription.user).selectinload(User.subscriptions).selectinload(Subscription.tariff))
+        )
+        result_subs = await db.execute(stmt_subs)
+        subs = result_subs.scalars().all()
+        for sub in subs:
+            if sub.remnawave_uuid and sub.user and sub.remnawave_uuid not in user_map:
+                user_map[sub.remnawave_uuid] = sub.user
+
+    return user_map
 
 
 def _build_traffic_items(
@@ -205,19 +231,23 @@ def _build_traffic_items(
             ):
                 continue
 
-        sub = user.subscription
+        subs = getattr(user, 'subscriptions', None) or []
+
+        # Primary subscription for backward-compat top-level fields
+        primary_sub = next((s for s in subs if s.is_active), subs[0] if subs else None)
         tariff_name = None
         subscription_status = None
         traffic_limit_gb = 0.0
         device_limit = 1
 
-        if sub:
-            subscription_status = _get_status(sub)
-            traffic_limit_gb = float(sub.traffic_limit_gb or 0)
-            device_limit = sub.device_limit or 1
-            if sub.tariff:
-                tariff_name = sub.tariff.name
+        if primary_sub:
+            subscription_status = _get_status(primary_sub)
+            traffic_limit_gb = float(primary_sub.traffic_limit_gb or 0)
+            device_limit = primary_sub.device_limit or 1
+            if primary_sub.tariff:
+                tariff_name = primary_sub.tariff.name
 
+        # Filtering uses primary sub values (keeps existing filter semantics)
         if tariff_filter is not None:
             if (tariff_name or '') not in tariff_filter:
                 continue
@@ -232,6 +262,18 @@ def _build_traffic_items(
 
         total_bytes = sum(traffic.values())
 
+        # Build per-subscription detail list for multi-subscription display
+        subscriptions_traffic = [
+            SubscriptionTrafficInfo(
+                subscription_id=sub.id,
+                tariff_name=sub.tariff.name if sub.tariff else None,
+                status=_get_status(sub),
+                traffic_limit_gb=float(sub.traffic_limit_gb or 0),
+                device_limit=sub.device_limit or 1,
+            )
+            for sub in subs
+        ]
+
         items.append(
             UserTrafficItem(
                 user_id=user.id,
@@ -245,6 +287,7 @@ def _build_traffic_items(
                 device_limit=device_limit,
                 node_traffic=traffic,
                 total_bytes=total_bytes,
+                subscriptions=subscriptions_traffic,
             )
         )
 
@@ -308,15 +351,21 @@ async def get_traffic_usage(
     # Collect all available tariff names (before filtering)
     available_tariffs = sorted(
         {
-            u.subscription.tariff.name
+            sub.tariff.name
             for u in user_map.values()
-            if u.subscription and u.subscription.tariff and u.subscription.tariff.name
+            for sub in (getattr(u, 'subscriptions', None) or [])
+            if sub.tariff and sub.tariff.name
         }
     )
 
     # Collect all available statuses (before filtering)
     available_statuses = sorted(
-        {_get_status(sub) for u in user_map.values() if (sub := u.subscription) and _get_status(sub)}
+        {
+            _get_status(sub)
+            for u in user_map.values()
+            for sub in (getattr(u, 'subscriptions', None) or [])
+            if _get_status(sub)
+        }
     )
 
     # Parse tariff filter
@@ -469,27 +518,42 @@ async def _build_enrichment(db: AsyncSession, user_map: dict[str, User]) -> dict
     enrichment: dict[int, UserTrafficEnrichment] = {}
     for uuid, user in user_map.items():
         uid = user.id
-        sub = user.subscription
+        subs_list = getattr(user, 'subscriptions', None) or []
+
+        # Primary subscription for backward-compat top-level date fields
+        primary_sub = next((s for s in subs_list if s.is_active), subs_list[0] if subs_list else None)
 
         start_date = None
         end_date = None
-        if sub:
-            if sub.start_date:
-                start_date = sub.start_date.isoformat()
-            if sub.end_date:
-                end_date = sub.end_date.isoformat()
+        if primary_sub:
+            if primary_sub.start_date:
+                start_date = primary_sub.start_date.isoformat()
+            if primary_sub.end_date:
+                end_date = primary_sub.end_date.isoformat()
 
         last_node_name = None
         last_uuid = last_node_uuid_by_user.get(uid)
         if last_uuid:
             last_node_name = node_uuid_to_name.get(last_uuid)
 
+        # Build per-subscription enrichment list for multi-subscription display
+        subscriptions_enrichment = [
+            SubscriptionEnrichmentInfo(
+                subscription_id=sub.id,
+                tariff_name=sub.tariff.name if sub.tariff else None,
+                start_date=sub.start_date.isoformat() if sub.start_date else None,
+                end_date=sub.end_date.isoformat() if sub.end_date else None,
+            )
+            for sub in subs_list
+        ]
+
         enrichment[uid] = UserTrafficEnrichment(
             devices_connected=devices_by_user.get(uid, 0),
             total_spent_kopeks=spending_map.get(uid, 0),
             subscription_start_date=start_date,
             subscription_end_date=end_date,
             last_node_name=last_node_name,
+            subscriptions=subscriptions_enrichment,
         )
 
     return enrichment
@@ -680,10 +744,7 @@ async def export_traffic_csv(
     filename = f'traffic_usage_{period_label}_{timestamp}.csv'
 
     try:
-        bot = Bot(
-            token=settings.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-        )
+        bot = create_bot()
         async with bot:
             await bot.send_document(
                 chat_id=admin.telegram_id,

app/cabinet/routes/admin_withdrawals.py

@@ -199,8 +199,7 @@ async def approve_withdrawal(
 
     # Notify user about approval
     try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
         from app.config import settings
         from app.services.notification_delivery_service import notification_delivery_service
 
@@ -211,7 +210,7 @@ async def approve_withdrawal(
                 formatted_amount = settings.format_price(withdrawal.amount_kopeks)
                 comment_text = f'\n{request.comment}' if request.comment else ''
                 tg_message = f'✅ Ваш запрос на вывод {formatted_amount} одобрен.{comment_text}'
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                 try:
                     await notification_delivery_service.notify_withdrawal_approved(
                         user=user,
@@ -251,8 +250,7 @@ async def reject_withdrawal(
 
     # Notify user about rejection
     try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
         from app.config import settings
         from app.services.notification_delivery_service import notification_delivery_service
 
@@ -263,7 +261,7 @@ async def reject_withdrawal(
                 formatted_amount = settings.format_price(withdrawal.amount_kopeks)
                 comment_text = f'\nПричина: {request.comment}' if request.comment else ''
                 tg_message = f'❌ Ваш запрос на вывод {formatted_amount} отклонён.{comment_text}'
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                 try:
                     await notification_delivery_service.notify_withdrawal_rejected(
                         user=user,

app/cabinet/routes/auth.py

@@ -6,7 +6,7 @@ from datetime import UTC, datetime
 
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, Request, status
-from sqlalchemy import select
+from sqlalchemy import func, select
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -28,10 +28,16 @@ from app.database.crud.user import (
     set_email_change_pending,
     verify_and_apply_email_change,
 )
-from app.database.models import CabinetRefreshToken, User
+from app.database.models import CabinetRefreshToken, User, UserStatus
 from app.services.campaign_service import AdvertisingCampaignService
 from app.services.disposable_email_service import disposable_email_service
 from app.services.referral_service import process_referral_registration
+from app.services.web_auth_service import (
+    WEB_AUTH_TOKEN_TTL,
+    consume_web_auth_token,
+    create_web_auth_token,
+    poll_web_auth_token,
+)
 from app.utils.cache import RateLimitCache, TokenReplayCache
 from app.utils.timezone import panel_datetime_to_utc
 
@@ -55,12 +61,15 @@ from ..auth.email_verification import (
     is_token_expired,
 )
 from ..auth.jwt_handler import get_refresh_token_expires_at
+from ..auth.merge_service import create_merge_token
 from ..dependencies import get_cabinet_db, get_current_cabinet_user
 from ..ip_utils import get_client_ip
 from ..schemas.auth import (
     AuthResponse,
     AutoLoginRequest,
     CampaignBonusInfo,
+    DeepLinkPollRequest,
+    DeepLinkTokenResponse,
     EmailChangeRequest,
     EmailChangeResponse,
     EmailChangeVerifyRequest,
@@ -188,12 +197,10 @@ async def _process_campaign_bonus(
             user.referred_by_id = campaign.partner_user_id
             await db.flush()
             try:
-                from aiogram import Bot
-                from aiogram.client.default import DefaultBotProperties
-                from aiogram.enums import ParseMode
+                from app.bot_factory import create_bot
 
-                bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
-                await process_referral_registration(db, user.id, campaign.partner_user_id, bot=bot)
+                async with create_bot() as bot:
+                    await process_referral_registration(db, user.id, campaign.partner_user_id, bot=bot)
                 logger.info(
                     'Referral set from campaign partner',
                     user_id=user.id,
@@ -233,11 +240,39 @@ async def _process_referral_code(
     db: AsyncSession,
     user: User,
     referral_code: str | None,
+    *,
+    is_new_user: bool = False,
 ) -> None:
-    """Set referred_by_id for user if referral_code is valid. Never raises."""
-    if not referral_code or user.referred_by_id:
+    """Process referral for a newly created user. Never raises.
+
+    Only applies to new users (is_new_user=True). Existing users cannot be
+    assigned a referrer — same logic as the bot /start handler.
+
+    Handles two cases:
+    - referred_by_id already set by create_user() → fire registration event
+    - referred_by_id not set (resolution failed earlier) → resolve, set, fire
+    """
+    if not referral_code or not is_new_user:
         return
     try:
+        from app.bot_factory import create_bot
+
+        # Lock user row to prevent concurrent referral application (TOCTOU race)
+        await db.execute(select(User).where(User.id == user.id).with_for_update())
+        await db.refresh(user)
+
+        # Case 1: referred_by_id already set by create_user() — just fire the event
+        if user.referred_by_id:
+            async with create_bot() as bot:
+                await process_referral_registration(db, user.id, user.referred_by_id, bot=bot)
+            logger.info(
+                'Referral registration processed for pre-set referrer',
+                user_id=user.id,
+                referrer_id=user.referred_by_id,
+            )
+            return
+
+        # Case 2: referred_by_id not set — resolve referral code and set it
         referrer = await get_user_by_referral_code(db, referral_code)
         if not referrer:
             return
@@ -247,12 +282,9 @@ async def _process_referral_code(
             return
         user.referred_by_id = referrer.id
         await db.flush()
-        from aiogram import Bot
-        from aiogram.client.default import DefaultBotProperties
-        from aiogram.enums import ParseMode
 
-        bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
-        await process_referral_registration(db, user.id, referrer.id, bot=bot)
+        async with create_bot() as bot:
+            await process_referral_registration(db, user.id, referrer.id, bot=bot)
         logger.info('Referral applied from code', user_id=user.id, referrer_id=referrer.id, referral_code=referral_code)
     except Exception as e:
         logger.error('Failed to process referral code', error=e, referral_code=referral_code)
@@ -283,94 +315,123 @@ async def _sync_subscription_from_panel_by_email(db: AsyncSession, user: User) -
                 logger.debug('No subscription found in panel for email', email=user.email)
                 return
 
-            # Take first user if multiple found
-            panel_user = panel_users[0]
-            logger.info('Found subscription in panel for email', email=user.email, uuid=panel_user.uuid)
-
-            # Check if another user already owns this remnawave_uuid
-            from app.database.crud.user import get_user_by_remnawave_uuid
-
-            existing_owner = await get_user_by_remnawave_uuid(db, panel_user.uuid)
-            if existing_owner and existing_owner.id != user.id:
-                logger.warning(
-                    'Panel UUID already belongs to another user, skipping sync',
-                    email=user.email,
-                    panel_uuid=panel_user.uuid,
-                    existing_owner_id=existing_owner.id,
-                )
-                return
-
-            # Link user to panel
-            user.remnawave_uuid = panel_user.uuid
-
-            # Create or update subscription
-            from app.database.crud.subscription import get_subscription_by_user_id
+            # In multi-tariff mode, sync ALL panel users (each = one subscription)
+            # In single-tariff mode, process only the first
+            from app.database.crud.subscription import get_active_subscriptions_by_user_id, get_subscription_by_user_id
             from app.database.models import Subscription, SubscriptionStatus
 
-            existing_sub = await get_subscription_by_user_id(db, user.id)
+            panel_users_to_sync = panel_users if settings.is_multi_tariff_enabled() else panel_users[:1]
 
-            # Parse panel data — panel returns local time with misleading +00:00 offset
-            expire_at = panel_datetime_to_utc(panel_user.expire_at)
-            traffic_limit_gb = panel_user.traffic_limit_bytes // (1024**3) if panel_user.traffic_limit_bytes > 0 else 0
-            traffic_used_gb = panel_user.used_traffic_bytes / (1024**3) if panel_user.used_traffic_bytes > 0 else 0
+            for panel_user in panel_users_to_sync:
+                logger.info('Syncing panel subscription for email', email=user.email, uuid=panel_user.uuid)
 
-            # Extract squad UUIDs from active_internal_squads
-            connected_squads = [s.get('uuid', '') for s in (panel_user.active_internal_squads or []) if s.get('uuid')]
+                # Check if another user already owns this remnawave_uuid
+                if settings.is_multi_tariff_enabled():
+                    from sqlalchemy import select as _select
 
-            # Device limit from panel
-            device_limit = panel_user.hwid_device_limit or 0
+                    from app.database.models import Subscription as _Subscription
 
-            # Determine status — expire_at is now naive UTC
-            current_time = datetime.now(UTC)
+                    _sub_result = await db.execute(
+                        _select(_Subscription).where(_Subscription.remnawave_uuid == panel_user.uuid)
+                    )
+                    _existing_sub = _sub_result.scalar_one_or_none()
+                    if _existing_sub and _existing_sub.user_id != user.id:
+                        logger.warning(
+                            'Panel UUID already owned by another user subscription, skipping',
+                            email=user.email,
+                            panel_uuid=panel_user.uuid,
+                            existing_owner_id=_existing_sub.user_id,
+                        )
+                        continue
+                else:
+                    from app.database.crud.user import get_user_by_remnawave_uuid
 
-            if panel_user.status.value == 'ACTIVE' and expire_at > current_time:
-                sub_status = SubscriptionStatus.ACTIVE
-            elif expire_at <= current_time:
-                sub_status = SubscriptionStatus.EXPIRED
-            else:
-                sub_status = SubscriptionStatus.DISABLED
+                    existing_owner = await get_user_by_remnawave_uuid(db, panel_user.uuid)
+                    if existing_owner and existing_owner.id != user.id:
+                        logger.warning(
+                            'Panel UUID already belongs to another user, skipping',
+                            email=user.email,
+                            panel_uuid=panel_user.uuid,
+                            existing_owner_id=existing_owner.id,
+                        )
+                        continue
 
-            if existing_sub:
-                # Update existing subscription (expire_at already naive UTC)
-                existing_sub.end_date = expire_at
-                existing_sub.traffic_limit_gb = traffic_limit_gb
-                existing_sub.traffic_used_gb = traffic_used_gb
-                existing_sub.status = sub_status.value
-                existing_sub.remnawave_short_uuid = panel_user.short_uuid
-                existing_sub.subscription_url = panel_user.subscription_url
-                existing_sub.subscription_crypto_link = panel_user.happ_crypto_link
-                existing_sub.connected_squads = connected_squads
-                existing_sub.device_limit = device_limit
-                existing_sub.is_trial = False  # Panel subscription is not trial
-                logger.info(
-                    'Updated subscription for email user squads: devices',
-                    email=user.email,
-                    connected_squads=connected_squads,
-                    device_limit=device_limit,
-                )
-            else:
-                # Create new subscription (expire_at and current_time already naive UTC)
-                new_sub = Subscription(
-                    user_id=user.id,
-                    start_date=current_time,
-                    end_date=expire_at,
-                    traffic_limit_gb=traffic_limit_gb,
-                    traffic_used_gb=traffic_used_gb,
-                    status=sub_status.value,
-                    is_trial=False,
-                    remnawave_short_uuid=panel_user.short_uuid,
-                    subscription_url=panel_user.subscription_url,
-                    subscription_crypto_link=panel_user.happ_crypto_link,
-                    connected_squads=connected_squads,
-                    device_limit=device_limit,
-                )
-                db.add(new_sub)
-                logger.info(
-                    'Created subscription for email user squads: devices',
-                    email=user.email,
-                    connected_squads=connected_squads,
-                    device_limit=device_limit,
+                # Link user to panel (only in single-tariff mode)
+                if not settings.is_multi_tariff_enabled():
+                    user.remnawave_uuid = panel_user.uuid
+
+                # Find existing subscription
+                if settings.is_multi_tariff_enabled():
+                    active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+                    existing_sub = next(
+                        (s for s in active_subs if s.remnawave_uuid == panel_user.uuid),
+                        None,
+                    )
+                else:
+                    existing_sub = await get_subscription_by_user_id(db, user.id)
+
+                # Parse panel data
+                expire_at = panel_datetime_to_utc(panel_user.expire_at)
+                traffic_limit_gb = (
+                    panel_user.traffic_limit_bytes // (1024**3) if panel_user.traffic_limit_bytes > 0 else 0
                 )
+                traffic_used_gb = panel_user.used_traffic_bytes / (1024**3) if panel_user.used_traffic_bytes > 0 else 0
+                connected_squads = [
+                    s.get('uuid', '') for s in (panel_user.active_internal_squads or []) if s.get('uuid')
+                ]
+                device_limit = panel_user.hwid_device_limit or 0
+
+                # Determine status
+                current_time = datetime.now(UTC)
+                if panel_user.status.value == 'ACTIVE' and expire_at > current_time:
+                    sub_status = SubscriptionStatus.ACTIVE
+                elif expire_at <= current_time:
+                    sub_status = SubscriptionStatus.EXPIRED
+                else:
+                    sub_status = SubscriptionStatus.DISABLED
+
+                if existing_sub:
+                    existing_sub.end_date = expire_at
+                    existing_sub.traffic_limit_gb = traffic_limit_gb
+                    existing_sub.traffic_used_gb = traffic_used_gb
+                    existing_sub.status = sub_status.value
+                    existing_sub.remnawave_short_uuid = panel_user.short_uuid
+                    existing_sub.subscription_url = panel_user.subscription_url
+                    existing_sub.subscription_crypto_link = panel_user.happ_crypto_link
+                    existing_sub.connected_squads = connected_squads
+                    existing_sub.device_limit = device_limit
+                    existing_sub.is_trial = False
+                    logger.info(
+                        'Updated subscription for email user',
+                        email=user.email,
+                        uuid=panel_user.uuid,
+                    )
+                else:
+                    from app.database.crud.subscription import generate_unique_short_id
+
+                    _short_id = await generate_unique_short_id(db)
+                    new_sub = Subscription(
+                        user_id=user.id,
+                        start_date=current_time,
+                        end_date=expire_at,
+                        traffic_limit_gb=traffic_limit_gb,
+                        traffic_used_gb=traffic_used_gb,
+                        status=sub_status.value,
+                        is_trial=False,
+                        remnawave_uuid=panel_user.uuid if settings.is_multi_tariff_enabled() else None,
+                        remnawave_short_id=_short_id,
+                        remnawave_short_uuid=panel_user.short_uuid,
+                        subscription_url=panel_user.subscription_url,
+                        subscription_crypto_link=panel_user.happ_crypto_link,
+                        connected_squads=connected_squads,
+                        device_limit=device_limit,
+                    )
+                    db.add(new_sub)
+                    logger.info(
+                        'Created subscription for email user',
+                        email=user.email,
+                        uuid=panel_user.uuid,
+                    )
 
             await db.commit()
 
@@ -400,7 +461,11 @@ async def auth_telegram(
             detail='Too many requests',
             headers={'Retry-After': '60'},
         )
-    user_data = validate_telegram_init_data(request.init_data)
+    # Telegram Desktop/iOS cache initData with stale auth_date (known Telegram bug:
+    # https://github.com/telegramdesktop/tdesktop/issues/28303).
+    # Use generous max_age: HMAC signature proves authenticity,
+    # JWT tokens handle actual session expiration after login.
+    user_data = validate_telegram_init_data(request.init_data, max_age_seconds=86400 * 30)
 
     if not user_data:
         raise HTTPException(
@@ -429,10 +494,35 @@ async def auth_telegram(
         try:
             referrer = await get_user_by_referral_code(db, request.referral_code)
             if referrer:
-                referrer_id = referrer.id
+                # Self-referral protection by telegram_id (user doesn't exist yet, can't compare user.id)
+                if referrer.telegram_id and referrer.telegram_id == telegram_id:
+                    logger.warning(
+                        'Self-referral attempt blocked via telegram_id',
+                        telegram_id=telegram_id,
+                        referral_code=request.referral_code,
+                    )
+                else:
+                    referrer_id = referrer.id
         except Exception as e:
             logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=e)
 
+    # Fallback: check Redis for pending referral from /start (user opened cabinet before completing bot registration)
+    if not referrer_id and not user and telegram_id:
+        try:
+            from app.services.referral_service import get_pending_referral
+
+            pending = await get_pending_referral(telegram_id)
+            if pending and pending.get('referrer_id'):
+                referrer_id = pending['referrer_id']
+                logger.info(
+                    'Resolved referral from Redis pending_referral (cabinet)',
+                    telegram_id=telegram_id,
+                    referrer_id=referrer_id,
+                )
+        except Exception as e:
+            logger.warning('Failed to check pending referral', error=e)
+
+    is_new_user = not user
     if not user:
         # Create new user from Telegram initData
         logger.info('Creating new user from cabinet (initData): telegram_id', telegram_id=telegram_id)
@@ -461,7 +551,7 @@ async def auth_telegram(
         if updated:
             logger.info('User profile updated from initData', user_id=user.id)
 
-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail='User account is not active',
@@ -476,8 +566,17 @@ async def auth_telegram(
     # Store refresh token
     await _store_refresh_token(db, user.id, response.refresh_token)
 
-    # Process referral code (before campaign bonus, which may also set referrer)
-    await _process_referral_code(db, user, request.referral_code)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
+    await _process_referral_code(db, user, request.referral_code, is_new_user=is_new_user)
+
+    # Clear Redis pending referral after successful user creation with referral
+    if referrer_id:
+        try:
+            from app.services.referral_service import clear_pending_referral
+
+            await clear_pending_referral(telegram_id)
+        except Exception:
+            pass
 
     # Process campaign bonus
     response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
@@ -510,7 +609,8 @@ async def auth_telegram_widget(
 
     widget_data = request.model_dump(exclude={'campaign_slug', 'referral_code'})
 
-    if not validate_telegram_login_widget(widget_data):
+    # Generous max_age: Telegram caches auth data with stale auth_date
+    if not validate_telegram_login_widget(widget_data, max_age_seconds=86400 * 30):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail='Invalid or expired Telegram authentication data',
@@ -524,10 +624,19 @@ async def auth_telegram_widget(
         try:
             referrer = await get_user_by_referral_code(db, request.referral_code)
             if referrer:
-                referrer_id = referrer.id
+                # Self-referral protection by telegram_id (user doesn't exist yet, can't compare user.id)
+                if referrer.telegram_id and referrer.telegram_id == request.id:
+                    logger.warning(
+                        'Self-referral attempt blocked via telegram_id',
+                        telegram_id=request.id,
+                        referral_code=request.referral_code,
+                    )
+                else:
+                    referrer_id = referrer.id
         except Exception as e:
             logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=e)
 
+    is_new_user = not user
     if not user:
         # Create new user from Telegram data
         logger.info(
@@ -544,7 +653,7 @@ async def auth_telegram_widget(
         )
         logger.info('User created successfully: id=, telegram_id', user_id=user.id, telegram_id=user.telegram_id)
 
-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail='User account is not active',
@@ -564,8 +673,17 @@ async def auth_telegram_widget(
     response = await _create_auth_response(user, db)
     await _store_refresh_token(db, user.id, response.refresh_token)
 
-    # Process referral code (before campaign bonus, which may also set referrer)
-    await _process_referral_code(db, user, request.referral_code)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
+    await _process_referral_code(db, user, request.referral_code, is_new_user=is_new_user)
+
+    # Clear Redis pending referral after successful registration
+    if referrer_id and request.id:
+        try:
+            from app.services.referral_service import clear_pending_referral
+
+            await clear_pending_referral(request.id)
+        except Exception:
+            pass
 
     # Process campaign bonus
     response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
@@ -656,10 +774,19 @@ async def auth_telegram_oidc(
         try:
             referrer = await get_user_by_referral_code(db, request.referral_code)
             if referrer:
-                referrer_id = referrer.id
-        except (ValueError, LookupError) as e:
-            logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=str(e))
+                # Self-referral protection by telegram_id (user doesn't exist yet, can't compare user.id)
+                if referrer.telegram_id and referrer.telegram_id == telegram_id:
+                    logger.warning(
+                        'Self-referral attempt blocked via telegram_id',
+                        telegram_id=telegram_id,
+                        referral_code=request.referral_code,
+                    )
+                else:
+                    referrer_id = referrer.id
+        except Exception as e:
+            logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=e)
 
+    is_new_user = not user
     if not user:
         logger.info('Creating new user from cabinet OIDC', telegram_id=telegram_id, username=username)
         user = await create_user(
@@ -673,7 +800,7 @@ async def auth_telegram_oidc(
         )
         logger.info('User created successfully', user_id=user.id, telegram_id=user.telegram_id)
 
-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail='User account is not active',
@@ -693,7 +820,17 @@ async def auth_telegram_oidc(
     response = await _create_auth_response(user, db)
     await _store_refresh_token(db, user.id, response.refresh_token)
 
-    await _process_referral_code(db, user, request.referral_code)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
+    await _process_referral_code(db, user, request.referral_code, is_new_user=is_new_user)
+
+    # Clear Redis pending referral after successful registration
+    if referrer_id and telegram_id:
+        try:
+            from app.services.referral_service import clear_pending_referral
+
+            await clear_pending_referral(telegram_id)
+        except Exception:
+            pass
 
     response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
     if response.campaign_bonus:
@@ -705,6 +842,7 @@ async def auth_telegram_oidc(
 @router.post('/email/register')
 async def register_email(
     request: EmailRegisterRequest,
+    raw_request: Request,
     user: User = Depends(get_current_cabinet_user),
     db: AsyncSession = Depends(get_cabinet_db),
 ):
@@ -713,7 +851,24 @@ async def register_email(
 
     Requires valid JWT token from Telegram authentication.
     Sends verification email to the provided address.
+    If the email belongs to another active user, offers account merge.
     """
+    # Rate limit
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'email_register', limit=5, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
+    # Check if user already has a verified email — block before doing anything else
+    if user.email and user.email_verified:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='You already have a verified email',
+        )
+
     # Check for disposable email
     if disposable_email_service.is_disposable(request.email):
         raise HTTPException(
@@ -721,20 +876,38 @@ async def register_email(
             detail='Disposable email addresses are not allowed',
         )
 
-    # Check if email already exists
-    existing_user = await db.execute(select(User).where(User.email == request.email))
-    if existing_user.scalar_one_or_none():
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail='This email is already registered',
+    # Check if email already exists (case-insensitive, exclude deleted users)
+    email_lower = (request.email or '').strip().lower()
+    existing_result = await db.execute(
+        select(User).where(
+            func.lower(User.email) == email_lower,
+            User.status != UserStatus.DELETED.value,
         )
-
-    # Check if user already has email
-    if user.email and user.email_verified:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail='You already have a verified email',
+    )
+    existing_email_user = existing_result.scalar_one_or_none()
+    if existing_email_user:
+        if existing_email_user.id == user.id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='This email is already linked to your account',
+            )
+        # Offer account merge instead of blocking
+        logger.info(
+            'Email register conflict: email already linked to another user, offering merge',
+            current_user_id=user.id,
+            existing_user_id=existing_email_user.id,
         )
+        merge_token = await create_merge_token(
+            primary_user_id=user.id,
+            secondary_user_id=existing_email_user.id,
+            provider='email',
+            provider_id=email_lower,
+        )
+        return {
+            'message': 'Account merge required',
+            'merge_required': True,
+            'merge_token': merge_token,
+        }
 
     # Update user
     user.email = request.email
@@ -774,7 +947,7 @@ async def register_email(
                 },
                 db=db,
             )
-            custom_subject, custom_body = override if override else (None, None)
+            custom_subject, custom_body = override or (None, None)
 
             await asyncio.to_thread(
                 email_service.send_verification_email,
@@ -837,8 +1010,9 @@ async def register_email_standalone(
             detail='Disposable email addresses are not allowed',
         )
 
-    # Проверить что email не занят
-    existing = await db.execute(select(User).where(User.email == request.email))
+    # Проверить что email не занят (без учёта регистра)
+    email_lower = (request.email or '').strip().lower()
+    existing = await db.execute(select(User).where(func.lower(User.email) == email_lower))
     if existing.scalar_one_or_none():
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -884,6 +1058,11 @@ async def register_email_standalone(
         user.email_verified_at = datetime.now(UTC)
         await db.commit()
         logger.info('Email auto-verified (test or verification disabled)', email=request.email, user_id=user.id)
+        # Sync existing panel subscription (same as manual verification flow)
+        try:
+            await _sync_subscription_from_panel_by_email(db, user)
+        except Exception:
+            logger.warning('Failed to sync panel subscription after auto-verify', user_id=user.id, exc_info=True)
     else:
         # Сгенерировать токен верификации
         verification_token = generate_verification_token()
@@ -911,7 +1090,7 @@ async def register_email_standalone(
                 },
                 db=db,
             )
-            custom_subject, custom_body = override if override else (None, None)
+            custom_subject, custom_body = override or (None, None)
 
             await asyncio.to_thread(
                 email_service.send_verification_email,
@@ -927,12 +1106,10 @@ async def register_email_standalone(
     # Обработать реферальную регистрацию (если есть реферер)
     if referrer:
         try:
-            from aiogram import Bot
-            from aiogram.client.default import DefaultBotProperties
-            from aiogram.enums import ParseMode
+            from app.bot_factory import create_bot
 
-            bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
-            await process_referral_registration(db, user.id, referrer.id, bot=bot)
+            async with create_bot() as bot:
+                await process_referral_registration(db, user.id, referrer.id, bot=bot)
             logger.info(
                 'Processed referral registration: user_id=, referrer_id', user_id=user.id, referrer_id=referrer.id
             )
@@ -1049,7 +1226,7 @@ async def resend_verification(
             },
             db=db,
         )
-        custom_subject, custom_body = override if override else (None, None)
+        custom_subject, custom_body = override or (None, None)
 
         await asyncio.to_thread(
             email_service.send_verification_email,
@@ -1096,8 +1273,9 @@ async def login_email(
     # Check if this is a test email login
     is_test_email = settings.is_test_email(request.email)
 
-    # Find user by email
-    result = await db.execute(select(User).where(User.email == request.email))
+    # Find user by email (case-insensitive)
+    email_lower = (request.email or '').strip().lower()
+    result = await db.execute(select(User).where(func.lower(User.email) == email_lower))
     user = result.scalar_one_or_none()
 
     if not user:
@@ -1140,7 +1318,7 @@ async def login_email(
             detail='Please verify your email first',
         )
 
-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail='User account is not active',
@@ -1289,7 +1467,7 @@ async def auto_login(
             detail='User not found',
         )
 
-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail='Account is deactivated',
@@ -1317,7 +1495,8 @@ async def forgot_password(
             detail='Too many requests',
             headers={'Retry-After': '60'},
         )
-    result = await db.execute(select(User).where(User.email == request.email))
+    email_lower = (request.email or '').strip().lower()
+    result = await db.execute(select(User).where(func.lower(User.email) == email_lower))
     user = result.scalar_one_or_none()
 
     # Always return success to prevent email enumeration
@@ -1356,7 +1535,7 @@ async def forgot_password(
             context={'username': user.first_name or '', 'reset_url': full_url, 'expire_hours': str(expire_hours)},
             db=db,
         )
-        custom_subject, custom_body = override if override else (None, None)
+        custom_subject, custom_body = override or (None, None)
 
         await asyncio.to_thread(
             email_service.send_password_reset_email,
@@ -1524,7 +1703,7 @@ async def request_email_change(
                 },
                 db=db,
             )
-            custom_subject, custom_body = override if override else (None, None)
+            custom_subject, custom_body = override or (None, None)
 
             try:
                 await asyncio.to_thread(
@@ -1579,7 +1758,7 @@ async def request_email_change(
             },
             db=db,
         )
-        custom_subject, custom_body = override if override else (None, None)
+        custom_subject, custom_body = override or (None, None)
 
         await asyncio.to_thread(
             email_service.send_email_change_code,
@@ -1670,3 +1849,130 @@ async def get_email_change_status(
         'new_email': user.email_change_new,
         'expires_at': user.email_change_expires.isoformat() if user.email_change_expires else None,
     }
+
+
+# --- Deep link auth (fallback when oauth.telegram.org is blocked) ---
+
+
+@router.post('/deeplink/request', response_model=DeepLinkTokenResponse)
+async def request_deep_link_token(
+    raw_request: Request,
+):
+    """Generate a one-time deep link auth token.
+
+    Frontend shows t.me/{bot}?start=webauth_{token} to the user.
+    No auth required (user is not logged in yet).
+    """
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'deeplink_request', limit=10, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
+    try:
+        token = await create_web_auth_token()
+    except RuntimeError:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail='Service temporarily unavailable',
+        )
+
+    bot_username = settings.get_bot_username()
+    if not bot_username:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail='Bot not configured',
+        )
+
+    return DeepLinkTokenResponse(
+        token=token,
+        bot_username=bot_username,
+        expires_in=WEB_AUTH_TOKEN_TTL,
+    )
+
+
+@router.post('/deeplink/poll', response_model=AuthResponse)
+async def poll_deep_link_token(
+    request: DeepLinkPollRequest,
+    raw_request: Request,
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Poll for deep link auth completion.
+
+    Returns 202 if still pending, AuthResponse if completed, 410 if expired.
+    """
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'deeplink_poll', limit=60, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
+    data = await poll_web_auth_token(request.token)
+
+    if data is None:
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail='Token expired or not found',
+        )
+
+    if data.get('status') == 'pending':
+        raise HTTPException(
+            status_code=status.HTTP_202_ACCEPTED,
+            detail='Waiting for confirmation',
+        )
+
+    if data.get('status') != 'linked':
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail='Invalid token state',
+        )
+
+    # Token is linked - consume it atomically
+    consumed = await consume_web_auth_token(request.token)
+    if not consumed:
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail='Token already consumed',
+        )
+
+    user_id = consumed.get('user_id')
+    if not user_id:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Invalid token data',
+        )
+
+    user = await get_user_by_id(db, int(user_id))
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail='User not found',
+        )
+
+    if user.status != UserStatus.ACTIVE.value:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Account is deactivated',
+        )
+
+    user.cabinet_last_login = datetime.now(UTC)
+    await db.commit()
+
+    response = await _create_auth_response(user, db)
+    await _store_refresh_token(db, user.id, response.refresh_token, device_info='deep_link')
+
+    # Deep link auth is always for existing users — referral code not applicable
+    # (kept for campaign bonus processing only)
+
+    # Process campaign bonus
+    response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
+    if response.campaign_bonus:
+        response.user = _user_to_response(user)
+
+    logger.info('Deep link auth successful', user_id=user.id, telegram_id=user.telegram_id)
+
+    return response

app/cabinet/routes/balance.py

@@ -4,16 +4,17 @@ import math
 import time
 from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
 
-import httpx
 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy import desc, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.bot_factory import create_bot
 from app.config import settings
+from app.database.crud.saved_payment_method import (
+    deactivate_payment_method,
+    get_active_payment_methods_by_user,
+)
 from app.database.crud.user import get_user_by_id
 from app.database.models import PaymentMethod, Transaction, User
 from app.services.payment_method_config_service import get_enabled_methods_for_user
@@ -35,6 +36,8 @@ from ..schemas.balance import (
     PaymentMethodResponse,
     PendingPaymentListResponse,
     PendingPaymentResponse,
+    SavedCardResponse,
+    SavedCardsListResponse,
     StarsInvoiceRequest,
     StarsInvoiceResponse,
     TopUpRequest,
@@ -102,8 +105,8 @@ async def get_transactions(
     for t in transactions:
         # Determine sign based on transaction type
         # Credits (positive): DEPOSIT, REFERRAL_REWARD, REFUND, POLL_REWARD
-        # Debits (negative): SUBSCRIPTION_PAYMENT, WITHDRAWAL
-        is_debit = t.type in ['subscription_payment', 'withdrawal']
+        # Debits (negative): SUBSCRIPTION_PAYMENT, WITHDRAWAL, GIFT_PAYMENT
+        is_debit = t.type in ['subscription_payment', 'withdrawal', 'gift_payment']
         amount_kopeks = -abs(t.amount_kopeks) if is_debit else abs(t.amount_kopeks)
 
         items.append(
@@ -198,7 +201,7 @@ async def get_payment_methods(
                         'description': description,
                     }
                 )
-            options = formatted_options if formatted_options else None
+            options = formatted_options or None
 
         methods.append(
             PaymentMethodResponse(
@@ -244,13 +247,16 @@ async def create_stars_invoice(
             detail='Maximum amount is 10,000.00 RUB',
         )
 
-    # Calculate Stars amount
+    # Calculate Stars amount and normalize kopeks to match exact star value
     try:
         amount_rubles = request.amount_kopeks / 100
         stars_amount = settings.rubles_to_stars(amount_rubles)
 
         if stars_amount <= 0:
             stars_amount = 1
+
+        # Normalize kopeks so credited amount = stars * rate (no rounding mismatch)
+        normalized_kopeks = round(stars_amount * settings.get_stars_rate() * 100)
     except Exception as e:
         logger.error('Error calculating Stars amount', error=e)
         raise HTTPException(
@@ -259,54 +265,41 @@ async def create_stars_invoice(
         )
 
     # Create payload for tracking payment
-    payload = f'balance_topup_{user.id}_{request.amount_kopeks}_{int(time.time())}'
+    payload = f'balance_topup_{user.id}_{normalized_kopeks}_{int(time.time())}'
 
     # Create invoice through Telegram Bot API
     try:
-        bot_token = settings.BOT_TOKEN
-        api_url = f'https://api.telegram.org/bot{bot_token}/createInvoiceLink'
+        from aiogram.exceptions import TelegramAPIError
+        from aiogram.types import LabeledPrice
 
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                api_url,
-                json={
-                    'title': 'Пополнение баланса VPN',
-                    'description': f'Пополнение баланса на {amount_rubles:.2f} ₽ ({stars_amount} ⭐)',
-                    'payload': payload,
-                    'provider_token': '',  # Empty for Stars
-                    'currency': 'XTR',
-                    'prices': [{'label': 'Пополнение баланса', 'amount': stars_amount}],
-                },
+        async with create_bot() as bot:
+            invoice_url = await bot.create_invoice_link(
+                title='Пополнение баланса VPN',
+                description=f'Пополнение баланса на {normalized_kopeks / 100:.2f} ₽ ({stars_amount} ⭐)',
+                payload=payload,
+                provider_token='',
+                currency='XTR',
+                prices=[LabeledPrice(label='Пополнение баланса', amount=stars_amount)],
             )
 
-            result = response.json()
+        logger.info(
+            'Created Stars invoice for balance top-up: user=, amount= kopeks, stars',
+            user_id=user.id,
+            amount_kopeks=request.amount_kopeks,
+            stars_amount=stars_amount,
+        )
 
-            if not result.get('ok'):
-                logger.error('Telegram API error', result=result)
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail='Failed to create Stars invoice',
-                )
+        return StarsInvoiceResponse(
+            invoice_url=invoice_url,
+            stars_amount=stars_amount,
+            amount_kopeks=normalized_kopeks,
+        )
 
-            invoice_url = result['result']
-            logger.info(
-                'Created Stars invoice for balance top-up: user=, amount= kopeks, stars',
-                user_id=user.id,
-                amount_kopeks=request.amount_kopeks,
-                stars_amount=stars_amount,
-            )
-
-            return StarsInvoiceResponse(
-                invoice_url=invoice_url,
-                stars_amount=stars_amount,
-                amount_kopeks=request.amount_kopeks,
-            )
-
-    except httpx.HTTPError as e:
-        logger.error('HTTP error creating Stars invoice', error=e)
+    except TelegramAPIError as e:
+        logger.error('Error creating Stars invoice', error=e)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail='Failed to connect to Telegram API',
+            detail='Failed to create Stars invoice',
         )
 
 
@@ -367,7 +360,7 @@ async def create_topup(
             option = (request.payment_option or '').strip().lower()
             # Use description with telegram_id for tax receipts
             description = settings.get_balance_payment_description(
-                request.amount_kopeks, telegram_user_id=user.telegram_id
+                request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
             )
             if option == 'sbp':
                 result = await payment_service.create_yookassa_sbp_payment(
@@ -390,7 +383,7 @@ async def create_topup(
 
             if result:
                 payment_url = result.get('confirmation_url')
-                payment_id = result.get('yookassa_payment_id')
+                payment_id = str(result.get('local_payment_id') or result.get('yookassa_payment_id') or 'pending')
             else:
                 raise HTTPException(
                     status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -430,7 +423,7 @@ async def create_topup(
                 amount_usd=amount_usd,
                 asset=settings.CRYPTOBOT_DEFAULT_ASSET,
                 description=settings.get_balance_payment_description(
-                    request.amount_kopeks, telegram_user_id=user.telegram_id
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
                 ),
                 payload=f'cabinet_topup_{user.id}_{request.amount_kopeks}',
             )
@@ -491,7 +484,7 @@ async def create_topup(
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
                 description=settings.get_balance_payment_description(
-                    request.amount_kopeks, telegram_user_id=user.telegram_id
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
                 ),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                 payment_method_code=method_code,
@@ -520,7 +513,9 @@ async def create_topup(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                 return_url=cabinet_return_url,
                 success_url=cabinet_success_url,
@@ -547,7 +542,9 @@ async def create_topup(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
             )
 
@@ -571,16 +568,16 @@ async def create_topup(
             option = (request.payment_option or '').strip().lower()
             if option not in {'card', 'sbp'}:
                 option = 'sbp'
-            provider_method = 'card' if option == 'card' else 'sbp'
 
             payment_service = PaymentService()
             result = await payment_service.create_pal24_payment(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
-                payment_method=provider_method,
             )
 
             if result:
@@ -619,7 +616,9 @@ async def create_topup(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                 return_url=cabinet_success_url,
                 failed_url=cabinet_failed_url,
@@ -646,7 +645,9 @@ async def create_topup(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 telegram_id=user.telegram_id,
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                 return_url=cabinet_success_url,
@@ -674,7 +675,9 @@ async def create_topup(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
             )
 
@@ -694,14 +697,22 @@ async def create_topup(
                     detail='KassaAI payment method is unavailable',
                 )
 
+            # Use payment_option to select sbp or card
+            KASSA_AI_OPTION_MAP = {'sbp': 44, 'card': 36}
+            option = (request.payment_option or '').strip().lower()
+            ps_id = KASSA_AI_OPTION_MAP.get(option)  # None = use env default
+
             payment_service = PaymentService()
             result = await payment_service.create_kassa_ai_payment(
                 db=db,
                 user_id=user.id,
                 amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                 email=getattr(user, 'email', None),
                 language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                payment_system_id=ps_id,
             )
 
             if result and result.get('payment_url'):
@@ -713,6 +724,35 @@ async def create_topup(
                     detail='Failed to create KassaAI payment',
                 )
 
+        elif request.payment_method == 'riopay':
+            if not settings.is_riopay_enabled():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='RioPay payment method is unavailable',
+                )
+
+            payment_service = PaymentService()
+            result = await payment_service.create_riopay_payment(
+                db=db,
+                user_id=user.id,
+                amount_kopeks=request.amount_kopeks,
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
+                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                success_url=cabinet_success_url,
+                fail_url=cabinet_failed_url,
+            )
+
+            if result and result.get('payment_url'):
+                payment_url = result.get('payment_url')
+                payment_id = str(result.get('local_payment_id') or result.get('riopay_order_id') or 'pending')
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail='Failed to create RioPay payment',
+                )
+
         elif request.payment_method == 'tribute':
             if not settings.TRIBUTE_ENABLED or not settings.TRIBUTE_DONATE_LINK:
                 raise HTTPException(
@@ -724,6 +764,35 @@ async def create_topup(
             payment_url = f'{settings.TRIBUTE_DONATE_LINK}&user_id={user_identifier}'
             payment_id = f'tribute_{user_identifier}_{request.amount_kopeks}'
 
+        elif request.payment_method == 'severpay':
+            if not settings.is_severpay_enabled():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='SeverPay payment method is unavailable',
+                )
+
+            payment_service = PaymentService()
+            result = await payment_service.create_severpay_payment(
+                db=db,
+                user_id=user.id,
+                amount_kopeks=request.amount_kopeks,
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
+                email=getattr(user, 'email', None),
+                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                return_url=cabinet_success_url,
+            )
+
+            if result and result.get('payment_url'):
+                payment_url = result.get('payment_url')
+                payment_id = str(result.get('local_payment_id') or result.get('order_id') or 'pending')
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail='Failed to create SeverPay payment',
+                )
+
         else:
             # For other payment methods, redirect to bot
             raise HTTPException(
@@ -864,6 +933,17 @@ def _get_status_info(record: PendingPayment) -> tuple[str, str]:
         }
         return mapping.get(status, ('❓', 'Неизвестно'))
 
+    if record.method == PaymentMethod.RIOPAY:
+        mapping = {
+            'pending': ('⏳', 'Ожидает оплаты'),
+            'success': ('✅', 'Оплачено'),
+            'failed': ('❌', 'Ошибка'),
+            'canceled': ('❌', 'Отменено'),
+            'expired': ('⌛', 'Истёк'),
+            'amount_mismatch': ('⚠️', 'Несовпадение суммы'),
+        }
+        return mapping.get(status, ('❓', 'Неизвестно'))
+
     return '❓', 'Неизвестно'
 
 
@@ -887,13 +967,15 @@ def _is_checkable(record: PendingPayment) -> bool:
     if record.method == PaymentMethod.YOOKASSA:
         return status in {'pending', 'waiting_for_capture'}
     if record.method == PaymentMethod.CRYPTOBOT:
-        return status in {'active'}
+        return status == 'active'
     if record.method == PaymentMethod.CLOUDPAYMENTS:
         return status in {'pending', 'authorized'}
     if record.method == PaymentMethod.FREEKASSA:
         return status in {'pending', 'created', 'processing'}
     if record.method == PaymentMethod.KASSA_AI:
         return status in {'pending', 'created', 'processing'}
+    if record.method == PaymentMethod.RIOPAY:
+        return status in {'pending'}
     return False
 
 
@@ -917,7 +999,12 @@ def _get_payment_url(record: PendingPayment) -> str | None:
         )
     elif record.method == PaymentMethod.PLATEGA:
         payment_url = getattr(payment, 'redirect_url', None) or payment_url
-    elif record.method in (PaymentMethod.CLOUDPAYMENTS, PaymentMethod.FREEKASSA, PaymentMethod.KASSA_AI):
+    elif record.method in (
+        PaymentMethod.CLOUDPAYMENTS,
+        PaymentMethod.FREEKASSA,
+        PaymentMethod.KASSA_AI,
+        PaymentMethod.RIOPAY,
+    ):
         payment_url = getattr(payment, 'payment_url', None) or payment_url
 
     return payment_url
@@ -1006,6 +1093,7 @@ async def get_latest_payment_by_method(
         MulenPayPayment,
         Pal24Payment,
         PlategaPayment,
+        RioPayPayment,
         WataPayment,
         YooKassaPayment,
     )
@@ -1021,6 +1109,7 @@ async def get_latest_payment_by_method(
         PaymentMethod.CLOUDPAYMENTS: CloudPaymentsPayment,
         PaymentMethod.FREEKASSA: FreekassaPayment,
         PaymentMethod.KASSA_AI: KassaAiPayment,
+        PaymentMethod.RIOPAY: RioPayPayment,
     }
 
     model = model_map.get(payment_method)
@@ -1142,7 +1231,7 @@ async def check_payment_status(
     old_is_paid = record.is_paid
 
     # Run manual check
-    bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    bot = create_bot()
     try:
         payment_service = PaymentService(bot=bot)
         updated = await run_manual_check(db, payment_method, payment_id, payment_service)
@@ -1173,3 +1262,55 @@ async def check_payment_status(
         old_status=old_status,
         new_status=updated.status,
     )
+
+
+@router.get('/saved-cards', response_model=SavedCardsListResponse)
+async def get_saved_cards(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get user's saved payment methods (cards) for recurrent payments."""
+    recurrent_enabled = settings.YOOKASSA_RECURRENT_ENABLED
+
+    if not recurrent_enabled:
+        return SavedCardsListResponse(cards=[], recurrent_enabled=False)
+
+    methods = await get_active_payment_methods_by_user(db, user.id)
+
+    cards = [
+        SavedCardResponse(
+            id=m.id,
+            method_type=m.method_type,
+            card_last4=m.card_last4,
+            card_type=m.card_type,
+            title=m.title,
+            created_at=m.created_at,
+        )
+        for m in methods
+    ]
+
+    return SavedCardsListResponse(cards=cards, recurrent_enabled=True)
+
+
+@router.delete('/saved-cards/{card_id}', status_code=status.HTTP_200_OK)
+async def delete_saved_card(
+    card_id: int,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Unlink (deactivate) a saved payment method."""
+    if not settings.YOOKASSA_RECURRENT_ENABLED:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Recurrent payments are not enabled',
+        )
+
+    success = await deactivate_payment_method(db, card_id, user.id)
+
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Saved card not found',
+        )
+
+    return {'success': True, 'message': 'Card unlinked successfully'}

app/cabinet/routes/branding.py

@@ -1,5 +1,6 @@
 """Branding routes for cabinet - logo, project name, and theme colors management."""
 
+import asyncio
 import json
 import os
 from pathlib import Path
@@ -39,6 +40,7 @@ YANDEX_METRIKA_ID_KEY = 'CABINET_YANDEX_METRIKA_ID'  # Stores counter ID (numeri
 GOOGLE_ADS_ID_KEY = 'CABINET_GOOGLE_ADS_ID'  # Stores conversion ID (e.g. "AW-123456789")
 GOOGLE_ADS_LABEL_KEY = 'CABINET_GOOGLE_ADS_LABEL'  # Stores conversion label (alphanumeric)
 LITE_MODE_ENABLED_KEY = 'CABINET_LITE_MODE_ENABLED'  # Stores "true" or "false"
+GIFT_ENABLED_KEY = 'CABINET_GIFT_ENABLED'  # Stores "true" or "false"
 ANIMATION_CONFIG_KEY = 'CABINET_ANIMATION_CONFIG'  # Stores JSON with animation config
 TELEGRAM_WIDGET_SIZE_KEY = 'TELEGRAM_WIDGET_SIZE'
 TELEGRAM_WIDGET_RADIUS_KEY = 'TELEGRAM_WIDGET_RADIUS'
@@ -242,6 +244,7 @@ class EmailAuthEnabledResponse(BaseModel):
     """Email auth enabled setting."""
 
     enabled: bool = True
+    verification_enabled: bool = True
 
 
 class EmailAuthEnabledUpdate(BaseModel):
@@ -276,6 +279,18 @@ class LiteModeEnabledUpdate(BaseModel):
     enabled: bool
 
 
+class GiftEnabledResponse(BaseModel):
+    """Gift feature enabled setting."""
+
+    enabled: bool = False
+
+
+class GiftEnabledUpdate(BaseModel):
+    """Request to update gift feature setting."""
+
+    enabled: bool
+
+
 class AnalyticsCountersResponse(BaseModel):
     """Analytics counter settings."""
 
@@ -388,7 +403,7 @@ async def get_logo():
     """
     logo_path = get_logo_path()
 
-    if logo_path is None or not logo_path.exists():
+    if logo_path is None or not await asyncio.to_thread(logo_path.exists):
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='No custom logo set')
 
     # Determine media type from file extension
@@ -457,7 +472,7 @@ async def upload_logo(
         )
 
     # Ensure directory exists
-    ensure_branding_dir()
+    await asyncio.to_thread(ensure_branding_dir)
 
     # Determine file extension from content type
     ext_map = {
@@ -470,12 +485,12 @@ async def upload_logo(
     extension = ext_map.get(file.content_type, '.png')
 
     # Remove old logo files with any extension
-    for old_file in BRANDING_DIR.glob('logo.*'):
-        old_file.unlink()
+    for old_file in await asyncio.to_thread(lambda: list(BRANDING_DIR.glob('logo.*'))):
+        await asyncio.to_thread(old_file.unlink)
 
     # Save new logo
     logo_path = BRANDING_DIR / f'logo{extension}'
-    logo_path.write_bytes(content)
+    await asyncio.to_thread(logo_path.write_bytes, content)
 
     # Mark that we have a custom logo
     await set_setting_value(db, BRANDING_LOGO_KEY, 'custom')
@@ -504,8 +519,8 @@ async def delete_logo(
 ):
     """Delete custom logo and revert to letter. Admin only."""
     # Remove logo files
-    for old_file in BRANDING_DIR.glob('logo.*'):
-        old_file.unlink()
+    for old_file in await asyncio.to_thread(lambda: list(BRANDING_DIR.glob('logo.*'))):
+        await asyncio.to_thread(old_file.unlink)
 
     # Update setting
     await set_setting_value(db, BRANDING_LOGO_KEY, 'default')
@@ -824,10 +839,16 @@ async def get_email_auth_enabled(
 
     if email_auth_value is not None:
         enabled = email_auth_value.lower() == 'true'
-        return EmailAuthEnabledResponse(enabled=enabled)
+        return EmailAuthEnabledResponse(
+            enabled=enabled,
+            verification_enabled=settings.is_cabinet_email_verification_enabled(),
+        )
 
     # Default: check config setting
-    return EmailAuthEnabledResponse(enabled=settings.is_cabinet_email_auth_enabled())
+    return EmailAuthEnabledResponse(
+        enabled=settings.is_cabinet_email_auth_enabled(),
+        verification_enabled=settings.is_cabinet_email_verification_enabled(),
+    )
 
 
 @router.patch('/email-auth', response_model=EmailAuthEnabledResponse)
@@ -841,7 +862,10 @@ async def update_email_auth_enabled(
 
     logger.info('Admin set email auth enabled', telegram_id=admin.telegram_id, enabled=payload.enabled)
 
-    return EmailAuthEnabledResponse(enabled=payload.enabled)
+    return EmailAuthEnabledResponse(
+        enabled=payload.enabled,
+        verification_enabled=settings.is_cabinet_email_verification_enabled(),
+    )
 
 
 # ============ Telegram Widget Config Routes ============
@@ -983,3 +1007,30 @@ async def update_lite_mode_enabled(
     logger.info('Admin set lite mode enabled', telegram_id=admin.telegram_id, enabled=payload.enabled)
 
     return LiteModeEnabledResponse(enabled=payload.enabled)
+
+
+# ============ Gift Feature Routes ============
+
+
+@router.get('/gift-enabled', response_model=GiftEnabledResponse)
+async def get_gift_enabled(
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get gift feature enabled setting. Public endpoint."""
+    value = await get_setting_value(db, GIFT_ENABLED_KEY)
+    if value is not None:
+        enabled = value.lower() == 'true'
+        return GiftEnabledResponse(enabled=enabled)
+    return GiftEnabledResponse(enabled=False)
+
+
+@router.patch('/gift-enabled', response_model=GiftEnabledResponse)
+async def update_gift_enabled(
+    payload: GiftEnabledUpdate,
+    admin: User = Depends(require_permission('settings:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Update gift feature enabled setting. Admin only."""
+    await set_setting_value(db, GIFT_ENABLED_KEY, str(payload.enabled).lower())
+    logger.info('Admin set gift enabled', telegram_id=admin.telegram_id, enabled=payload.enabled)
+    return GiftEnabledResponse(enabled=payload.enabled)

app/cabinet/routes/contests.py

@@ -9,14 +9,28 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.config import settings
 from app.database.crud.contest import (
     create_attempt,
     get_active_rounds,
     get_attempt,
     increment_winner_count,
 )
-from app.database.crud.subscription import get_subscription_by_user_id
+from app.database.crud.subscription import get_active_subscriptions_by_user_id, get_subscription_by_user_id
 from app.database.models import SubscriptionStatus, User
+
+
+async def _resolve_subscription_for_prize(db, user_id: int):
+    """Resolve best subscription for applying contest prize (days/traffic)."""
+    if settings.is_multi_tariff_enabled():
+        active_subs = await get_active_subscriptions_by_user_id(db, user_id)
+        # Prefer non-daily with most days left
+        non_daily = [s for s in active_subs if not (s.tariff and getattr(s.tariff, 'is_daily', False))]
+        eligible = non_daily or active_subs
+        return max(eligible, key=lambda s: s.days_left) if eligible else None
+    return await get_subscription_by_user_id(db, user_id)
+
+
 from app.services.contest_rotation_service import (
     GAME_ANAGRAM,
     GAME_BLITZ,
@@ -86,6 +100,7 @@ def _user_allowed(subscription) -> bool:
     return subscription.status in {
         SubscriptionStatus.ACTIVE.value,
         SubscriptionStatus.TRIAL.value,
+        SubscriptionStatus.LIMITED.value,
     }
 
 
@@ -97,7 +112,7 @@ async def _award_prize(db: AsyncSession, user_id: int, prize_type: str, prize_va
         except ValueError:
             return 'Error: invalid prize value'
 
-        subscription = await get_subscription_by_user_id(db, user_id)
+        subscription = await _resolve_subscription_for_prize(db, user_id)
         if not subscription:
             return 'Error: subscription not found'
 
@@ -121,6 +136,9 @@ async def _award_prize(db: AsyncSession, user_id: int, prize_type: str, prize_va
         if not user:
             return 'Error: user not found'
 
+        from app.database.crud.user import lock_user_for_update
+
+        user = await lock_user_for_update(db, user)
         user.balance_kopeks += int(round(amount * 100))
         await db.commit()
         await db.refresh(user)
@@ -147,7 +165,7 @@ async def get_contests_count(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Get count of contests available for the user."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)
 
     if not _user_allowed(subscription):
         return ContestsCountResponse(count=0)
@@ -179,7 +197,7 @@ async def get_contests(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Get list of available contests/games."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)
 
     if not _user_allowed(subscription):
         raise HTTPException(
@@ -226,7 +244,7 @@ async def get_contest_game(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Get game data for a specific contest round."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)
 
     if not _user_allowed(subscription):
         raise HTTPException(
@@ -346,7 +364,7 @@ async def submit_contest_answer(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Submit answer for a contest round."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)
 
     if not _user_allowed(subscription):
         raise HTTPException(

app/cabinet/routes/gift.py

@@ -0,0 +1,806 @@
+"""Gift subscription routes for cabinet."""
+
+import asyncio
+import re
+from datetime import UTC, datetime
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.config import settings
+from app.database.crud.system_setting import get_setting_value
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.crud.transaction import create_transaction, emit_transaction_side_effects
+from app.database.crud.user import subtract_user_balance
+from app.database.models import (
+    GuestPurchase,
+    GuestPurchaseStatus,
+    PaymentMethod,
+    Tariff,
+    TransactionType,
+    User,
+)
+from app.services.guest_purchase_service import (
+    GuestPurchaseError,
+    create_purchase,
+    fulfill_purchase,
+)
+from app.services.payment_method_config_service import get_enabled_methods_for_user
+from app.utils.cache import RateLimitCache
+from app.utils.promo_offer import get_user_active_promo_discount_percent
+
+from ..dependencies import get_cabinet_db, get_current_cabinet_user
+from ..schemas.gift import (
+    ActivateGiftRequest,
+    ActivateGiftResponse,
+    GiftConfigPaymentMethod,
+    GiftConfigResponse,
+    GiftConfigSubOption,
+    GiftConfigTariff,
+    GiftConfigTariffPeriod,
+    GiftPurchaseRequest,
+    GiftPurchaseResponse,
+    GiftPurchaseStatusResponse,
+    PendingGiftResponse,
+    ReceivedGiftResponse,
+    SentGiftResponse,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/gift', tags=['Cabinet Gift'])
+
+GIFT_ENABLED_KEY = 'CABINET_GIFT_ENABLED'
+
+_EMAIL_RE = re.compile(r'^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$')
+_TELEGRAM_RE = re.compile(r'^@?[a-zA-Z][a-zA-Z0-9_]{4,31}$')
+
+
+async def _is_gift_enabled(db: AsyncSession) -> bool:
+    """Check if the gift feature is enabled via system settings."""
+    value = await get_setting_value(db, GIFT_ENABLED_KEY)
+    if value is not None:
+        return value.lower() == 'true'
+    return False
+
+
+@router.get('/config', response_model=GiftConfigResponse)
+async def get_gift_config(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get gift subscription configuration: tariffs, payment methods, balance."""
+    enabled = await _is_gift_enabled(db)
+    if not enabled:
+        return GiftConfigResponse(
+            is_enabled=False,
+            balance_kopeks=user.balance_kopeks,
+        )
+
+    # Load active tariffs visible in gift section
+    result = await db.execute(
+        select(Tariff)
+        .where(Tariff.is_active.is_(True), Tariff.show_in_gift.is_(True))
+        .order_by(Tariff.display_order, Tariff.id)
+    )
+    tariffs_db = result.scalars().all()
+
+    # Get user's promo group for discount calculation
+    promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+    if promo_group is None:
+        promo_group = getattr(user, 'promo_group', None)
+    promo_group_name = promo_group.name if promo_group else None
+
+    # Get active promo offer discount
+    promo_offer_discount_percent = get_user_active_promo_discount_percent(user)
+
+    tariffs: list[GiftConfigTariff] = []
+    for tariff in tariffs_db:
+        period_days_list = tariff.get_available_periods()
+        periods: list[GiftConfigTariffPeriod] = []
+        for days in period_days_list:
+            base_price = tariff.get_price_for_period(days)
+            if base_price is None:
+                continue
+
+            original_price = base_price
+            price = base_price
+
+            # Apply promo group discount
+            from app.services.pricing_engine import PricingEngine
+
+            promo_group_discount = 0
+            if promo_group:
+                promo_group_discount = promo_group.get_discount_percent('period', days)
+                if promo_group_discount > 0:
+                    price = PricingEngine.apply_discount(price, promo_group_discount)
+
+            # Apply active promo offer discount (stacks on top)
+            if promo_offer_discount_percent > 0:
+                price = PricingEngine.apply_discount(price, promo_offer_discount_percent)
+
+            # Ensure minimum price of 1 kopek after all discounts
+            price = max(1, price)
+
+            # Calculate combined discount percent
+            combined_discount = 0
+            if original_price > 0 and original_price != price:
+                combined_discount = int((original_price - price) * 100 / original_price)
+
+            periods.append(
+                GiftConfigTariffPeriod(
+                    days=days,
+                    price_kopeks=price,
+                    price_label=settings.format_price(price),
+                    original_price_kopeks=original_price if combined_discount > 0 else None,
+                    discount_percent=combined_discount if combined_discount > 0 else None,
+                )
+            )
+        if not periods:
+            continue
+        tariffs.append(
+            GiftConfigTariff(
+                id=tariff.id,
+                name=tariff.name,
+                description=tariff.description,
+                traffic_limit_gb=tariff.traffic_limit_gb,
+                device_limit=tariff.device_limit,
+                periods=periods,
+            )
+        )
+
+    # Load payment methods available for this user
+    enabled_methods = await get_enabled_methods_for_user(db, user=user)
+    payment_methods: list[GiftConfigPaymentMethod] = []
+    for method_data in enabled_methods:
+        sub_options = None
+        raw_options = method_data.get('options')
+        if raw_options:
+            sub_options = [GiftConfigSubOption(id=opt['id'], name=opt.get('name', opt['id'])) for opt in raw_options]
+        payment_methods.append(
+            GiftConfigPaymentMethod(
+                method_id=method_data['id'],
+                display_name=method_data['name'],
+                min_amount_kopeks=method_data.get('min_amount_kopeks'),
+                max_amount_kopeks=method_data.get('max_amount_kopeks'),
+                sub_options=sub_options,
+            )
+        )
+
+    return GiftConfigResponse(
+        is_enabled=True,
+        tariffs=tariffs,
+        payment_methods=payment_methods,
+        balance_kopeks=user.balance_kopeks,
+        currency_symbol=getattr(settings, 'CURRENCY_SYMBOL', '\u20bd'),
+        promo_group_name=promo_group_name,
+        active_discount_percent=promo_offer_discount_percent if promo_offer_discount_percent > 0 else None,
+        active_discount_expires_at=(
+            getattr(user, 'promo_offer_discount_expires_at', None) if promo_offer_discount_percent > 0 else None
+        ),
+    )
+
+
+@router.post('/purchase', response_model=GiftPurchaseResponse)
+async def create_gift_purchase(
+    body: GiftPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Create a gift subscription purchase from the cabinet."""
+    enabled = await _is_gift_enabled(db)
+    if not enabled:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Gift feature is not enabled',
+        )
+
+    # Rate limit: 5 gift purchases per 60 seconds per user
+    is_limited = await RateLimitCache.is_rate_limited(user.id, 'gift_purchase', limit=5, window=60)
+    if is_limited:
+        raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS, detail='Too many requests')
+
+    # Check if user has purchase restrictions
+    if getattr(user, 'restriction_subscription', False):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Purchases are restricted for this account',
+        )
+
+    # Recipient is optional — when omitted, buyer gets a code to share manually
+    has_recipient = bool(body.recipient_type and body.recipient_value)
+
+    if has_recipient:
+        # Validate recipient format
+        if body.recipient_type == 'email' and not _EMAIL_RE.match(body.recipient_value):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Invalid email format',
+            )
+        if body.recipient_type == 'telegram' and not _TELEGRAM_RE.match(body.recipient_value):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Invalid Telegram username format',
+            )
+
+        # Prevent self-gift
+        if body.recipient_type == 'telegram':
+            normalized_recipient = body.recipient_value.lstrip('@').lower()
+            if user.username and user.username.lower() == normalized_recipient:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='Cannot gift to yourself',
+                )
+        elif body.recipient_type == 'email':
+            if user.email and user.email.lower() == body.recipient_value.lower():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='Cannot gift to yourself',
+                )
+
+    # Find tariff and validate period
+    tariff = await get_tariff_by_id(db, body.tariff_id)
+    if tariff is None or not tariff.is_active or not tariff.show_in_gift:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tariff not found or inactive',
+        )
+
+    # Validate that period has a configured price before locking
+    if tariff.get_price_for_period(body.period_days) is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Price is not configured for this period',
+        )
+
+    # Lock user BEFORE price computation to prevent TOCTOU on promo offer
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    from app.services.pricing_engine import pricing_engine
+
+    pricing_result = await pricing_engine.calculate_tariff_purchase_price(
+        tariff,
+        body.period_days,
+        device_limit=tariff.device_limit,
+        user=user,
+    )
+    price_kopeks = max(1, pricing_result.final_total)
+    consume_promo = pricing_result.promo_offer_discount > 0
+
+    # Determine buyer contact info
+    if user.email:
+        buyer_contact_type = 'email'
+        buyer_contact_value = user.email
+    elif user.username:
+        buyer_contact_type = 'telegram'
+        buyer_contact_value = f'@{user.username}'
+    else:
+        buyer_contact_type = 'telegram'
+        buyer_contact_value = f'id:{user.telegram_id or user.id}'
+
+    # Pre-check: try to resolve Telegram username — DB first, then Bot API.
+    # Only relevant when a recipient is explicitly specified.
+    recipient_warning: str | None = None
+    pre_resolved_telegram_id: int | None = None
+    if has_recipient and body.recipient_type == 'telegram':
+        tg_username = body.recipient_value.lstrip('@')
+        normalized_username = tg_username.lower()
+
+        # 1) Check local DB — user may already be registered in the bot
+        db_result = await db.execute(
+            select(User.telegram_id).where(
+                func.lower(User.username) == normalized_username,
+                User.telegram_id.isnot(None),
+            )
+        )
+        db_telegram_id = db_result.scalar_one_or_none()
+
+        if db_telegram_id is not None:
+            pre_resolved_telegram_id = db_telegram_id
+        else:
+            # 2) Fall back to Bot API (works for public usernames the bot has seen)
+            try:
+                from app.bot_factory import create_bot
+
+                async with create_bot() as bot:
+                    chat = await asyncio.wait_for(bot.get_chat(chat_id=f'@{tg_username}'), timeout=5.0)
+                    pre_resolved_telegram_id = chat.id
+            except Exception:
+                recipient_warning = 'telegram_unresolvable'
+                logger.warning(
+                    'Telegram username not resolvable for gift',
+                    username=tg_username,
+                    buyer_id=user.id,
+                )
+
+    # Gateway mode: create payment via external provider
+    if body.payment_mode == 'gateway':
+        if not body.payment_method:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='payment_method is required for gateway mode',
+            )
+
+        purchase_kwargs: dict = (
+            {
+                'gift_recipient_type': body.recipient_type,
+                'gift_recipient_value': body.recipient_value,
+                'gift_message': body.gift_message,
+            }
+            if has_recipient
+            else {
+                'gift_message': body.gift_message,
+            }
+        )
+
+        try:
+            purchase = await create_purchase(
+                db,
+                landing=None,
+                tariff=tariff,
+                period_days=body.period_days,
+                amount_kopeks=price_kopeks,
+                contact_type=buyer_contact_type,
+                contact_value=buyer_contact_value,
+                payment_method=body.payment_method,
+                is_gift=True,
+                source='cabinet',
+                buyer_user_id=user.id,
+                commit=False,
+                **purchase_kwargs,
+            )
+        except GuestPurchaseError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=exc.message) from exc
+
+        # Persist warning so it survives the gateway redirect
+        if recipient_warning:
+            purchase.recipient_warning = recipient_warning
+
+        # Build return URL for after payment
+        cabinet_base = (settings.CABINET_URL or '').rstrip('/')
+        return_url = f'{cabinet_base}/gift/result?token={purchase.token[:12]}'
+
+        from app.services.payment_service import PaymentService
+
+        # Stars payments need a Bot instance to create invoice links
+        bot = None
+        if body.payment_method == 'telegram_stars':
+            from app.bot_factory import create_bot
+
+            bot = create_bot()
+
+        try:
+            payment_service = PaymentService(bot=bot)
+            payment_result = await payment_service.create_guest_payment(
+                db=db,
+                amount_kopeks=price_kopeks,
+                payment_method=body.payment_method,
+                description=f'Gift: {tariff.name} ({body.period_days}d)',
+                purchase_token=purchase.token,
+                return_url=return_url,
+            )
+        finally:
+            if bot:
+                await bot.session.close()
+
+        if payment_result is None:
+            await db.rollback()
+            raise HTTPException(
+                status_code=status.HTTP_502_BAD_GATEWAY,
+                detail='Payment provider is unavailable, please try again later',
+            )
+
+        payment_url = payment_result.get('payment_url')
+        if not payment_url:
+            await db.rollback()
+            logger.error(
+                'Gift payment created but no payment_url returned',
+                purchase_token=purchase.token[:5],
+                provider=payment_result.get('provider'),
+            )
+            raise HTTPException(
+                status_code=status.HTTP_502_BAD_GATEWAY,
+                detail='Payment provider returned an invalid response',
+            )
+
+        # Consume promo offer discount before committing gateway purchase
+        if consume_promo and getattr(user, 'promo_offer_discount_percent', 0):
+            user.promo_offer_discount_percent = 0
+            user.promo_offer_discount_source = None
+            user.promo_offer_discount_expires_at = None
+
+        await db.commit()
+        await db.refresh(purchase)
+
+        return GiftPurchaseResponse(
+            status='created',
+            purchase_token=purchase.token[:12],
+            payment_url=payment_url,
+            warning=recipient_warning,
+        )
+
+    # Balance mode
+    if user.balance_kopeks < price_kopeks:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Insufficient balance',
+        )
+
+    # Create purchase record
+    balance_purchase_kwargs: dict = (
+        {
+            'gift_recipient_type': body.recipient_type,
+            'gift_recipient_value': body.recipient_value,
+            'gift_message': body.gift_message,
+        }
+        if has_recipient
+        else {
+            'gift_message': body.gift_message,
+        }
+    )
+
+    try:
+        purchase = await create_purchase(
+            db,
+            landing=None,
+            tariff=tariff,
+            period_days=body.period_days,
+            amount_kopeks=price_kopeks,
+            contact_type=buyer_contact_type,
+            contact_value=buyer_contact_value,
+            payment_method='balance',
+            is_gift=True,
+            source='cabinet',
+            buyer_user_id=user.id,
+            commit=False,
+            **balance_purchase_kwargs,
+        )
+    except GuestPurchaseError as exc:
+        raise HTTPException(status_code=exc.status_code, detail=exc.message) from exc
+
+    # Persist warning on purchase record
+    if recipient_warning:
+        purchase.recipient_warning = recipient_warning
+
+    # Subtract balance (consume promo offer if one was applied)
+    balance_ok = await subtract_user_balance(
+        db,
+        user,
+        price_kopeks,
+        description=f'Gift: {tariff.name} ({body.period_days}d)',
+        create_transaction=False,
+        consume_promo_offer=consume_promo,
+    )
+    if not balance_ok:
+        await db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Insufficient balance',
+        )
+
+    # Transaction description: include recipient when specified
+    tx_description = f'Gift: {tariff.name} ({body.period_days}d)'
+    if has_recipient:
+        tx_description += f' -> {body.recipient_value}'
+
+    # Create transaction record
+    transaction = await create_transaction(
+        db,
+        user_id=user.id,
+        type=TransactionType.GIFT_PAYMENT,
+        amount_kopeks=price_kopeks,
+        description=tx_description,
+        payment_method=PaymentMethod.BALANCE,
+        commit=False,
+    )
+
+    # Mark purchase as paid
+    purchase.status = GuestPurchaseStatus.PAID.value
+    purchase.paid_at = datetime.now(UTC)
+
+    await db.commit()
+
+    # Emit deferred side-effects after atomic commit
+    await emit_transaction_side_effects(
+        db,
+        transaction,
+        amount_kopeks=price_kopeks,
+        user_id=user.id,
+        type=TransactionType.GIFT_PAYMENT,
+        payment_method=PaymentMethod.BALANCE,
+        description=tx_description,
+    )
+
+    # Capture token before fulfill_purchase — session state may change after rollback inside fulfill
+    purchase_token = purchase.token
+
+    # Only fulfill immediately when a specific recipient was provided.
+    # Code-only gifts (no recipient) stay in PAID status until someone activates via code.
+    if has_recipient:
+        try:
+            await fulfill_purchase(db, purchase_token, pre_resolved_telegram_id=pre_resolved_telegram_id)
+        except Exception:
+            logger.exception(
+                'Gift purchase fulfillment failed (purchase is paid, will retry)',
+                purchase_id=purchase.id,
+            )
+
+    return GiftPurchaseResponse(
+        status='ok',
+        purchase_token=purchase_token[:12],
+        warning=recipient_warning,
+    )
+
+
+@router.get('/pending', response_model=list[PendingGiftResponse])
+async def get_pending_gifts(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get pending gift purchases that the current user can activate."""
+    result = await db.execute(
+        select(GuestPurchase)
+        .options(selectinload(GuestPurchase.tariff))
+        .where(
+            GuestPurchase.user_id == user.id,
+            GuestPurchase.is_gift.is_(True),
+            GuestPurchase.status == GuestPurchaseStatus.PENDING_ACTIVATION.value,
+        )
+        .order_by(GuestPurchase.created_at.desc())
+        .limit(100)
+    )
+    purchases = result.scalars().all()
+
+    pending: list[PendingGiftResponse] = []
+    for p in purchases:
+        # Determine sender display name
+        sender_display = None
+        if p.contact_value:
+            sender_display = p.contact_value
+
+        pending.append(
+            PendingGiftResponse(
+                token=p.token[:12],
+                tariff_name=p.tariff.name if p.tariff else None,
+                period_days=p.period_days,
+                gift_message=p.gift_message,
+                sender_display=sender_display,
+                created_at=p.created_at,
+            )
+        )
+
+    return pending
+
+
+@router.get('/purchase/{token}', response_model=GiftPurchaseStatusResponse)
+async def get_gift_purchase_status(
+    token: str,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get the status of a cabinet gift purchase."""
+    if len(token) >= 64:
+        token_filter = GuestPurchase.token == token
+    else:
+        token_filter = GuestPurchase.token.startswith(token)
+
+    result = await db.execute(select(GuestPurchase).options(selectinload(GuestPurchase.tariff)).where(token_filter))
+    purchase = result.scalars().first()
+    if purchase is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Purchase not found',
+        )
+
+    # Uniform 404 prevents token existence oracle
+    if purchase.buyer_user_id != user.id:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Purchase not found',
+        )
+
+    tariff_name = purchase.tariff.name if purchase.tariff else None
+
+    recipient_contact_value = None
+    if purchase.gift_recipient_value:
+        recipient_contact_value = purchase.gift_recipient_value
+
+    is_code_only = purchase.is_gift and not purchase.gift_recipient_type
+
+    return GiftPurchaseStatusResponse(
+        status=purchase.status,
+        is_gift=True,
+        is_code_only=is_code_only,
+        purchase_token=purchase.token[:12] if is_code_only else None,
+        recipient_contact_value=recipient_contact_value,
+        gift_message=purchase.gift_message,
+        tariff_name=tariff_name,
+        period_days=purchase.period_days,
+        warning=purchase.recipient_warning,
+    )
+
+
+@router.get('/sent', response_model=list[SentGiftResponse])
+async def get_sent_gifts(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get all gifts the current user has sent."""
+    result = await db.execute(
+        select(GuestPurchase)
+        .options(selectinload(GuestPurchase.tariff), selectinload(GuestPurchase.user))
+        .where(
+            GuestPurchase.buyer_user_id == user.id,
+            GuestPurchase.is_gift.is_(True),
+        )
+        .order_by(GuestPurchase.created_at.desc())
+        .limit(100)
+    )
+    purchases = result.scalars().all()
+
+    sent: list[SentGiftResponse] = []
+    for p in purchases:
+        activated_by_username = None
+        if p.status == GuestPurchaseStatus.DELIVERED.value and p.user and p.user.username:
+            activated_by_username = f'@{p.user.username}'
+
+        sent.append(
+            SentGiftResponse(
+                token=p.token[:12],
+                tariff_name=p.tariff.name if p.tariff else None,
+                period_days=p.period_days,
+                device_limit=p.tariff.device_limit if p.tariff else 1,
+                status=p.status,
+                gift_recipient_value=p.gift_recipient_value,
+                gift_message=p.gift_message,
+                activated_by_username=activated_by_username,
+                created_at=p.created_at,
+            )
+        )
+
+    return sent
+
+
+@router.get('/received', response_model=list[ReceivedGiftResponse])
+async def get_received_gifts(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get all gifts the current user has received."""
+    result = await db.execute(
+        select(GuestPurchase)
+        .options(selectinload(GuestPurchase.tariff), selectinload(GuestPurchase.buyer))
+        .where(
+            GuestPurchase.user_id == user.id,
+            GuestPurchase.is_gift.is_(True),
+        )
+        .order_by(GuestPurchase.created_at.desc())
+        .limit(100)
+    )
+    purchases = result.scalars().all()
+
+    received: list[ReceivedGiftResponse] = []
+    for p in purchases:
+        sender_display = None
+        if p.buyer and p.buyer.username:
+            sender_display = f'@{p.buyer.username}'
+        elif p.contact_value:
+            sender_display = p.contact_value
+
+        received.append(
+            ReceivedGiftResponse(
+                token=p.token[:12],
+                tariff_name=p.tariff.name if p.tariff else None,
+                period_days=p.period_days,
+                device_limit=p.tariff.device_limit if p.tariff else 1,
+                status=p.status,
+                sender_display=sender_display,
+                gift_message=p.gift_message,
+                created_at=p.created_at,
+            )
+        )
+
+    return received
+
+
+@router.post('/activate', response_model=ActivateGiftResponse)
+async def activate_gift_by_code(
+    body: ActivateGiftRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Activate a gift subscription by its code (token)."""
+    from app.services.guest_purchase_service import activate_purchase as svc_activate
+
+    # Bug 2 fix: rate limit activation attempts to prevent brute-force token enumeration
+    is_limited = await RateLimitCache.is_rate_limited(user.id, 'gift_activate', limit=10, window=60)
+    if is_limited:
+        raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS, detail='Too many requests')
+
+    code = body.code.strip()
+    if code.upper().startswith('GIFT-') or code.upper().startswith('GIFT_'):
+        code = code[5:]
+
+    if len(code) < 8:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail='Code too short')
+
+    # Support both full token and prefix-based lookup (displayed codes are truncated)
+    if len(code) >= 64:
+        # Full token — exact match
+        token_filter = GuestPurchase.token == code
+    else:
+        # Prefix match — for short display codes like GIFT-XXXXXXXXXXXX
+        token_filter = GuestPurchase.token.startswith(code)
+
+    result = await db.execute(
+        select(GuestPurchase)
+        .options(selectinload(GuestPurchase.tariff))
+        .where(token_filter, GuestPurchase.is_gift.is_(True))
+        .with_for_update()
+    )
+    purchase = result.scalars().first()
+
+    if purchase is None or not purchase.is_gift:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Gift not found',
+        )
+
+    # Bug 1 fix: check ownership BEFORE leaking any status/tariff info
+    if purchase.user_id is not None and purchase.user_id != user.id:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Gift not found',
+        )
+
+    # Prevent self-activation: buyer cannot activate their own gift
+    if purchase.buyer_user_id is not None and purchase.buyer_user_id == user.id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Cannot activate your own gift',
+        )
+
+    if purchase.status == GuestPurchaseStatus.DELIVERED.value:
+        return ActivateGiftResponse(
+            status='activated',
+            tariff_name=purchase.tariff.name if purchase.tariff else None,
+            period_days=purchase.period_days,
+        )
+
+    # Code-only gifts are in PAID status; directed gifts are in PENDING_ACTIVATION
+    activatable_statuses = {
+        GuestPurchaseStatus.PENDING_ACTIVATION.value,
+        GuestPurchaseStatus.PAID.value,
+    }
+    if purchase.status not in activatable_statuses:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='This gift cannot be activated',
+        )
+
+    # For code-only gifts (user_id is None), link the purchase to the activating user
+    if purchase.user_id is None:
+        purchase.user_id = user.id
+
+    # Transition PAID → PENDING_ACTIVATION so activate_purchase() accepts it
+    if purchase.status == GuestPurchaseStatus.PAID.value:
+        purchase.status = GuestPurchaseStatus.PENDING_ACTIVATION.value
+
+    await db.flush()
+
+    try:
+        await svc_activate(db, purchase.token, skip_notification=True)
+    except GuestPurchaseError as exc:
+        raise HTTPException(status_code=exc.status_code, detail=exc.message) from exc
+
+    return ActivateGiftResponse(
+        status='activated',
+        tariff_name=purchase.tariff.name if purchase.tariff else None,
+        period_days=purchase.period_days,
+    )

app/cabinet/routes/info.py

@@ -91,7 +91,7 @@ class SupportConfigResponse(BaseModel):
     """Support/tickets configuration for miniapp."""
 
     tickets_enabled: bool
-    support_type: str  # "tickets", "profile", "url"
+    support_type: str  # "tickets", "profile", "url", "both"
     support_url: str | None = None
     support_username: str | None = None
 
@@ -160,7 +160,7 @@ async def get_rules(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Get service rules - uses same function as bot."""
-    requested_lang = language.split('-')[0].lower()
+    requested_lang = language.split('-', maxsplit=1)[0].lower()
 
     # Use the same function as bot to ensure consistent content
     content = await get_current_rules_content(db, requested_lang)
@@ -299,7 +299,7 @@ async def get_support_config():
         support_type = 'profile'
     else:  # both
         tickets_enabled = True
-        support_type = 'tickets'
+        support_type = 'both'
 
     return SupportConfigResponse(
         tickets_enabled=tickets_enabled,

app/cabinet/routes/landing.py

@@ -342,7 +342,9 @@ async def _load_landing_tariffs(
                 effective_discount = tariff_override if tariff_override is not None else discount.percent
                 original_price_kopeks = price
                 original_price_label = settings.format_price(price)
-                price = max(1, price - (price * effective_discount // 100))
+                from app.services.pricing_engine import PricingEngine
+
+                price = max(1, PricingEngine.apply_discount(price, effective_discount))
 
             periods.append(
                 LandingTariffPeriod(
@@ -548,7 +550,7 @@ async def create_landing_purchase(
     No authentication required.
     """
     client_ip = get_client_ip(raw_request)
-    if await RateLimitCache.is_ip_rate_limited(client_ip, 'landing_purchase', limit=5, window=60, fail_closed=True):
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'landing_purchase', limit=30, window=60, fail_closed=True):
         raise HTTPException(
             status_code=status.HTTP_429_TOO_MANY_REQUESTS,
             detail='Too many purchase attempts, please try again later',
@@ -607,6 +609,13 @@ async def create_landing_purchase(
     except GuestPurchaseError as exc:
         raise HTTPException(status_code=exc.status_code, detail=exc.message) from exc
 
+    # Gift purchases require the tariff to be visible in the gift section
+    if body.is_gift and not tariff.show_in_gift:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='This tariff is not available for gift purchases',
+        )
+
     # Validate amount against per-method min/max limits (before creating purchase record)
     min_amount = method_config.get('min_amount_kopeks')
     max_amount = method_config.get('max_amount_kopeks')

app/cabinet/routes/media.py

@@ -3,13 +3,11 @@
 import mimetypes
 
 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from aiogram.types import BufferedInputFile
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, Response, UploadFile, status
 from pydantic import BaseModel
 
+from app.bot_factory import create_bot
 from app.config import settings
 from app.database.models import User
 
@@ -98,10 +96,7 @@ async def upload_media(
     target_chat_id = _resolve_target_chat_id()
     upload = BufferedInputFile(file_bytes, filename=file.filename or 'upload')
 
-    bot = Bot(
-        token=settings.BOT_TOKEN,
-        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-    )
+    bot = create_bot()
 
     try:
         if media_type_normalized == 'photo':
@@ -158,10 +153,7 @@ async def download_media(
     Download media file by file_id.
     Used to display images/documents in ticket messages.
     """
-    bot = Bot(
-        token=settings.BOT_TOKEN,
-        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-    )
+    bot = create_bot()
 
     try:
         file = await bot.get_file(file_id)

app/cabinet/routes/news.py

@@ -0,0 +1,177 @@
+"""Public news routes for cabinet - user-facing news/blog section."""
+
+import time
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Path, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news import (
+    get_news_article_by_slug,
+    get_news_categories,
+    get_published_news,
+    get_published_news_count,
+    increment_views,
+)
+from app.database.models import NewsArticle, User
+
+from ..dependencies import get_cabinet_db, get_current_cabinet_user
+from ..schemas.news import (
+    NewsArticleListItem,
+    NewsArticleResponse,
+    NewsListResponse,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+# Slug constraint: alphanumeric, hyphens, underscores, max 500 chars
+_SLUG_MAX_LENGTH: int = 500
+_SLUG_PATTERN: str = r'^[a-zA-Z0-9_-]+$'
+
+# --- View counter deduplication ---
+# In-memory TTL cache to prevent a single user from inflating view counts.
+# Key: (user_id, article_id), Value: timestamp of last counted view.
+# Views from the same user on the same article within _VIEW_DEDUP_SECONDS are ignored.
+_VIEW_DEDUP_SECONDS: int = 300  # 5 minutes
+_VIEW_DEDUP_MAX_SIZE: int = 10_000  # max entries before eviction
+_view_dedup_cache: dict[tuple[int, int], float] = {}
+
+
+def _should_count_view(user_id: int, article_id: int) -> bool:
+    """Return True if this view should be counted (not a duplicate within TTL)."""
+    now = time.monotonic()
+    key = (user_id, article_id)
+    last_seen = _view_dedup_cache.get(key)
+
+    if last_seen is not None and (now - last_seen) < _VIEW_DEDUP_SECONDS:
+        return False
+
+    # Evict stale entries if cache grows too large
+    if len(_view_dedup_cache) >= _VIEW_DEDUP_MAX_SIZE:
+        cutoff = now - _VIEW_DEDUP_SECONDS
+        stale_keys = [k for k, v in _view_dedup_cache.items() if v < cutoff]
+        for k in stale_keys:
+            del _view_dedup_cache[k]
+
+    _view_dedup_cache[key] = now
+    return True
+
+
+router = APIRouter(prefix='/news', tags=['Cabinet News'])
+
+
+def _article_to_response(article: NewsArticle, *, include_content: bool = True) -> dict[str, Any]:
+    """Convert NewsArticle ORM instance to response dict.
+
+    ``author_name`` is only resolved when ``include_content=True`` (single-article
+    detail view) because the author relationship is not eagerly loaded for list
+    queries -- accessing it there would trigger a lazy-load or raise
+    ``MissingGreenlet`` in async context.
+    """
+    data: dict[str, Any] = {
+        'id': article.id,
+        'title': article.title,
+        'slug': article.slug,
+        'excerpt': article.excerpt,
+        'category': article.category,
+        'category_color': article.category_color,
+        'tag': article.tag,
+        'featured_image_url': article.featured_image_url,
+        'is_published': article.is_published,
+        'is_featured': article.is_featured,
+        'published_at': article.published_at,
+        'read_time_minutes': article.read_time_minutes,
+        'views_count': article.views_count,
+    }
+
+    if include_content:
+        author_name: str | None = None
+        if article.author:
+            author_name = article.author.first_name or article.author.username or f'#{article.author.id}'
+        data['content'] = article.content
+        data['author_name'] = author_name
+        data['created_at'] = article.created_at
+        data['updated_at'] = article.updated_at
+
+    return data
+
+
+# NOTE: /categories MUST be declared before /{slug} to avoid route conflict
+@router.get('/categories', response_model=list[str])
+async def list_categories(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> list[str]:
+    """Get list of distinct news categories."""
+    try:
+        return await get_news_categories(db)
+    except Exception:
+        logger.exception('Failed to get news categories')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to load categories',
+        )
+
+
+@router.get('', response_model=NewsListResponse)
+async def list_published_news(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    category: str | None = Query(None, max_length=100),
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+) -> NewsListResponse:
+    """Get paginated list of published news articles.
+
+    SQLAlchemy AsyncSession does not support concurrent operations, so
+    queries run sequentially.
+    """
+    try:
+        articles = await get_published_news(db, category=category, limit=limit, offset=offset)
+        total = await get_published_news_count(db, category=category)
+        categories = await get_news_categories(db)
+
+        items = [NewsArticleListItem(**_article_to_response(a, include_content=False)) for a in articles]
+
+        return NewsListResponse(items=items, total=total, categories=categories)
+    except HTTPException:
+        raise
+    except Exception:
+        logger.exception('Failed to list published news')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to load news',
+        )
+
+
+@router.get('/{slug}', response_model=NewsArticleResponse)
+async def get_article_by_slug(
+    slug: str = Path(..., max_length=_SLUG_MAX_LENGTH, pattern=_SLUG_PATTERN),
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Get a single published news article by slug. Increments view count."""
+    article = await get_news_article_by_slug(db, slug)
+
+    if not article or not article.is_published:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    # Build response dict while session attributes are still loaded.
+    # increment_views() calls db.commit() which expires all ORM attributes;
+    # accessing them afterwards triggers lazy-load → MissingGreenlet in async.
+    response_data = _article_to_response(article, include_content=True)
+
+    # Increment views with per-user deduplication (5-min TTL).
+    if _should_count_view(user.id, article.id):
+        try:
+            new_count = await increment_views(db, article.id)
+            response_data['views_count'] = new_count
+        except Exception:
+            logger.warning('Failed to increment views', article_id=article.id)
+
+    return NewsArticleResponse(**response_data)

app/cabinet/routes/oauth.py

@@ -40,6 +40,8 @@ async def _finalize_oauth_login(
     provider: str,
     campaign_slug: str | None = None,
     referral_code: str | None = None,
+    *,
+    is_new_user: bool = False,
 ) -> AuthResponse:
     """Update last login, create tokens, store refresh token."""
     user.cabinet_last_login = datetime.now(UTC)
@@ -47,10 +49,10 @@ async def _finalize_oauth_login(
     auth_response = await _create_auth_response(user, db)
     await _store_refresh_token(db, user.id, auth_response.refresh_token, device_info=f'oauth:{provider}')
 
-    # Process referral code (before campaign bonus, which may also set referrer)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
     from .auth import _process_referral_code, _user_to_response
 
-    await _process_referral_code(db, user, referral_code)
+    await _process_referral_code(db, user, referral_code, is_new_user=is_new_user)
 
     auth_response.campaign_bonus = await _process_campaign_bonus(db, user, campaign_slug)
     if auth_response.campaign_bonus:
@@ -232,4 +234,19 @@ async def oauth_callback(
         referred_by_id=referrer_id,
     )
     logger.info('New OAuth user created', provider=provider, user_id=user.id)
-    return await _finalize_oauth_login(db, user, provider, request.campaign_slug, request.referral_code)
+
+    # Commit user before panel sync (sync does its own commit/rollback)
+    await db.commit()
+
+    # Sync existing panel subscriptions by email (if verified)
+    if user_info.email and user_info.email_verified:
+        try:
+            from app.cabinet.routes.auth import _sync_subscription_from_panel_by_email
+
+            await _sync_subscription_from_panel_by_email(db, user)
+        except Exception:
+            logger.warning('Failed to sync panel subscription for new OAuth user', user_id=user.id, exc_info=True)
+
+    return await _finalize_oauth_login(
+        db, user, provider, request.campaign_slug, request.referral_code, is_new_user=True
+    )

app/cabinet/routes/partner_application.py

@@ -178,12 +178,11 @@ async def apply_for_partner(
 
     # Уведомляем админов о новой заявке
     try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
         from app.services.admin_notification_service import AdminNotificationService
 
         if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
-            bot = Bot(token=settings.BOT_TOKEN)
+            bot = create_bot()
             try:
                 notification_service = AdminNotificationService(bot)
                 await notification_service.send_partner_application_notification(

app/cabinet/routes/promo.py

@@ -204,15 +204,11 @@ async def get_loyalty_tiers(
     total_spent_kopeks = await get_user_total_spent_kopeks(db, user.id)
     total_spent_rubles = total_spent_kopeks / 100
 
-    # Get user's current promo group
-    await db.refresh(user, ['promo_group', 'user_promo_groups'])
-    current_promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
-    current_tier_name = current_promo_group.name if current_promo_group else None
-
     # Get all auto-assign promo groups (sorted by threshold ascending)
     auto_groups = await get_auto_assign_promo_groups(db)
 
     tiers: list[LoyaltyTierInfo] = []
+    current_tier_name: str | None = None
     next_tier_name: str | None = None
     next_tier_threshold: float | None = None
 
@@ -220,7 +216,15 @@ async def get_loyalty_tiers(
         threshold_kopeks = group.auto_assign_total_spent_kopeks or 0
         threshold_rubles = threshold_kopeks / 100
         is_achieved = total_spent_kopeks >= threshold_kopeks
-        is_current = current_promo_group and current_promo_group.id == group.id
+
+        # Track highest achieved tier as "current" (by spending, not by assignment)
+        if is_achieved:
+            current_tier_name = group.name
+
+        # Find next tier (first not achieved)
+        if not is_achieved and next_tier_name is None:
+            next_tier_name = group.name
+            next_tier_threshold = threshold_rubles
 
         # Get period discounts
         period_discounts = {}
@@ -241,15 +245,16 @@ async def get_loyalty_tiers(
                 traffic_discount_percent=group.traffic_discount_percent or 0,
                 device_discount_percent=group.device_discount_percent or 0,
                 period_discounts=period_discounts,
-                is_current=is_current,
+                is_current=False,
                 is_achieved=is_achieved,
             )
         )
 
-        # Find next tier (first not achieved)
-        if not is_achieved and next_tier_name is None:
-            next_tier_name = group.name
-            next_tier_threshold = threshold_rubles
+    # Mark only the highest achieved tier as "current"
+    for tier in reversed(tiers):
+        if tier.is_achieved:
+            tier.is_current = True
+            break
 
     # Calculate progress to next tier
     progress_percent = 0.0
@@ -304,7 +309,7 @@ async def claim_promo_offer(
 
     # Handle test access offers
     if effect_type == 'test_access':
-        await db.refresh(user, ['subscription'])
+        await db.refresh(user, ['subscriptions'])
         success, newly_added, expires_at, error_code = await promo_offer_service.grant_test_access(
             db,
             user,

app/cabinet/routes/promocode.py

@@ -20,6 +20,7 @@ class PromocodeActivateRequest(BaseModel):
     """Request to activate a promo code."""
 
     code: str = Field(..., min_length=1, max_length=50, description='Promo code to activate')
+    subscription_id: int | None = Field(None, description='Subscription ID for multi-tariff promo codes')
 
 
 class PromocodeActivateResponse(BaseModel):
@@ -41,7 +42,7 @@ class PromocodeDeactivateResponse(BaseModel):
     discount_percent: int = 0
 
 
-@router.post('/activate', response_model=PromocodeActivateResponse)
+@router.post('/activate')
 async def activate_promocode(
     request: PromocodeActivateRequest,
     user: User = Depends(get_current_cabinet_user),
@@ -50,7 +51,17 @@ async def activate_promocode(
     """Activate a promo code for the current user."""
     promocode_service = PromoCodeService()
 
-    result = await promocode_service.activate_promocode(db=db, user_id=user.id, code=request.code.strip())
+    result = await promocode_service.activate_promocode(
+        db=db, user_id=user.id, code=request.code.strip(), subscription_id=request.subscription_id
+    )
+
+    if result.get('error') == 'select_subscription':
+        return {
+            'success': False,
+            'error': 'select_subscription',
+            'eligible_subscriptions': result.get('eligible_subscriptions', []),
+            'code': result.get('code', request.code.strip()),
+        }
 
     if result['success']:
         balance_before_rubles = result.get('balance_before_kopeks', 0) / 100
@@ -72,6 +83,7 @@ async def activate_promocode(
         'already_used_by_user': 'You have already used this promo code',
         'active_discount_exists': 'You already have an active discount. Deactivate it first via /deactivate-discount',
         'no_subscription_for_days': 'This promo code requires an active or expired subscription',
+        'subscription_not_found': 'Subscription not found',
         'not_first_purchase': 'This promo code is only available for first purchase',
         'daily_limit': 'Too many promo code activations today',
         'user_not_found': 'User not found',

app/cabinet/routes/referral.py

@@ -91,13 +91,14 @@ async def get_referral_info(
     referral_entitlement = max(0, total_earnings - withdrawn - pending)
     available_balance = min(user.balance_kopeks, referral_entitlement)
 
-    # Build referral link
-    bot_username = settings.get_bot_username() or 'bot'
-    referral_link = f'https://t.me/{bot_username}?start={user.referral_code}'
+    # Build referral links
+    referral_link = (settings.get_cabinet_referral_link(user.referral_code) or '') if user.referral_code else ''
+    bot_referral_link = settings.get_bot_referral_link(user.referral_code) if user.referral_code else ''
 
     return ReferralInfoResponse(
         referral_code=user.referral_code or '',
         referral_link=referral_link,
+        bot_referral_link=bot_referral_link,
         total_referrals=total_referrals,
         active_referrals=active_referrals,
         total_earnings_kopeks=total_earnings,
@@ -118,7 +119,11 @@ async def get_referral_list(
 ):
     """Get list of invited users."""
     # Base query with eager loading of subscription relationship
-    query = select(User).options(selectinload(User.subscription)).where(User.referred_by_id == user.id)
+    query = (
+        select(User)
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
+        .where(User.referred_by_id == user.id)
+    )
 
     # Get total count
     count_query = select(func.count()).select_from(User).where(User.referred_by_id == user.id)
@@ -138,7 +143,7 @@ async def get_referral_list(
             username=r.username,
             first_name=r.first_name,
             created_at=r.created_at,
-            has_subscription=r.subscription is not None,
+            has_subscription=bool(getattr(r, 'subscriptions', None)),
             has_paid=r.has_had_paid_subscription,
         )
         for r in referrals
@@ -243,5 +248,6 @@ async def get_referral_terms():
         first_topup_bonus_rubles=settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS / 100,
         inviter_bonus_kopeks=settings.REFERRAL_INVITER_BONUS_KOPEKS,
         inviter_bonus_rubles=settings.REFERRAL_INVITER_BONUS_KOPEKS / 100,
+        max_commission_payments=settings.REFERRAL_MAX_COMMISSION_PAYMENTS,
         partner_section_visible=settings.REFERRAL_PARTNER_SECTION_VISIBLE,
     )

app/cabinet/routes/subscription_modules/__init__.py

@@ -0,0 +1,30 @@
+"""Subscription sub-modules for cabinet API.
+
+Each module contains a subset of endpoints from the original monolithic subscription.py.
+The main subscription.py includes all sub-routers for backward compatibility.
+"""
+
+from .autopay import router as autopay_router
+from .daily import router as daily_router
+from .devices import router as devices_router
+from .multi_tariff import router as multi_tariff_router
+from .purchase import router as purchase_router
+from .renewal import router as renewal_router
+from .servers import router as servers_router
+from .status import router as status_router
+from .tariff_switch import router as tariff_switch_router
+from .traffic import router as traffic_router
+
+
+__all__ = [
+    'autopay_router',
+    'daily_router',
+    'devices_router',
+    'multi_tariff_router',
+    'purchase_router',
+    'renewal_router',
+    'servers_router',
+    'status_router',
+    'tariff_switch_router',
+    'traffic_router',
+]

app/cabinet/routes/subscription_modules/autopay.py

@@ -0,0 +1,78 @@
+"""Autopay settings endpoint.
+
+PATCH /subscription/autopay
+"""
+
+from __future__ import annotations
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import AutopayUpdateRequest
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.patch('/autopay')
+async def update_autopay(
+    request: AutopayUpdateRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Update autopay settings."""
+    from .helpers import resolve_subscription
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    if request.enabled:
+        # Classic subscriptions cannot use autopay when tariff mode is enabled
+        from app.config import settings
+
+        if settings.is_tariffs_mode() and not subscription.tariff_id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Autopay is not available for classic subscriptions. Please purchase a tariff.',
+            )
+
+        # Триальные подписки — пробник, автопродление не имеет смысла
+        if subscription.is_trial:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Autopay is not available for trial subscriptions',
+            )
+
+        # Суточные подписки имеют свой механизм продления (DailySubscriptionService),
+        # глобальный autopay для них запрещён
+        await db.refresh(subscription, ['tariff'])
+        if subscription.tariff and getattr(subscription.tariff, 'is_daily', False):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Autopay is not available for daily subscriptions',
+            )
+
+    subscription.autopay_enabled = request.enabled
+
+    if request.days_before is not None:
+        subscription.autopay_days_before = request.days_before
+
+    await db.commit()
+
+    return {
+        'message': 'Autopay settings updated',
+        'autopay_enabled': subscription.autopay_enabled,
+        'autopay_days_before': subscription.autopay_days_before,
+    }

app/cabinet/routes/subscription_modules/daily.py

@@ -0,0 +1,183 @@
+"""Daily subscription management endpoints.
+
+POST /subscription/pause
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.models import User
+from app.services.subscription_service import SubscriptionService
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from .helpers import resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.post('/pause')
+async def toggle_subscription_pause(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Toggle pause/resume for daily subscription."""
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    tariff_id = getattr(subscription, 'tariff_id', None)
+    if not tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Subscription has no tariff',
+        )
+
+    tariff = await get_tariff_by_id(db, tariff_id)
+    if not tariff or not getattr(tariff, 'is_daily', False):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Pause is only available for daily tariffs',
+        )
+
+    # Determine current state
+    from app.database.models import SubscriptionStatus
+
+    is_currently_paused = getattr(subscription, 'is_daily_paused', False)
+    was_disabled = subscription.status in (
+        SubscriptionStatus.DISABLED.value,
+        SubscriptionStatus.EXPIRED.value,
+        SubscriptionStatus.LIMITED.value,
+    )
+
+    # System-DISABLED subs (insufficient balance) should always be treated as needing resume,
+    # even if is_daily_paused is False (it's set by the system, not the user)
+    if was_disabled and not is_currently_paused:
+        new_paused_state = False  # Force resume path
+    else:
+        new_paused_state = not is_currently_paused
+
+    raw_daily_price = getattr(tariff, 'daily_price_kopeks', 0)
+
+    # Lock user BEFORE discount computation to prevent TOCTOU on promo group
+    # IMPORTANT: must happen BEFORE modifying subscription — lock_user_for_pricing
+    # reloads subscriptions via selectinload which resets in-memory changes
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Re-fetch subscription after lock (selectinload may have replaced the ORM object)
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        raise HTTPException(status_code=404, detail='Subscription not found after lock')
+
+    subscription.is_daily_paused = new_paused_state
+
+    # Apply group discount to daily price (consistent with DailySubscriptionService and miniapp resume)
+    from app.services.pricing_engine import PricingEngine
+
+    promo_group = PricingEngine.resolve_promo_group(user)
+    daily_group_pct = promo_group.get_discount_percent('period', 1) if promo_group else 0
+    daily_price = (
+        PricingEngine.apply_discount(raw_daily_price, daily_group_pct) if daily_group_pct > 0 else raw_daily_price
+    )
+
+    # If resuming, check balance and charge
+    if not new_paused_state:
+        if daily_price > 0 and user.balance_kopeks < daily_price:
+            raise HTTPException(
+                status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                detail={
+                    'code': 'insufficient_balance',
+                    'message': 'Insufficient balance to resume daily subscription',
+                    'required': daily_price,
+                    'balance': user.balance_kopeks,
+                },
+            )
+
+        # Charge daily fee FIRST, then restore ACTIVE status
+        if was_disabled:
+            if daily_price > 0:
+                from app.database.crud.user import subtract_user_balance
+
+                deducted = await subtract_user_balance(
+                    db,
+                    user,
+                    daily_price,
+                    f'Суточная оплата тарифа «{tariff.name}» (возобновление)',
+                    mark_as_paid_subscription=True,
+                )
+                if not deducted:
+                    raise HTTPException(
+                        status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                        detail={
+                            'code': 'insufficient_balance',
+                            'message': 'Balance deduction failed',
+                            'required': daily_price,
+                            'balance': user.balance_kopeks,
+                        },
+                    )
+
+                from app.database.crud.transaction import create_transaction
+                from app.database.models import TransactionType
+
+                try:
+                    await create_transaction(
+                        db=db,
+                        user_id=user.id,
+                        type=TransactionType.SUBSCRIPTION_PAYMENT,
+                        amount_kopeks=daily_price,
+                        description=f'Суточная оплата тарифа «{tariff.name}» (возобновление)',
+                    )
+                except Exception as exc:
+                    logger.warning('Failed to create resume transaction', error=exc)
+
+            # Balance deducted successfully — now activate
+            subscription.status = SubscriptionStatus.ACTIVE.value
+            subscription.last_daily_charge_at = datetime.now(UTC)
+            subscription.end_date = datetime.now(UTC) + timedelta(days=1)
+
+    await db.commit()
+    await db.refresh(subscription)
+    await db.refresh(user)
+
+    # Sync with RemnaWave only when resuming from DISABLED state
+    if not new_paused_state and was_disabled:
+        try:
+            subscription_service = SubscriptionService()
+            await subscription_service.create_remnawave_user(
+                db,
+                subscription,
+                reset_traffic=False,
+                reset_reason=None,
+            )
+        except Exception as e:
+            logger.error('Error syncing RemnaWave user on resume', error=e)
+
+    if new_paused_state:
+        message = 'Daily subscription paused'
+    else:
+        message = 'Daily subscription resumed'
+
+    return {
+        'success': True,
+        'message': message,
+        'is_paused': new_paused_state,
+        'balance_kopeks': user.balance_kopeks,
+        'balance_label': settings.format_price(user.balance_kopeks),
+    }

app/cabinet/routes/subscription_modules/helpers.py

@@ -0,0 +1,234 @@
+"""Shared helper functions for subscription modules."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+import structlog
+
+from app.config import settings
+
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import Subscription, User
+
+from ...schemas.subscription import (
+    ServerInfo,
+    SubscriptionResponse,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def resolve_subscription(
+    db: AsyncSession,
+    user: User,
+    subscription_id: int | None,
+) -> Subscription | None:
+    """Resolve target subscription: by ID in multi-tariff mode, or legacy fallback.
+
+    Args:
+        db: Database session.
+        user: Current user.
+        subscription_id: Optional subscription ID (from query param).
+
+    Returns:
+        Target Subscription or None if not found.
+
+    Raises:
+        HTTPException: If subscription_id provided but not found for this user.
+    """
+    from fastapi import HTTPException
+
+    from app.database.crud.subscription import get_subscription_by_id_for_user
+
+    if subscription_id and settings.is_multi_tariff_enabled():
+        subscription = await get_subscription_by_id_for_user(db, subscription_id, user.id)
+        if not subscription:
+            raise HTTPException(status_code=404, detail='Subscription not found')
+        return subscription
+
+    if settings.is_multi_tariff_enabled() and not subscription_id:
+        from app.database.crud.subscription import get_active_subscriptions_by_user_id
+
+        active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+        if active_subs:
+            non_daily = [s for s in active_subs if not getattr(s, 'is_daily_tariff', False)]
+            pool = non_daily or active_subs
+            return max(pool, key=lambda s: s.days_left)
+        return None
+
+    await db.refresh(user, ['subscriptions'])
+    return user.subscription
+
+
+def _get_addon_discount_percent(
+    user: User | None,
+    category: str,
+    period_days_hint: int | None = None,
+) -> int:
+    """Get addon discount percent for user — delegates to PricingEngine."""
+    from app.services.pricing_engine import PricingEngine
+
+    return PricingEngine.get_addon_discount_percent(user, category, period_days_hint)
+
+
+def _apply_addon_discount(
+    user: User,
+    category: str,
+    amount: int,
+    period_days: int | None = None,
+) -> dict[str, int]:
+    """Apply addon discount to amount.
+
+    Returns dict with keys: discounted, discount, percent
+    """
+    from app.utils.pricing_utils import apply_percentage_discount
+
+    percent = _get_addon_discount_percent(user, category, period_days)
+    if percent <= 0 or amount <= 0:
+        return {'discounted': amount, 'discount': 0, 'percent': 0}
+
+    discounted_amount, discount_value = apply_percentage_discount(amount, percent)
+    return {
+        'discounted': discounted_amount,
+        'discount': discount_value,
+        'percent': percent,
+    }
+
+
+def _subscription_to_response(
+    subscription: Subscription,
+    servers: list[ServerInfo] | None = None,
+    tariff_name: str | None = None,
+    traffic_purchases: list[dict[str, Any]] | None = None,
+    user: User | None = None,
+) -> SubscriptionResponse:
+    """Convert Subscription model to response."""
+    now = datetime.now(UTC)
+
+    # Use actual_status property for correct status (same as bot uses)
+    actual_status = subscription.actual_status
+    is_expired = actual_status == 'expired'
+    is_active = actual_status in ('active', 'trial')
+    is_limited = actual_status == 'limited'
+
+    # Calculate time remaining
+    days_left = 0
+    hours_left = 0
+    minutes_left = 0
+    time_left_display = ''
+
+    if subscription.end_date and not is_expired:
+        time_delta = subscription.end_date - now
+        total_seconds = max(0, int(time_delta.total_seconds()))
+
+        days_left = total_seconds // 86400  # 86400 seconds in a day
+        remaining_seconds = total_seconds % 86400
+        hours_left = remaining_seconds // 3600
+        minutes_left = (remaining_seconds % 3600) // 60
+
+        # Create human-readable display
+        if days_left > 0:
+            time_left_display = f'{days_left}d {hours_left}h'
+        elif hours_left > 0:
+            time_left_display = f'{hours_left}h {minutes_left}m'
+        elif minutes_left > 0:
+            time_left_display = f'{minutes_left}m'
+        else:
+            time_left_display = '0m'
+    else:
+        time_left_display = '0m'
+
+    traffic_limit_gb = subscription.traffic_limit_gb or 0
+    traffic_used_gb = subscription.traffic_used_gb or 0.0
+
+    if traffic_limit_gb > 0:
+        traffic_used_percent = min(100, (traffic_used_gb / traffic_limit_gb) * 100)
+    else:
+        traffic_used_percent = 0
+
+    # Check if this is a daily tariff
+    is_daily_paused = getattr(subscription, 'is_daily_paused', False) or False
+    tariff_id = getattr(subscription, 'tariff_id', None)
+
+    # Use subscription's is_daily_tariff property if available
+    is_daily = False
+    daily_price_kopeks = None
+
+    if hasattr(subscription, 'is_daily_tariff'):
+        is_daily = subscription.is_daily_tariff
+    elif tariff_id and hasattr(subscription, 'tariff') and subscription.tariff:
+        is_daily = getattr(subscription.tariff, 'is_daily', False)
+
+    # Get daily_price_kopeks, tariff_name, traffic_reset_mode from tariff
+    traffic_reset_mode = None
+    if tariff_id and hasattr(subscription, 'tariff') and subscription.tariff:
+        daily_price_kopeks = getattr(subscription.tariff, 'daily_price_kopeks', None)
+        # Применяем скидку промогруппы + promo-offer для отображения
+        if daily_price_kopeks and daily_price_kopeks > 0 and user:
+            from app.services.pricing_engine import PricingEngine
+            from app.utils.promo_offer import get_user_active_promo_discount_percent
+
+            _promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+            _group_pct = _promo_group.get_discount_percent('period', 1) if _promo_group else 0
+            _offer_pct = get_user_active_promo_discount_percent(user)
+            if _group_pct > 0 or _offer_pct > 0:
+                daily_price_kopeks, _, _ = PricingEngine.apply_stacked_discounts(
+                    daily_price_kopeks, _group_pct, _offer_pct
+                )
+        if not tariff_name:  # Only set if not passed as parameter
+            tariff_name = getattr(subscription.tariff, 'name', None)
+        traffic_reset_mode = (
+            getattr(subscription.tariff, 'traffic_reset_mode', None) or settings.DEFAULT_TRAFFIC_RESET_STRATEGY
+        )
+
+    # Calculate next daily charge time (24 hours after last charge)
+    next_daily_charge_at = None
+    if is_daily and not is_daily_paused:
+        last_charge = getattr(subscription, 'last_daily_charge_at', None)
+        if last_charge:
+            next_charge = last_charge + timedelta(days=1)
+            # Если время списания уже прошло — не показываем (DailySubscriptionService обработает)
+            if next_charge > datetime.now(UTC):
+                next_daily_charge_at = next_charge
+
+    # Проверяем настройку скрытия ссылки (скрывается только текст, кнопки работают)
+    hide_link = settings.should_hide_subscription_link()
+
+    return SubscriptionResponse(
+        id=subscription.id,
+        status=actual_status,  # Use actual_status instead of raw status
+        is_trial=subscription.is_trial or actual_status == 'trial',
+        start_date=subscription.start_date,
+        end_date=subscription.end_date,
+        days_left=days_left,
+        hours_left=hours_left,
+        minutes_left=minutes_left,
+        time_left_display=time_left_display,
+        traffic_limit_gb=traffic_limit_gb,
+        traffic_used_gb=round(traffic_used_gb, 2),
+        traffic_used_percent=round(traffic_used_percent, 1),
+        device_limit=subscription.device_limit or 0,
+        connected_squads=subscription.connected_squads or [],
+        servers=servers or [],
+        autopay_enabled=subscription.autopay_enabled or False,
+        autopay_days_before=subscription.autopay_days_before or 3,
+        subscription_url=subscription.subscription_url,
+        hide_subscription_link=hide_link,
+        is_active=is_active,
+        is_expired=is_expired,
+        is_limited=is_limited,
+        traffic_purchases=traffic_purchases or [],
+        is_daily=is_daily,
+        is_daily_paused=is_daily_paused,
+        daily_price_kopeks=daily_price_kopeks,
+        next_daily_charge_at=next_daily_charge_at,
+        tariff_id=tariff_id,
+        tariff_name=tariff_name,
+        traffic_reset_mode=traffic_reset_mode,
+    )

app/cabinet/routes/subscription_modules/multi_tariff.py

@@ -0,0 +1,156 @@
+"""Multi-tariff subscription endpoints for cabinet API.
+
+GET /subscriptions — list all user subscriptions (multi-tariff)
+GET /subscriptions/{id} — get specific subscription details
+"""
+
+from __future__ import annotations
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.subscription import (
+    decrement_subscription_server_counts,
+    get_all_subscriptions_by_user_id,
+    get_subscription_by_id_for_user,
+)
+from app.database.models import SubscriptionStatus, User
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/subscriptions', tags=['Cabinet Multi-Tariff'], redirect_slashes=False)
+
+
+class SubscriptionListItem(BaseModel):
+    id: int
+    status: str
+    tariff_id: int | None = None
+    tariff_name: str | None = None
+    traffic_limit_gb: int = 0
+    traffic_used_gb: float = 0.0
+    device_limit: int = 1
+    end_date: str | None = None
+    subscription_url: str | None = None
+    subscription_crypto_link: str | None = None
+    is_trial: bool = False
+    is_daily: bool = False
+    is_daily_paused: bool = False
+    autopay_enabled: bool = False
+    connected_squads: list[str] | None = None
+
+
+class SubscriptionsListResponse(BaseModel):
+    subscriptions: list[SubscriptionListItem]
+    multi_tariff_enabled: bool
+
+
+def _subscription_to_list_item(sub) -> SubscriptionListItem:
+    tariff_name = None
+    if sub.tariff:
+        tariff_name = sub.tariff.name
+
+    return SubscriptionListItem(
+        id=sub.id,
+        status=sub.actual_status,
+        tariff_id=sub.tariff_id,
+        tariff_name=tariff_name,
+        traffic_limit_gb=sub.traffic_limit_gb or 0,
+        traffic_used_gb=sub.traffic_used_gb or 0.0,
+        device_limit=sub.device_limit or 1,
+        end_date=sub.end_date.isoformat() if sub.end_date else None,
+        subscription_url=sub.subscription_url,
+        subscription_crypto_link=sub.subscription_crypto_link,
+        is_trial=sub.is_trial or False,
+        is_daily=bool(sub.tariff and getattr(sub.tariff, 'is_daily', False)),
+        is_daily_paused=bool(getattr(sub, 'is_daily_paused', False)),
+        autopay_enabled=sub.autopay_enabled or False,
+        connected_squads=sub.connected_squads,
+    )
+
+
+@router.get('', response_model=SubscriptionsListResponse)
+async def list_subscriptions(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> SubscriptionsListResponse:
+    """List all user subscriptions. Returns all subscriptions regardless of multi-tariff mode."""
+    subscriptions = await get_all_subscriptions_by_user_id(db, user.id)
+    items = [_subscription_to_list_item(sub) for sub in subscriptions]
+    return SubscriptionsListResponse(
+        subscriptions=items,
+        multi_tariff_enabled=settings.is_multi_tariff_enabled(),
+    )
+
+
+@router.get('/{subscription_id}', response_model=SubscriptionListItem)
+async def get_subscription_detail(
+    subscription_id: int,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> SubscriptionListItem:
+    """Get specific subscription details with ownership check."""
+    subscription = await get_subscription_by_id_for_user(db, subscription_id, user.id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Subscription not found',
+        )
+    return _subscription_to_list_item(subscription)
+
+
+@router.delete('/{subscription_id}')
+async def delete_subscription(
+    subscription_id: int,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> dict:
+    """Delete an expired/disabled subscription. Active subscriptions cannot be deleted."""
+    subscription = await get_subscription_by_id_for_user(db, subscription_id, user.id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Subscription not found',
+        )
+
+    # Only expired/disabled subscriptions can be deleted
+    deletable_statuses = {
+        SubscriptionStatus.EXPIRED.value,
+        SubscriptionStatus.DISABLED.value,
+    }
+    if getattr(subscription, 'actual_status', subscription.status) not in deletable_statuses:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Only expired or disabled subscriptions can be deleted',
+        )
+
+    # Delete from RemnaWave panel (stops webhooks / phantom notifications)
+    if subscription.remnawave_uuid:
+        try:
+            from app.services.subscription_service import SubscriptionService
+
+            service = SubscriptionService()
+            await service.delete_remnawave_user(subscription.remnawave_uuid)
+        except Exception as e:
+            logger.warning('Failed to delete RemnaWave user on subscription delete', error=e)
+
+    # Decrement server counts
+    await decrement_subscription_server_counts(db, subscription)
+
+    # Delete the subscription
+    await db.delete(subscription)
+    await db.commit()
+
+    logger.info(
+        'Subscription deleted by user',
+        subscription_id=subscription_id,
+        user_id=user.id,
+        tariff_id=subscription.tariff_id,
+    )
+
+    return {'message': 'Subscription deleted'}

app/cabinet/routes/subscription_modules/renewal.py

@@ -0,0 +1,269 @@
+"""Subscription renewal endpoints.
+
+GET /subscription/renewal-options
+POST /subscription/renew
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.models import PaymentMethod, SubscriptionStatus, User
+from app.services.pricing_engine import pricing_engine
+from app.services.subscription_renewal_service import (
+    SubscriptionRenewalChargeError,
+    SubscriptionRenewalService,
+)
+from app.services.user_cart_service import user_cart_service
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import (
+    RenewalOptionResponse,
+    RenewalRequest,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/renewal-options', response_model=list[RenewalOptionResponse])
+async def get_renewal_options(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Get available subscription renewal options with prices."""
+    from .helpers import resolve_subscription
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        return []
+
+    # Classic subscriptions cannot be renewed when tariff mode is enabled
+    if settings.is_tariffs_mode() and not subscription.tariff_id:
+        return []
+
+    _non_renewable = {SubscriptionStatus.DISABLED.value, SubscriptionStatus.PENDING.value}
+    _actual_status = getattr(subscription, 'actual_status', subscription.status)
+    if _actual_status in _non_renewable:
+        return []
+
+    # Determine available periods
+    if subscription.tariff_id and subscription.tariff and subscription.tariff.period_prices:
+        periods = sorted(int(k) for k in subscription.tariff.period_prices.keys())
+    else:
+        periods = settings.get_available_renewal_periods()
+
+    options = []
+
+    for period in periods:
+        pricing = await pricing_engine.calculate_renewal_price(db, subscription, period, user=user)
+
+        if pricing.final_total <= 0 and pricing.base_price <= 0:
+            continue
+
+        original_price = pricing.original_total
+        combined_discount = 0
+        if original_price > 0 and original_price != pricing.final_total:
+            combined_discount = int((original_price - pricing.final_total) * 100 / original_price)
+
+        options.append(
+            RenewalOptionResponse(
+                period_days=period,
+                price_kopeks=pricing.final_total,
+                price_rubles=pricing.final_total / 100,
+                discount_percent=combined_discount,
+                original_price_kopeks=original_price if combined_discount > 0 else None,
+            )
+        )
+
+    return options
+
+
+@router.post('/renew')
+async def renew_subscription(
+    request: RenewalRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Renew subscription (pay from balance)."""
+    if getattr(user, 'restriction_subscription', False):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Subscription renewal is restricted for this account',
+        )
+
+    # Support subscription_id from both query param and body (backward compat)
+    from .helpers import resolve_subscription
+
+    _sub_id = subscription_id or request.subscription_id
+    subscription = await resolve_subscription(db, user, _sub_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    # Classic subscriptions cannot be renewed when tariff mode is enabled
+    if settings.is_tariffs_mode() and not subscription.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Classic subscriptions cannot be renewed. Please purchase a tariff.',
+        )
+
+    _non_renewable = {SubscriptionStatus.DISABLED.value, SubscriptionStatus.PENDING.value}
+    _actual_status = getattr(subscription, 'actual_status', subscription.status)
+    if _actual_status in _non_renewable:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f'Cannot renew subscription with status: {_actual_status}',
+        )
+
+    if subscription.tariff_id and subscription.tariff and subscription.tariff.period_prices:
+        available_periods = [int(p) for p in subscription.tariff.period_prices.keys()]
+    else:
+        available_periods = settings.get_available_renewal_periods()
+
+    if request.period_days not in available_periods:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Selected renewal period is not available',
+        )
+
+    # Lock user row to prevent TOCTOU on promo-offer state
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Unified pricing via PricingEngine
+    pricing = await pricing_engine.calculate_renewal_price(
+        db,
+        subscription,
+        request.period_days,
+        user=user,
+    )
+    price_kopeks = pricing.final_total
+    promo_offer_discount_value = pricing.promo_offer_discount
+    promo_offer_discount_percent = pricing.breakdown.get('offer_discount_pct', 0)
+
+    if price_kopeks <= 0 and pricing.base_price <= 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid renewal period',
+        )
+
+    original_price_kopeks = pricing.original_total
+    discount_percent = 0
+    if original_price_kopeks > 0 and original_price_kopeks != price_kopeks:
+        discount_percent = int((original_price_kopeks - price_kopeks) * 100 / original_price_kopeks)
+
+    tariff = subscription.tariff if subscription.tariff_id else None
+
+    # Check balance
+    if user.balance_kopeks < price_kopeks:
+        missing = price_kopeks - user.balance_kopeks
+
+        # Get tariff info for cart
+        tariff_id = subscription.tariff_id
+        tariff_name = None
+        tariff_traffic_limit_gb = None
+        tariff_allowed_squads = None
+
+        if tariff_id:
+            tariff = await get_tariff_by_id(db, tariff_id)
+            if tariff:
+                tariff_name = tariff.name
+                tariff_traffic_limit_gb = tariff.traffic_limit_gb
+                tariff_allowed_squads = tariff.allowed_squads or []
+
+        # Save cart for auto-purchase after balance top-up
+        cart_data: dict[str, Any] = {
+            'cart_mode': 'extend',
+            'subscription_id': subscription.id,
+            'tariff_id': tariff_id,
+            'period_days': request.period_days,
+            'total_price': price_kopeks,
+            'user_id': user.id,
+            'saved_cart': True,
+            'missing_amount': missing,
+            'return_to_cart': True,
+            'description': f'Продление подписки на {request.period_days} дней'
+            + (f' ({tariff_name})' if tariff_name else ''),
+            'discount_percent': discount_percent,
+            'consume_promo_offer': promo_offer_discount_value > 0,
+            'source': 'cabinet',
+        }
+
+        # Add subscription parameters for auto-purchase
+        if tariff_id:
+            cart_data['traffic_limit_gb'] = tariff_traffic_limit_gb
+            # Сохраняем актуальный device_limit подписки (включая докупленные устройства)
+            cart_data['device_limit'] = subscription.device_limit
+            cart_data['allowed_squads'] = tariff_allowed_squads
+        else:
+            # Classic mode: сохраняем текущие параметры подписки для корректной автопокупки
+            cart_data['device_limit'] = subscription.device_limit
+            cart_data['traffic_limit_gb'] = subscription.traffic_limit_gb
+
+        try:
+            await user_cart_service.save_user_cart(user.id, cart_data)
+            logger.info('Cart saved for auto-renewal (cabinet) user', user_id=user.id)
+        except Exception as e:
+            logger.error('Error saving cart for auto-renewal (cabinet)', error=e)
+
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail={
+                'code': 'insufficient_funds',
+                'message': f'Недостаточно средств. Не хватает {settings.format_price(missing)}',
+                'missing_amount': missing,
+                'cart_saved': True,
+                'cart_mode': 'extend',
+            },
+        )
+
+    # Centralized renewal: balance deduction, extension, RemnaWave sync, admin notification,
+    # server price recording, and compensating refund on failure.
+    renewal_description = f'Продление подписки на {request.period_days} дней' + (f' ({tariff.name})' if tariff else '')
+    renewal_service = SubscriptionRenewalService()
+
+    try:
+        result = await renewal_service.finalize(
+            db,
+            user,
+            subscription,
+            pricing,
+            description=renewal_description,
+            payment_method=PaymentMethod.BALANCE,
+        )
+    except SubscriptionRenewalChargeError:
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail={
+                'code': 'insufficient_funds',
+                'message': 'Недостаточно средств (concurrent check)',
+            },
+        )
+
+    response: dict[str, Any] = {
+        'message': 'Subscription renewed successfully',
+        'new_end_date': result.subscription.end_date.isoformat(),
+        'amount_paid_kopeks': price_kopeks,
+    }
+
+    # Add discount info to response
+    if promo_offer_discount_value > 0:
+        response['promo_discount_percent'] = promo_offer_discount_percent
+        response['promo_discount_amount_kopeks'] = promo_offer_discount_value
+        response['original_price_kopeks'] = original_price_kopeks
+
+    return response

app/cabinet/routes/subscription_modules/servers.py

@@ -0,0 +1,261 @@
+"""Server/country management endpoints.
+
+GET /subscription/countries
+POST /subscription/countries
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.services.subscription_service import SubscriptionService
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from .helpers import resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/countries')
+async def get_available_countries(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Get available countries/servers for the user."""
+    from app.database.crud.server_squad import get_available_server_squads
+    from app.utils.pricing_utils import apply_percentage_discount, calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    promo_group_id = user.promo_group_id
+    available_servers = await get_available_server_squads(db, promo_group_id=promo_group_id)
+
+    connected_squads = []
+    days_left = 0
+    if subscription:
+        connected_squads = subscription.connected_squads or []
+        if subscription.end_date:
+            delta = subscription.end_date - datetime.now(UTC)
+            days_left = max(0, delta.days)
+
+    # Get discount from promo group via PricingEngine (respects apply_discounts_to_addons flag)
+    from app.services.pricing_engine import PricingEngine
+
+    servers_discount_percent = PricingEngine.get_addon_discount_percent(user, 'servers', None)
+
+    countries = []
+    for server in available_servers:
+        base_price = server.price_kopeks
+
+        # Apply discount
+        if servers_discount_percent > 0:
+            discounted_price, _ = apply_percentage_discount(base_price, servers_discount_percent)
+        else:
+            discounted_price = base_price
+
+        # Calculate prorated price if subscription exists
+        prorated_price = discounted_price
+        if subscription and subscription.end_date:
+            prorated_price, _ = calculate_prorated_price(
+                discounted_price,
+                subscription.end_date,
+            )
+
+        countries.append(
+            {
+                'uuid': server.squad_uuid,
+                'name': server.display_name,
+                'country_code': server.country_code,
+                'base_price_kopeks': base_price,
+                'price_kopeks': prorated_price,  # Prorated price with discount
+                'price_per_month_kopeks': discounted_price,  # Monthly price with discount
+                'price_rubles': prorated_price / 100,
+                'is_available': server.is_available and not server.is_full,
+                'is_connected': server.squad_uuid in connected_squads,
+                'has_discount': servers_discount_percent > 0,
+                'discount_percent': servers_discount_percent,
+            }
+        )
+
+    return {
+        'countries': countries,
+        'connected_count': len(connected_squads),
+        'has_subscription': subscription is not None,
+        'days_left': days_left,
+        'discount_percent': servers_discount_percent,
+    }
+
+
+@router.post('/countries')
+async def update_countries(
+    request: dict[str, Any],
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Update subscription countries/servers."""
+    from app.database.crud.server_squad import add_user_to_servers, get_available_server_squads, get_server_ids_by_uuids
+    from app.database.crud.subscription import add_subscription_servers
+    from app.database.crud.transaction import create_transaction
+    from app.database.crud.user import subtract_user_balance
+    from app.database.models import TransactionType
+    from app.utils.pricing_utils import apply_percentage_discount, calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    if subscription.is_trial:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Country management is not available for trial subscriptions',
+        )
+
+    selected_countries = request.get('countries', [])
+    if not selected_countries:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='At least one country must be selected',
+        )
+
+    current_countries = subscription.connected_squads or []
+    promo_group_id = user.promo_group_id
+
+    available_servers = await get_available_server_squads(db, promo_group_id=promo_group_id)
+    allowed_country_ids = {server.squad_uuid for server in available_servers}
+
+    # Validate selected countries
+    for country_uuid in selected_countries:
+        if country_uuid not in allowed_country_ids:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Country {country_uuid} is not available',
+            )
+
+    added = [c for c in selected_countries if c not in current_countries]
+    removed = [c for c in current_countries if c not in selected_countries]
+
+    if not added and not removed:
+        return {
+            'message': 'No changes detected',
+            'connected_squads': current_countries,
+        }
+
+    # Lock user row to prevent TOCTOU on promo-offer state
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Calculate cost for added servers
+    total_cost = 0
+    added_names = []
+    removed_names = []
+
+    from app.services.pricing_engine import PricingEngine
+
+    servers_discount_percent = PricingEngine.get_addon_discount_percent(user, 'servers', None)
+
+    added_server_prices = []
+
+    for server in available_servers:
+        if server.squad_uuid in added:
+            server_price_per_month = server.price_kopeks
+            if servers_discount_percent > 0:
+                discounted_per_month, _ = apply_percentage_discount(
+                    server_price_per_month,
+                    servers_discount_percent,
+                )
+            else:
+                discounted_per_month = server_price_per_month
+
+            charged_price, charged_days = calculate_prorated_price(
+                discounted_per_month,
+                subscription.end_date,
+            )
+
+            total_cost += charged_price
+            added_names.append(server.display_name)
+            added_server_prices.append(charged_price)
+
+        if server.squad_uuid in removed:
+            removed_names.append(server.display_name)
+
+    # Check balance
+    if total_cost > 0 and user.balance_kopeks < total_cost:
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail=f'Insufficient balance. Need {total_cost / 100:.2f} RUB, have {user.balance_kopeks / 100:.2f} RUB',
+        )
+
+    # Deduct balance and update subscription
+    if added and total_cost > 0:
+        success = await subtract_user_balance(db, user, total_cost, f'Adding countries: {", ".join(added_names)}')
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail='Failed to charge balance',
+            )
+
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=total_cost,
+            description=f'Adding countries to subscription: {", ".join(added_names)}',
+        )
+
+    # Add servers to subscription
+    if added:
+        added_server_ids = await get_server_ids_by_uuids(db, added)
+        if added_server_ids:
+            await add_subscription_servers(db, subscription, added_server_ids, added_server_prices)
+            try:
+                await add_user_to_servers(db, added_server_ids)
+            except Exception as e:
+                logger.error('Ошибка обновления счётчика серверов', error=e)
+
+    # Update connected squads
+    subscription.connected_squads = selected_countries
+    subscription.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    # Sync with RemnaWave
+    try:
+        from app.config import settings
+
+        subscription_service = SubscriptionService()
+        _has_panel = (
+            getattr(subscription, 'remnawave_uuid', None)
+            if settings.is_multi_tariff_enabled()
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _has_panel:
+            await subscription_service.update_remnawave_user(db, subscription, sync_squads=True)
+        else:
+            await subscription_service.create_remnawave_user(db, subscription)
+    except Exception as e:
+        logger.error('Failed to sync countries with RemnaWave', error=e)
+
+    await db.refresh(subscription)
+
+    return {
+        'message': 'Countries updated successfully',
+        'added': added_names,
+        'removed': removed_names,
+        'amount_paid_kopeks': total_cost,
+        'connected_squads': subscription.connected_squads,
+    }

app/cabinet/routes/subscription_modules/status.py

@@ -0,0 +1,526 @@
+"""Subscription status endpoints.
+
+GET /subscription — subscription info
+GET /subscription/connection-link
+GET /subscription/happ-downloads
+GET /subscription/app-config
+"""
+
+from __future__ import annotations
+
+import base64
+import re
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.models import ServerSquad, User
+from app.services.remnawave_service import RemnaWaveService
+from app.services.system_settings_service import bot_configuration_service
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import (
+    ServerInfo,
+    SubscriptionStatusResponse,
+)
+from .helpers import _subscription_to_response, resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/info', response_model=SubscriptionStatusResponse)
+async def get_subscription(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Get current user's subscription details."""
+    # Reload user from current session to get fresh data
+    # (user object is from different session in get_current_cabinet_user)
+    from app.database.crud.user import get_user_by_id
+
+    fresh_user = await get_user_by_id(db, user.id)
+
+    if not fresh_user:
+        return SubscriptionStatusResponse(has_subscription=False, subscription=None)
+
+    subscription = await resolve_subscription(db, fresh_user, subscription_id)
+
+    if not subscription:
+        # Return 200 with has_subscription: false instead of 404
+        return SubscriptionStatusResponse(has_subscription=False, subscription=None)
+
+    # Load tariff for daily subscription check and tariff name
+    tariff_name = None
+    if subscription.tariff_id:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if tariff:
+            subscription.tariff = tariff
+            tariff_name = tariff.name
+
+    # Fetch server names for connected squads
+    servers: list[ServerInfo] = []
+    connected_squads = subscription.connected_squads or []
+    if connected_squads:
+        result = await db.execute(select(ServerSquad).where(ServerSquad.squad_uuid.in_(connected_squads)))
+        server_squads = result.scalars().all()
+        servers = [
+            ServerInfo(uuid=sq.squad_uuid, name=sq.display_name, country_code=sq.country_code) for sq in server_squads
+        ]
+
+    # Fetch traffic purchases (monthly packages)
+    traffic_purchases_data = []
+    from app.database.models import TrafficPurchase
+
+    now = datetime.now(UTC)
+    purchases_query = (
+        select(TrafficPurchase)
+        .where(TrafficPurchase.subscription_id == subscription.id)
+        .where(TrafficPurchase.expires_at > now)
+        .order_by(TrafficPurchase.expires_at.asc())
+    )
+    purchases_result = await db.execute(purchases_query)
+    purchases = purchases_result.scalars().all()
+
+    for purchase in purchases:
+        time_remaining = purchase.expires_at - now
+        days_remaining = max(0, int(time_remaining.total_seconds() / 86400))
+        total_duration_seconds = (purchase.expires_at - purchase.created_at).total_seconds()
+        elapsed_seconds = (now - purchase.created_at).total_seconds()
+        progress_percent = min(
+            100.0, max(0.0, (elapsed_seconds / total_duration_seconds * 100) if total_duration_seconds > 0 else 0)
+        )
+
+        traffic_purchases_data.append(
+            {
+                'id': purchase.id,
+                'traffic_gb': purchase.traffic_gb,
+                'expires_at': purchase.expires_at,
+                'created_at': purchase.created_at,
+                'days_remaining': days_remaining,
+                'progress_percent': round(progress_percent, 1),
+            }
+        )
+
+    subscription_data = _subscription_to_response(
+        subscription, servers, tariff_name, traffic_purchases_data, user=fresh_user
+    )
+    return SubscriptionStatusResponse(has_subscription=True, subscription=subscription_data)
+
+
+# ============ Connection Link ============
+
+
+@router.get('/connection-link')
+async def get_connection_link(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Get subscription connection link and instructions."""
+    from app.utils.subscription_utils import (
+        convert_subscription_link_to_happ_scheme,
+        get_display_subscription_link,
+        get_happ_cryptolink_redirect_link,
+    )
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    subscription_url = subscription.subscription_url
+    if not subscription_url:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Subscription link not yet generated',
+        )
+
+    display_link = get_display_subscription_link(subscription)
+    happ_redirect = get_happ_cryptolink_redirect_link(subscription_url) if settings.is_happ_cryptolink_mode() else None
+    happ_scheme_link = (
+        convert_subscription_link_to_happ_scheme(subscription_url) if settings.is_happ_cryptolink_mode() else None
+    )
+
+    connect_mode = settings.CONNECT_BUTTON_MODE
+    hide_subscription_link = settings.should_hide_subscription_link()
+
+    return {
+        'subscription_url': subscription_url if not hide_subscription_link else None,
+        'display_link': display_link if not hide_subscription_link else None,
+        'happ_redirect_link': happ_redirect,
+        'happ_scheme_link': happ_scheme_link,
+        'connect_mode': connect_mode,
+        'hide_link': hide_subscription_link,
+        'instructions': {
+            'steps': [
+                'Copy the subscription link',
+                'Open your VPN application',
+                "Find 'Add subscription' or 'Import' option",
+                'Paste the copied link',
+            ]
+        },
+    }
+
+
+# ============ hApp Downloads ============
+
+
+@router.get('/happ-downloads')
+async def get_happ_downloads(
+    user: User = Depends(get_current_cabinet_user),
+) -> dict[str, Any]:
+    """Get hApp download links for different platforms."""
+    platforms = {
+        'ios': {
+            'name': 'iOS (iPhone/iPad)',
+            'icon': '🍎',
+            'link': settings.get_happ_download_link('ios'),
+        },
+        'android': {
+            'name': 'Android',
+            'icon': '🤖',
+            'link': settings.get_happ_download_link('android'),
+        },
+        'macos': {
+            'name': 'macOS',
+            'icon': '🖥️',
+            'link': settings.get_happ_download_link('macos'),
+        },
+        'windows': {
+            'name': 'Windows',
+            'icon': '💻',
+            'link': settings.get_happ_download_link('windows'),
+        },
+    }
+
+    # Filter out platforms without links
+    available_platforms = {k: v for k, v in platforms.items() if v['link']}
+
+    return {
+        'platforms': available_platforms,
+        'happ_enabled': bool(available_platforms),
+    }
+
+
+# ============ App Config for Connection ============
+
+
+def _get_remnawave_config_uuid() -> str | None:
+    """Get RemnaWave config UUID from system settings or env."""
+    try:
+        return bot_configuration_service.get_current_value('CABINET_REMNA_SUB_CONFIG')
+    except Exception:
+        return settings.CABINET_REMNA_SUB_CONFIG
+
+
+def _extract_scheme_from_buttons(buttons: list[dict[str, Any]]) -> tuple[str, bool]:
+    """Extract URL scheme from buttons list.
+
+    Returns:
+        Tuple of (scheme, uses_crypto_link).
+        uses_crypto_link=True when the template is {{HAPP_CRYPT4_LINK}},
+        meaning subscription_crypto_link should be used as payload.
+    """
+    for btn in buttons:
+        if not isinstance(btn, dict):
+            continue
+        link = btn.get('link', '') or btn.get('url', '') or btn.get('buttonLink', '')
+        if not link:
+            continue
+        link_upper = link.upper()
+
+        # Check for {{HAPP_CRYPT4_LINK}} -- uses crypto link as payload
+        if '{{HAPP_CRYPT4_LINK}}' in link_upper or 'HAPP_CRYPT4_LINK' in link_upper:
+            scheme = re.sub(r'\{\{HAPP_CRYPT4_LINK\}\}', '', link, flags=re.IGNORECASE)
+            if scheme and '://' in scheme:
+                return scheme, True
+
+        # Check for {{SUBSCRIPTION_LINK}} -- uses plain subscription_url as payload
+        if '{{SUBSCRIPTION_LINK}}' in link_upper or 'SUBSCRIPTION_LINK' in link_upper:
+            scheme = re.sub(r'\{\{SUBSCRIPTION_LINK\}\}', '', link, flags=re.IGNORECASE)
+            if scheme and '://' in scheme:
+                return scheme, False
+
+        # Also check for type="subscriptionLink" buttons with custom schemes
+        btn_type = btn.get('type', '')
+        if btn_type == 'subscriptionLink' and '://' in link and not link.startswith('http'):
+            scheme = link.split('{{')[0] if '{{' in link else link
+            if scheme and '://' in scheme:
+                return scheme, False
+    return '', False
+
+
+def _get_url_scheme_for_app(app: dict[str, Any]) -> tuple[str, bool]:
+    """Get URL scheme for app - from config, buttons, or fallback by name.
+
+    Returns:
+        Tuple of (scheme, uses_crypto_link).
+        uses_crypto_link=True means the app template uses {{HAPP_CRYPT4_LINK}},
+        so subscription_crypto_link should be used as the deep link payload.
+    """
+    # 1. Check urlScheme field (cabinet format stores usesCryptoLink alongside)
+    scheme = str(app.get('urlScheme', '')).strip()
+    if scheme:
+        uses_crypto = bool(app.get('usesCryptoLink', False))
+        return scheme, uses_crypto
+
+    # 2. Extract from buttons in blocks (RemnaWave format)
+    blocks = app.get('blocks', [])
+    for block in blocks:
+        if not isinstance(block, dict):
+            continue
+        buttons = block.get('buttons', [])
+        scheme, uses_crypto = _extract_scheme_from_buttons(buttons)
+        if scheme:
+            return scheme, uses_crypto
+
+    # 3. Check buttons directly in app (alternative structure)
+    direct_buttons = app.get('buttons', [])
+    if direct_buttons:
+        scheme, uses_crypto = _extract_scheme_from_buttons(direct_buttons)
+        if scheme:
+            return scheme, uses_crypto
+
+    # No scheme found
+    logger.debug(
+        '_get_url_scheme_for_app: No scheme found for app has blocks: has buttons: has urlScheme',
+        get=app.get('name'),
+        get_2=bool(app.get('blocks')),
+        get_3=bool(app.get('buttons')),
+        get_4=bool(app.get('urlScheme')),
+    )
+    return '', False
+
+
+async def _load_app_config_async() -> dict[str, Any] | None:
+    """Load app config from RemnaWave API (if configured).
+
+    Returns None when no Remnawave config is set or API fails.
+    """
+    remnawave_uuid = _get_remnawave_config_uuid()
+
+    if remnawave_uuid:
+        try:
+            service = RemnaWaveService()
+            async with service.get_api_client() as api:
+                config = await api.get_subscription_page_config(remnawave_uuid)
+                if config and config.config:
+                    logger.debug('Loaded app config from RemnaWave', remnawave_uuid=remnawave_uuid)
+                    raw = dict(config.config)
+                    raw['_isRemnawave'] = True
+                    return raw
+        except Exception as e:
+            logger.warning('Failed to load RemnaWave config', error=e)
+
+    return None
+
+
+def _create_deep_link(
+    app: dict[str, Any], subscription_url: str, subscription_crypto_link: str | None = None
+) -> str | None:
+    """Create deep link for app with subscription URL.
+
+    Uses urlScheme from RemnaWave config (e.g. "happ://add/", "v2rayng://install-config?url=")
+    combined with the appropriate payload URL.
+
+    Two Happ schemes exist in RemnaWave:
+      - happ://add/{{SUBSCRIPTION_LINK}}       -> uses plain subscription_url
+      - happ://crypt4/{{HAPP_CRYPT4_LINK}}     -> uses subscription_crypto_link
+    """
+    if not isinstance(app, dict):
+        return None
+
+    if not subscription_url and not subscription_crypto_link:
+        return None
+
+    scheme, uses_crypto = _get_url_scheme_for_app(app)
+    if not scheme:
+        logger.debug('_create_deep_link: no urlScheme for app', get=app.get('name', 'unknown'))
+        return None
+
+    # Pick the correct payload based on which template the app uses
+    if uses_crypto:
+        if not subscription_crypto_link:
+            logger.debug(
+                '_create_deep_link: app requires crypto link but none available', get=app.get('name', 'unknown')
+            )
+            return None
+        payload = subscription_crypto_link
+    else:
+        if not subscription_url:
+            logger.debug(
+                '_create_deep_link: app requires subscription_url but none available', get=app.get('name', 'unknown')
+            )
+            return None
+        payload = subscription_url
+
+    if app.get('isNeedBase64Encoding'):
+        try:
+            payload = base64.b64encode(payload.encode('utf-8')).decode('utf-8')
+        except Exception as e:
+            logger.warning('Failed to encode payload to base64', error=e)
+
+    return f'{scheme}{payload}'
+
+
+def _resolve_button_url(
+    url: str,
+    subscription_url: str | None,
+    subscription_crypto_link: str | None,
+) -> str:
+    """Resolve template variables in button URLs.
+
+    Matches remnawave/subscription-page frontend TemplateEngine:
+    - {{SUBSCRIPTION_LINK}} -> plain subscription URL
+    - {{HAPP_CRYPT3_LINK}} -> crypto link
+    - {{HAPP_CRYPT4_LINK}} -> crypto link
+    """
+    if not url:
+        return url
+    result = url
+    if subscription_url:
+        result = result.replace('{{SUBSCRIPTION_LINK}}', subscription_url)
+    if subscription_crypto_link:
+        result = result.replace('{{HAPP_CRYPT3_LINK}}', subscription_crypto_link)
+        result = result.replace('{{HAPP_CRYPT4_LINK}}', subscription_crypto_link)
+    return result
+
+
+@router.get('/app-config')
+async def get_app_config(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Get app configuration for connection with deep links."""
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    subscription_url = None
+    subscription_crypto_link = None
+    if subscription:
+        subscription_url = subscription.subscription_url
+        subscription_crypto_link = subscription.subscription_crypto_link
+
+    # Generate crypto link on the fly if subscription_url exists but crypto link is missing.
+    # This covers synced users where enrich_happ_links was not called.
+    if subscription_url and not subscription_crypto_link:
+        try:
+            service = RemnaWaveService()
+            async with service.get_api_client() as api:
+                encrypted = await api.encrypt_happ_crypto_link(subscription_url)
+                if encrypted:
+                    subscription_crypto_link = encrypted
+                    if subscription:
+                        subscription.subscription_crypto_link = encrypted
+                        await db.commit()
+                        logger.info(
+                            'Generated and saved crypto link for user',
+                            user_id=user.id,
+                        )
+        except Exception as e:
+            logger.debug('Could not generate crypto link', error=e)
+
+    config = await _load_app_config_async()
+
+    if not config:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='App configuration not set up.',
+        )
+
+    config.pop('_isRemnawave', None)
+    hide_link = settings.should_hide_subscription_link()
+
+    # Build platformNames from displayName of each platform
+    platform_names: dict[str, Any] = {}
+    for pk, pd in config.get('platforms', {}).items():
+        if isinstance(pd, dict) and 'displayName' in pd:
+            platform_names[pk] = pd['displayName']
+    fallback_names = {
+        'ios': {'en': 'iPhone/iPad'},
+        'android': {'en': 'Android'},
+        'macos': {'en': 'macOS'},
+        'windows': {'en': 'Windows'},
+        'linux': {'en': 'Linux'},
+        'androidTV': {'en': 'Android TV'},
+        'appleTV': {'en': 'Apple TV'},
+    }
+    for k, v in fallback_names.items():
+        if k not in platform_names:
+            platform_names[k] = v
+
+    # Serve original blocks/svgLibrary enriched with deep links and resolved URLs.
+    platforms: dict[str, Any] = {}
+    for platform_key, platform_data in config.get('platforms', {}).items():
+        if not isinstance(platform_data, dict):
+            continue
+        apps = platform_data.get('apps', [])
+        if not isinstance(apps, list):
+            continue
+
+        enriched_apps = []
+        for app in apps:
+            if not isinstance(app, dict):
+                continue
+
+            # Generate deep link
+            deep_link = None
+            if subscription_url or subscription_crypto_link:
+                deep_link = _create_deep_link(app, subscription_url, subscription_crypto_link)
+            app['deepLink'] = deep_link
+
+            # Resolve templates only for subscriptionLink and copyButton (not external)
+            for block in app.get('blocks', []):
+                if not isinstance(block, dict):
+                    continue
+                for btn in block.get('buttons', []):
+                    if not isinstance(btn, dict):
+                        continue
+                    btn_type = btn.get('type', '')
+                    if btn_type in ('subscriptionLink', 'copyButton'):
+                        url = btn.get('url', '') or btn.get('link', '')
+                        if url and '{{' in url:
+                            resolved = _resolve_button_url(
+                                url,
+                                subscription_url,
+                                subscription_crypto_link,
+                            )
+                            # Only set resolvedUrl if ALL templates were resolved;
+                            # otherwise let the frontend fall through to deepLink/subscriptionUrl
+                            if '{{' not in resolved:
+                                btn['resolvedUrl'] = resolved
+
+            enriched_apps.append(app)
+
+        if enriched_apps:
+            platform_output = {k: v for k, v in platform_data.items() if k != 'apps'}
+            platform_output['apps'] = enriched_apps
+            platforms[platform_key] = platform_output
+
+    return {
+        'isRemnawave': True,
+        'platforms': platforms,
+        'svgLibrary': config.get('svgLibrary', {}),
+        'baseTranslations': config.get('baseTranslations'),
+        'baseSettings': config.get('baseSettings'),
+        'uiConfig': config.get('uiConfig', {}),
+        'platformNames': platform_names,
+        'hasSubscription': bool(subscription_url or subscription_crypto_link),
+        'subscriptionUrl': subscription_url,
+        'subscriptionCryptoLink': subscription_crypto_link,
+        'hideLink': hide_link,
+        'branding': config.get('brandingSettings', {}),
+    }

app/cabinet/routes/subscription_modules/tariff_switch.py

@@ -0,0 +1,500 @@
+"""Tariff switching endpoints.
+
+POST /subscription/tariff/switch/preview
+POST /subscription/tariff/switch
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.crud.transaction import create_transaction
+from app.database.crud.user import subtract_user_balance
+from app.database.models import PaymentMethod, Subscription, TransactionType, User
+from app.services.pricing_engine import pricing_engine
+from app.services.remnawave_service import RemnaWaveService
+from app.services.subscription_service import SubscriptionService
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import TariffPurchaseRequest
+from .helpers import _subscription_to_response, resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.post('/tariff/switch/preview')
+async def preview_tariff_switch(
+    request: TariffPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Preview tariff switch - shows cost calculation."""
+    if not settings.is_tariffs_mode():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Tariffs mode is not enabled',
+        )
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription or not subscription.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='No active subscription with tariff',
+        )
+
+    # Use actual_status for correct status check (handles time-based expiration)
+    actual_status = subscription.actual_status
+    if actual_status == 'expired':
+        # For expired subscriptions, user should purchase a new tariff, not switch
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_expired',
+                'message': 'Subscription is expired. Please purchase a new tariff instead of switching.',
+                'use_purchase_flow': True,
+            },
+        )
+    if actual_status not in ('active', 'trial'):
+        # For disabled/pending subscriptions, block switching with generic error
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_not_active',
+                'message': f'Subscription is not active (status: {actual_status}). Cannot switch tariff.',
+            },
+        )
+
+    current_tariff = await get_tariff_by_id(db, subscription.tariff_id)
+    new_tariff = await get_tariff_by_id(db, request.tariff_id)
+
+    if not new_tariff or not new_tariff.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tariff not found or inactive',
+        )
+
+    if subscription.tariff_id == request.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Already on this tariff',
+        )
+
+    # Check tariff availability for user's promo group
+    # Use get_primary_promo_group() for correct promo group resolution
+    promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+    if promo_group is None:
+        promo_group = getattr(user, 'promo_group', None)
+    promo_group_id = promo_group.id if promo_group else None
+    if not new_tariff.is_available_for_promo_group(promo_group_id):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Tariff not available for your promo group',
+        )
+
+    # Calculate remaining days
+    remaining_days = 0
+    if subscription.end_date and subscription.end_date > datetime.now(UTC):
+        delta = subscription.end_date - datetime.now(UTC)
+        remaining_days = max(0, delta.days)
+
+    # Calculate switch cost (PricingEngine handles all cases: periodic<->periodic, daily->periodic, periodic->daily)
+    switch_result = pricing_engine.calculate_tariff_switch_cost(
+        current_tariff,
+        new_tariff,
+        remaining_days,
+        user=user,
+    )
+    upgrade_cost = switch_result.upgrade_cost
+    is_upgrade = switch_result.is_upgrade
+    base_upgrade_cost = switch_result.raw_cost
+    discount_value = switch_result.discount_value
+    period_discount_percent = switch_result.effective_discount_pct
+
+    balance = user.balance_kopeks or 0
+    has_enough = balance >= upgrade_cost
+    missing = max(0, upgrade_cost - balance) if not has_enough else 0
+
+    response: dict[str, Any] = {
+        'can_switch': has_enough,
+        'current_tariff_id': current_tariff.id if current_tariff else None,
+        'current_tariff_name': current_tariff.name if current_tariff else None,
+        'new_tariff_id': new_tariff.id,
+        'new_tariff_name': new_tariff.name,
+        'remaining_days': remaining_days,
+        'upgrade_cost_kopeks': upgrade_cost,
+        'upgrade_cost_label': settings.format_price(upgrade_cost) if upgrade_cost > 0 else 'Бесплатно',
+        'balance_kopeks': balance,
+        'balance_label': settings.format_price(balance),
+        'has_enough_balance': has_enough,
+        'missing_amount_kopeks': missing,
+        'missing_amount_label': settings.format_price(missing) if missing > 0 else '',
+        'is_upgrade': is_upgrade,
+    }
+
+    # Add discount info if applicable
+    if period_discount_percent > 0 and discount_value > 0:
+        response['discount_percent'] = period_discount_percent
+        response['discount_kopeks'] = discount_value
+        response['base_upgrade_cost_kopeks'] = base_upgrade_cost
+
+    return response
+
+
+@router.post('/tariff/switch')
+async def switch_tariff(
+    request: TariffPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Switch to a different tariff without changing end date."""
+    if not settings.is_tariffs_mode():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Tariffs mode is not enabled',
+        )
+
+    resolved = await resolve_subscription(db, user, subscription_id)
+
+    if not resolved or not resolved.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='No active subscription with tariff',
+        )
+
+    # Guard: prevent switching to a tariff the user already owns (multi-tariff)
+    if settings.is_multi_tariff_enabled() and request.tariff_id:
+        from app.database.crud.subscription import get_subscription_by_user_and_tariff
+
+        existing_target = await get_subscription_by_user_and_tariff(db, user.id, request.tariff_id)
+        if existing_target and existing_target.id != resolved.id:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail='You already have an active subscription for the target tariff',
+            )
+
+    # Lock subscription row to prevent concurrent tariff switches
+    locked_result = await db.execute(
+        select(Subscription)
+        .where(Subscription.id == resolved.id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
+    subscription = locked_result.scalar_one()
+
+    # Use actual_status for correct status check (handles time-based expiration)
+    actual_status = subscription.actual_status
+    if actual_status == 'expired':
+        # For expired subscriptions, user should purchase a new tariff, not switch
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_expired',
+                'message': 'Subscription is expired. Please purchase a new tariff instead of switching.',
+                'use_purchase_flow': True,
+            },
+        )
+    if actual_status not in ('active', 'trial'):
+        # For disabled/pending subscriptions, block switching with generic error
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_not_active',
+                'message': f'Subscription is not active (status: {actual_status}). Cannot switch tariff.',
+            },
+        )
+
+    current_tariff = await get_tariff_by_id(db, subscription.tariff_id)
+    new_tariff = await get_tariff_by_id(db, request.tariff_id)
+
+    if not new_tariff or not new_tariff.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tariff not found or inactive',
+        )
+
+    if subscription.tariff_id == request.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Already on this tariff',
+        )
+
+    # Check tariff availability
+    # Use get_primary_promo_group() for correct promo group resolution
+    promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+    if promo_group is None:
+        promo_group = getattr(user, 'promo_group', None)
+    promo_group_id = promo_group.id if promo_group else None
+    if not new_tariff.is_available_for_promo_group(promo_group_id):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Tariff not available',
+        )
+
+    # Lock user BEFORE price computation to prevent TOCTOU on promo offer
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Calculate remaining days
+    remaining_days = 0
+    if subscription.end_date and subscription.end_date > datetime.now(UTC):
+        delta = subscription.end_date - datetime.now(UTC)
+        remaining_days = max(0, delta.days)
+
+    # Calculate cost (PricingEngine handles all cases: periodic<->periodic, daily->periodic, periodic->daily)
+    switch_result = pricing_engine.calculate_tariff_switch_cost(
+        current_tariff,
+        new_tariff,
+        remaining_days,
+        user=user,
+    )
+    upgrade_cost = switch_result.upgrade_cost
+    base_upgrade_cost = switch_result.raw_cost
+    discount_value = switch_result.discount_value
+    period_discount_percent = switch_result.effective_discount_pct
+    new_period_days = switch_result.new_period_days
+
+    # Validate daily price for switching TO daily
+    new_is_daily = getattr(new_tariff, 'is_daily', False)
+    current_is_daily = getattr(current_tariff, 'is_daily', False) if current_tariff else False
+    switching_to_daily = not current_is_daily and new_is_daily
+    switching_from_daily = current_is_daily and not new_is_daily
+
+    if switching_to_daily and (getattr(new_tariff, 'daily_price_kopeks', 0) or 0) <= 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Daily tariff has invalid price',
+        )
+
+    # Charge if upgrade
+    switch_transaction = None
+    if upgrade_cost > 0:
+        if user.balance_kopeks < upgrade_cost:
+            missing = upgrade_cost - user.balance_kopeks
+            raise HTTPException(
+                status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                detail={
+                    'code': 'insufficient_funds',
+                    'message': f'Insufficient funds. Missing {settings.format_price(missing)}',
+                    'missing_amount': missing,
+                },
+            )
+
+        if switching_to_daily:
+            description = f"Переход на суточный тариф '{new_tariff.name}'"
+        elif switching_from_daily:
+            description = f"Переход с суточного на тариф '{new_tariff.name}' ({new_period_days} дней)"
+        else:
+            description = f"Переход на тариф '{new_tariff.name}' (доплата за {remaining_days} дней)"
+
+        # Add discount info to description if applicable
+        if period_discount_percent > 0 and discount_value > 0:
+            description += f' (скидка {period_discount_percent}%)'
+
+        success = await subtract_user_balance(
+            db,
+            user,
+            upgrade_cost,
+            description,
+            consume_promo_offer=switch_result.offer_discount_pct > 0,
+            mark_as_paid_subscription=True,
+            commit=False,
+        )
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail='Failed to charge balance',
+            )
+
+        # Create transaction (commit=False to keep FOR UPDATE lock held)
+        switch_transaction = await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=upgrade_cost,
+            description=description,
+            payment_method=PaymentMethod.BALANCE,
+            commit=False,
+        )
+    else:
+        # Free switch (downgrade) — record in history
+        description = f"Переход на тариф '{new_tariff.name}'"
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=0,
+            description=description,
+            commit=False,
+        )
+
+    # Update subscription
+    old_tariff_name = current_tariff.name if current_tariff else 'Unknown'
+
+    # Reset device limit to new tariff base (extra purchased devices are not carried over)
+    from app.database.crud.subscription import calc_device_limit_on_tariff_switch
+
+    # Re-load subscription to avoid MissingGreenlet from expired lazy relationship
+    # (subtract_user_balance re-selects User with populate_existing=True which expires relationships)
+    await db.refresh(subscription)
+
+    subscription.tariff_id = new_tariff.id
+    subscription.traffic_limit_gb = new_tariff.traffic_limit_gb
+    subscription.device_limit = calc_device_limit_on_tariff_switch(
+        current_device_limit=subscription.device_limit,
+        old_tariff_device_limit=current_tariff.device_limit if current_tariff else None,
+        new_tariff_device_limit=new_tariff.device_limit,
+        max_device_limit=new_tariff.max_device_limit,
+    )
+    subscription.connected_squads = new_tariff.allowed_squads or []
+
+    # Reset purchased traffic and delete TrafficPurchase records on tariff switch
+    from sqlalchemy import delete as sql_delete
+
+    from app.database.models import TrafficPurchase
+
+    await db.execute(sql_delete(TrafficPurchase).where(TrafficPurchase.subscription_id == subscription.id))
+    subscription.purchased_traffic_gb = 0
+    subscription.traffic_reset_at = None
+
+    if settings.RESET_TRAFFIC_ON_TARIFF_SWITCH:
+        subscription.traffic_used_gb = 0.0
+
+    if switching_to_daily:
+        # Switching TO daily - reset end_date to 1 day, set last_daily_charge_at
+        subscription.end_date = datetime.now(UTC) + timedelta(days=1)
+        subscription.last_daily_charge_at = datetime.now(UTC)
+        subscription.is_daily_paused = False
+    elif switching_from_daily:
+        subscription.end_date = datetime.now(UTC) + timedelta(days=new_period_days)
+        subscription.is_daily_paused = False
+
+    subscription.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    # Emit deferred side-effects after atomic commit
+    if upgrade_cost > 0 and switch_transaction:
+        from app.database.crud.transaction import emit_transaction_side_effects
+
+        await emit_transaction_side_effects(
+            db,
+            switch_transaction,
+            amount_kopeks=upgrade_cost,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            payment_method=PaymentMethod.BALANCE,
+        )
+
+    # Sync with RemnaWave (optionally reset traffic based on admin setting)
+    should_reset_traffic = settings.RESET_TRAFFIC_ON_TARIFF_SWITCH
+    # Refresh subscription after commit (all objects are expired)
+    await db.refresh(subscription)
+
+    try:
+        subscription_service = SubscriptionService()
+        _has_panel = (
+            getattr(subscription, 'remnawave_uuid', None)
+            if settings.is_multi_tariff_enabled()
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _has_panel:
+            await subscription_service.update_remnawave_user(
+                db,
+                subscription,
+                reset_traffic=should_reset_traffic,
+                reset_reason='смена тарифа',
+                sync_squads=True,
+            )
+        else:
+            await subscription_service.create_remnawave_user(
+                db,
+                subscription,
+                reset_traffic=should_reset_traffic,
+                reset_reason='смена тарифа',
+            )
+    except Exception as e:
+        logger.error('Failed to sync tariff switch with RemnaWave', error=e)
+
+    # Reset all devices on tariff switch
+    devices_reset = False
+    _switch_uuid = (
+        subscription.remnawave_uuid
+        if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+        else user.remnawave_uuid
+    )
+    if _switch_uuid:
+        try:
+            service = RemnaWaveService()
+            async with service.get_api_client() as api:
+                await api.reset_user_devices(_switch_uuid)
+                devices_reset = True
+                logger.info('Reset all devices for user on tariff switch', user_id=user.id)
+        except Exception as e:
+            logger.error('Failed to reset devices on tariff switch', error=e)
+
+    await db.refresh(user)
+    await db.refresh(subscription)
+
+    # Отправляем уведомление админам о смене тарифа
+    try:
+        from aiogram import Bot
+
+        from app.services.admin_notification_service import AdminNotificationService
+
+        if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
+            bot = Bot(token=settings.BOT_TOKEN)
+            try:
+                notification_service = AdminNotificationService(bot)
+                await notification_service.send_subscription_purchase_notification(
+                    db=db,
+                    user=user,
+                    subscription=subscription,
+                    transaction=switch_transaction if upgrade_cost > 0 else None,
+                    period_days=remaining_days if remaining_days > 0 else new_period_days,
+                    was_trial_conversion=False,
+                    amount_kopeks=upgrade_cost,
+                    purchase_type='tariff_switch',
+                )
+            finally:
+                await bot.session.close()
+    except Exception as e:
+        logger.error('Failed to send admin notification for tariff switch', error=e)
+
+    # Refresh expired objects after db.commit() in _record_subscription_event
+    await db.refresh(subscription)
+    await db.refresh(user)
+
+    response: dict[str, Any] = {
+        'success': True,
+        'message': f"Switched from '{old_tariff_name}' to '{new_tariff.name}'"
+        + (' (devices reset)' if devices_reset else ''),
+        'subscription': _subscription_to_response(subscription, user=user),
+        'old_tariff_name': old_tariff_name,
+        'new_tariff_id': new_tariff.id,
+        'new_tariff_name': new_tariff.name,
+        'charged_kopeks': upgrade_cost,
+        'balance_kopeks': user.balance_kopeks,
+        'balance_label': settings.format_price(user.balance_kopeks),
+    }
+
+    # Add discount info if applicable
+    if period_discount_percent > 0 and discount_value > 0:
+        response['discount_percent'] = period_discount_percent
+        response['discount_kopeks'] = discount_value
+        response['base_charged_kopeks'] = base_upgrade_cost
+
+    return response

app/cabinet/routes/subscription_modules/traffic.py

@@ -0,0 +1,770 @@
+"""Traffic management endpoints.
+
+GET /subscription/traffic-packages
+POST /subscription/traffic
+PUT /subscription/traffic
+POST /subscription/refresh-traffic
+POST /subscription/traffic/save-cart
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.crud.transaction import create_transaction
+from app.database.crud.user import subtract_user_balance
+from app.database.models import TransactionType, User
+from app.services.pricing_engine import pricing_engine
+from app.services.remnawave_service import RemnaWaveService
+from app.services.subscription_service import SubscriptionService
+from app.services.user_cart_service import user_cart_service
+from app.utils.cache import RateLimitCache, cache, cache_key
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import (
+    TrafficPackageResponse,
+    TrafficPurchaseRequest,
+)
+from .helpers import _apply_addon_discount, resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/traffic-packages', response_model=list[TrafficPackageResponse])
+async def get_traffic_packages(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+):
+    """Get available traffic packages."""
+    from app.database.crud.tariff import get_tariff_by_id
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        return []
+
+    # Режим тарифов - берём пакеты из тарифа
+    if settings.is_tariffs_mode() and subscription.tariff_id:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if not tariff:
+            return []
+
+        # Проверяем, разрешена ли докупка для этого тарифа
+        if not getattr(tariff, 'traffic_topup_enabled', False):
+            return []
+
+        # Проверяем безлимит
+        if tariff.traffic_limit_gb == 0:
+            return []
+
+        packages = tariff.get_traffic_topup_packages() if hasattr(tariff, 'get_traffic_topup_packages') else {}
+        result = []
+
+        for gb, price in packages.items():
+            if price <= 0:
+                continue
+            result.append(
+                TrafficPackageResponse(
+                    gb=gb,
+                    price_kopeks=price,
+                    price_rubles=price / 100,
+                    is_unlimited=False,
+                )
+            )
+
+        return sorted(result, key=lambda x: x.gb)
+
+    # Classic режим - глобальные настройки
+    if not settings.is_traffic_topup_enabled():
+        return []
+
+    # Проверяем настройку тарифа пользователя (allow_traffic_topup)
+    if subscription.tariff_id:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if tariff and not tariff.allow_traffic_topup:
+            return []
+
+    packages = settings.get_traffic_topup_packages()
+    result = []
+
+    for pkg in packages:
+        if not pkg.get('enabled', True):
+            continue
+        if pkg['price'] <= 0:
+            continue
+
+        result.append(
+            TrafficPackageResponse(
+                gb=pkg['gb'],
+                price_kopeks=pkg['price'],
+                price_rubles=pkg['price'] / 100,
+                is_unlimited=pkg['gb'] == 0,
+            )
+        )
+
+    return result
+
+
+@router.post('/traffic')
+async def purchase_traffic(
+    request: TrafficPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+):
+    """Purchase additional traffic."""
+    if getattr(user, 'restriction_subscription', False):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Subscription purchases are restricted for this account',
+        )
+
+    from app.database.crud.subscription import add_subscription_traffic
+    from app.database.crud.tariff import get_tariff_by_id
+    from app.utils.pricing_utils import calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+    tariff = None
+    base_price_kopeks = 0
+    is_tariff_mode = settings.is_tariffs_mode() and subscription.tariff_id
+
+    # Режим тарифов
+    if is_tariff_mode:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if not tariff:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Tariff not found',
+            )
+
+        # Проверяем, разрешена ли докупка
+        if not getattr(tariff, 'traffic_topup_enabled', False):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Traffic top-up is disabled for this tariff',
+            )
+
+        # Проверяем безлимит
+        if tariff.traffic_limit_gb == 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Cannot add traffic to unlimited subscription',
+            )
+
+        # Проверяем лимит докупки
+        max_topup_limit = getattr(tariff, 'max_topup_traffic_gb', 0) or 0
+        if max_topup_limit > 0:
+            current_traffic = subscription.traffic_limit_gb or 0
+            new_traffic = current_traffic + request.gb
+            if new_traffic > max_topup_limit:
+                available_gb = max(0, max_topup_limit - current_traffic)
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f'Traffic limit exceeded. Max: {max_topup_limit} GB, available: {available_gb} GB',
+                )
+
+        # Получаем цену из тарифа
+        packages = tariff.get_traffic_topup_packages() if hasattr(tariff, 'get_traffic_topup_packages') else {}
+        if request.gb not in packages:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Traffic package {request.gb}GB is not available',
+            )
+        base_price_kopeks = packages[request.gb]
+        if base_price_kopeks <= 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Traffic package {request.gb}GB has no price configured',
+            )
+
+    else:
+        # Classic режим
+        if not settings.is_traffic_topup_enabled():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Traffic top-up feature is disabled',
+            )
+
+        # Проверяем настройку тарифа (allow_traffic_topup)
+        if subscription.tariff_id:
+            tariff = await get_tariff_by_id(db, subscription.tariff_id)
+            if tariff and not tariff.allow_traffic_topup:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='Traffic top-up is not available for your tariff',
+                )
+
+        # Получаем цену из глобальных настроек
+        packages = settings.get_traffic_topup_packages()
+        matching_pkg = next((pkg for pkg in packages if pkg['gb'] == request.gb and pkg.get('enabled', True)), None)
+        if not matching_pkg:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Invalid traffic package',
+            )
+        base_price_kopeks = matching_pkg['price']
+        if base_price_kopeks <= 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Traffic package has no price configured',
+            )
+
+    # На тарифах пакеты трафика покупаются на 1 месяц (30 дней),
+    # цена в тарифе уже месячная — не умножаем на оставшиеся месяцы подписки.
+    # Пропорциональный расчёт применяем только в классическом режиме.
+    if is_tariff_mode:
+        prorated_price = base_price_kopeks
+        days_charged = 30
+    else:
+        prorated_price, days_charged = calculate_prorated_price(
+            base_price_kopeks,
+            subscription.end_date,
+        )
+
+    # Lock user row to prevent TOCTOU on promo-offer state
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Apply discount from promo group using proper method
+    period_hint_days = days_charged if days_charged > 0 else 30
+    discount_result = _apply_addon_discount(user, 'traffic', prorated_price, period_hint_days)
+    final_price = discount_result['discounted']
+    traffic_discount_percent = discount_result['percent']
+    discount_value = discount_result['discount']
+
+    # Ensure minimum price after discount (except for 100% discount)
+    if traffic_discount_percent < 100 and final_price > 0:
+        final_price = max(100, final_price)
+
+    # Проверяем баланс
+    if user.balance_kopeks < final_price:
+        missing = final_price - user.balance_kopeks
+
+        # Save cart for auto-purchase after balance top-up
+        cart_data = {
+            'cart_mode': 'add_traffic',
+            'subscription_id': subscription.id,
+            'traffic_gb': request.gb,
+            'price_kopeks': final_price,
+            'base_price_kopeks': prorated_price,
+            'discount_percent': traffic_discount_percent,
+            'source': 'cabinet',
+            'description': f'Докупка {request.gb} ГБ трафика',
+        }
+
+        try:
+            await user_cart_service.save_user_cart(user.id, cart_data)
+            logger.info(
+                'Cart saved for traffic purchase (cabinet) user + discount',
+                user_id=user.id,
+                gb=request.gb,
+                traffic_discount_percent=traffic_discount_percent,
+            )
+        except Exception as e:
+            logger.error('Error saving cart for traffic purchase (cabinet)', error=e)
+
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail={
+                'code': 'insufficient_funds',
+                'message': f'Недостаточно средств. Не хватает {settings.format_price(missing)}',
+                'missing_amount': missing,
+                'cart_saved': True,
+                'cart_mode': 'add_traffic',
+            },
+        )
+
+    # Формируем описание
+    if traffic_discount_percent > 0:
+        traffic_description = f'Докупка {request.gb} ГБ трафика (скидка {traffic_discount_percent}%)'
+    else:
+        traffic_description = f'Докупка {request.gb} ГБ трафика'
+
+    # Списываем баланс
+    success = await subtract_user_balance(db, user, final_price, traffic_description)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to charge balance',
+        )
+
+    # Добавляем трафик (add_subscription_traffic обновляет purchased_traffic_gb, traffic_reset_at и коммитит)
+    await add_subscription_traffic(db, subscription, request.gb)
+
+    # Реактивируем подписку если она была DISABLED/EXPIRED (например, после LIMITED/EXPIRED в RemnaWave)
+    from app.database.crud.subscription import reactivate_subscription
+
+    await reactivate_subscription(db, subscription)
+
+    # Синхронизируем с RemnaWave
+    try:
+        subscription_service = SubscriptionService()
+        _panel_uuid = (
+            subscription.remnawave_uuid
+            if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _panel_uuid:
+            await subscription_service.update_remnawave_user(db, subscription)
+            if subscription.status == 'active':
+                await subscription_service.enable_remnawave_user(_panel_uuid)
+        else:
+            await subscription_service.create_remnawave_user(db, subscription)
+    except Exception as e:
+        logger.error('Failed to sync traffic with RemnaWave', error=e)
+
+    # Создаём транзакцию
+    await create_transaction(
+        db=db,
+        user_id=user.id,
+        type=TransactionType.SUBSCRIPTION_PAYMENT,
+        amount_kopeks=final_price,
+        description=traffic_description,
+    )
+
+    await db.refresh(user)
+    await db.refresh(subscription)
+
+    # Отправляем уведомление админам
+    try:
+        from aiogram import Bot
+
+        from app.services.admin_notification_service import AdminNotificationService
+
+        if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
+            bot = Bot(token=settings.BOT_TOKEN)
+            try:
+                notification_service = AdminNotificationService(bot)
+                old_traffic = subscription.traffic_limit_gb - request.gb
+                await notification_service.send_subscription_update_notification(
+                    db=db,
+                    user=user,
+                    subscription=subscription,
+                    update_type='traffic',
+                    old_value=old_traffic,
+                    new_value=subscription.traffic_limit_gb,
+                    price_paid=final_price,
+                )
+            finally:
+                await bot.session.close()
+    except Exception as e:
+        logger.error('Failed to send admin notification for traffic purchase', error=e)
+
+    response: dict[str, Any] = {
+        'success': True,
+        'message': 'Traffic purchased successfully',
+        'gb_added': request.gb,
+        'new_traffic_limit_gb': subscription.traffic_limit_gb,
+        'amount_paid_kopeks': final_price,
+        'new_balance_kopeks': user.balance_kopeks,
+    }
+
+    if traffic_discount_percent > 0:
+        response['discount_percent'] = traffic_discount_percent
+        response['discount_kopeks'] = discount_value
+        response['base_price_kopeks'] = prorated_price
+
+    return response
+
+
+@router.post('/traffic/save-cart')
+async def save_traffic_cart(
+    request: TrafficPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, bool]:
+    """Save cart for traffic purchase (for insufficient balance flow)."""
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='У вас нет активной подписки',
+        )
+
+    if subscription.status not in ['active', 'trial']:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Ваша подписка неактивна',
+        )
+
+    if subscription.is_trial:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Докупка трафика недоступна на пробном периоде',
+        )
+
+    if subscription.traffic_limit_gb == 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='У вас уже безлимитный трафик',
+        )
+
+    # Get traffic price from tariff or settings
+    tariff = None
+    base_price_kopeks = 0
+    is_tariff_mode = settings.is_tariffs_mode() and subscription.tariff_id
+
+    if is_tariff_mode:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if not tariff:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Тариф не найден',
+            )
+
+        if not getattr(tariff, 'traffic_topup_enabled', False):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Докупка трафика недоступна на вашем тарифе',
+            )
+
+        packages = tariff.get_traffic_topup_packages() if hasattr(tariff, 'get_traffic_topup_packages') else {}
+        if request.gb not in packages:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Пакет трафика {request.gb} ГБ недоступен',
+            )
+        base_price_kopeks = packages[request.gb]
+    else:
+        if not settings.is_traffic_topup_enabled():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Докупка трафика отключена',
+            )
+
+        packages = settings.get_traffic_topup_packages()
+        matching_pkg = next((pkg for pkg in packages if pkg['gb'] == request.gb and pkg.get('enabled', True)), None)
+        if not matching_pkg:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Недоступный пакет трафика',
+            )
+        base_price_kopeks = matching_pkg['price']
+
+    # Calculate prorated price (days-based), then apply discount
+    from app.utils.pricing_utils import calculate_prorated_price as _calc_prorated
+
+    now = datetime.now(UTC)
+    days_left = max(1, (subscription.end_date - now).days)
+    prorated_price, _ = _calc_prorated(
+        base_price_kopeks,
+        subscription.end_date,
+    )
+    discount_result = _apply_addon_discount(user, 'traffic', prorated_price, days_left)
+    final_price = discount_result['discounted']
+    traffic_discount_percent = discount_result['percent']
+
+    # Save cart for auto-purchase after balance top-up
+    cart_data = {
+        'cart_mode': 'add_traffic',
+        'subscription_id': subscription.id,
+        'traffic_gb': request.gb,
+        'price_kopeks': final_price,
+        'base_price_kopeks': base_price_kopeks,
+        'discount_percent': traffic_discount_percent,
+        'source': 'cabinet',
+        'description': f'Докупка {request.gb} ГБ трафика',
+    }
+    await user_cart_service.save_user_cart(user.id, cart_data)
+    logger.info('Cart saved for traffic purchase (cabinet save-cart) user +', user_id=user.id, gb=request.gb)
+
+    return {'success': True, 'cart_saved': True}
+
+
+# ============ Traffic Switch (Change Traffic Package) ============
+
+
+@router.put('/traffic')
+async def switch_traffic_package(
+    request: TrafficPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Switch to a different traffic package (change limit)."""
+    from app.utils.pricing_utils import calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    if subscription.is_trial:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Traffic management is only available for paid subscriptions',
+        )
+
+    current_traffic = subscription.traffic_limit_gb or 0
+    new_traffic = request.gb
+
+    if current_traffic == new_traffic:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Already on this traffic package',
+        )
+
+    # Get available packages
+    packages = settings.get_traffic_packages()
+    current_pkg = next((p for p in packages if p['gb'] == current_traffic and p.get('enabled', True)), None)
+    new_pkg = next((p for p in packages if p['gb'] == new_traffic and p.get('enabled', True)), None)
+
+    if not new_pkg:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid traffic package',
+        )
+
+    # Calculate price difference (only charge for upgrade)
+    current_price = current_pkg['price'] if current_pkg else 0
+    new_price = new_pkg['price']
+
+    if new_price > current_price:
+        # Upgrade - charge difference
+        price_diff = new_price - current_price
+
+        # Lock user row to prevent TOCTOU on promo-offer state
+        from app.database.crud.user import lock_user_for_pricing
+
+        user = await lock_user_for_pricing(db, user.id)
+
+        # Apply promo discount via PricingEngine
+        price_diff, _discount_val, traffic_discount_percent = pricing_engine.calculate_traffic_discount(
+            price_diff,
+            user,
+        )
+
+        # Prorated calculation
+        final_price, days_charged = calculate_prorated_price(price_diff, subscription.end_date)
+
+        if user.balance_kopeks < final_price:
+            raise HTTPException(
+                status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                detail=f'Insufficient balance. Need {final_price / 100:.2f} RUB',
+            )
+
+        # Charge balance
+        description = f'Traffic upgrade from {current_traffic}GB to {new_traffic}GB'
+        success = await subtract_user_balance(db, user, final_price, description)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail='Failed to charge balance',
+            )
+
+        # Create transaction
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=final_price,
+            description=description,
+        )
+
+        charged = final_price
+    else:
+        # Downgrade - no charge, no refund
+        charged = 0
+
+    # Update subscription — delete TrafficPurchase records before resetting purchased_traffic_gb
+    from sqlalchemy import delete as sql_delete
+
+    from app.database.models import TrafficPurchase
+
+    await db.execute(sql_delete(TrafficPurchase).where(TrafficPurchase.subscription_id == subscription.id))
+    subscription.traffic_limit_gb = new_traffic
+    subscription.purchased_traffic_gb = 0  # Reset purchased traffic on switch
+    subscription.traffic_reset_at = None  # Reset traffic reset date
+    subscription.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    # Sync with RemnaWave
+    try:
+        subscription_service = SubscriptionService()
+        _panel_uuid2 = (
+            subscription.remnawave_uuid
+            if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _panel_uuid2:
+            await subscription_service.update_remnawave_user(db, subscription)
+        else:
+            await subscription_service.create_remnawave_user(db, subscription)
+    except Exception as e:
+        logger.error('Failed to sync traffic switch with RemnaWave', error=e)
+
+    await db.refresh(user)
+    await db.refresh(subscription)
+
+    return {
+        'success': True,
+        'message': f'Traffic changed from {current_traffic}GB to {new_traffic}GB',
+        'old_traffic_gb': current_traffic,
+        'new_traffic_gb': new_traffic,
+        'charged_kopeks': charged,
+        'balance_kopeks': user.balance_kopeks,
+        'balance_label': settings.format_price(user.balance_kopeks),
+    }
+
+
+# ============ Traffic Refresh ============
+
+# Rate limit: 1 request per 60 seconds per user
+TRAFFIC_REFRESH_RATE_LIMIT = 1
+TRAFFIC_REFRESH_RATE_WINDOW = 60  # seconds
+TRAFFIC_CACHE_TTL = 60  # Cache traffic data for 60 seconds
+
+
+@router.post('/refresh-traffic')
+async def refresh_traffic(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+):
+    """
+    Refresh traffic usage from RemnaWave panel.
+    Rate limited to 1 request per 60 seconds.
+    """
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No active subscription',
+        )
+
+    # Use per-subscription key when subscription_id is available so that refreshing
+    # Sub B is not blocked by a previous refresh of Sub A (multi-tariff mode).
+    cache_suffix = f'{user.id}_{subscription_id}' if subscription_id is not None else str(user.id)
+
+    # Check rate limit
+    is_limited = await RateLimitCache.is_rate_limited(
+        cache_suffix,
+        'traffic_refresh',
+        TRAFFIC_REFRESH_RATE_LIMIT,
+        TRAFFIC_REFRESH_RATE_WINDOW,
+    )
+
+    if is_limited:
+        # Check if we have cached data
+        traffic_cache_key = cache_key('traffic', cache_suffix)
+        cached_data = await cache.get(traffic_cache_key)
+
+        if cached_data:
+            return {
+                'success': True,
+                'cached': True,
+                'rate_limited': True,
+                'retry_after_seconds': TRAFFIC_REFRESH_RATE_WINDOW,
+                **cached_data,
+            }
+
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=f'Rate limited. Try again in {TRAFFIC_REFRESH_RATE_WINDOW} seconds.',
+            headers={'Retry-After': str(TRAFFIC_REFRESH_RATE_WINDOW)},
+        )
+
+    # Fetch traffic from RemnaWave
+    try:
+        remnawave_service = RemnaWaveService()
+
+        # Resolve panel UUID for traffic lookup
+        _traffic_uuid = (
+            subscription.remnawave_uuid
+            if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+            else user.remnawave_uuid
+        )
+        if user.telegram_id and not settings.is_multi_tariff_enabled():
+            traffic_stats = await remnawave_service.get_user_traffic_stats(user.telegram_id)
+        elif _traffic_uuid:
+            traffic_stats = await remnawave_service.get_user_traffic_stats_by_uuid(_traffic_uuid)
+        else:
+            traffic_stats = None
+
+        if not traffic_stats:
+            # Return current database values if RemnaWave unavailable
+            traffic_data = {
+                'traffic_used_bytes': int((subscription.traffic_used_gb or 0) * (1024**3)),
+                'traffic_used_gb': round(subscription.traffic_used_gb or 0, 2),
+                'traffic_limit_bytes': int((subscription.traffic_limit_gb or 0) * (1024**3)),
+                'traffic_limit_gb': subscription.traffic_limit_gb or 0,
+                'traffic_used_percent': round(
+                    ((subscription.traffic_used_gb or 0) / (subscription.traffic_limit_gb or 1)) * 100
+                    if subscription.traffic_limit_gb
+                    else 0,
+                    1,
+                ),
+                'is_unlimited': (subscription.traffic_limit_gb or 0) == 0,
+            }
+            return {
+                'success': True,
+                'cached': False,
+                'source': 'database',
+                **traffic_data,
+            }
+
+        # Update subscription with fresh data
+        used_gb = traffic_stats.get('used_traffic_gb', 0)
+        if abs((subscription.traffic_used_gb or 0) - used_gb) > 0.01:
+            subscription.traffic_used_gb = used_gb
+            subscription.updated_at = datetime.now(UTC)
+            await db.commit()
+
+        # Calculate percentage
+        limit_gb = subscription.traffic_limit_gb or 0
+        if limit_gb > 0:
+            percent = min(100, (used_gb / limit_gb) * 100)
+        else:
+            percent = 0
+
+        traffic_data = {
+            'traffic_used_bytes': traffic_stats.get('used_traffic_bytes', 0),
+            'traffic_used_gb': round(used_gb, 2),
+            'traffic_limit_bytes': traffic_stats.get('traffic_limit_bytes', 0),
+            'traffic_limit_gb': limit_gb,
+            'traffic_used_percent': round(percent, 1),
+            'is_unlimited': limit_gb == 0,
+            'lifetime_used_bytes': traffic_stats.get('lifetime_used_traffic_bytes', 0),
+            'lifetime_used_gb': round(traffic_stats.get('lifetime_used_traffic_gb', 0), 2),
+        }
+
+        # Cache the result
+        traffic_cache_key = cache_key('traffic', cache_suffix)
+        await cache.set(traffic_cache_key, traffic_data, TRAFFIC_CACHE_TTL)
+
+        return {
+            'success': True,
+            'cached': False,
+            'source': 'remnawave',
+            **traffic_data,
+        }
+
+    except Exception as e:
+        logger.error('Error refreshing traffic for user', user_id=user.id, error=e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to refresh traffic data',
+        )

app/cabinet/routes/websocket.py

@@ -317,7 +317,8 @@ async def notify_user_balance_change(
 
 async def notify_user_subscription_activated(
     user_id: int,
-    expires_at: str,
+    subscription_id: int | None = None,
+    expires_at: str = '',
     tariff_name: str = '',
 ) -> None:
     """Уведомить пользователя об активации подписки."""
@@ -325,6 +326,7 @@ async def notify_user_subscription_activated(
         user_id,
         {
             'type': 'subscription.activated',
+            'subscription_id': subscription_id,
             'expires_at': expires_at,
             'tariff_name': tariff_name,
         },
@@ -359,7 +361,8 @@ async def notify_user_subscription_expired(user_id: int) -> None:
 
 async def notify_user_subscription_renewed(
     user_id: int,
-    new_expires_at: str,
+    subscription_id: int | None = None,
+    new_expires_at: str = '',
     amount_kopeks: int = 0,
 ) -> None:
     """Уведомить пользователя о продлении подписки."""
@@ -367,6 +370,7 @@ async def notify_user_subscription_renewed(
         user_id,
         {
             'type': 'subscription.renewed',
+            'subscription_id': subscription_id,
             'new_expires_at': new_expires_at,
             'amount_kopeks': amount_kopeks,
             'amount_rubles': amount_kopeks / 100,

app/cabinet/routes/wheel.py

@@ -5,7 +5,6 @@ API роуты колеса удачи для пользователей.
 import math
 import time
 
-import httpx
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
@@ -50,10 +49,22 @@ async def get_wheel_config(
     # Проверяем доступность
     availability = await wheel_service.check_availability(db, user)
 
-    # Проверяем наличие подписки
-    from app.database.crud.subscription import get_subscription_by_user_id
+    # Проверяем наличие подписки (multi-tariff aware)
+    if settings.is_multi_tariff_enabled():
+        from app.database.crud.subscription import get_active_subscriptions_by_user_id
 
-    subscription = await get_subscription_by_user_id(db, user.id)
+        active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+        # Check if user has any active subscription for wheel access
+        if active_subs:
+            _non_daily = [s for s in active_subs if not getattr(s, 'is_daily_tariff', False)]
+            _pool = _non_daily or active_subs
+            subscription = max(_pool, key=lambda s: s.days_left)
+        else:
+            subscription = None
+    else:
+        from app.database.crud.subscription import get_subscription_by_user_id
+
+        subscription = await get_subscription_by_user_id(db, user.id)
     has_subscription = subscription is not None and subscription.is_active
 
     prizes_display = [
@@ -67,6 +78,14 @@ async def get_wheel_config(
         for p in prizes
     ]
 
+    # Build eligible subscriptions for frontend picker
+    eligible_subs_display = None
+    if availability.eligible_subscriptions:
+        eligible_subs_display = [
+            {'id': s.id, 'tariff_name': s.tariff_name, 'days_left': s.days_left}
+            for s in availability.eligible_subscriptions
+        ]
+
     return WheelConfigResponse(
         is_enabled=config.is_enabled,
         name=config.name,
@@ -84,6 +103,7 @@ async def get_wheel_config(
         user_balance_kopeks=availability.user_balance_kopeks,
         required_balance_kopeks=availability.required_balance_kopeks,
         has_subscription=has_subscription,
+        eligible_subscriptions=eligible_subs_display,
     )
 
 
@@ -115,7 +135,7 @@ async def spin_wheel(
     db: AsyncSession = Depends(get_cabinet_db),
 ):
     """Крутить колесо удачи."""
-    result = await wheel_service.spin(db, user, request.payment_type.value)
+    result = await wheel_service.spin(db, user, request.payment_type.value, subscription_id=request.subscription_id)
 
     if not result.success:
         # Возвращаем ошибку в теле ответа, а не HTTP exception
@@ -220,10 +240,22 @@ async def create_stars_invoice(
             detail='Оплата Stars не включена',
         )
 
-    # Проверяем наличие активной подписки
-    from app.database.crud.subscription import get_subscription_by_user_id
+    # Проверяем наличие активной подписки (multi-tariff aware)
+    if settings.is_multi_tariff_enabled():
+        from app.database.crud.subscription import get_active_subscriptions_by_user_id
 
-    subscription = await get_subscription_by_user_id(db, user.id)
+        active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+        # Check if user has any active subscription for Stars invoice
+        if active_subs:
+            _non_daily = [s for s in active_subs if not getattr(s, 'is_daily_tariff', False)]
+            _pool = _non_daily or active_subs
+            subscription = max(_pool, key=lambda s: s.days_left)
+        else:
+            subscription = None
+    else:
+        from app.database.crud.subscription import get_subscription_by_user_id
+
+        subscription = await get_subscription_by_user_id(db, user.id)
     if not subscription or not subscription.is_active:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -251,44 +283,31 @@ async def create_stars_invoice(
 
     # Создаем invoice через Telegram Bot API
     try:
-        bot_token = settings.BOT_TOKEN
-        api_url = f'https://api.telegram.org/bot{bot_token}/createInvoiceLink'
+        from aiogram.exceptions import TelegramAPIError
+        from aiogram.types import LabeledPrice
 
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                api_url,
-                json={
-                    'title': 'Колесо удачи',
-                    'description': f'Спин колеса удачи ({stars_amount} ⭐)',
-                    'payload': payload,
-                    'provider_token': '',  # Пустой для Stars
-                    'currency': 'XTR',
-                    'prices': [{'label': 'Спин колеса', 'amount': stars_amount}],
-                },
+        from app.bot_factory import create_bot
+
+        async with create_bot() as bot:
+            invoice_url = await bot.create_invoice_link(
+                title='Колесо удачи',
+                description=f'Спин колеса удачи ({stars_amount} ⭐)',
+                payload=payload,
+                provider_token='',
+                currency='XTR',
+                prices=[LabeledPrice(label='Спин колеса', amount=stars_amount)],
             )
 
-            result = response.json()
+        logger.info('Created Stars invoice for wheel spin: user=, stars', user_id=user.id, stars_amount=stars_amount)
 
-            if not result.get('ok'):
-                logger.error('Telegram API error', result=result)
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail='Ошибка создания инвойса',
-                )
+        return StarsInvoiceResponse(
+            invoice_url=invoice_url,
+            stars_amount=stars_amount,
+        )
 
-            invoice_url = result['result']
-            logger.info(
-                'Created Stars invoice for wheel spin: user=, stars', user_id=user.id, stars_amount=stars_amount
-            )
-
-            return StarsInvoiceResponse(
-                invoice_url=invoice_url,
-                stars_amount=stars_amount,
-            )
-
-    except httpx.HTTPError as e:
-        logger.error('HTTP error creating invoice', error=e)
+    except TelegramAPIError as e:
+        logger.error('Error creating invoice', error=e)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail='Ошибка соединения с Telegram',
+            detail='Ошибка создания инвойса',
         )

app/cabinet/routes/withdrawal.py

@@ -70,12 +70,11 @@ async def create_withdrawal(
 
     # Уведомляем админов о запросе на вывод
     try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
         from app.services.admin_notification_service import AdminNotificationService
 
         if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
-            bot = Bot(token=settings.BOT_TOKEN)
+            bot = create_bot()
             try:
                 notification_service = AdminNotificationService(bot)
                 await notification_service.send_withdrawal_request_notification(

app/cabinet/schemas/auth.py

@@ -187,3 +187,28 @@ class EmailChangeResponse(BaseModel):
     message: str = Field(..., description='Success message')
     new_email: str = Field(..., description='New email address pending verification')
     expires_in_minutes: int = Field(..., description='Code expiration time in minutes')
+
+
+class DeepLinkTokenResponse(BaseModel):
+    """Response with deep link auth token."""
+
+    token: str = Field(..., description='One-time auth token')
+    bot_username: str = Field(..., description='Bot username for deep link')
+    expires_in: int = Field(..., description='Token TTL in seconds')
+
+
+class DeepLinkPollRequest(BaseModel):
+    """Request to poll deep link auth status.
+
+    Deep link auth is always for existing bot users — referral codes are not applicable here.
+    Only campaign_slug is supported (campaign bonus can apply to existing users).
+    """
+
+    token: str = Field(..., min_length=16, max_length=128, description='Deep link auth token')
+    campaign_slug: str | None = Field(
+        None,
+        min_length=1,
+        max_length=64,
+        pattern=r'^[a-zA-Z0-9_-]+$',
+        description='Campaign slug captured from cabinet URL',
+    )

app/cabinet/schemas/balance.py

@@ -3,7 +3,7 @@
 from datetime import datetime
 from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class BalanceResponse(BaseModel):
@@ -26,8 +26,7 @@ class TransactionResponse(BaseModel):
     created_at: datetime
     completed_at: datetime | None = None
 
-    class Config:
-        from_attributes = True
+    model_config = ConfigDict(from_attributes=True)
 
 
 class TransactionListResponse(BaseModel):
@@ -114,8 +113,7 @@ class PendingPaymentResponse(BaseModel):
     user_telegram_id: int | None = None
     user_username: str | None = None
 
-    class Config:
-        from_attributes = True
+    model_config = ConfigDict(from_attributes=True)
 
 
 class PendingPaymentListResponse(BaseModel):
@@ -137,3 +135,23 @@ class ManualCheckResponse(BaseModel):
     status_changed: bool = False
     old_status: str | None = None
     new_status: str | None = None
+
+
+class SavedCardResponse(BaseModel):
+    """Saved payment method (card) for recurrent payments."""
+
+    id: int
+    method_type: str
+    card_last4: str | None = None
+    card_type: str | None = None
+    title: str | None = None
+    created_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class SavedCardsListResponse(BaseModel):
+    """List of saved payment methods."""
+
+    cards: list[SavedCardResponse]
+    recurrent_enabled: bool = False

app/cabinet/schemas/broadcasts.py

@@ -3,7 +3,7 @@
 from datetime import datetime
 from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 # ============ Channel Types ============
@@ -75,6 +75,27 @@ class BroadcastButtonsResponse(BaseModel):
     buttons: list[BroadcastButton]
 
 
+class CustomBroadcastButton(BaseModel):
+    """Custom button for broadcast message."""
+
+    label: str = Field(..., min_length=1, max_length=64)
+    action_type: Literal['callback', 'url'] = 'callback'
+    action_value: str = Field(..., min_length=1, max_length=256)
+
+    @field_validator('action_value')
+    @classmethod
+    def validate_action_value(cls, v: str, info) -> str:
+        action_type = info.data.get('action_type', 'callback')
+        if action_type == 'url':
+            if not v.startswith(('https://', 'tg://')):
+                raise ValueError('URL must start with https:// or tg://')
+        elif action_type == 'callback':
+            # Telegram API limits callback_data to 64 bytes
+            if len(v.encode('utf-8')) > 64:
+                raise ValueError('Callback data must be at most 64 bytes')
+        return v
+
+
 # ============ Media ============
 
 
@@ -95,6 +116,7 @@ class BroadcastCreateRequest(BaseModel):
     target: str
     message_text: str = Field(..., min_length=1, max_length=4000)
     selected_buttons: list[str] = Field(default_factory=lambda: ['home'])
+    custom_buttons: list[CustomBroadcastButton] = Field(default_factory=list, max_length=10)
     media: BroadcastMediaRequest | None = None
 
 
@@ -187,6 +209,7 @@ class CombinedBroadcastCreateRequest(BaseModel):
     # Telegram-specific fields
     message_text: str | None = Field(default=None, max_length=4000)
     selected_buttons: list[str] = Field(default_factory=lambda: ['home'])
+    custom_buttons: list[CustomBroadcastButton] = Field(default_factory=list, max_length=10)
     media: BroadcastMediaRequest | None = None
 
     # Email-specific fields

app/cabinet/schemas/gift.py

@@ -0,0 +1,131 @@
+"""Schemas for cabinet gift subscription feature."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class GiftConfigSubOption(BaseModel):
+    id: str
+    name: str
+
+
+class GiftConfigTariffPeriod(BaseModel):
+    days: int
+    price_kopeks: int
+    price_label: str
+    original_price_kopeks: int | None = None
+    discount_percent: int | None = None
+
+
+class GiftConfigTariff(BaseModel):
+    id: int
+    name: str
+    description: str | None = None
+    traffic_limit_gb: int
+    device_limit: int
+    periods: list[GiftConfigTariffPeriod]
+
+
+class GiftConfigPaymentMethod(BaseModel):
+    method_id: str
+    display_name: str
+    description: str | None = None
+    icon_url: str | None = None
+    min_amount_kopeks: int | None = None
+    max_amount_kopeks: int | None = None
+    sub_options: list[GiftConfigSubOption] | None = None
+
+
+class GiftConfigResponse(BaseModel):
+    is_enabled: bool
+    tariffs: list[GiftConfigTariff] = []
+    payment_methods: list[GiftConfigPaymentMethod] = []
+    balance_kopeks: int = 0
+    currency_symbol: str = '\u20bd'
+    promo_group_name: str | None = None
+    active_discount_percent: int | None = None
+    active_discount_expires_at: datetime | None = None
+
+
+class GiftPurchaseRequest(BaseModel):
+    tariff_id: int = Field(gt=0)
+    period_days: int = Field(gt=0, le=3650)
+    recipient_type: str | None = Field(default=None, pattern=r'^(email|telegram)$')
+    recipient_value: str | None = Field(default=None, max_length=255)
+    gift_message: str | None = Field(default=None, max_length=1000)
+    payment_mode: str = Field(pattern=r'^(balance|gateway)$')
+    payment_method: str | None = Field(default=None, max_length=50)
+
+    @model_validator(mode='after')
+    def validate_payment(self) -> GiftPurchaseRequest:
+        if self.payment_mode == 'gateway' and not self.payment_method:
+            raise ValueError('payment_method is required for gateway mode')
+        return self
+
+
+class GiftPurchaseResponse(BaseModel):
+    status: str
+    purchase_token: str
+    payment_url: str | None = None
+    warning: str | None = None
+
+
+class GiftPurchaseStatusResponse(BaseModel):
+    status: str
+    is_gift: bool = True
+    is_code_only: bool = False
+    purchase_token: str | None = None
+    recipient_contact_value: str | None = None
+    gift_message: str | None = None
+    tariff_name: str | None = None
+    period_days: int | None = None
+    warning: str | None = None
+
+
+class PendingGiftResponse(BaseModel):
+    token: str
+    tariff_name: str | None = None
+    period_days: int
+    gift_message: str | None = None
+    sender_display: str | None = None
+    created_at: datetime | None = None
+
+
+class SentGiftResponse(BaseModel):
+    """A gift the current user has sent."""
+
+    token: str
+    tariff_name: str | None = None
+    period_days: int
+    device_limit: int = 1
+    status: str
+    gift_recipient_value: str | None = None
+    gift_message: str | None = None
+    activated_by_username: str | None = None
+    created_at: datetime | None = None
+
+
+class ReceivedGiftResponse(BaseModel):
+    """A gift the current user has received."""
+
+    token: str
+    tariff_name: str | None = None
+    period_days: int
+    device_limit: int = 1
+    status: str
+    sender_display: str | None = None
+    gift_message: str | None = None
+    created_at: datetime | None = None
+
+
+class ActivateGiftRequest(BaseModel):
+    code: str = Field(min_length=1, max_length=100)
+
+
+class ActivateGiftResponse(BaseModel):
+    status: str
+    tariff_name: str | None = None
+    period_days: int | None = None

app/cabinet/schemas/news.py

@@ -0,0 +1,332 @@
+"""Schemas for news articles in cabinet.
+
+Security notes:
+- featured_image_url is validated to only accept http/https schemes.
+- category_color is validated as a strict hex color (#RGB, #RRGGBB, etc.).
+- Slug is sanitized to only allow [a-zA-Z0-9_-].
+- Content is server-side sanitized to strip <script>, event handlers, and
+  dangerous URI schemes as a defense-in-depth measure. The frontend also
+  sanitizes via DOMPurify, but server-side sanitization protects against
+  alternative consumers (mobile apps, RSS, email digests) and compromised
+  frontends.
+"""
+
+import re
+from datetime import datetime
+from urllib.parse import urlparse
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+
+# Pre-compiled regex for hex color validation (reused across validators)
+_HEX_COLOR_RE: re.Pattern[str] = re.compile(r'^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$')
+
+# Pre-compiled regex for collapsing repeated hyphens in slugs
+_MULTI_HYPHEN_RE: re.Pattern[str] = re.compile(r'-+')
+
+# Maximum slug length (matches DB column constraint)
+_MAX_SLUG_LENGTH: int = 500
+
+# Allowed URL schemes for user-supplied URLs (featured_image_url)
+_SAFE_URL_SCHEMES: frozenset[str] = frozenset({'http', 'https'})
+
+# Cyrillic-to-Latin transliteration map for slug generation
+_TRANSLIT_MAP: dict[str, str] = {
+    'а': 'a',
+    'б': 'b',
+    'в': 'v',
+    'г': 'g',
+    'д': 'd',
+    'е': 'e',
+    'ё': 'yo',
+    'ж': 'zh',
+    'з': 'z',
+    'и': 'i',
+    'й': 'y',
+    'к': 'k',
+    'л': 'l',
+    'м': 'm',
+    'н': 'n',
+    'о': 'o',
+    'п': 'p',
+    'р': 'r',
+    'с': 's',
+    'т': 't',
+    'у': 'u',
+    'ф': 'f',
+    'х': 'kh',
+    'ц': 'ts',
+    'ч': 'ch',
+    'ш': 'sh',
+    'щ': 'shch',
+    'ъ': '',
+    'ы': 'y',
+    'ь': '',
+    'э': 'e',
+    'ю': 'yu',
+    'я': 'ya',
+}
+
+
+def _slugify(title: str) -> str:
+    """Generate a URL-safe slug from a title, transliterating Cyrillic."""
+    slug = title.lower()
+    result: list[str] = []
+    for ch in slug:
+        if ch in _TRANSLIT_MAP:
+            result.append(_TRANSLIT_MAP[ch])
+        elif ch.isascii() and (ch.isalnum() or ch in '-_'):
+            result.append(ch)
+        elif ch == ' ':
+            result.append('-')
+    slug = ''.join(result)
+    slug = _MULTI_HYPHEN_RE.sub('-', slug).strip('-')
+    return slug[:_MAX_SLUG_LENGTH] or 'untitled'
+
+
+def _validate_hex_color(v: str) -> str:
+    """Validate a hex color string. Raises ValueError on invalid input."""
+    if not _HEX_COLOR_RE.match(v):
+        msg = 'category_color must be a valid hex color (e.g. #00e5a0)'
+        raise ValueError(msg)
+    return v
+
+
+def _validate_safe_url(v: str) -> str:
+    """Validate that a URL uses http or https scheme only.
+
+    Prevents javascript:, data:, vbscript:, and other dangerous URI schemes
+    from being stored in the database and later rendered in <img> or <a> tags.
+    """
+    try:
+        parsed = urlparse(v)
+    except Exception:
+        msg = 'Invalid URL format'
+        raise ValueError(msg)
+
+    if parsed.scheme not in _SAFE_URL_SCHEMES:
+        msg = f'URL scheme must be http or https, got: {parsed.scheme!r}'
+        raise ValueError(msg)
+
+    if not parsed.netloc:
+        msg = 'URL must have a valid host'
+        raise ValueError(msg)
+
+    return v
+
+
+# --- Server-side HTML content sanitization ---
+# Pre-compiled patterns for stripping the most dangerous HTML constructs.
+# This is a defense-in-depth measure: the frontend also sanitizes via DOMPurify.
+# Uses regex rather than a full HTML parser to avoid adding a new dependency.
+# Strips: <script>, <style>, <object>, <embed>, <applet>, <base>, <form>,
+# <link>, <meta> tags and all on* event handler attributes.
+_DANGEROUS_TAGS_RE: re.Pattern[str] = re.compile(
+    r'<\s*/?\s*(script|style|object|embed|applet|base|form|link(?:\s)|meta)\b[^>]*>',
+    re.IGNORECASE | re.DOTALL,
+)
+# Match on* event handler attributes, e.g. onclick="...", onerror='...'
+_EVENT_HANDLER_RE: re.Pattern[str] = re.compile(
+    r'\s+on[a-z]+\s*=\s*(?:"[^"]*"|\'[^\']*\'|[^\s>]+)',
+    re.IGNORECASE,
+)
+# Match javascript:, vbscript:, data: in href/src attributes
+_DANGEROUS_URI_RE: re.Pattern[str] = re.compile(
+    r'((?:href|src)\s*=\s*["\'])\s*(javascript|vbscript|data)\s*:',
+    re.IGNORECASE,
+)
+
+
+def _sanitize_html_content(html: str) -> str:
+    """Strip dangerous HTML constructs from article content.
+
+    This is NOT a replacement for DOMPurify on the frontend. It is a
+    defense-in-depth layer that removes the most obvious XSS vectors
+    at the storage boundary. A full HTML sanitizer (nh3, bleach) would
+    be stronger, but this avoids adding a new dependency.
+    """
+    if not html:
+        return html
+
+    # 1. Remove dangerous tags and their content
+    result = _DANGEROUS_TAGS_RE.sub('', html)
+
+    # Also strip <script>...</script> content (tag + body)
+    result = re.sub(r'<script\b[^>]*>[\s\S]*?</script>', '', result, flags=re.IGNORECASE)
+    result = re.sub(r'<style\b[^>]*>[\s\S]*?</style>', '', result, flags=re.IGNORECASE)
+
+    # 2. Remove event handler attributes
+    result = _EVENT_HANDLER_RE.sub('', result)
+
+    # 3. Neutralize dangerous URI schemes in href/src
+    result = _DANGEROUS_URI_RE.sub(r'\1about:', result)
+
+    return result
+
+
+class NewsArticleResponse(BaseModel):
+    """Full news article response (detail view)."""
+
+    id: int
+    title: str
+    slug: str
+    content: str
+    excerpt: str | None
+    category: str
+    category_color: str
+    tag: str | None
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None
+    is_published: bool
+    is_featured: bool
+    published_at: datetime | None
+    read_time_minutes: int
+    views_count: int
+    author_name: str | None = None
+    created_at: datetime
+    updated_at: datetime | None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class NewsArticleListItem(BaseModel):
+    """Compact news article for list views."""
+
+    id: int
+    title: str
+    slug: str
+    excerpt: str | None
+    category: str
+    category_color: str
+    tag: str | None
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None
+    is_published: bool
+    is_featured: bool
+    published_at: datetime | None
+    read_time_minutes: int
+    views_count: int
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class NewsListResponse(BaseModel):
+    """Paginated list of news articles."""
+
+    items: list[NewsArticleListItem]
+    total: int
+    categories: list[str] = Field(default_factory=list)
+
+
+class NewsCreateRequest(BaseModel):
+    """Request to create a news article."""
+
+    title: str = Field(..., min_length=1, max_length=500)
+    slug: str | None = Field(None, min_length=1, max_length=500)
+    content: str = Field(default='', max_length=500_000)
+    excerpt: str | None = Field(None, max_length=1000)
+    category: str = Field(..., min_length=1, max_length=100)
+    category_color: str = Field(default='#00e5a0', max_length=20)
+    tag: str | None = Field(None, max_length=50)
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None = Field(None, max_length=2000)
+    is_published: bool = False
+    is_featured: bool = False
+    read_time_minutes: int = Field(default=1, ge=1, le=60)
+
+    @field_validator('content')
+    @classmethod
+    def sanitize_content(cls, v: str) -> str:
+        """Strip dangerous HTML from article content (defense-in-depth)."""
+        return _sanitize_html_content(v)
+
+    @field_validator('category_color')
+    @classmethod
+    def validate_hex_color(cls, v: str) -> str:
+        return _validate_hex_color(v)
+
+    @field_validator('featured_image_url')
+    @classmethod
+    def validate_featured_image_url(cls, v: str | None) -> str | None:
+        """Reject javascript:, data:, and other dangerous URL schemes."""
+        if v is not None:
+            return _validate_safe_url(v)
+        return v
+
+    @model_validator(mode='before')
+    @classmethod
+    def auto_generate_slug(cls, data: dict) -> dict:  # type: ignore[type-arg]
+        """Generate slug from title when not explicitly provided."""
+        if isinstance(data, dict) and not data.get('slug'):
+            title = data.get('title', '')
+            data['slug'] = _slugify(title) if isinstance(title, str) else 'untitled'
+        return data
+
+    @field_validator('slug')
+    @classmethod
+    def sanitize_slug(cls, v: str | None) -> str | None:
+        """Ensure slug contains only URL-safe characters, transliterating Cyrillic."""
+        if v is not None:
+            return _slugify(v)
+        return v
+
+
+class NewsUpdateRequest(BaseModel):
+    """Request to update a news article."""
+
+    title: str | None = Field(None, min_length=1, max_length=500)
+    slug: str | None = Field(None, min_length=1, max_length=500)
+    content: str | None = Field(None, max_length=500_000)
+    excerpt: str | None = None
+    category: str | None = Field(None, min_length=1, max_length=100)
+    category_color: str | None = Field(None, max_length=20)
+    tag: str | None = None
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None = Field(None, max_length=2000)
+    is_published: bool | None = None
+    is_featured: bool | None = None
+    read_time_minutes: int | None = Field(None, ge=1, le=60)
+
+    @field_validator('content')
+    @classmethod
+    def sanitize_content(cls, v: str | None) -> str | None:
+        """Strip dangerous HTML from article content (defense-in-depth)."""
+        if v is not None:
+            return _sanitize_html_content(v)
+        return v
+
+    @field_validator('category_color')
+    @classmethod
+    def validate_hex_color(cls, v: str | None) -> str | None:
+        if v is not None:
+            return _validate_hex_color(v)
+        return v
+
+    @field_validator('featured_image_url')
+    @classmethod
+    def validate_featured_image_url(cls, v: str | None) -> str | None:
+        """Reject javascript:, data:, and other dangerous URL schemes."""
+        if v is not None:
+            return _validate_safe_url(v)
+        return v
+
+    @field_validator('slug')
+    @classmethod
+    def sanitize_slug(cls, v: str | None) -> str | None:
+        """Ensure slug contains only URL-safe characters, transliterating Cyrillic."""
+        if v is not None:
+            return _slugify(v)
+        return v
+
+
+class NewsToggleResponse(BaseModel):
+    """Response after toggling publish/featured status."""
+
+    id: int
+    is_published: bool
+    is_featured: bool
+    published_at: datetime | None

app/cabinet/schemas/news_categories.py

@@ -0,0 +1,48 @@
+"""Schemas for news categories."""
+
+import re
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+_HEX_COLOR_RE: re.Pattern[str] = re.compile(r'^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$')
+
+
+class NewsCategoryCreate(BaseModel):
+    """Request to create a news category."""
+
+    name: str = Field(..., min_length=1, max_length=100)
+    color: str = Field(default='#00e5a0', max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str) -> str:
+        if not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsCategoryUpdate(BaseModel):
+    """Request to update a news category."""
+
+    name: str | None = Field(None, min_length=1, max_length=100)
+    color: str | None = Field(None, max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str | None) -> str | None:
+        if v is not None and not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsCategoryResponse(BaseModel):
+    """News category response."""
+
+    id: int
+    name: str
+    color: str
+
+    model_config = ConfigDict(from_attributes=True)

app/cabinet/schemas/news_media.py

@@ -0,0 +1,17 @@
+"""Schemas for news media upload responses."""
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class NewsMediaUploadResponse(BaseModel):
+    """Response returned after a successful media upload."""
+
+    url: str
+    thumbnail_url: str | None = None
+    media_type: Literal['image', 'video']
+    filename: str
+    size_bytes: int
+    width: int | None = None
+    height: int | None = None

app/cabinet/schemas/news_tags.py

@@ -0,0 +1,48 @@
+"""Schemas for news tags."""
+
+import re
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+_HEX_COLOR_RE: re.Pattern[str] = re.compile(r'^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$')
+
+
+class NewsTagCreate(BaseModel):
+    """Request to create a news tag."""
+
+    name: str = Field(..., min_length=1, max_length=50)
+    color: str = Field(default='#94a3b8', max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str) -> str:
+        if not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsTagUpdate(BaseModel):
+    """Request to update a news tag."""
+
+    name: str | None = Field(None, min_length=1, max_length=50)
+    color: str | None = Field(None, max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str | None) -> str | None:
+        if v is not None and not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsTagResponse(BaseModel):
+    """News tag response."""
+
+    id: int
+    name: str
+    color: str
+
+    model_config = ConfigDict(from_attributes=True)

app/cabinet/schemas/referral.py

@@ -10,6 +10,7 @@ class ReferralInfoResponse(BaseModel):
 
     referral_code: str
     referral_link: str
+    bot_referral_link: str = ''
     total_referrals: int
     active_referrals: int
     total_earnings_kopeks: int
@@ -80,4 +81,5 @@ class ReferralTermsResponse(BaseModel):
     first_topup_bonus_rubles: float
     inviter_bonus_kopeks: int
     inviter_bonus_rubles: float
+    max_commission_payments: int = 0
     partner_section_visible: bool = True

app/cabinet/schemas/remnawave.py

@@ -47,11 +47,9 @@ class ServerInfo(BaseModel):
     """Server hardware info."""
 
     cpu_cores: int
-    cpu_physical_cores: int
     memory_total: int
     memory_used: int
     memory_free: int
-    memory_available: int
     uptime_seconds: int
 
 
@@ -108,22 +106,22 @@ class NodeInfo(BaseModel):
     is_disabled: bool
     is_node_online: bool
     is_xray_running: bool
-    users_online: int | None = None
+    users_online: int = 0
     traffic_used_bytes: int | None = None
     traffic_limit_bytes: int | None = None
     last_status_change: datetime | None = None
     last_status_message: str | None = None
-    xray_uptime: str | None = None
+    xray_uptime: int = 0
     is_traffic_tracking_active: bool = False
     traffic_reset_day: int | None = None
     notify_percent: int | None = None
     consumption_multiplier: float = 1.0
-    cpu_count: int | None = None
-    cpu_model: str | None = None
-    total_ram: str | None = None
     created_at: datetime | None = None
     updated_at: datetime | None = None
     provider_uuid: str | None = None
+    versions: dict[str, str] | None = None
+    system: dict[str, Any] | None = None
+    active_plugin_uuid: str | None = None
 
 
 class NodesListResponse(BaseModel):

app/cabinet/schemas/subscription.py

@@ -48,6 +48,7 @@ class SubscriptionData(BaseModel):
     hide_subscription_link: bool = False  # Скрывать ли отображение ссылки (но кнопки работают)
     is_active: bool
     is_expired: bool
+    is_limited: bool = False
     traffic_purchases: list[TrafficPurchaseInfo] = []
     # Daily tariff fields
     is_daily: bool = False
@@ -87,6 +88,10 @@ class RenewalRequest(BaseModel):
     """Request to renew subscription."""
 
     period_days: int = Field(..., ge=1, le=3650, description='Renewal period in days')
+    subscription_id: int | None = Field(
+        default=None,
+        description='ID of subscription to renew (required in multi-tariff mode)',
+    )
 
 
 class TrafficPackageResponse(BaseModel):

app/cabinet/schemas/tariffs.py

@@ -54,6 +54,7 @@ class TariffListItem(BaseModel):
     is_daily: bool = False
     daily_price_kopeks: int = 0
     allow_traffic_topup: bool = True
+    show_in_gift: bool = True
     traffic_limit_gb: int
     device_limit: int
     tier_level: int
@@ -111,9 +112,11 @@ class TariffDetailResponse(BaseModel):
     is_daily: bool = False
     daily_price_kopeks: int = 0
     # Режим сброса трафика
-    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
     # Внешний сквад RemnaWave
     external_squad_uuid: str | None = None
+    # Показывать в подарках
+    show_in_gift: bool = True
     created_at: datetime
     updated_at: datetime | None = None
 
@@ -167,9 +170,11 @@ class TariffCreateRequest(BaseModel):
     is_daily: bool = False
     daily_price_kopeks: int = Field(0, ge=0)
     # Режим сброса трафика
-    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
     # Внешний сквад RemnaWave
     external_squad_uuid: str | None = Field(None, pattern=UUID_PATTERN)
+    # Показывать в подарках
+    show_in_gift: bool = True
 
 
 class TariffUpdateRequest(BaseModel):
@@ -206,9 +211,11 @@ class TariffUpdateRequest(BaseModel):
     is_daily: bool | None = None
     daily_price_kopeks: int | None = Field(None, ge=0)
     # Режим сброса трафика
-    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
     # Внешний сквад RemnaWave
     external_squad_uuid: str | None = Field(None, pattern=UUID_PATTERN)
+    # Показывать в подарках
+    show_in_gift: bool | None = None
 
 
 class TariffSortOrderRequest(BaseModel):
@@ -243,3 +250,15 @@ class TariffStatsResponse(BaseModel):
     trial_subscriptions: int
     revenue_kopeks: int
     revenue_rubles: float
+
+
+class SyncSquadsResponse(BaseModel):
+    """Response after syncing squads for tariff subscriptions."""
+
+    tariff_id: int
+    tariff_name: str
+    total_subscriptions: int
+    updated_count: int
+    failed_count: int
+    skipped_count: int
+    errors: list[str] = Field(default_factory=list)

app/cabinet/schemas/traffic.py

@@ -9,18 +9,31 @@ class TrafficNodeInfo(BaseModel):
     country_code: str
 
 
+class SubscriptionTrafficInfo(BaseModel):
+    """Per-subscription traffic metadata for multi-subscription display."""
+
+    subscription_id: int
+    tariff_name: str | None
+    status: str | None
+    traffic_limit_gb: float
+    device_limit: int
+
+
 class UserTrafficItem(BaseModel):
     user_id: int
     telegram_id: int | None
     username: str | None
     email: str | None
     full_name: str
+    # Primary subscription fields (backward compat — reflect the active/first sub)
     tariff_name: str | None
     subscription_status: str | None
     traffic_limit_gb: float
     device_limit: int
     node_traffic: dict[str, int]  # {node_uuid: total_bytes}
     total_bytes: int
+    # All subscriptions for multi-subscription display
+    subscriptions: list[SubscriptionTrafficInfo] = Field(default_factory=list)
 
 
 class TrafficUsageResponse(BaseModel):
@@ -34,12 +47,24 @@ class TrafficUsageResponse(BaseModel):
     available_statuses: list[str]
 
 
+class SubscriptionEnrichmentInfo(BaseModel):
+    """Per-subscription enrichment (dates) for multi-subscription display."""
+
+    subscription_id: int
+    tariff_name: str | None
+    start_date: str | None
+    end_date: str | None
+
+
 class UserTrafficEnrichment(BaseModel):
     devices_connected: int = 0
     total_spent_kopeks: int = 0
+    # Primary subscription dates (backward compat — reflect the active/first sub)
     subscription_start_date: str | None = None
     subscription_end_date: str | None = None
     last_node_name: str | None = None
+    # All subscriptions for multi-subscription display
+    subscriptions: list[SubscriptionEnrichmentInfo] = Field(default_factory=list)
 
 
 class TrafficEnrichmentResponse(BaseModel):

app/cabinet/schemas/users.py

@@ -1,13 +1,13 @@
 """Schemas for Admin Users management in cabinet."""
 
 from datetime import datetime
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, Field
 
 
-class UserStatusEnum(str, Enum):
+class UserStatusEnum(StrEnum):
     """User status enum."""
 
     ACTIVE = 'active'
@@ -15,17 +15,18 @@ class UserStatusEnum(str, Enum):
     DELETED = 'deleted'
 
 
-class SubscriptionStatusEnum(str, Enum):
+class SubscriptionStatusEnum(StrEnum):
     """Subscription status enum."""
 
     TRIAL = 'trial'
     ACTIVE = 'active'
     EXPIRED = 'expired'
     DISABLED = 'disabled'
+    LIMITED = 'limited'
     PENDING = 'pending'
 
 
-class SortByEnum(str, Enum):
+class SortByEnum(StrEnum):
     """Sort options for users list."""
 
     CREATED_AT = 'created_at'
@@ -176,9 +177,12 @@ class UserDetailResponse(BaseModel):
     last_activity: datetime | None = None
     cabinet_last_login: datetime | None = None
 
-    # Subscription
+    # Subscription (legacy single, kept for backward compat)
     subscription: UserSubscriptionInfo | None = None
 
+    # All subscriptions (multi-tariff)
+    subscriptions: list[UserSubscriptionInfo] = []
+
     # Promo group
     promo_group: UserPromoGroupInfo | None = None
 
@@ -281,9 +285,12 @@ class UpdateSubscriptionRequest(BaseModel):
     """Request to update user subscription."""
 
     action: str = Field(
-        ..., description='Action: extend, set_end_date, change_tariff, set_traffic, toggle_autopay, cancel'
+        ..., description='Action: extend, shorten, set_end_date, change_tariff, set_traffic, toggle_autopay, cancel'
     )
 
+    # Target subscription (required in multi-tariff mode for non-create actions)
+    subscription_id: int | None = Field(None, description='Subscription ID to target (multi-tariff)')
+
     # For extend action
     days: int | None = Field(None, ge=1, le=3650, description='Days to extend')
 
@@ -386,6 +393,37 @@ class UpdateReferralCommissionResponse(BaseModel):
     message: str
 
 
+class AssignReferrerRequest(BaseModel):
+    """Request to manually assign a referrer to a user."""
+
+    referrer_id: int = Field(..., gt=0, description='ID of the referrer user')
+
+
+class AssignReferrerResponse(BaseModel):
+    """Response after referrer assignment."""
+
+    success: bool
+    old_referrer_id: int | None = None
+    new_referrer_id: int | None = None
+    message: str
+
+
+class RemoveReferrerResponse(BaseModel):
+    """Response after removing a user's referrer."""
+
+    success: bool
+    old_referrer_id: int | None = None
+    message: str
+
+
+class RemoveReferralResponse(BaseModel):
+    """Response after removing a specific referral from a user."""
+
+    success: bool
+    removed_user_id: int
+    message: str
+
+
 class DeviceInfo(BaseModel):
     """Individual device info."""
 
@@ -607,6 +645,10 @@ class PanelSyncStatusResponse(BaseModel):
     remnawave_uuid: str | None = None
     last_sync: datetime | None = None
 
+    # Multi-tariff context
+    subscription_id: int | None = None
+    subscription_tariff_name: str | None = None
+
     # Bot data
     bot_subscription_status: str | None = None
     bot_subscription_end_date: datetime | None = None
@@ -696,3 +738,40 @@ class DisableUserResponse(BaseModel):
     panel_deactivated: bool = False
     user_blocked: bool = False
     panel_error: str | None = None
+
+
+# === Gifts ===
+
+
+class AdminUserGiftItem(BaseModel):
+    """Gift item for admin user detail view."""
+
+    id: int
+    token: str
+    status: str
+    tariff_name: str | None = None
+    period_days: int
+    device_limit: int = 1
+    amount_kopeks: int
+    payment_method: str | None = None
+    gift_recipient_type: str | None = None
+    gift_recipient_value: str | None = None
+    gift_message: str | None = None
+    buyer_user_id: int | None = None
+    buyer_username: str | None = None
+    buyer_full_name: str | None = None
+    receiver_user_id: int | None = None
+    receiver_username: str | None = None
+    receiver_full_name: str | None = None
+    created_at: datetime | None = None
+    paid_at: datetime | None = None
+    delivered_at: datetime | None = None
+
+
+class AdminUserGiftsResponse(BaseModel):
+    """Response with sent and received gifts for admin user detail."""
+
+    sent: list[AdminUserGiftItem] = []
+    received: list[AdminUserGiftItem] = []
+    sent_total: int = 0
+    received_total: int = 0

app/cabinet/schemas/wheel.py

@@ -1,7 +1,7 @@
 """Схемы для колеса удачи (Fortune Wheel)."""
 
 from datetime import datetime
-from enum import Enum
+from enum import StrEnum
 
 from pydantic import BaseModel, Field
 
@@ -9,14 +9,14 @@ from pydantic import BaseModel, Field
 # ==================== ENUMS ====================
 
 
-class WheelPaymentType(str, Enum):
+class WheelPaymentType(StrEnum):
     """Способы оплаты спина."""
 
     TELEGRAM_STARS = 'telegram_stars'
     SUBSCRIPTION_DAYS = 'subscription_days'
 
 
-class WheelPrizeType(str, Enum):
+class WheelPrizeType(StrEnum):
     """Типы призов."""
 
     SUBSCRIPTION_DAYS = 'subscription_days'
@@ -61,6 +61,7 @@ class WheelConfigResponse(BaseModel):
     user_balance_kopeks: int = 0
     required_balance_kopeks: int = 0
     has_subscription: bool = False
+    eligible_subscriptions: list[dict] | None = None
 
 
 class SpinAvailabilityResponse(BaseModel):
@@ -81,6 +82,7 @@ class SpinRequest(BaseModel):
     """Запрос на спин."""
 
     payment_type: WheelPaymentType
+    subscription_id: int | None = None
 
 
 class SpinResultResponse(BaseModel):

app/cabinet/services/email_service.py

@@ -17,14 +17,33 @@ logger = structlog.get_logger(__name__)
 class EmailService:
     """Service for sending emails via SMTP."""
 
-    def __init__(self):
-        self.host = settings.SMTP_HOST
-        self.port = settings.SMTP_PORT
-        self.user = settings.SMTP_USER
-        self.password = settings.SMTP_PASSWORD
-        self.from_email = settings.get_smtp_from_email()
-        self.from_name = settings.SMTP_FROM_NAME
-        self.use_tls = settings.SMTP_USE_TLS
+    @property
+    def host(self) -> str | None:
+        return settings.SMTP_HOST
+
+    @property
+    def port(self) -> int:
+        return settings.SMTP_PORT
+
+    @property
+    def user(self) -> str | None:
+        return settings.SMTP_USER
+
+    @property
+    def password(self) -> str | None:
+        return settings.SMTP_PASSWORD
+
+    @property
+    def from_email(self) -> str | None:
+        return settings.get_smtp_from_email()
+
+    @property
+    def from_name(self) -> str:
+        return settings.SMTP_FROM_NAME
+
+    @property
+    def use_tls(self) -> bool:
+        return settings.SMTP_USE_TLS
 
     def is_configured(self) -> bool:
         """Check if SMTP is properly configured."""
@@ -71,6 +90,11 @@ class EmailService:
             logger.warning('SMTP is not configured, cannot send email')
             return False
 
+        sender_email = self.from_email
+        if not sender_email or '@' not in sender_email:
+            logger.error('Invalid or missing SMTP from_email, cannot send email', from_email=sender_email)
+            return False
+
         # Defensive: strip newlines to prevent header injection
         to_email = to_email.strip().replace('\n', '').replace('\r', '')
         subject = subject.replace('\n', '').replace('\r', '')
@@ -79,11 +103,11 @@ class EmailService:
             msg = MIMEMultipart('alternative')
             msg['Subject'] = subject
             safe_from_name = self.from_name.replace('\n', '').replace('\r', '') if self.from_name else ''
-            safe_from_email = self.from_email.replace('\n', '').replace('\r', '') if self.from_email else ''
+            safe_from_email = sender_email.replace('\n', '').replace('\r', '')
             msg['From'] = f'{safe_from_name} <{safe_from_email}>'
             msg['To'] = to_email
             msg['Date'] = formatdate(localtime=False)
-            msg['Message-ID'] = make_msgid(domain=self.from_email.split('@')[-1])
+            msg['Message-ID'] = make_msgid(domain=safe_from_email.split('@')[-1])
 
             # Plain text version
             if body_text is None:
@@ -103,7 +127,7 @@ class EmailService:
             msg.attach(part2)
 
             with self._get_smtp_connection() as smtp:
-                smtp.sendmail(self.from_email, to_email, msg.as_string())
+                smtp.sendmail(safe_from_email, to_email, msg.as_string())
 
             logger.info('Email sent successfully to', to_email=to_email)
             return True

app/cabinet/services/email_template_overrides.py

@@ -198,7 +198,7 @@ async def get_rendered_override(
         for key, value in context.items():
             body_html = body_html.replace(f'{{{key}}}', html.escape(str(value)))
 
-    rendered = templates._get_base_template(body_html, language)
+    rendered = templates._wrap_override_template(body_html, language)
     subject = override['subject']
 
     # Also substitute in subject

app/cabinet/services/email_templates.py

@@ -74,6 +74,39 @@ class EmailNotificationTemplates:
 
         return template_func(language, context)
 
+    def _wrap_override_template(self, content: str, language: str = 'ru') -> str:
+        """Wrap override template content appropriately based on its structure.
+
+        Three-tier detection:
+        1. Full HTML document (<!DOCTYPE or <html>) — return as-is, no wrapping
+        2. Styled content (has <style> tag or background CSS) — minimal HTML wrapper
+           without forced colors, headers, or footers
+        3. Simple HTML fragment — wrap with base template (header, footer, white bg)
+           for backward compatibility
+        """
+        content_stripped = content.strip()
+        content_lower = content_stripped.lower()
+
+        # Tier 1: Full HTML document — return as-is
+        if content_lower.startswith('<!doctype') or content_lower.startswith('<html'):
+            return content_stripped
+
+        # Tier 2: Styled content — minimal wrapper without forced styling
+        if '<style' in content_lower or 'background' in content_lower:
+            return f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body style="margin: 0; padding: 0;">
+    {content}
+</body>
+</html>"""
+
+        # Tier 3: Simple HTML fragment — use base template for structure
+        return self._get_base_template(content, language)
+
     def _get_base_template(self, content: str, language: str = 'ru') -> str:
         """Wrap content in base HTML template."""
         footer_texts = {
@@ -318,18 +351,26 @@ class EmailNotificationTemplates:
         """Template for subscription expiring notification."""
         days_left = context.get('days_left', 0)
         expires_at = context.get('expires_at', '')
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_zh = f'<p>套餐: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_ua = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
 
         subjects = {
-            'ru': f'Подписка истекает через {days_left} дн.',
-            'en': f'Subscription expires in {days_left} day(s)',
+            'ru': f'Подписка{tariff_suffix_ru} истекает через {days_left} дн.',
+            'en': f'Subscription{tariff_suffix_en} expires in {days_left} day(s)',
             'zh': f'订阅将在 {days_left} 天后到期',
-            'ua': f'Підписка закінчується через {days_left} дн.',
+            'ua': f'Підписка{tariff_suffix_ru} закінчується через {days_left} дн.',
         }
 
         bodies = {
             'ru': f"""
                 <h2>Подписка скоро истекает</h2>
                 <div class="highlight warning">
+                    {tariff_line_ru}
                     <p>Ваша подписка истекает через <strong>{days_left}</strong> дн.</p>
                     <p>Дата истечения: <strong>{expires_at}</strong></p>
                 </div>
@@ -339,6 +380,7 @@ class EmailNotificationTemplates:
             'en': f"""
                 <h2>Subscription Expiring Soon</h2>
                 <div class="highlight warning">
+                    {tariff_line_en}
                     <p>Your subscription expires in <strong>{days_left}</strong> day(s).</p>
                     <p>Expiration date: <strong>{expires_at}</strong></p>
                 </div>
@@ -348,6 +390,7 @@ class EmailNotificationTemplates:
             'zh': f"""
                 <h2>订阅即将到期</h2>
                 <div class="highlight warning">
+                    {tariff_line_zh}
                     <p>您的订阅将在 <strong>{days_left}</strong> 天后到期。</p>
                     <p>到期日期: <strong>{expires_at}</strong></p>
                 </div>
@@ -357,6 +400,7 @@ class EmailNotificationTemplates:
             'ua': f"""
                 <h2>Підписка скоро закінчується</h2>
                 <div class="highlight warning">
+                    {tariff_line_ua}
                     <p>Ваша підписка закінчується через <strong>{days_left}</strong> дн.</p>
                     <p>Дата закінчення: <strong>{expires_at}</strong></p>
                 </div>
@@ -372,17 +416,26 @@ class EmailNotificationTemplates:
 
     def _subscription_expired_template(self, language: str, context: dict[str, Any]) -> dict[str, str]:
         """Template for subscription expired notification."""
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_zh = f'<p>套餐: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_ua = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+
         subjects = {
-            'ru': 'Подписка истекла',
-            'en': 'Subscription Expired',
+            'ru': f'Подписка{tariff_suffix_ru} истекла',
+            'en': f'Subscription{tariff_suffix_en} Expired',
             'zh': '订阅已到期',
-            'ua': 'Підписка закінчилась',
+            'ua': f'Підписка{tariff_suffix_ru} закінчилась',
         }
 
         bodies = {
             'ru': f"""
                 <h2>Подписка истекла</h2>
                 <div class="highlight danger">
+                    {tariff_line_ru}
                     <p>Ваша подписка истекла. Доступ к VPN отключён.</p>
                 </div>
                 <p>Оформите новую подписку, чтобы продолжить использование сервиса.</p>
@@ -391,6 +444,7 @@ class EmailNotificationTemplates:
             'en': f"""
                 <h2>Subscription Expired</h2>
                 <div class="highlight danger">
+                    {tariff_line_en}
                     <p>Your subscription has expired. VPN access has been disabled.</p>
                 </div>
                 <p>Purchase a new subscription to continue using our service.</p>
@@ -399,6 +453,7 @@ class EmailNotificationTemplates:
             'zh': f"""
                 <h2>订阅已到期</h2>
                 <div class="highlight danger">
+                    {tariff_line_zh}
                     <p>您的订阅已到期。VPN访问已被禁用。</p>
                 </div>
                 <p>请购买新订阅以继续使用我们的服务。</p>
@@ -407,6 +462,7 @@ class EmailNotificationTemplates:
             'ua': f"""
                 <h2>Підписка закінчилась</h2>
                 <div class="highlight danger">
+                    {tariff_line_ua}
                     <p>Ваша підписка закінчилась. Доступ до VPN вимкнено.</p>
                 </div>
                 <p>Оформіть нову підписку, щоб продовжити використання сервісу.</p>
@@ -422,18 +478,24 @@ class EmailNotificationTemplates:
     def _subscription_renewed_template(self, language: str, context: dict[str, Any]) -> dict[str, str]:
         """Template for subscription renewed notification."""
         new_expires_at = context.get('new_expires_at', '')
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''
 
         subjects = {
-            'ru': 'Подписка продлена',
-            'en': 'Subscription Renewed',
+            'ru': f'Подписка{tariff_suffix_ru} продлена',
+            'en': f'Subscription{tariff_suffix_en} Renewed',
             'zh': '订阅已续订',
-            'ua': 'Підписку продовжено',
+            'ua': f'Підписку{tariff_suffix_ru} продовжено',
         }
 
         bodies = {
             'ru': f"""
                 <h2>Подписка успешно продлена!</h2>
                 <div class="highlight success">
+                    {tariff_line_ru}
                     <p>Ваша подписка была успешно продлена.</p>
                     <p>Новая дата истечения: <strong>{new_expires_at}</strong></p>
                 </div>
@@ -443,6 +505,7 @@ class EmailNotificationTemplates:
             'en': f"""
                 <h2>Subscription Successfully Renewed!</h2>
                 <div class="highlight success">
+                    {tariff_line_en}
                     <p>Your subscription has been successfully renewed.</p>
                     <p>New expiration date: <strong>{new_expires_at}</strong></p>
                 </div>
@@ -459,18 +522,24 @@ class EmailNotificationTemplates:
     def _subscription_activated_template(self, language: str, context: dict[str, Any]) -> dict[str, str]:
         """Template for subscription activated notification."""
         expires_at = context.get('expires_at', '')
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''
 
         subjects = {
-            'ru': 'Подписка активирована',
-            'en': 'Subscription Activated',
+            'ru': f'Подписка{tariff_suffix_ru} активирована',
+            'en': f'Subscription{tariff_suffix_en} Activated',
             'zh': '订阅已激活',
-            'ua': 'Підписку активовано',
+            'ua': f'Підписку{tariff_suffix_ru} активовано',
         }
 
         bodies = {
             'ru': f"""
                 <h2>Подписка активирована!</h2>
                 <div class="highlight success">
+                    {tariff_line_ru}
                     <p>Ваша VPN подписка успешно активирована.</p>
                     <p>Действует до: <strong>{expires_at}</strong></p>
                 </div>
@@ -480,6 +549,7 @@ class EmailNotificationTemplates:
             'en': f"""
                 <h2>Subscription Activated!</h2>
                 <div class="highlight success">
+                    {tariff_line_en}
                     <p>Your VPN subscription has been successfully activated.</p>
                     <p>Valid until: <strong>{expires_at}</strong></p>
                 </div>
@@ -1340,6 +1410,8 @@ class EmailNotificationTemplates:
         tariff_name = html.escape(context.get('tariff_name', ''))
         period_days = context.get('period_days', 0)
         cabinet_url = html.escape(context.get('cabinet_url', ''))
+        cabinet_email = html.escape(context.get('cabinet_email', ''))
+        cabinet_password = context.get('cabinet_password', '')
 
         subjects = {
             'ru': 'Ваша VPN подписка готова',
@@ -1349,6 +1421,66 @@ class EmailNotificationTemplates:
             'fa': 'اشتراک VPN شما آماده است',
         }
 
+        creds_block_ru = (
+            f"""
+                <div class="highlight">
+                    <p><strong>Данные для входа в личный кабинет:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>Пароль:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_en = (
+            f"""
+                <div class="highlight">
+                    <p><strong>Your cabinet login credentials:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>Password:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_zh = (
+            f"""
+                <div class="highlight">
+                    <p><strong>个人中心登录信息：</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>密码:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_ua = (
+            f"""
+                <div class="highlight">
+                    <p><strong>Дані для входу в особистий кабінет:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>Пароль:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_fa = (
+            f"""
+                <div class="highlight">
+                    <p><strong>اطلاعات ورود به پنل کاربری:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>رمز عبور:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
         bodies = {
             'ru': f"""
                 <h2>Ваша VPN подписка готова!</h2>
@@ -1356,6 +1488,7 @@ class EmailNotificationTemplates:
                     <p>Тариф: <strong>{tariff_name}</strong></p>
                     <p>Период: <strong>{period_days} дней</strong></p>
                 </div>
+                {creds_block_ru}
                 <p>Подписка активирована в вашем личном кабинете.</p>
                 <p style="text-align: center;"><a href="{cabinet_url}" class="button">Перейти в личный кабинет</a></p>
             """,
@@ -1365,6 +1498,7 @@ class EmailNotificationTemplates:
                     <p>Plan: <strong>{tariff_name}</strong></p>
                     <p>Period: <strong>{period_days} days</strong></p>
                 </div>
+                {creds_block_en}
                 <p>Your subscription has been activated in your cabinet.</p>
                 <p style="text-align: center;"><a href="{cabinet_url}" class="button">Go to Cabinet</a></p>
             """,
@@ -1374,6 +1508,7 @@ class EmailNotificationTemplates:
                     <p>套餐: <strong>{tariff_name}</strong></p>
                     <p>期限: <strong>{period_days} 天</strong></p>
                 </div>
+                {creds_block_zh}
                 <p>订阅已在您的个人中心激活。</p>
                 <p style="text-align: center;"><a href="{cabinet_url}" class="button">前往个人中心</a></p>
             """,
@@ -1383,6 +1518,7 @@ class EmailNotificationTemplates:
                     <p>Тариф: <strong>{tariff_name}</strong></p>
                     <p>Період: <strong>{period_days} днів</strong></p>
                 </div>
+                {creds_block_ua}
                 <p>Підписка активована у вашому особистому кабінеті.</p>
                 <p style="text-align: center;"><a href="{cabinet_url}" class="button">Перейти до кабінету</a></p>
             """,
@@ -1392,6 +1528,7 @@ class EmailNotificationTemplates:
                     <p>طرح: <strong>{tariff_name}</strong></p>
                     <p>مدت: <strong>{period_days} روز</strong></p>
                 </div>
+                {creds_block_fa}
                 <p>اشتراک شما در پنل کاربری فعال شده است.</p>
                 <p style="text-align: center;"><a href="{cabinet_url}" class="button">رفتن به پنل کاربری</a></p>
             """,

app/config.py

@@ -1,14 +1,13 @@
 import hashlib
 import hmac
 import html
-import math
 import os
 import re
 from collections import defaultdict
 from datetime import time
 from pathlib import Path
 from typing import Literal
-from urllib.parse import urlparse
+from urllib.parse import quote as _url_quote, urlparse
 from zoneinfo import ZoneInfo
 
 import structlog
@@ -57,6 +56,17 @@ class Settings(BaseSettings):
     ADMIN_NOTIFICATIONS_TICKET_TOPIC_ID: int | None = None
     ADMIN_NOTIFICATIONS_NALOG_TOPIC_ID: int | None = None
 
+    # Раздельные топики для уведомлений (если не задано — fallback на ADMIN_NOTIFICATIONS_TOPIC_ID)
+    ADMIN_NOTIFICATIONS_PURCHASES_TOPIC_ID: int | None = None  # Покупки подписок
+    ADMIN_NOTIFICATIONS_RENEWALS_TOPIC_ID: int | None = None  # Продления
+    ADMIN_NOTIFICATIONS_TRIALS_TOPIC_ID: int | None = None  # Триалы
+    ADMIN_NOTIFICATIONS_BALANCE_TOPIC_ID: int | None = None  # Пополнение баланса
+    ADMIN_NOTIFICATIONS_ADDONS_TOPIC_ID: int | None = None  # Докупка трафика/устройств/серверов
+    ADMIN_NOTIFICATIONS_INFRASTRUCTURE_TOPIC_ID: int | None = None  # Ноды, техработы, статус панели
+    ADMIN_NOTIFICATIONS_ERRORS_TOPIC_ID: int | None = None  # Ошибки бота
+    ADMIN_NOTIFICATIONS_PROMO_TOPIC_ID: int | None = None  # Промокоды, кампании, промогруппы
+    ADMIN_NOTIFICATIONS_PARTNERS_TOPIC_ID: int | None = None  # Партнёрки, выводы, админ-действия
+
     # Настройки очереди чеков NaloGO
     NALOGO_QUEUE_CHECK_INTERVAL: int = 300  # Интервал проверки очереди (секунды)
     NALOGO_QUEUE_RECEIPT_DELAY: int = 3  # Задержка между отправкой чеков (секунды)
@@ -108,6 +118,7 @@ class Settings(BaseSettings):
     REMNAWAVE_WEBHOOK_ENABLED: bool = False
     REMNAWAVE_WEBHOOK_PATH: str = '/remnawave-webhook'
     REMNAWAVE_WEBHOOK_SECRET: str | None = None  # HMAC-SHA256 shared secret (min 32 chars)
+    REMNAWAVE_WEBHOOK_NOTIFY_NODE_CONNECTION_STATUS: bool = True
 
     # Webhook user notification toggles (what Telegram messages users receive from webhook events)
     WEBHOOK_NOTIFY_USER_ENABLED: bool = True
@@ -197,6 +208,11 @@ class Settings(BaseSettings):
     # - tariffs: режим тарифов (готовые пакеты с фиксированными параметрами)
     SALES_MODE: str = 'tariffs'
 
+    # Multi-tariff mode: allows users to purchase multiple tariffs simultaneously
+    # Only works when SALES_MODE='tariffs'
+    MULTI_TARIFF_ENABLED: bool = False
+    MAX_ACTIVE_SUBSCRIPTIONS: int = 10
+
     # ID тарифа для триала в режиме тарифов (0 = использовать стандартные настройки триала)
     # Если указан ID тарифа, параметры триала берутся из тарифа (traffic_limit_gb, device_limit, allowed_squads)
     # Длительность триала всё равно берётся из TRIAL_DURATION_DAYS
@@ -220,6 +236,7 @@ class Settings(BaseSettings):
     REFERRAL_FIRST_TOPUP_BONUS_KOPEKS: int = 10000
     REFERRAL_INVITER_BONUS_KOPEKS: int = 10000
     REFERRAL_COMMISSION_PERCENT: int = 25
+    REFERRAL_MAX_COMMISSION_PAYMENTS: int = 0  # Макс. кол-во платежей реферала с комиссией (0 = без лимита)
 
     REFERRAL_PROGRAM_ENABLED: bool = True
     REFERRAL_NOTIFICATIONS_ENABLED: bool = True
@@ -353,8 +370,9 @@ class Settings(BaseSettings):
     YOOKASSA_TRUSTED_PROXY_NETWORKS: str = ''
     YOOKASSA_MIN_AMOUNT_KOPEKS: int = 5000
     YOOKASSA_MAX_AMOUNT_KOPEKS: int = 1000000
-    YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED: bool = False
-    DISABLE_TOPUP_BUTTONS: bool = False
+    YOOKASSA_RECURRENT_ENABLED: bool = False
+    YOOKASSA_RECURRENT_REQUIRED: bool = False
+    YOOKASSA_TEST_MODE: bool = False
     SUPPORT_TOPUP_ENABLED: bool = True
     PAYMENT_VERIFICATION_AUTO_CHECK_ENABLED: bool = False
     PAYMENT_VERIFICATION_AUTO_CHECK_INTERVAL_MINUTES: int = 10
@@ -364,6 +382,7 @@ class Settings(BaseSettings):
     NALOGO_PASSWORD: str | None = None
     NALOGO_DEVICE_ID: str | None = None
     NALOGO_STORAGE_PATH: str = './nalogo_tokens.json'
+    NALOGO_PROXY_URL: str | None = None  # SOCKS proxy for nalog.ru; falls back to PROXY_URL if not set
 
     AUTO_PURCHASE_AFTER_TOPUP_ENABLED: bool = False
 
@@ -449,6 +468,7 @@ class Settings(BaseSettings):
     PLATEGA_FAILED_URL: str | None = None
     PLATEGA_CURRENCY: str = 'RUB'
     PLATEGA_ACTIVE_METHODS: str = '2,10,11,12,13'
+    PLATEGA_INLINE_METHODS: bool = True
     PLATEGA_MIN_AMOUNT_KOPEKS: int = 10000
     PLATEGA_MAX_AMOUNT_KOPEKS: int = 100000000
     PLATEGA_WEBHOOK_PATH: str = '/platega-webhook'
@@ -533,6 +553,35 @@ class Settings(BaseSettings):
     KASSA_AI_WEBHOOK_PORT: int = 8089
     # Способ оплаты: 44 = СБП (QR код), 36 = Карты РФ, 43 = SberPay
     KASSA_AI_PAYMENT_SYSTEM_ID: int = 44
+    # Раздельные методы оплаты KassaAI (отображаются как отдельные кнопки)
+    KASSA_AI_SBP_ENABLED: bool = False  # СБП — payment_system_id=44
+    KASSA_AI_SBP_DISPLAY_NAME: str = 'СБП (KassaAI)'
+    KASSA_AI_CARD_ENABLED: bool = False  # Карты РФ — payment_system_id=36
+    KASSA_AI_CARD_DISPLAY_NAME: str = 'Карта (KassaAI)'
+
+    # RioPay (api.riopay.online) v2.0.1
+    RIOPAY_ENABLED: bool = False
+    RIOPAY_API_TOKEN: str | None = None  # x-api-token header
+    RIOPAY_WEBHOOK_SECRET: str | None = None  # HMAC-SHA512 ключ для вебхуков (по умолчанию = API_TOKEN)
+    RIOPAY_DISPLAY_NAME: str = 'RioPay'
+    RIOPAY_CURRENCY: str = 'RUB'
+    RIOPAY_MIN_AMOUNT_KOPEKS: int = 10000  # 100₽
+    RIOPAY_MAX_AMOUNT_KOPEKS: int = 100000000  # 1 000 000₽
+    RIOPAY_WEBHOOK_PATH: str = '/riopay-webhook'
+    RIOPAY_SUCCESS_URL: str | None = None
+    RIOPAY_FAIL_URL: str | None = None
+
+    # SeverPay (severpay.io)
+    SEVERPAY_ENABLED: bool = False
+    SEVERPAY_MID: int | None = None  # Merchant ID
+    SEVERPAY_TOKEN: str | None = None  # Secret token for HMAC-SHA256
+    SEVERPAY_DISPLAY_NAME: str = 'SeverPay'
+    SEVERPAY_CURRENCY: str = 'RUB'
+    SEVERPAY_MIN_AMOUNT_KOPEKS: int = 10000  # 100₽
+    SEVERPAY_MAX_AMOUNT_KOPEKS: int = 10000000  # 100 000₽
+    SEVERPAY_WEBHOOK_PATH: str = '/severpay-webhook'
+    SEVERPAY_RETURN_URL: str | None = None
+    SEVERPAY_LIFETIME: int = 1440  # minutes, 30-4320
 
     MAIN_MENU_MODE: str = 'default'  # 'default' | 'cabinet'
     # Стиль кнопок Cabinet: primary (синий), success (зелёный), danger (красный), '' (по умолчанию для каждой секции)
@@ -540,6 +589,13 @@ class Settings(BaseSettings):
     CONNECT_BUTTON_MODE: str = 'miniapp_subscription'
     MINIAPP_CUSTOM_URL: str = ''
     MINIAPP_STATIC_PATH: str = 'miniapp'
+
+    # Media upload settings (news article images/videos)
+    MEDIA_UPLOAD_DIR: str = './uploads'
+    MEDIA_MAX_IMAGE_SIZE_MB: int = 10
+    MEDIA_MAX_VIDEO_SIZE_MB: int = 50
+    MEDIA_IMAGE_MAX_DIMENSION: int = 2048
+    MEDIA_JPEG_QUALITY: int = 85
     MINIAPP_PURCHASE_URL: str = ''
     MINIAPP_SERVICE_NAME_EN: str = 'Bedolaga VPN'
     MINIAPP_SERVICE_NAME_RU: str = 'Bedolaga VPN'
@@ -762,6 +818,27 @@ class Settings(BaseSettings):
     BAN_SYSTEM_API_TOKEN: str | None = None
     BAN_SYSTEM_REQUEST_TIMEOUT: int = 30
 
+    # SOCKS5 proxy for routing bot traffic to Telegram API
+    # Format: socks5://user:password@host:port or socks5://host:port
+    PROXY_URL: str | None = None
+
+    @field_validator('PROXY_URL', 'NALOGO_PROXY_URL', mode='before')
+    @classmethod
+    def validate_proxy_url(cls, value: str | None) -> str | None:
+        if not value:
+            return None
+        from urllib.parse import urlparse
+
+        parsed = urlparse(value)
+        if parsed.scheme not in ('socks5', 'socks5h', 'socks4'):
+            raise ValueError(
+                f'Proxy URL must use socks5://, socks5h://, or socks4:// scheme, got: {parsed.scheme!r}. '
+                'HTTP proxies are not supported for security reasons.'
+            )
+        if not parsed.hostname:
+            raise ValueError('Proxy URL must contain a hostname')
+        return value
+
     @field_validator('MAIN_MENU_MODE', mode='before')
     @classmethod
     def normalize_main_menu_mode(cls, value: str | None) -> str:
@@ -888,6 +965,17 @@ class Settings(BaseSettings):
         """Проверяет, используется ли SQLite"""
         return 'sqlite' in self.get_database_url()
 
+    def get_proxy_url(self) -> str | None:
+        """Return SOCKS5 proxy URL or None."""
+        return self.PROXY_URL if self.PROXY_URL else None
+
+    def get_nalogo_proxy_url(self) -> str | None:
+        """Return SOCKS proxy URL for nalogo or None.
+
+        Uses NALOGO_PROXY_URL if set, otherwise falls back to PROXY_URL.
+        """
+        return self.NALOGO_PROXY_URL or self.PROXY_URL
+
     def is_admin(self, telegram_id: int | None = None, email: str | None = None) -> bool:
         """
         Check if user is admin by telegram_id or email.
@@ -937,12 +1025,12 @@ class Settings(BaseSettings):
     def get_test_email(self) -> str | None:
         """Get test email for development/testing."""
         email = (self.TEST_EMAIL or '').strip().lower()
-        return email if email else None
+        return email or None
 
     def get_test_email_password(self) -> str | None:
         """Get test email password."""
         password = (self.TEST_EMAIL_PASSWORD or '').strip()
-        return password if password else None
+        return password or None
 
     def is_test_email(self, email: str) -> bool:
         """Check if email is the configured test email."""
@@ -1059,12 +1147,17 @@ class Settings(BaseSettings):
         username_clean = (username or '').lstrip('@')
         full_name_value = full_name or ''
 
+        # Remnawave разрешает только буквы, цифры, подчёркивания и дефисы
+        def _sanitize(value: str) -> str:
+            result = re.sub(r'[^0-9A-Za-z_-]+', '_', value)
+            return re.sub(r'_+', '_', result).strip('_-')
+
         # Для email-пользователей формируем уникальный identifier
         if telegram_id:
             identifier = str(telegram_id)
         elif email:
-            email_prefix = email.split('@')[0][:10]
-            identifier = f'email_{email_prefix}_{user_id}' if user_id else f'email_{email_prefix}'
+            email_prefix = _sanitize(email.split('@')[0][:10])
+            identifier = _sanitize(f'email_{email_prefix}_{user_id}' if user_id else f'email_{email_prefix}')
         elif user_id:
             identifier = f'id_{user_id}'
         else:
@@ -1078,20 +1171,18 @@ class Settings(BaseSettings):
                 'username_clean': username_clean,
                 'telegram_id': str(telegram_id) if telegram_id else identifier,
                 'identifier': identifier,
-                'email': email.split('@')[0] if email else '',
+                'email': _sanitize(email.split('@')[0]) if email else '',
                 'user_id': str(user_id) if user_id else '',
             },
         )
 
         raw_username = template.format_map(values).strip()
-        # Remnawave разрешает только буквы, цифры, подчёркивания и дефисы
-        sanitized_username = re.sub(r'[^0-9A-Za-z_-]+', '_', raw_username)
-        sanitized_username = re.sub(r'_+', '_', sanitized_username).strip('_-')
+        sanitized_username = _sanitize(raw_username)
 
         if not sanitized_username:
-            sanitized_username = f'user_{identifier}'
+            sanitized_username = _sanitize(f'user_{identifier}')
 
-        return sanitized_username[:36]
+        return sanitized_username[:36].strip('_-') or 'user'
 
     @staticmethod
     def parse_daily_time_list(raw_value: str | None) -> list[time]:
@@ -1223,10 +1314,6 @@ class Settings(BaseSettings):
 
         return bool(value)
 
-    def is_quick_amount_buttons_enabled(self) -> bool:
-        """Показывать ли кнопки быстрого выбора суммы пополнения."""
-        return self.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not self.DISABLE_TOPUP_BUTTONS
-
     def get_available_languages(self) -> list[str]:
         defaults = ['ru', 'en', 'ua', 'zh', 'fa']
 
@@ -1401,6 +1488,46 @@ class Settings(BaseSettings):
                 return value
         return None
 
+    _CABINET_URL_DEFAULT = 'https://example.com/cabinet'
+
+    def _encode_referral_code(self, referral_code: str) -> str:
+        """Validate and URL-encode a referral code."""
+        if not referral_code:
+            raise ValueError('referral_code must not be empty or None')
+        return _url_quote(referral_code, safe='')
+
+    def _normalized_cabinet_url(self) -> str | None:
+        """Return normalized cabinet URL, or None if not configured."""
+        cabinet_url = (self.CABINET_URL or '').strip().rstrip('/')
+        if not cabinet_url or cabinet_url == self._CABINET_URL_DEFAULT:
+            return None
+        return cabinet_url
+
+    def get_referral_link(self, referral_code: str, bot_username: str | None = None) -> str:
+        """Build a referral link pointing to the web cabinet.
+
+        Falls back to a Telegram bot deep link when CABINET_URL is not configured.
+        """
+        cabinet_link = self.get_cabinet_referral_link(referral_code)
+        if cabinet_link:
+            return cabinet_link
+        return self.get_bot_referral_link(referral_code, bot_username)
+
+    def get_bot_referral_link(self, referral_code: str, bot_username: str | None = None) -> str:
+        """Always return the Telegram bot deep link for a referral code."""
+        safe_code = self._encode_referral_code(referral_code)
+        username = bot_username or self.get_bot_username() or 'bot'
+        return f'https://t.me/{username}?start={safe_code}'
+
+    def get_cabinet_referral_link(self, referral_code: str) -> str | None:
+        """Return the cabinet referral link, or None if cabinet is not configured."""
+        cabinet_url = self._normalized_cabinet_url()
+        if not cabinet_url:
+            return None
+        safe_code = self._encode_referral_code(referral_code)
+        sep = '&' if '?' in cabinet_url else '?'
+        return f'{cabinet_url}{sep}ref={safe_code}'
+
     def is_deep_links_enabled(self) -> bool:
         return self.ENABLE_DEEP_LINKS
 
@@ -1507,7 +1634,7 @@ class Settings(BaseSettings):
                 except (ValueError, IndexError):
                     continue
 
-        return packages if packages else self.get_traffic_packages()
+        return packages or self.get_traffic_packages()
 
     def get_traffic_topup_price(self, gb: int | None) -> int:
         """Возвращает цену докупки для указанного количества ГБ."""
@@ -1554,6 +1681,14 @@ class Settings(BaseSettings):
     def get_disabled_mode_device_limit(self) -> int | None:
         return self.get_devices_selection_disabled_amount()
 
+    def is_multi_tariff_enabled(self) -> bool:
+        """Проверяет, включен ли мультитарифный режим."""
+        return self.MULTI_TARIFF_ENABLED and self.SALES_MODE == 'tariffs'
+
+    def get_max_active_subscriptions(self) -> int:
+        """Максимальное число одновременных подписок (>1 только в multi-tariff)."""
+        return self.MAX_ACTIVE_SUBSCRIPTIONS if self.is_multi_tariff_enabled() else 1
+
     def is_tariffs_mode(self) -> bool:
         """Проверяет, включен ли режим продаж 'Тарифы'."""
         return self.SALES_MODE == 'tariffs'
@@ -1597,7 +1732,7 @@ class Settings(BaseSettings):
 
     def get_yookassa_display_name(self) -> str:
         name = (self.YOOKASSA_DISPLAY_NAME or '').strip()
-        return name if name else 'YooKassa'
+        return name or 'YooKassa'
 
     def is_nalogo_enabled(self) -> bool:
         return self.NALOGO_ENABLED and self.NALOGO_INN is not None and self.NALOGO_PASSWORD is not None
@@ -1617,14 +1752,14 @@ class Settings(BaseSettings):
 
     def get_cryptobot_display_name(self) -> str:
         name = (self.CRYPTOBOT_DISPLAY_NAME or '').strip()
-        return name if name else 'CryptoBot'
+        return name or 'CryptoBot'
 
     def is_heleket_enabled(self) -> bool:
         return self.HELEKET_ENABLED and self.HELEKET_MERCHANT_ID is not None and self.HELEKET_API_KEY is not None
 
     def get_heleket_display_name(self) -> str:
         name = (self.HELEKET_DISPLAY_NAME or '').strip()
-        return name if name else 'Heleket Crypto'
+        return name or 'Heleket Crypto'
 
     def is_mulenpay_enabled(self) -> bool:
         return (
@@ -1662,7 +1797,7 @@ class Settings(BaseSettings):
 
     def get_pal24_display_name(self) -> str:
         name = (self.PAL24_DISPLAY_NAME or '').strip()
-        return name if name else 'PAL24'
+        return name or 'PAL24'
 
     def is_platega_enabled(self) -> bool:
         return self.PLATEGA_ENABLED and self.PLATEGA_MERCHANT_ID is not None and self.PLATEGA_SECRET is not None
@@ -1742,7 +1877,7 @@ class Settings(BaseSettings):
 
     def get_wata_display_name(self) -> str:
         name = (self.WATA_DISPLAY_NAME or '').strip()
-        return name if name else 'Wata'
+        return name or 'Wata'
 
     def is_cloudpayments_enabled(self) -> bool:
         return (
@@ -1753,7 +1888,7 @@ class Settings(BaseSettings):
 
     def get_cloudpayments_display_name(self) -> str:
         name = (self.CLOUDPAYMENTS_DISPLAY_NAME or '').strip()
-        return name if name else 'CloudPayments'
+        return name or 'CloudPayments'
 
     def is_freekassa_enabled(self) -> bool:
         return (
@@ -1766,7 +1901,7 @@ class Settings(BaseSettings):
 
     def get_freekassa_display_name(self) -> str:
         name = (self.FREEKASSA_DISPLAY_NAME or '').strip()
-        return name if name else 'Freekassa'
+        return name or 'Freekassa'
 
     def get_freekassa_display_name_html(self) -> str:
         return html.escape(self.get_freekassa_display_name())
@@ -1776,7 +1911,7 @@ class Settings(BaseSettings):
 
     def get_freekassa_sbp_display_name(self) -> str:
         name = (self.FREEKASSA_SBP_DISPLAY_NAME or '').strip()
-        return name if name else 'СБП (QR код)'
+        return name or 'СБП (QR код)'
 
     def get_freekassa_sbp_display_name_html(self) -> str:
         return html.escape(self.get_freekassa_sbp_display_name())
@@ -1786,7 +1921,7 @@ class Settings(BaseSettings):
 
     def get_freekassa_card_display_name(self) -> str:
         name = (self.FREEKASSA_CARD_DISPLAY_NAME or '').strip()
-        return name if name else 'Карта РФ'
+        return name or 'Карта РФ'
 
     def get_freekassa_card_display_name_html(self) -> str:
         return html.escape(self.get_freekassa_card_display_name())
@@ -1801,11 +1936,51 @@ class Settings(BaseSettings):
 
     def get_kassa_ai_display_name(self) -> str:
         name = (self.KASSA_AI_DISPLAY_NAME or '').strip()
-        return name if name else 'KassaAI'
+        return name or 'KassaAI'
 
     def get_kassa_ai_display_name_html(self) -> str:
         return html.escape(self.get_kassa_ai_display_name())
 
+    def is_riopay_enabled(self) -> bool:
+        return self.RIOPAY_ENABLED and self.RIOPAY_API_TOKEN is not None
+
+    def get_riopay_display_name(self) -> str:
+        name = (self.RIOPAY_DISPLAY_NAME or '').strip()
+        return name or 'RioPay'
+
+    def get_riopay_display_name_html(self) -> str:
+        return html.escape(self.get_riopay_display_name())
+
+    def is_severpay_enabled(self) -> bool:
+        return self.SEVERPAY_ENABLED and self.SEVERPAY_MID is not None and self.SEVERPAY_TOKEN is not None
+
+    def get_severpay_display_name(self) -> str:
+        name = (self.SEVERPAY_DISPLAY_NAME or '').strip()
+        return name if name else 'SeverPay'
+
+    def get_severpay_display_name_html(self) -> str:
+        return html.escape(self.get_severpay_display_name())
+
+    def is_kassa_ai_sbp_enabled(self) -> bool:
+        return self.KASSA_AI_SBP_ENABLED and self.is_kassa_ai_enabled()
+
+    def get_kassa_ai_sbp_display_name(self) -> str:
+        name = (self.KASSA_AI_SBP_DISPLAY_NAME or '').strip()
+        return name if name else 'СБП (KassaAI)'
+
+    def get_kassa_ai_sbp_display_name_html(self) -> str:
+        return html.escape(self.get_kassa_ai_sbp_display_name())
+
+    def is_kassa_ai_card_enabled(self) -> bool:
+        return self.KASSA_AI_CARD_ENABLED and self.is_kassa_ai_enabled()
+
+    def get_kassa_ai_card_display_name(self) -> str:
+        name = (self.KASSA_AI_CARD_DISPLAY_NAME or '').strip()
+        return name if name else 'Карта (KassaAI)'
+
+    def get_kassa_ai_card_display_name_html(self) -> str:
+        return html.escape(self.get_kassa_ai_card_display_name())
+
     def is_payment_verification_auto_check_enabled(self) -> bool:
         return self.PAYMENT_VERIFICATION_AUTO_CHECK_ENABLED
 
@@ -1901,7 +2076,7 @@ class Settings(BaseSettings):
             '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
+        return link or None
 
     def is_maintenance_mode(self) -> bool:
         return self.MAINTENANCE_MODE
@@ -1989,7 +2164,7 @@ class Settings(BaseSettings):
         # т.к. в режиме classic цена складывается из серверов/трафика/устройств)
         periods = sorted(allowed_periods)
 
-        return periods if periods else [30, 90, 180]
+        return periods or [30, 90, 180]
 
     def get_available_renewal_periods(self) -> list[int]:
         """
@@ -2014,7 +2189,7 @@ class Settings(BaseSettings):
         # Возвращаем только разрешённые периоды (без фильтрации по цене)
         periods = sorted(allowed_periods)
 
-        return periods if periods else [30, 90, 180]
+        return periods or [30, 90, 180]
 
     def get_configured_subscription_periods(self) -> list[int]:
         """
@@ -2054,13 +2229,17 @@ class Settings(BaseSettings):
         except (ValueError, AttributeError):
             return [30, 60, 90, 180, 360]
 
-    def get_balance_payment_description(self, amount_kopeks: int, telegram_user_id: int | None = None) -> str:
+    def get_balance_payment_description(
+        self, amount_kopeks: int, telegram_user_id: int | None = None, user_db_id: int | None = None
+    ) -> str:
         # Базовое описание
         description = f'{self.PAYMENT_BALANCE_DESCRIPTION} на {self.format_price(amount_kopeks)}'
 
-        # Если передан user_id, добавляем его
+        # Добавляем идентификатор пользователя (TG ID приоритет, fallback на DB ID)
         if telegram_user_id is not None:
             description += f' (ID {telegram_user_id})'
+        elif user_db_id is not None:
+            description += f' (U{user_db_id})'
 
         # Формируем финальную строку по шаблону
         return self.PAYMENT_BALANCE_TEMPLATE.format(service_name=self.PAYMENT_SERVICE_NAME, description=description)
@@ -2079,7 +2258,7 @@ class Settings(BaseSettings):
 
     def get_telegram_stars_display_name(self) -> str:
         name = (self.TELEGRAM_STARS_DISPLAY_NAME or '').strip()
-        return name if name else 'Telegram Stars'
+        return name or 'Telegram Stars'
 
     def stars_to_rubles(self, stars: int) -> float:
         return stars * self.get_stars_rate()
@@ -2088,7 +2267,7 @@ class Settings(BaseSettings):
         rate = self.get_stars_rate()
         if rate <= 0:
             raise ValueError('Stars rate must be positive')
-        return max(1, math.ceil(rubles / rate))
+        return max(1, round(rubles / rate))
 
     def get_admin_notifications_chat_id(self) -> int | None:
         if not self.ADMIN_NOTIFICATIONS_CHAT_ID:
@@ -2116,7 +2295,7 @@ class Settings(BaseSettings):
 
     def get_backup_archive_password(self) -> str | None:
         password = (self.BACKUP_ARCHIVE_PASSWORD or '').strip()
-        return password if password else None
+        return password or None
 
     # === Log Rotation Methods ===
 
@@ -2197,7 +2376,7 @@ class Settings(BaseSettings):
                 except ValueError:
                     continue
 
-            return packages if packages else self._get_fallback_traffic_packages()
+            return packages or self._get_fallback_traffic_packages()
 
         except Exception as e:
             logger.warning('ERROR PARSING CONFIG', error=e)
@@ -2330,13 +2509,13 @@ class Settings(BaseSettings):
 
         if contact.startswith(('t.me/', 'telegram.me/', 'telegram.dog/')):
             url = self.get_support_contact_url()
-            return url if url else contact
+            return url or contact
 
         contact_without_prefix = contact.lstrip('@')
 
         if '.' in contact_without_prefix:
             url = self.get_support_contact_url()
-            return url if url else contact
+            return url or contact
 
         if re.fullmatch(r'[A-Za-z0-9_]{3,}', contact_without_prefix):
             return f'@{contact_without_prefix}'
@@ -2473,6 +2652,9 @@ class Settings(BaseSettings):
             raw_path = 'miniapp'
         return Path(raw_path)
 
+    def get_media_upload_path(self) -> Path:
+        return Path(self.MEDIA_UPLOAD_DIR)
+
     # Cabinet methods
     def is_cabinet_enabled(self) -> bool:
         return bool(self.CABINET_ENABLED)
@@ -2656,6 +2838,25 @@ PERIOD_PRICES: dict[int, int] = {}
 refresh_period_prices()
 
 
+def _build_classic_period_prices() -> dict[int, int]:
+    """Build classic-mode period prices directly from PRICE_*_DAYS settings.
+
+    Unlike PERIOD_PRICES (which may use DB tariff prices in tariffs mode),
+    this always reflects the env/settings values — the canonical prices for
+    classic (non-tariff) subscriptions.
+    """
+    return {days: getattr(settings, field_name, 0) for days, field_name in _PERIOD_PRICE_FIELDS.items()}
+
+
+CLASSIC_PERIOD_PRICES: dict[int, int] = _build_classic_period_prices()
+
+
+def refresh_classic_period_prices() -> None:
+    """Rebuild CLASSIC_PERIOD_PRICES from current settings."""
+    CLASSIC_PERIOD_PRICES.clear()
+    CLASSIC_PERIOD_PRICES.update(_build_classic_period_prices())
+
+
 def get_traffic_prices() -> dict[int, int]:
     packages = settings.get_traffic_packages()
     return {package['gb']: package['price'] for package in packages}

app/database/crud/campaign.py

@@ -5,6 +5,7 @@ from sqlalchemy import and_, delete, func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 
+from app.database.crud.transaction import REAL_PAYMENT_METHODS
 from app.database.models import (
     AdvertisingCampaign,
     AdvertisingCampaignRegistration,
@@ -268,11 +269,13 @@ async def get_campaign_statistics(
     )
     subscription_bonuses_issued = subscription_count_result.scalar() or 0
 
+    # Only count real deposits (exclude promo bonuses, wheel prizes, admin top-ups)
     deposits_result = await db.execute(
         select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
             Transaction.user_id.in_(select(registrations_subquery.c.user_id)),
             Transaction.type == TransactionType.DEPOSIT.value,
             Transaction.is_completed.is_(True),
+            Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
         )
     )
     deposits_total = deposits_result.scalar() or 0
@@ -363,7 +366,8 @@ async def get_campaign_statistics(
                 first_payment_amount_by_user[user_id] = amount_value
                 first_payment_time_by_user[user_id] = created_at
 
-    total_revenue = deposits_total + subscription_payments_total
+    # Revenue = only real deposits (exclude bonus-funded subscription spending)
+    total_revenue = deposits_total
 
     paid_user_ids = set(paid_users_from_transactions)
     paid_user_ids.update(conversion_user_ids)

app/database/crud/cryptobot.py

@@ -67,13 +67,34 @@ async def get_cryptobot_payment_by_id(db: AsyncSession, payment_id: int) -> Cryp
     return result.scalar_one_or_none()
 
 
+async def get_cryptobot_payment_by_invoice_id_for_update(db: AsyncSession, invoice_id: str) -> CryptoBotPayment | None:
+    result = await db.execute(
+        select(CryptoBotPayment)
+        .options(selectinload(CryptoBotPayment.user))
+        .where(CryptoBotPayment.invoice_id == invoice_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
+    return result.scalar_one_or_none()
+
+
 async def get_cryptobot_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> CryptoBotPayment | None:
-    result = await db.execute(select(CryptoBotPayment).where(CryptoBotPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(CryptoBotPayment)
+        .where(CryptoBotPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
     return result.scalar_one_or_none()
 
 
 async def update_cryptobot_payment_status(
-    db: AsyncSession, invoice_id: str, status: str, paid_at: datetime | None = None
+    db: AsyncSession,
+    invoice_id: str,
+    status: str,
+    paid_at: datetime | None = None,
+    *,
+    commit: bool = True,
 ) -> CryptoBotPayment | None:
     payment = await get_cryptobot_payment_by_invoice_id(db, invoice_id)
 
@@ -86,8 +107,11 @@ async def update_cryptobot_payment_status(
     if status == 'paid' and paid_at:
         payment.paid_at = paid_at
 
-    await db.commit()
-    await db.refresh(payment)
+    if commit:
+        await db.commit()
+        await db.refresh(payment)
+    else:
+        await db.flush()
 
     logger.info('Обновлен статус CryptoBot платежа', invoice_id=invoice_id, status=status)
     return payment

app/database/crud/freekassa.py

@@ -63,7 +63,12 @@ async def get_freekassa_payment_by_id(db: AsyncSession, payment_id: int) -> Free
 
 
 async def get_freekassa_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> FreekassaPayment | None:
-    result = await db.execute(select(FreekassaPayment).where(FreekassaPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(FreekassaPayment)
+        .where(FreekassaPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
     return result.scalar_one_or_none()
 
 

app/database/crud/kassa_ai.py

@@ -65,7 +65,12 @@ async def get_kassa_ai_payment_by_id(db: AsyncSession, payment_id: int) -> Kassa
 
 
 async def get_kassa_ai_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> KassaAiPayment | None:
-    result = await db.execute(select(KassaAiPayment).where(KassaAiPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(KassaAiPayment)
+        .where(KassaAiPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
     return result.scalar_one_or_none()
 
 

app/database/crud/mulenpay.py

@@ -58,7 +58,12 @@ async def get_mulenpay_payment_by_local_id(db: AsyncSession, payment_id: int) ->
 
 
 async def get_mulenpay_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> MulenPayPayment | None:
-    result = await db.execute(select(MulenPayPayment).where(MulenPayPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(MulenPayPayment)
+        .where(MulenPayPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
     return result.scalar_one_or_none()
 
 

app/database/crud/news.py

@@ -0,0 +1,288 @@
+"""CRUD operations for news articles."""
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from sqlalchemy import delete, func, nullslast, select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import NewsArticle
+
+
+logger = structlog.get_logger(__name__)
+
+# Fields that can be set via update_news_article
+_ALLOWED_UPDATE_FIELDS: frozenset[str] = frozenset(
+    {
+        'title',
+        'slug',
+        'content',
+        'excerpt',
+        'category',
+        'category_color',
+        'tag',
+        'category_id',
+        'tag_id',
+        'featured_image_url',
+        'is_published',
+        'is_featured',
+        'published_at',
+        'read_time_minutes',
+    }
+)
+
+# Fields that can be explicitly set to None
+_NULLABLE_UPDATE_FIELDS: frozenset[str] = frozenset(
+    {
+        'excerpt',
+        'tag',
+        'category_id',
+        'tag_id',
+        'featured_image_url',
+        'published_at',
+    }
+)
+
+
+async def create_news_article(
+    db: AsyncSession,
+    *,
+    title: str,
+    slug: str,
+    content: str = '',
+    excerpt: str | None = None,
+    category: str = '',
+    category_color: str = '#00e5a0',
+    tag: str | None = None,
+    category_id: int | None = None,
+    tag_id: int | None = None,
+    featured_image_url: str | None = None,
+    is_published: bool = False,
+    is_featured: bool = False,
+    published_at: datetime | None = None,
+    read_time_minutes: int = 1,
+    created_by: int | None = None,
+) -> NewsArticle:
+    """Create a new news article.
+
+    Raises:
+        IntegrityError: if slug is not unique (caller must handle).
+    """
+    # Auto-set published_at when publishing without explicit date
+    if is_published and published_at is None:
+        published_at = datetime.now(UTC)
+
+    article = NewsArticle(
+        title=title,
+        slug=slug,
+        content=content,
+        excerpt=excerpt,
+        category=category,
+        category_color=category_color,
+        tag=tag,
+        category_id=category_id,
+        tag_id=tag_id,
+        featured_image_url=featured_image_url,
+        is_published=is_published,
+        is_featured=is_featured,
+        published_at=published_at,
+        read_time_minutes=read_time_minutes,
+        created_by=created_by,
+    )
+
+    db.add(article)
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(article)
+
+    logger.info(
+        'Created news article',
+        article_id=article.id,
+        slug=article.slug,
+        is_published=article.is_published,
+    )
+    return article
+
+
+async def get_news_article_by_id(db: AsyncSession, article_id: int) -> NewsArticle | None:
+    """Get a news article by ID with author, category, and tag relationships."""
+    result = await db.execute(
+        select(NewsArticle)
+        .options(
+            selectinload(NewsArticle.author),
+            selectinload(NewsArticle.category_obj),
+            selectinload(NewsArticle.tag_obj),
+        )
+        .where(NewsArticle.id == article_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_news_article_by_slug(db: AsyncSession, slug: str) -> NewsArticle | None:
+    """Get a news article by slug with author, category, and tag relationships."""
+    result = await db.execute(
+        select(NewsArticle)
+        .options(
+            selectinload(NewsArticle.author),
+            selectinload(NewsArticle.category_obj),
+            selectinload(NewsArticle.tag_obj),
+        )
+        .where(NewsArticle.slug == slug)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_published_news(
+    db: AsyncSession,
+    *,
+    category: str | None = None,
+    limit: int = 20,
+    offset: int = 0,
+) -> list[NewsArticle]:
+    """Get published news articles, ordered by published_at descending.
+
+    Does NOT load the author relationship -- list views do not need it.
+    """
+    stmt = select(NewsArticle).where(NewsArticle.is_published.is_(True))
+    if category:
+        stmt = stmt.where(NewsArticle.category == category)
+
+    # NULLs last so articles without published_at don't float to the top in DESC
+    stmt = stmt.order_by(nullslast(NewsArticle.published_at.desc())).offset(offset).limit(limit)
+
+    result = await db.execute(stmt)
+    return list(result.scalars().all())
+
+
+async def get_published_news_count(
+    db: AsyncSession,
+    *,
+    category: str | None = None,
+) -> int:
+    """Get count of published news articles, optionally filtered by category."""
+    stmt = select(func.count(NewsArticle.id)).where(NewsArticle.is_published.is_(True))
+    if category:
+        stmt = stmt.where(NewsArticle.category == category)
+
+    result = await db.execute(stmt)
+    return result.scalar_one() or 0
+
+
+async def get_all_news(
+    db: AsyncSession,
+    *,
+    limit: int = 50,
+    offset: int = 0,
+) -> list[NewsArticle]:
+    """Get all news articles (admin), ordered by created_at descending."""
+    stmt = select(NewsArticle).order_by(NewsArticle.created_at.desc()).offset(offset).limit(limit)
+    result = await db.execute(stmt)
+    return list(result.scalars().all())
+
+
+async def get_all_news_count(db: AsyncSession) -> int:
+    """Get total count of all news articles."""
+    result = await db.execute(select(func.count(NewsArticle.id)))
+    return result.scalar_one() or 0
+
+
+async def get_news_categories(db: AsyncSession) -> list[str]:
+    """Get distinct categories from published articles."""
+    result = await db.execute(
+        select(NewsArticle.category)
+        .where(NewsArticle.is_published.is_(True))
+        .where(NewsArticle.category != '')
+        .distinct()
+        .order_by(NewsArticle.category)
+    )
+    return list(result.scalars().all())
+
+
+async def unfeature_all_news(db: AsyncSession) -> None:
+    """Remove featured flag from all articles (so only one can be featured).
+
+    Does NOT commit. The caller must commit the session to persist this change.
+    This is intentional — the caller should commit both this operation and the
+    subsequent feature operation atomically.
+    """
+    await db.execute(update(NewsArticle).where(NewsArticle.is_featured.is_(True)).values(is_featured=False))
+
+
+async def update_news_article(
+    db: AsyncSession,
+    article: NewsArticle,
+    **kwargs: Any,
+) -> NewsArticle:
+    """Update a news article. Only whitelisted fields are applied.
+
+    Raises:
+        IntegrityError: if slug conflicts with another article (caller must handle).
+    """
+    update_data: dict[str, Any] = {}
+    for key, value in kwargs.items():
+        if key not in _ALLOWED_UPDATE_FIELDS:
+            continue
+        if value is None and key not in _NULLABLE_UPDATE_FIELDS:
+            continue
+        update_data[key] = value
+
+    # Auto-set published_at when transitioning to published
+    if update_data.get('is_published') and not article.is_published and not update_data.get('published_at'):
+        if article.published_at is None:
+            update_data['published_at'] = datetime.now(UTC)
+
+    if not update_data:
+        return article
+
+    update_data['updated_at'] = datetime.now(UTC)
+
+    await db.execute(update(NewsArticle).where(NewsArticle.id == article.id).values(**update_data))
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(article)
+
+    logger.info(
+        'Updated news article',
+        article_id=article.id,
+        slug=article.slug,
+        updated_fields=list(update_data.keys()),
+    )
+    return article
+
+
+async def delete_news_article(db: AsyncSession, article: NewsArticle) -> None:
+    """Delete a news article."""
+    # Capture fields before commit expires the ORM instance attributes
+    article_id = article.id
+    article_slug = article.slug
+
+    await db.execute(delete(NewsArticle).where(NewsArticle.id == article_id))
+    await db.commit()
+
+    logger.info('Deleted news article', article_id=article_id, slug=article_slug)
+
+
+async def increment_views(db: AsyncSession, article_id: int) -> int:
+    """Atomically increment the views counter and return the new count.
+
+    Uses UPDATE … RETURNING so the caller can patch the ORM instance directly
+    without issuing a second SELECT (db.refresh).
+    """
+    result = await db.execute(
+        update(NewsArticle)
+        .where(NewsArticle.id == article_id)
+        .values(views_count=NewsArticle.views_count + 1)
+        .returning(NewsArticle.views_count)
+    )
+    await db.commit()
+    row = result.fetchone()
+    return row[0] if row else 0

app/database/crud/news_categories.py

@@ -0,0 +1,87 @@
+"""CRUD operations for news categories."""
+
+import structlog
+from sqlalchemy import select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import NewsArticle, NewsCategory
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def get_all_categories(db: AsyncSession) -> list[NewsCategory]:
+    """Get all news categories ordered by name."""
+    result = await db.execute(select(NewsCategory).order_by(NewsCategory.name))
+    return list(result.scalars().all())
+
+
+async def get_category_by_id(db: AsyncSession, category_id: int) -> NewsCategory | None:
+    """Get a single news category by primary key."""
+    result = await db.execute(select(NewsCategory).where(NewsCategory.id == category_id))
+    return result.scalar_one_or_none()
+
+
+async def create_category(db: AsyncSession, *, name: str, color: str = '#00e5a0') -> NewsCategory:
+    """Create a new news category.
+
+    Raises:
+        IntegrityError: if a category with the same name already exists (caller must handle).
+    """
+    category = NewsCategory(name=name.strip(), color=color)
+    db.add(category)
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(category)
+    logger.info('Created news category', category_id=category.id, name=category.name)
+    return category
+
+
+async def update_category(
+    db: AsyncSession,
+    category: NewsCategory,
+    **kwargs: str | None,
+) -> NewsCategory:
+    """Update an existing news category.
+
+    Supported kwargs: name, color.
+
+    Raises:
+        IntegrityError: if the new name conflicts with an existing category.
+    """
+    update_data: dict[str, str] = {}
+    if 'name' in kwargs and kwargs['name'] is not None:
+        update_data['name'] = kwargs['name'].strip()
+    if 'color' in kwargs and kwargs['color'] is not None:
+        update_data['color'] = kwargs['color']
+
+    if not update_data:
+        return category
+
+    await db.execute(update(NewsCategory).where(NewsCategory.id == category.id).values(**update_data))
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(category)
+    logger.info('Updated news category', category_id=category.id, updated_fields=list(update_data.keys()))
+    return category
+
+
+async def delete_category(db: AsyncSession, category: NewsCategory) -> None:
+    """Delete a news category and clear category fields from all linked articles."""
+    cat_id, cat_name = category.id, category.name
+    # Clear legacy string fields on articles that reference this category
+    await db.execute(
+        update(NewsArticle)
+        .where(NewsArticle.category_id == cat_id)
+        .values(category='', category_color='#00e5a0', category_id=None)
+    )
+    await db.delete(category)
+    await db.commit()
+    logger.info('Deleted news category', category_id=cat_id, name=cat_name)

app/database/crud/news_tags.py

@@ -0,0 +1,83 @@
+"""CRUD operations for news tags."""
+
+import structlog
+from sqlalchemy import select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import NewsArticle, NewsTag
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def get_all_tags(db: AsyncSession) -> list[NewsTag]:
+    """Get all news tags ordered by name."""
+    result = await db.execute(select(NewsTag).order_by(NewsTag.name))
+    return list(result.scalars().all())
+
+
+async def get_tag_by_id(db: AsyncSession, tag_id: int) -> NewsTag | None:
+    """Get a single news tag by primary key."""
+    result = await db.execute(select(NewsTag).where(NewsTag.id == tag_id))
+    return result.scalar_one_or_none()
+
+
+async def create_tag(db: AsyncSession, *, name: str, color: str = '#94a3b8') -> NewsTag:
+    """Create a new news tag.
+
+    Raises:
+        IntegrityError: if a tag with the same name already exists (caller must handle).
+    """
+    tag = NewsTag(name=name.strip(), color=color)
+    db.add(tag)
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(tag)
+    logger.info('Created news tag', tag_id=tag.id, name=tag.name)
+    return tag
+
+
+async def update_tag(
+    db: AsyncSession,
+    tag: NewsTag,
+    **kwargs: str | None,
+) -> NewsTag:
+    """Update an existing news tag.
+
+    Supported kwargs: name, color.
+
+    Raises:
+        IntegrityError: if the new name conflicts with an existing tag.
+    """
+    update_data: dict[str, str] = {}
+    if 'name' in kwargs and kwargs['name'] is not None:
+        update_data['name'] = kwargs['name'].strip()
+    if 'color' in kwargs and kwargs['color'] is not None:
+        update_data['color'] = kwargs['color']
+
+    if not update_data:
+        return tag
+
+    await db.execute(update(NewsTag).where(NewsTag.id == tag.id).values(**update_data))
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(tag)
+    logger.info('Updated news tag', tag_id=tag.id, updated_fields=list(update_data.keys()))
+    return tag
+
+
+async def delete_tag(db: AsyncSession, tag: NewsTag) -> None:
+    """Delete a news tag and clear tag fields from all linked articles."""
+    tag_id, tag_name = tag.id, tag.name
+    # Clear legacy string field on articles that reference this tag
+    await db.execute(update(NewsArticle).where(NewsArticle.tag_id == tag_id).values(tag=None, tag_id=None))
+    await db.delete(tag)
+    await db.commit()
+    logger.info('Deleted news tag', tag_id=tag_id, name=tag_name)

app/database/crud/notification.py

@@ -34,6 +34,8 @@ async def record_notification(
     subscription_id: int,
     notification_type: str,
     days_before: int | None = None,
+    *,
+    commit: bool = True,
 ) -> None:
     already_exists = await notification_sent(db, user_id, subscription_id, notification_type, days_before)
     if already_exists:
@@ -45,18 +47,22 @@ async def record_notification(
         days_before=days_before,
     )
     db.add(notification)
-    await db.commit()
+    if commit:
+        await db.commit()
 
 
-async def clear_notifications(db: AsyncSession, subscription_id: int) -> None:
+async def clear_notifications(db: AsyncSession, subscription_id: int, *, commit: bool = True) -> None:
     await db.execute(delete(SentNotification).where(SentNotification.subscription_id == subscription_id))
-    await db.commit()
+    if commit:
+        await db.commit()
 
 
 async def clear_notification_by_type(
     db: AsyncSession,
     subscription_id: int,
     notification_type: str,
+    *,
+    commit: bool = True,
 ) -> None:
     await db.execute(
         delete(SentNotification).where(
@@ -64,4 +70,5 @@ async def clear_notification_by_type(
             SentNotification.notification_type == notification_type,
         )
     )
-    await db.commit()
+    if commit:
+        await db.commit()

app/database/crud/pal24.py

@@ -67,7 +67,12 @@ async def get_pal24_payment_by_id(db: AsyncSession, payment_id: int) -> Pal24Pay
 
 
 async def get_pal24_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> Pal24Payment | None:
-    result = await db.execute(select(Pal24Payment).where(Pal24Payment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(Pal24Payment)
+        .where(Pal24Payment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
     return result.scalar_one_or_none()
 
 

app/database/crud/platega.py

@@ -71,7 +71,12 @@ async def get_platega_payment_by_id(db: AsyncSession, payment_id: int) -> Plateg
 
 
 async def get_platega_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> PlategaPayment | None:
-    result = await db.execute(select(PlategaPayment).where(PlategaPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(PlategaPayment)
+        .where(PlategaPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
     return result.scalar_one_or_none()
 
 

app/database/crud/promo_group.py

@@ -3,7 +3,7 @@ from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 
-from app.database.models import PromoGroup, User, UserPromoGroup
+from app.database.models import PromoGroup, Subscription, User, UserPromoGroup
 
 
 def _normalize_period_discounts(period_discounts: dict[int, int] | None) -> dict[int, int]:
@@ -97,9 +97,9 @@ async def create_promo_group(
 ) -> 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
-    )
+    if auto_assign_total_spent_kopeks is not None:
+        value = max(0, auto_assign_total_spent_kopeks)
+        auto_assign_total_spent_kopeks = value if value > 0 else None
 
     existing_default = await get_default_promo_group(db)
     should_be_default = existing_default is None or is_default
@@ -168,7 +168,8 @@ async def update_promo_group(
         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)
+        value = max(0, auto_assign_total_spent_kopeks)
+        group.auto_assign_total_spent_kopeks = value if value > 0 else None
     if apply_discounts_to_addons is not None:
         group.apply_discounts_to_addons = bool(apply_discounts_to_addons)
 
@@ -258,7 +259,7 @@ async def get_promo_group_members(
 ) -> list[User]:
     result = await db.execute(
         select(User)
-        .options(selectinload(User.subscription))
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
         .where(User.promo_group_id == group_id)
         .order_by(User.created_at.desc())
         .offset(offset)