import logging
import re
from datetime import datetime, timedelta
from typing import Optional, List, Tuple, Dict, Any, Callable
from enum import Enum
from dataclasses import dataclass
from aiogram import Dispatcher, types, F
from aiogram.exceptions import TelegramForbiddenError, TelegramBadRequest
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.fsm.context import FSMContext
from sqlalchemy.ext.asyncio import AsyncSession
from app.config import settings
from app.states import AdminStates
from app.database.models import User, UserStatus, Subscription, SubscriptionStatus, TransactionType
from app.database.crud.user import (
get_user_by_id,
get_user_by_telegram_id,
get_user_by_username,
get_referrals,
)
from app.database.crud.campaign import (
get_campaign_registration_by_user,
get_campaign_statistics,
)
from app.keyboards.admin import (
get_admin_users_keyboard, get_user_management_keyboard,
get_admin_pagination_keyboard, get_confirmation_keyboard,
get_admin_users_filters_keyboard, get_user_promo_group_keyboard,
get_user_restrictions_keyboard
)
from app.localization.texts import get_texts
from app.services.user_service import UserService
from app.services.admin_notification_service import AdminNotificationService
from app.database.crud.promo_group import get_promo_groups_with_counts
from app.utils.decorators import admin_required, error_handler
from app.utils.formatters import format_datetime, format_time_ago
from app.utils.user_utils import get_effective_referral_commission_percent
from app.services.remnawave_service import RemnaWaveService
from app.external.remnawave_api import TrafficLimitStrategy
from app.database.crud.server_squad import (
get_all_server_squads,
get_server_squad_by_uuid,
get_server_squad_by_id,
get_server_ids_by_uuids,
)
from app.database.crud.tariff import get_all_tariffs, get_tariff_by_id
from app.services.subscription_service import SubscriptionService
from app.utils.subscription_utils import (
resolve_hwid_device_limit_for_payload,
)
logger = logging.getLogger(__name__)
# =============================================================================
# Конфигурация фильтров пользователей
# =============================================================================
class UserFilterType(Enum):
"""Типы фильтрации пользователей."""
BALANCE = "balance"
TRAFFIC = "traffic"
ACTIVITY = "activity"
SPENDING = "spending"
PURCHASES = "purchases"
CAMPAIGN = "campaign"
@dataclass
class UserFilterConfig:
"""Конфигурация для типа фильтра."""
fsm_state: Any # State из AdminStates
title: str
empty_message: str
pagination_prefix: str
order_param: str # параметр для get_users_page
# Конфигурация для каждого типа фильтра
USER_FILTER_CONFIGS: Dict[UserFilterType, UserFilterConfig] = {
UserFilterType.BALANCE: UserFilterConfig(
fsm_state=AdminStates.viewing_user_from_balance_list,
title="👥 Список пользователей по балансу",
empty_message="👥 Пользователи не найдены",
pagination_prefix="admin_users_balance_list",
order_param="order_by_balance",
),
UserFilterType.TRAFFIC: UserFilterConfig(
fsm_state=AdminStates.viewing_user_from_traffic_list,
title="👥 Список пользователей по использованному трафику",
empty_message="📶 Пользователи с трафиком не найдены",
pagination_prefix="admin_users_traffic_list",
order_param="order_by_traffic",
),
UserFilterType.ACTIVITY: UserFilterConfig(
fsm_state=AdminStates.viewing_user_from_last_activity_list,
title="👥 Пользователи по активности",
empty_message="🕒 Пользователи с активностью не найдены",
pagination_prefix="admin_users_activity_list",
order_param="order_by_last_activity",
),
UserFilterType.SPENDING: UserFilterConfig(
fsm_state=AdminStates.viewing_user_from_spending_list,
title="👥 Пользователи по сумме трат",
empty_message="💳 Пользователи с тратами не найдены",
pagination_prefix="admin_users_spending_list",
order_param="order_by_total_spent",
),
UserFilterType.PURCHASES: UserFilterConfig(
fsm_state=AdminStates.viewing_user_from_purchases_list,
title="👥 Пользователи по количеству покупок",
empty_message="🛒 Пользователи с покупками не найдены",
pagination_prefix="admin_users_purchases_list",
order_param="order_by_purchase_count",
),
UserFilterType.CAMPAIGN: UserFilterConfig(
fsm_state=AdminStates.viewing_user_from_campaign_list,
title="👥 Пользователи по кампании регистрации",
empty_message="📢 Пользователи с кампанией не найдены",
pagination_prefix="admin_users_campaign_list",
order_param="", # использует специальный метод
),
}
def _get_user_status_emoji(user: User) -> str:
"""Возвращает эмодзи статуса пользователя."""
if user.status == UserStatus.ACTIVE.value:
return "✅"
elif user.status == UserStatus.BLOCKED.value:
return "🚫"
return "🗑️"
def _get_subscription_emoji(user: User) -> str:
"""Возвращает эмодзи подписки пользователя."""
if not user.subscription:
return "❌"
if user.subscription.is_trial:
return "🎁"
if user.subscription.is_active:
return "💎"
return "⏰"
def _build_user_button_text(
user: User,
filter_type: UserFilterType,
extra_data: Optional[Dict[str, Any]] = None,
language: str = "ru"
) -> str:
"""
Формирует текст кнопки пользователя в зависимости от типа фильтра.
Args:
user: Пользователь
filter_type: Тип фильтра
extra_data: Дополнительные данные (spending_map, campaign_map и т.д.)
language: Язык пользователя
"""
status_emoji = _get_user_status_emoji(user)
sub_emoji = _get_subscription_emoji(user)
if filter_type == UserFilterType.BALANCE:
button_text = f"{status_emoji} {sub_emoji} {user.full_name}"
if user.balance_kopeks > 0:
button_text += f" | 💰 {settings.format_price(user.balance_kopeks)}"
if user.subscription and user.subscription.end_date:
days_left = (user.subscription.end_date - datetime.utcnow()).days
button_text += f" | 📅 {days_left}д"
elif filter_type == UserFilterType.TRAFFIC:
if user.subscription:
sub = user.subscription
used = sub.traffic_used_gb or 0.0
if sub.traffic_limit_gb and sub.traffic_limit_gb > 0:
limit_display = f"{sub.traffic_limit_gb}"
else:
limit_display = "♾️"
traffic_display = f"{used:.1f}/{limit_display} ГБ"
else:
traffic_display = "нет подписки"
button_text = f"{status_emoji} {sub_emoji} {user.full_name} | 📶 {traffic_display}"
if user.balance_kopeks > 0:
button_text += f" | 💰 {settings.format_price(user.balance_kopeks)}"
elif filter_type == UserFilterType.ACTIVITY:
activity_display = (
format_time_ago(user.last_activity, language)
if user.last_activity
else "неизвестно"
)
button_text = f"{status_emoji} {sub_emoji} {user.full_name} | 🕒 {activity_display}"
elif filter_type in (UserFilterType.SPENDING, UserFilterType.PURCHASES):
stats = extra_data.get(user.id, {"total_spent": 0, "purchase_count": 0}) if extra_data else {}
total_spent = stats.get("total_spent", 0)
purchases = stats.get("purchase_count", 0)
if filter_type == UserFilterType.SPENDING:
button_text = f"{status_emoji} {user.full_name} | 💳 {settings.format_price(total_spent)} | 🛒 {purchases}"
else:
button_text = f"{status_emoji} {user.full_name} | 🛒 {purchases} | 💳 {settings.format_price(total_spent)}"
elif filter_type == UserFilterType.CAMPAIGN:
info = extra_data.get(user.id, {}) if extra_data else {}
campaign_name = info.get("campaign_name") or "Без кампании"
registered_at = info.get("registered_at")
registered_display = format_datetime(registered_at) if registered_at else "неизвестно"
button_text = f"{status_emoji} {user.full_name} | 📢 {campaign_name} | 📅 {registered_display}"
else:
button_text = f"{status_emoji} {sub_emoji} {user.full_name}"
# Обрезка длинных имён
if len(button_text) > 60:
short_name = user.full_name[:17] + "..." if len(user.full_name) > 20 else user.full_name
# Пересобираем с коротким именем
if filter_type == UserFilterType.BALANCE:
button_text = f"{status_emoji} {sub_emoji} {short_name}"
if user.balance_kopeks > 0:
button_text += f" | 💰 {settings.format_price(user.balance_kopeks)}"
elif filter_type == UserFilterType.TRAFFIC:
if user.subscription:
sub = user.subscription
used = sub.traffic_used_gb or 0.0
if sub.traffic_limit_gb and sub.traffic_limit_gb > 0:
limit_display = f"{sub.traffic_limit_gb}"
else:
limit_display = "♾️"
traffic_display = f"{used:.1f}/{limit_display} ГБ"
else:
traffic_display = "нет"
button_text = f"{status_emoji} {sub_emoji} {short_name} | 📶 {traffic_display}"
else:
button_text = f"{status_emoji} {short_name}"
return button_text
async def _show_users_list_filtered(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
filter_type: UserFilterType,
page: int = 1
) -> None:
"""
Универсальная функция отображения отфильтрованного списка пользователей.
Args:
callback: Callback query
db_user: Текущий администратор
db: Сессия БД
state: FSM состояние
filter_type: Тип фильтра
page: Номер страницы
"""
config = USER_FILTER_CONFIGS[filter_type]
# Устанавливаем FSM состояние
await state.set_state(config.fsm_state)
user_service = UserService()
extra_data: Optional[Dict[str, Any]] = None
# Получаем данные в зависимости от типа фильтра
if filter_type == UserFilterType.CAMPAIGN:
users_data = await user_service.get_users_by_campaign_page(db, page=page, limit=10)
extra_data = users_data.get("campaigns", {})
else:
kwargs = {"db": db, "page": page, "limit": 10, config.order_param: True}
users_data = await user_service.get_users_page(**kwargs)
users = users_data.get("users", [])
# Если нет пользователей
if not users:
await callback.message.edit_text(
config.empty_message,
reply_markup=get_admin_users_keyboard(db_user.language)
)
await callback.answer()
return
# Для spending/purchases нужны дополнительные данные
if filter_type in (UserFilterType.SPENDING, UserFilterType.PURCHASES):
extra_data = await user_service.get_user_spending_stats_map(
db, [user.id for user in users]
)
# Формируем текст заголовка
text = f"{config.title} (стр. {page}/{users_data['total_pages']})\n\n"
text += "Нажмите на пользователя для управления:"
# Формируем клавиатуру
keyboard = []
for user in users:
button_text = _build_user_button_text(user, filter_type, extra_data, db_user.language)
keyboard.append([
types.InlineKeyboardButton(
text=button_text,
callback_data=f"admin_user_manage_{user.id}"
)
])
# Пагинация
if users_data["total_pages"] > 1:
pagination_row = get_admin_pagination_keyboard(
users_data["current_page"],
users_data["total_pages"],
config.pagination_prefix,
"admin_users",
db_user.language
).inline_keyboard[0]
keyboard.append(pagination_row)
# Дополнительные кнопки
keyboard.extend([
[
types.InlineKeyboardButton(text="🔍 Поиск", callback_data="admin_users_search"),
types.InlineKeyboardButton(text="📊 Статистика", callback_data="admin_users_stats")
],
[
types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")
]
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def show_users_menu(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_service = UserService()
stats = await user_service.get_user_statistics(db)
text = f"""
👥 Управление пользователями
📊 Статистика:
• Всего: {stats['total_users']}
• Активных: {stats['active_users']}
• Заблокированных: {stats['blocked_users']}
📈 Новые пользователи:
• Сегодня: {stats['new_today']}
• За неделю: {stats['new_week']}
• За месяц: {stats['new_month']}
Выберите действие:
"""
await callback.message.edit_text(
text,
reply_markup=get_admin_users_keyboard(db_user.language)
)
await callback.answer()
@admin_required
@error_handler
async def show_users_filters(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
text = ("⚙️ Фильтры пользователей\n\nВыберите фильтр для отображения пользователей:\n")
await callback.message.edit_text(
text,
reply_markup=get_admin_users_filters_keyboard(db_user.language)
)
await callback.answer()
@admin_required
@error_handler
async def show_users_list(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
# Сбрасываем состояние, так как мы в обычном списке
await state.set_state(None)
user_service = UserService()
users_data = await user_service.get_users_page(db, page=page, limit=10)
if not users_data["users"]:
await callback.message.edit_text(
"👥 Пользователи не найдены",
reply_markup=get_admin_users_keyboard(db_user.language)
)
await callback.answer()
return
text = f"👥 Список пользователей (стр. {page}/{users_data['total_pages']})\n\n"
text += "Нажмите на пользователя для управления:"
keyboard = []
for user in users_data["users"]:
if user.status == UserStatus.ACTIVE.value:
status_emoji = "✅"
elif user.status == UserStatus.BLOCKED.value:
status_emoji = "🚫"
else:
status_emoji = "🗑️"
subscription_emoji = ""
if user.subscription:
if user.subscription.is_trial:
subscription_emoji = "🎁"
elif user.subscription.is_active:
subscription_emoji = "💎"
else:
subscription_emoji = "⏰"
else:
subscription_emoji = "❌"
button_text = f"{status_emoji} {subscription_emoji} {user.full_name}"
if user.balance_kopeks > 0:
button_text += f" | 💰 {settings.format_price(user.balance_kopeks)}"
button_text += f" | 📅 {format_time_ago(user.created_at, db_user.language)}"
if len(button_text) > 60:
short_name = user.full_name
if len(short_name) > 20:
short_name = short_name[:17] + "..."
button_text = f"{status_emoji} {subscription_emoji} {short_name}"
if user.balance_kopeks > 0:
button_text += f" | 💰 {settings.format_price(user.balance_kopeks)}"
keyboard.append([
types.InlineKeyboardButton(
text=button_text,
callback_data=f"admin_user_manage_{user.id}"
)
])
if users_data["total_pages"] > 1:
pagination_row = get_admin_pagination_keyboard(
users_data["current_page"],
users_data["total_pages"],
"admin_users_list",
"admin_users",
db_user.language
).inline_keyboard[0]
keyboard.append(pagination_row)
keyboard.extend([
[
types.InlineKeyboardButton(text="🔍 Поиск", callback_data="admin_users_search"),
types.InlineKeyboardButton(text="📊 Статистика", callback_data="admin_users_stats")
],
[
types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")
]
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def show_users_list_by_balance(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Список пользователей, отсортированный по балансу (убывание)."""
await _show_users_list_filtered(callback, db_user, db, state, UserFilterType.BALANCE, page)
@admin_required
@error_handler
async def show_users_ready_to_renew(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Показывает пользователей с истекшей подпиской и балансом >= порога."""
await state.set_state(AdminStates.viewing_user_from_ready_to_renew_list)
texts = get_texts(db_user.language)
threshold = getattr(
settings,
"SUBSCRIPTION_RENEWAL_BALANCE_THRESHOLD_KOPEKS",
20000,
)
user_service = UserService()
users_data = await user_service.get_users_ready_to_renew(
db,
min_balance_kopeks=threshold,
page=page,
limit=10,
)
amount_text = settings.format_price(threshold)
header = texts.t(
"ADMIN_USERS_FILTER_RENEW_READY_TITLE",
"♻️ Пользователи готовы к продлению",
)
description = texts.t(
"ADMIN_USERS_FILTER_RENEW_READY_DESC",
"Подписка истекла, а на балансе осталось {amount} или больше.",
).format(amount=amount_text)
if not users_data["users"]:
empty_text = texts.t(
"ADMIN_USERS_FILTER_RENEW_READY_EMPTY",
"Сейчас нет пользователей, которые подходят под этот фильтр.",
)
await callback.message.edit_text(
f"{header}\n\n{description}\n\n{empty_text}",
reply_markup=get_admin_users_keyboard(db_user.language),
)
await callback.answer()
return
text = f"{header}\n\n{description}\n\n"
text += "Нажмите на пользователя для управления:"
keyboard = []
current_time = datetime.utcnow()
for user in users_data["users"]:
subscription = user.subscription
status_emoji = "✅" if user.status == UserStatus.ACTIVE.value else "🚫"
subscription_emoji = "❌"
expired_days = "?"
if subscription:
if subscription.is_trial:
subscription_emoji = "🎁"
elif subscription.is_active:
subscription_emoji = "💎"
else:
subscription_emoji = "⏰"
if subscription.end_date:
delta = current_time - subscription.end_date
expired_days = delta.days
button_text = (
f"{status_emoji} {subscription_emoji} {user.full_name}"
f" | 💰 {settings.format_price(user.balance_kopeks)}"
f" | ⏰ {expired_days}д ист."
)
if len(button_text) > 60:
short_name = user.full_name
if len(short_name) > 20:
short_name = short_name[:17] + "..."
button_text = (
f"{status_emoji} {subscription_emoji} {short_name}"
f" | 💰 {settings.format_price(user.balance_kopeks)}"
)
keyboard.append([
types.InlineKeyboardButton(
text=button_text,
callback_data=f"admin_user_manage_{user.id}",
)
])
if users_data["total_pages"] > 1:
pagination_row = get_admin_pagination_keyboard(
users_data["current_page"],
users_data["total_pages"],
"admin_users_ready_to_renew_list",
"admin_users_ready_to_renew_filter",
db_user.language,
).inline_keyboard[0]
keyboard.append(pagination_row)
keyboard.extend([
[
types.InlineKeyboardButton(
text="🔍 Поиск",
callback_data="admin_users_search",
),
types.InlineKeyboardButton(
text="📊 Статистика",
callback_data="admin_users_stats",
),
],
[
types.InlineKeyboardButton(
text="⬅️ Назад",
callback_data="admin_users",
)
],
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
)
await callback.answer()
@admin_required
@error_handler
async def show_users_list_by_traffic(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Список пользователей, отсортированный по использованному трафику (убывание)."""
await _show_users_list_filtered(callback, db_user, db, state, UserFilterType.TRAFFIC, page)
@admin_required
@error_handler
async def show_users_list_by_last_activity(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Список пользователей, отсортированный по последней активности."""
await _show_users_list_filtered(callback, db_user, db, state, UserFilterType.ACTIVITY, page)
@admin_required
@error_handler
async def show_users_list_by_spending(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Список пользователей, отсортированный по сумме трат (убывание)."""
await _show_users_list_filtered(callback, db_user, db, state, UserFilterType.SPENDING, page)
@admin_required
@error_handler
async def show_users_list_by_purchases(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Список пользователей, отсортированный по количеству покупок (убывание)."""
await _show_users_list_filtered(callback, db_user, db, state, UserFilterType.PURCHASES, page)
@admin_required
@error_handler
async def show_users_list_by_campaign(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
page: int = 1
):
"""Список пользователей по кампании регистрации."""
await _show_users_list_filtered(callback, db_user, db, state, UserFilterType.CAMPAIGN, page)
@admin_required
@error_handler
async def handle_users_list_pagination_fixed(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_balance_list_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list_by_balance(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list_by_balance(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_traffic_list_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list_by_traffic(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list_by_traffic(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_activity_list_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list_by_last_activity(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list_by_last_activity(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_spending_list_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list_by_spending(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list_by_spending(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_purchases_list_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list_by_purchases(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list_by_purchases(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_ready_to_renew_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
page = int(callback.data.split('_')[-1])
await show_users_ready_to_renew(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_ready_to_renew(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def handle_users_campaign_list_pagination(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
try:
callback_parts = callback.data.split('_')
page = int(callback_parts[-1])
await show_users_list_by_campaign(callback, db_user, db, state, page)
except (ValueError, IndexError) as e:
logger.error(f"Ошибка парсинга номера страницы: {e}")
await show_users_list_by_campaign(callback, db_user, db, state, 1)
@admin_required
@error_handler
async def start_user_search(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
await callback.message.edit_text(
"🔍 Поиск пользователя\n\n"
"Введите для поиска:\n"
"• Telegram ID\n"
"• Username (без @)\n"
"• Имя или фамилию\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_users")]
])
)
await state.set_state(AdminStates.waiting_for_user_search)
await callback.answer()
@admin_required
@error_handler
async def show_users_statistics(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_service = UserService()
stats = await user_service.get_user_statistics(db)
from sqlalchemy import select, func, or_
current_time = datetime.utcnow()
active_subscription_query = (
select(func.count(Subscription.id))
.join(User, Subscription.user_id == User.id)
.where(
User.status == UserStatus.ACTIVE.value,
Subscription.status.in_(
[
SubscriptionStatus.ACTIVE.value,
SubscriptionStatus.TRIAL.value,
]
),
Subscription.end_date > current_time,
)
)
users_with_subscription = (
await db.execute(active_subscription_query)
).scalar() or 0
trial_subscription_query = (
select(func.count(Subscription.id))
.join(User, Subscription.user_id == User.id)
.where(
User.status == UserStatus.ACTIVE.value,
Subscription.end_date > current_time,
or_(
Subscription.status == SubscriptionStatus.TRIAL.value,
Subscription.is_trial.is_(True),
),
)
)
trial_users = (await db.execute(trial_subscription_query)).scalar() or 0
users_without_subscription = max(
stats["active_users"] - users_with_subscription,
0,
)
avg_balance_result = await db.execute(
select(func.avg(User.balance_kopeks))
.where(User.status == UserStatus.ACTIVE.value)
)
avg_balance = avg_balance_result.scalar() or 0
text = f"""
📊 Детальная статистика пользователей
👥 Общие показатели:
• Всего: {stats['total_users']}
• Активных: {stats['active_users']}
• Заблокированных: {stats['blocked_users']}
📱 Подписки:
• С активной подпиской: {users_with_subscription}
• На триале: {trial_users}
• Без подписки: {users_without_subscription}
💰 Финансы:
• Средний баланс: {settings.format_price(int(avg_balance))}
📈 Регистрации:
• Сегодня: {stats['new_today']}
• За неделю: {stats['new_week']}
• За месяц: {stats['new_month']}
📊 Активность:
• Конверсия в подписку: {(users_with_subscription / max(stats['active_users'], 1) * 100):.1f}%
• Доля триальных: {(trial_users / max(users_with_subscription, 1) * 100):.1f}%
"""
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_users_stats")],
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
])
)
await callback.answer()
async def _render_user_subscription_overview(
callback: types.CallbackQuery,
db: AsyncSession,
user_id: int
) -> bool:
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return False
user = profile["user"]
subscription = profile["subscription"]
text = "📱 Подписка и настройки пользователя\n\n"
user_link = f'{user.full_name}'
text += f"👤 {user_link} (ID: {user.telegram_id})\n\n"
keyboard = []
if subscription:
status_emoji = "✅" if subscription.is_active else "❌"
type_emoji = "🎁" if subscription.is_trial else "💎"
traffic_display = f"{subscription.traffic_used_gb:.1f}/"
if subscription.traffic_limit_gb == 0:
traffic_display += "♾️ ГБ"
else:
traffic_display += f"{subscription.traffic_limit_gb} ГБ"
text += f"Статус: {status_emoji} {'Активна' if subscription.is_active else 'Неактивна'}\n"
text += f"Тип: {type_emoji} {'Триал' if subscription.is_trial else 'Платная'}\n"
# Отображение тарифа
if subscription.tariff_id:
tariff = await get_tariff_by_id(db, subscription.tariff_id)
if tariff:
text += f"Тариф: 📦 {tariff.name}\n"
else:
text += f"Тариф: ID {subscription.tariff_id} (удалён)\n"
text += f"Начало: {format_datetime(subscription.start_date)}\n"
text += f"Окончание: {format_datetime(subscription.end_date)}\n"
text += f"Трафик: {traffic_display}\n"
text += f"Устройства: {subscription.device_limit}\n"
if subscription.is_active:
days_left = (subscription.end_date - datetime.utcnow()).days
text += f"Осталось дней: {days_left}\n"
current_squads = subscription.connected_squads or []
if current_squads:
text += "\nПодключенные серверы:\n"
for squad_uuid in current_squads:
try:
server = await get_server_squad_by_uuid(db, squad_uuid)
if server:
text += f"• {server.display_name}\n"
else:
text += f"• {squad_uuid[:8]}... (неизвестный)\n"
except Exception as e:
logger.error(f"Ошибка получения сервера {squad_uuid}: {e}")
text += f"• {squad_uuid[:8]}... (ошибка загрузки)\n"
else:
text += "\nПодключенные серверы: отсутствуют\n"
keyboard = [
[
types.InlineKeyboardButton(
text="⏰ Продлить",
callback_data=f"admin_sub_extend_{user_id}"
),
types.InlineKeyboardButton(
text="💳 Купить подписку",
callback_data=f"admin_sub_buy_{user_id}"
)
],
[
types.InlineKeyboardButton(
text="🔄 Тип подписки",
callback_data=f"admin_sub_change_type_{user_id}"
),
types.InlineKeyboardButton(
text="📊 Добавить трафик",
callback_data=f"admin_sub_traffic_{user_id}"
)
],
[
types.InlineKeyboardButton(
text="🌍 Сменить сервер",
callback_data=f"admin_user_change_server_{user_id}"
),
types.InlineKeyboardButton(
text="📱 Устройства",
callback_data=f"admin_user_devices_{user_id}"
)
],
[
types.InlineKeyboardButton(
text="🛠️ Лимит трафика",
callback_data=f"admin_user_traffic_{user_id}"
),
types.InlineKeyboardButton(
text="🔄 Сбросить устройства",
callback_data=f"admin_user_reset_devices_{user_id}"
)
]
]
if settings.is_modem_enabled():
modem_status = "✅" if getattr(subscription, 'modem_enabled', False) else "❌"
keyboard.append([
types.InlineKeyboardButton(
text=f"📡 Модем ({modem_status})",
callback_data=f"admin_user_modem_{user_id}"
)
])
# Кнопки тарифов в режиме тарифов
if settings.is_tariffs_mode():
keyboard.append([
types.InlineKeyboardButton(
text="📦 Сменить тариф",
callback_data=f"admin_sub_change_tariff_{user_id}"
),
types.InlineKeyboardButton(
text="💳 Купить тариф",
callback_data=f"admin_tariff_buy_{user_id}"
)
])
if subscription.is_active:
keyboard.append([
types.InlineKeyboardButton(
text="🚫 Деактивировать",
callback_data=f"admin_sub_deactivate_{user_id}"
)
])
else:
keyboard.append([
types.InlineKeyboardButton(
text="✅ Активировать",
callback_data=f"admin_sub_activate_{user_id}"
)
])
else:
text += "❌ Подписка отсутствует\n\n"
text += "Пользователь еще не активировал подписку."
keyboard = [
[
types.InlineKeyboardButton(
text="🎁 Выдать триал",
callback_data=f"admin_sub_grant_trial_{user_id}"
),
types.InlineKeyboardButton(
text="💎 Выдать подписку",
callback_data=f"admin_sub_grant_{user_id}"
)
]
]
keyboard.append([
types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
return True
@admin_required
@error_handler
async def show_user_subscription(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
if await _render_user_subscription_overview(callback, db, user_id):
await callback.answer()
@admin_required
@error_handler
async def show_user_transactions(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
from app.database.crud.transaction import get_user_transactions
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
transactions = await get_user_transactions(db, user_id, limit=10)
text = f"💳 Транзакции пользователя\n\n"
user_link = f'{user.full_name}'
text += f"👤 {user_link} (ID: {user.telegram_id})\n"
text += f"💰 Текущий баланс: {settings.format_price(user.balance_kopeks)}\n\n"
if transactions:
text += "Последние транзакции:\n\n"
for transaction in transactions:
type_emoji = "📈" if transaction.amount_kopeks > 0 else "📉"
text += f"{type_emoji} {settings.format_price(abs(transaction.amount_kopeks))}\n"
text += f"📋 {transaction.description}\n"
text += f"📅 {format_datetime(transaction.created_at)}\n\n"
else:
text += "📭 Транзакции отсутствуют"
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def confirm_user_delete(
callback: types.CallbackQuery,
db_user: User
):
user_id = int(callback.data.split('_')[-1])
await callback.message.edit_text(
"🗑️ Удаление пользователя\n\n"
"⚠️ ВНИМАНИЕ!\n"
"Вы уверены, что хотите удалить этого пользователя?\n\n"
"Это действие:\n"
"• Пометит пользователя как удаленного\n"
"• Деактивирует его подписку\n"
"• Заблокирует доступ к боту\n\n"
"Данное действие необратимо!",
reply_markup=get_confirmation_keyboard(
f"admin_user_delete_confirm_{user_id}",
f"admin_user_manage_{user_id}",
db_user.language
)
)
await callback.answer()
@admin_required
@error_handler
async def delete_user_account(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
success = await user_service.delete_user_account(db, user_id, db_user.id)
if success:
await callback.message.edit_text(
"✅ Пользователь успешно удален",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👥 К списку пользователей", callback_data="admin_users_list")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка удаления пользователя",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def process_user_search(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
query = message.text.strip()
if not query:
await message.answer("❌ Введите корректный запрос для поиска")
return
user_service = UserService()
search_results = await user_service.search_users(db, query, page=1, limit=10)
if not search_results["users"]:
await message.answer(
f"🔍 По запросу '{query}' ничего не найдено",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
])
)
await state.clear()
return
text = f"🔍 Результаты поиска: '{query}'\n\n"
text += "Выберите пользователя:"
keyboard = []
for user in search_results["users"]:
if user.status == UserStatus.ACTIVE.value:
status_emoji = "✅"
elif user.status == UserStatus.BLOCKED.value:
status_emoji = "🚫"
else:
status_emoji = "🗑️"
subscription_emoji = ""
if user.subscription:
if user.subscription.is_trial:
subscription_emoji = "🎁"
elif user.subscription.is_active:
subscription_emoji = "💎"
else:
subscription_emoji = "⏰"
else:
subscription_emoji = "❌"
button_text = f"{status_emoji} {subscription_emoji} {user.full_name}"
button_text += f" | 🆔 {user.telegram_id}"
if user.balance_kopeks > 0:
button_text += f" | 💰 {settings.format_price(user.balance_kopeks)}"
if len(button_text) > 60:
short_name = user.full_name
if len(short_name) > 15:
short_name = short_name[:12] + "..."
button_text = f"{status_emoji} {subscription_emoji} {short_name} | 🆔 {user.telegram_id}"
keyboard.append([
types.InlineKeyboardButton(
text=button_text,
callback_data=f"admin_user_manage_{user.id}"
)
])
keyboard.append([
types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")
])
await message.answer(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await state.clear()
@admin_required
@error_handler
async def show_user_management(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
# Поддерживаем переход "из тикета": admin_user_manage_{userId}_from_ticket_{ticketId}
parts = callback.data.split('_')
try:
user_id = int(parts[3]) # admin_user_manage_{userId}
except Exception:
user_id = int(callback.data.split('_')[-1])
origin_ticket_id = None
if "from" in parts and "ticket" in parts:
try:
origin_ticket_id = int(parts[-1])
except Exception:
origin_ticket_id = None
# Если пришли из тикета — запомним в состоянии, чтобы сохранять кнопку возврата
try:
if origin_ticket_id:
await state.update_data(origin_ticket_id=origin_ticket_id, origin_ticket_user_id=user_id)
except Exception:
pass
# Если не пришло в колбэке — попробуем достать из состояния
if origin_ticket_id is None:
try:
data_state = await state.get_data()
if data_state.get("origin_ticket_user_id") == user_id:
origin_ticket_id = data_state.get("origin_ticket_id")
except Exception:
pass
# Проверяем, откуда пришел пользователь
back_callback = "admin_users_list"
# Если callback_data содержит информацию о том, что мы пришли из списка по балансу
# В реальности это сложно определить, поэтому будем использовать состояние
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
user = profile["user"]
subscription = profile["subscription"]
texts = get_texts(db_user.language)
status_map = {
UserStatus.ACTIVE.value: texts.ADMIN_USER_STATUS_ACTIVE,
UserStatus.BLOCKED.value: texts.ADMIN_USER_STATUS_BLOCKED,
UserStatus.DELETED.value: texts.ADMIN_USER_STATUS_DELETED,
}
status_text = status_map.get(user.status, texts.ADMIN_USER_STATUS_UNKNOWN)
username_display = (
f"@{user.username}" if user.username else texts.ADMIN_USER_USERNAME_NOT_SET
)
last_activity = (
format_time_ago(user.last_activity, db_user.language)
if user.last_activity
else texts.ADMIN_USER_LAST_ACTIVITY_UNKNOWN
)
sections = [
texts.ADMIN_USER_MANAGEMENT_PROFILE.format(
name=user.full_name,
telegram_id=user.telegram_id,
username=username_display,
status=status_text,
language=user.language,
balance=settings.format_price(user.balance_kopeks),
transactions=profile["transactions_count"],
registration=format_datetime(user.created_at),
last_activity=last_activity,
registration_days=profile["registration_days"],
)
]
if subscription:
subscription_type = (
texts.ADMIN_USER_SUBSCRIPTION_TYPE_TRIAL
if subscription.is_trial
else texts.ADMIN_USER_SUBSCRIPTION_TYPE_PAID
)
subscription_status = (
texts.ADMIN_USER_SUBSCRIPTION_STATUS_ACTIVE
if subscription.is_active
else texts.ADMIN_USER_SUBSCRIPTION_STATUS_INACTIVE
)
traffic_usage = texts.ADMIN_USER_TRAFFIC_USAGE.format(
used=f"{subscription.traffic_used_gb:.1f}",
limit=subscription.traffic_limit_gb,
)
sections.append(
texts.ADMIN_USER_MANAGEMENT_SUBSCRIPTION.format(
type=subscription_type,
status=subscription_status,
end_date=format_datetime(subscription.end_date),
traffic=traffic_usage,
devices=subscription.device_limit,
countries=len(subscription.connected_squads),
)
)
else:
sections.append(texts.ADMIN_USER_MANAGEMENT_SUBSCRIPTION_NONE)
# Display promo groups
primary_group = user.get_primary_promo_group()
if primary_group:
sections.append(
texts.t(
"ADMIN_USER_PROMO_GROUPS_PRIMARY",
"⭐ Основная: {name} (Priority: {priority})",
).format(name=primary_group.name, priority=getattr(primary_group, "priority", 0))
)
sections.append(
texts.ADMIN_USER_MANAGEMENT_PROMO_GROUP.format(
name=primary_group.name,
server_discount=primary_group.server_discount_percent,
traffic_discount=primary_group.traffic_discount_percent,
device_discount=primary_group.device_discount_percent,
)
)
# Show additional groups if any
if user.user_promo_groups and len(user.user_promo_groups) > 1:
additional_groups = [
upg.promo_group for upg in user.user_promo_groups
if upg.promo_group and upg.promo_group.id != primary_group.id
]
if additional_groups:
sections.append(
texts.t(
"ADMIN_USER_PROMO_GROUPS_ADDITIONAL",
"Дополнительные группы:",
)
)
for group in additional_groups:
sections.append(
f" • {group.name} (Priority: {getattr(group, 'priority', 0)})"
)
else:
sections.append(texts.ADMIN_USER_MANAGEMENT_PROMO_GROUP_NONE)
# Показать ограничения пользователя если есть
restriction_topup = getattr(user, 'restriction_topup', False)
restriction_subscription = getattr(user, 'restriction_subscription', False)
if restriction_topup or restriction_subscription:
restriction_lines = ["⚠️ Ограничения:"]
if restriction_topup:
restriction_lines.append(" • 🚫 Пополнение запрещено")
if restriction_subscription:
restriction_lines.append(" • 🚫 Продление/покупка запрещена")
restriction_reason = getattr(user, 'restriction_reason', None)
if restriction_reason:
restriction_lines.append(f" 📝 Причина: {restriction_reason}")
sections.append("\n".join(restriction_lines))
text = "\n\n".join(sections)
# Проверяем состояние, чтобы определить, откуда пришел пользователь
current_state = await state.get_state()
if current_state == AdminStates.viewing_user_from_balance_list:
back_callback = "admin_users_balance_filter"
elif current_state == AdminStates.viewing_user_from_traffic_list:
back_callback = "admin_users_traffic_filter"
elif current_state == AdminStates.viewing_user_from_last_activity_list:
back_callback = "admin_users_activity_filter"
elif current_state == AdminStates.viewing_user_from_spending_list:
back_callback = "admin_users_spending_filter"
elif current_state == AdminStates.viewing_user_from_purchases_list:
back_callback = "admin_users_purchases_filter"
elif current_state == AdminStates.viewing_user_from_campaign_list:
back_callback = "admin_users_campaign_filter"
elif current_state == AdminStates.viewing_user_from_ready_to_renew_list:
back_callback = "admin_users_ready_to_renew_filter"
# Базовая клавиатура профиля
kb = get_user_management_keyboard(user.id, user.status, db_user.language, back_callback)
# Если пришли из тикета — добавим в начало кнопку возврата к тикету
try:
if origin_ticket_id:
back_to_ticket_btn = types.InlineKeyboardButton(
text="🎫 Вернуться к тикету",
callback_data=f"admin_view_ticket_{origin_ticket_id}"
)
kb.inline_keyboard.insert(0, [back_to_ticket_btn])
except Exception:
pass
await callback.message.edit_text(
text,
reply_markup=kb
)
await callback.answer()
async def _build_user_referrals_view(
db: AsyncSession,
language: str,
user_id: int,
limit: int = 30,
) -> Optional[Tuple[str, InlineKeyboardMarkup]]:
texts = get_texts(language)
user = await get_user_by_id(db, user_id)
if not user:
return None
referrals = await get_referrals(db, user_id)
effective_percent = get_effective_referral_commission_percent(user)
default_percent = settings.REFERRAL_COMMISSION_PERCENT
header = texts.t(
"ADMIN_USER_REFERRALS_TITLE",
"🤝 Рефералы пользователя",
)
summary = texts.t(
"ADMIN_USER_REFERRALS_SUMMARY",
"👤 {name} (ID: {telegram_id})\n👥 Всего рефералов: {count}",
).format(
name=user.full_name,
telegram_id=user.telegram_id,
count=len(referrals),
)
lines: List[str] = [header, summary]
if user.referral_commission_percent is None:
lines.append(
texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_DEFAULT",
"• Процент комиссии: {percent}% (стандартное значение)",
).format(percent=effective_percent)
)
else:
lines.append(
texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_CUSTOM",
"• Индивидуальный процент: {percent}% (стандарт: {default_percent}%)",
).format(
percent=user.referral_commission_percent,
default_percent=default_percent,
)
)
if referrals:
lines.append(
texts.t(
"ADMIN_USER_REFERRALS_LIST_HEADER",
"Список рефералов:",
)
)
items = []
for referral in referrals[:limit]:
username_part = (
f", @{referral.username}"
if referral.username
else ""
)
referral_link = f'{referral.full_name}'
items.append(
texts.t(
"ADMIN_USER_REFERRALS_LIST_ITEM",
"• {name} (ID: {telegram_id}{username_part})",
).format(
name=referral_link,
telegram_id=referral.telegram_id,
username_part=username_part,
)
)
lines.append("\n".join(items))
if len(referrals) > limit:
remaining = len(referrals) - limit
lines.append(
texts.t(
"ADMIN_USER_REFERRALS_LIST_TRUNCATED",
"• … и ещё {count} рефералов",
).format(count=remaining)
)
else:
lines.append(
texts.t(
"ADMIN_USER_REFERRALS_EMPTY",
"Рефералов пока нет.",
)
)
lines.append(
texts.t(
"ADMIN_USER_REFERRALS_EDIT_HINT",
"✏️ Чтобы изменить список, нажмите «✏️ Редактировать» ниже.",
)
)
keyboard = InlineKeyboardMarkup(
inline_keyboard=[
[
InlineKeyboardButton(
text=texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_EDIT_BUTTON",
"📈 Изменить процент",
),
callback_data=f"admin_user_referral_percent_{user_id}",
)
],
[
InlineKeyboardButton(
text=texts.t(
"ADMIN_USER_REFERRALS_EDIT_BUTTON",
"✏️ Редактировать",
),
callback_data=f"admin_user_referrals_edit_{user_id}",
)
],
[
InlineKeyboardButton(
text=texts.BACK,
callback_data=f"admin_user_manage_{user_id}",
)
],
]
)
return "\n\n".join(lines), keyboard
@admin_required
@error_handler
async def show_user_referrals(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
):
user_id = int(callback.data.split('_')[-1])
current_state = await state.get_state()
if current_state in {AdminStates.editing_user_referrals, AdminStates.editing_user_referral_percent}:
data = await state.get_data()
preserved_data = {
key: value
for key, value in data.items()
if key not in {"editing_referrals_user_id", "referrals_message_id", "editing_referral_percent_user_id"}
}
await state.clear()
if preserved_data:
await state.update_data(**preserved_data)
view = await _build_user_referrals_view(db, db_user.language, user_id)
if not view:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
text, keyboard = view
await callback.message.edit_text(
text,
reply_markup=keyboard,
)
await callback.answer()
@admin_required
@error_handler
async def start_edit_referral_percent(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext,
db: AsyncSession,
):
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
texts = get_texts(db_user.language)
effective_percent = get_effective_referral_commission_percent(user)
default_percent = settings.REFERRAL_COMMISSION_PERCENT
prompt = texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_PROMPT",
(
"📈 Индивидуальный процент реферальной комиссии\n\n"
"Текущее значение: {current}%\n"
"Стандартное значение: {default}%\n\n"
"Отправьте новое значение от 0 до 100 или слово 'стандарт' для сброса."
),
).format(current=effective_percent, default=default_percent)
keyboard = InlineKeyboardMarkup(
inline_keyboard=[
[
InlineKeyboardButton(
text="5%",
callback_data=f"admin_user_referral_percent_set_{user_id}_5",
),
InlineKeyboardButton(
text="10%",
callback_data=f"admin_user_referral_percent_set_{user_id}_10",
),
],
[
InlineKeyboardButton(
text="15%",
callback_data=f"admin_user_referral_percent_set_{user_id}_15",
),
InlineKeyboardButton(
text="20%",
callback_data=f"admin_user_referral_percent_set_{user_id}_20",
),
],
[
InlineKeyboardButton(
text=texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_RESET_BUTTON",
"♻️ Сбросить на стандартный",
),
callback_data=f"admin_user_referral_percent_reset_{user_id}",
)
],
[
InlineKeyboardButton(
text=texts.BACK,
callback_data=f"admin_user_referrals_{user_id}",
)
],
]
)
await state.update_data(editing_referral_percent_user_id=user_id)
await state.set_state(AdminStates.editing_user_referral_percent)
await callback.message.edit_text(
prompt,
reply_markup=keyboard,
)
await callback.answer()
async def _update_referral_commission_percent(
db: AsyncSession,
user_id: int,
percent: Optional[int],
admin_id: int,
) -> Tuple[bool, Optional[int]]:
try:
user = await get_user_by_id(db, user_id)
if not user:
return False, None
user.referral_commission_percent = percent
user.updated_at = datetime.utcnow()
await db.commit()
effective = get_effective_referral_commission_percent(user)
logger.info(
"Админ %s обновил реферальный процент пользователя %s: %s",
admin_id,
user_id,
percent,
)
return True, effective
except Exception as e:
logger.error(
"Ошибка обновления реферального процента пользователя %s: %s",
user_id,
e,
)
try:
await db.rollback()
except Exception as rollback_error:
logger.error("Ошибка отката транзакции: %s", rollback_error)
return False, None
async def _render_referrals_after_update(
callback: types.CallbackQuery,
db: AsyncSession,
db_user: User,
user_id: int,
success_message: str,
):
view = await _build_user_referrals_view(db, db_user.language, user_id)
if view:
text, keyboard = view
text = f"{success_message}\n\n" + text
await callback.message.edit_text(text, reply_markup=keyboard)
else:
await callback.message.edit_text(success_message)
@admin_required
@error_handler
async def set_referral_percent_button(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext,
):
parts = callback.data.split('_')
if "reset" in parts:
user_id = int(parts[-1])
percent_value: Optional[int] = None
else:
user_id = int(parts[-2])
percent_value = int(parts[-1])
texts = get_texts(db_user.language)
success, effective_percent = await _update_referral_commission_percent(
db,
user_id,
percent_value,
db_user.id,
)
if not success:
await callback.answer("❌ Не удалось обновить процент", show_alert=True)
return
await state.clear()
success_message = texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_UPDATED",
"✅ Процент обновлён: {percent}%",
).format(percent=effective_percent)
await _render_referrals_after_update(callback, db, db_user, user_id, success_message)
await callback.answer()
@admin_required
@error_handler
async def process_referral_percent_input(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession,
):
data = await state.get_data()
user_id = data.get("editing_referral_percent_user_id")
if not user_id:
await message.answer("❌ Не удалось определить пользователя")
return
raw_text = message.text.strip()
normalized = raw_text.lower()
percent_value: Optional[int]
if normalized in {"стандарт", "standard", "default"}:
percent_value = None
else:
normalized_number = raw_text.replace(',', '.').strip()
try:
percent_float = float(normalized_number)
except (TypeError, ValueError):
await message.answer(
get_texts(db_user.language).t(
"ADMIN_USER_REFERRAL_COMMISSION_INVALID",
"❌ Введите число от 0 до 100 или слово 'стандарт'",
)
)
return
percent_value = int(round(percent_float))
if percent_value < 0 or percent_value > 100:
await message.answer(
get_texts(db_user.language).t(
"ADMIN_USER_REFERRAL_COMMISSION_INVALID",
"❌ Введите число от 0 до 100 или слово 'стандарт'",
)
)
return
texts = get_texts(db_user.language)
success, effective_percent = await _update_referral_commission_percent(
db,
int(user_id),
percent_value,
db_user.id,
)
if not success:
await message.answer("❌ Не удалось обновить процент")
return
await state.clear()
success_message = texts.t(
"ADMIN_USER_REFERRAL_COMMISSION_UPDATED",
"✅ Процент обновлён: {percent}%",
).format(percent=effective_percent)
view = await _build_user_referrals_view(db, db_user.language, int(user_id))
if view:
text, keyboard = view
await message.answer(f"{success_message}\n\n{text}", reply_markup=keyboard)
else:
await message.answer(success_message)
@admin_required
@error_handler
async def start_edit_user_referrals(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext,
db: AsyncSession,
):
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
texts = get_texts(db_user.language)
prompt = texts.t(
"ADMIN_USER_REFERRALS_EDIT_PROMPT",
(
"✏️ Редактирование рефералов\n\n"
"Отправьте список рефералов для пользователя {name} (ID: {telegram_id}):\n"
"• Используйте TG ID или @username\n"
"• Значения можно указывать через запятую, пробел или с новой строки\n"
"• Чтобы очистить список, отправьте 0 или слово 'нет'\n\n"
"Или нажмите кнопку ниже, чтобы отменить."
),
).format(
name=user.full_name,
telegram_id=user.telegram_id,
)
await state.update_data(
editing_referrals_user_id=user_id,
referrals_message_id=callback.message.message_id,
)
await callback.message.edit_text(
prompt,
reply_markup=InlineKeyboardMarkup(
inline_keyboard=[
[
InlineKeyboardButton(
text=texts.BACK,
callback_data=f"admin_user_referrals_{user_id}",
)
]
]
),
)
await state.set_state(AdminStates.editing_user_referrals)
await callback.answer()
@admin_required
@error_handler
async def process_edit_user_referrals(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession,
):
texts = get_texts(db_user.language)
data = await state.get_data()
user_id = data.get("editing_referrals_user_id")
if not user_id:
await message.answer(
texts.t(
"ADMIN_USER_REFERRALS_STATE_LOST",
"❌ Не удалось определить пользователя. Попробуйте начать сначала.",
)
)
await state.clear()
return
raw_text = message.text.strip()
lower_text = raw_text.lower()
clear_keywords = {"0", "нет", "none", "пусто", "clear"}
clear_requested = lower_text in clear_keywords
tokens: List[str] = []
if not clear_requested:
parts = re.split(r"[,\n]+", raw_text)
for part in parts:
for token in part.split():
cleaned = token.strip()
if cleaned and cleaned not in tokens:
tokens.append(cleaned)
found_users: List[User] = []
not_found: List[str] = []
skipped_self: List[str] = []
duplicate_tokens: List[str] = []
seen_ids = set()
for token in tokens:
normalized = token.strip()
if not normalized:
continue
if normalized.startswith("@"):
normalized = normalized[1:]
user = None
if normalized.isdigit():
try:
user = await get_user_by_telegram_id(db, int(normalized))
except ValueError:
user = None
else:
user = await get_user_by_username(db, normalized)
if not user:
not_found.append(token)
continue
if user.id == user_id:
skipped_self.append(token)
continue
if user.id in seen_ids:
duplicate_tokens.append(token)
continue
seen_ids.add(user.id)
found_users.append(user)
if not found_users and not clear_requested:
error_lines = [
texts.t(
"ADMIN_USER_REFERRALS_NO_VALID",
"❌ Не удалось найти ни одного пользователя по введённым данным.",
)
]
if not_found:
error_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_INVALID_ENTRIES",
"Не найдены: {values}",
).format(values=", ".join(not_found))
)
if skipped_self:
error_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_SELF_SKIPPED",
"Пропущены значения пользователя: {values}",
).format(values=", ".join(skipped_self))
)
await message.answer("\n".join(error_lines))
return
user_service = UserService()
new_referral_ids = [user.id for user in found_users] if not clear_requested else []
success, details = await user_service.update_user_referrals(
db,
user_id,
new_referral_ids,
db_user.id,
)
if not success:
await message.answer(
texts.t(
"ADMIN_USER_REFERRALS_UPDATE_ERROR",
"❌ Не удалось обновить рефералов. Попробуйте позже.",
)
)
return
response_lines = [
texts.t(
"ADMIN_USER_REFERRALS_UPDATED",
"✅ Список рефералов обновлён.",
)
]
total_referrals = details.get("total", len(new_referral_ids))
added = details.get("added", 0)
removed = details.get("removed", 0)
response_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_UPDATED_TOTAL",
"• Текущий список: {total}",
).format(total=total_referrals)
)
if added > 0:
response_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_UPDATED_ADDED",
"• Добавлено: {count}",
).format(count=added)
)
if removed > 0:
response_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_UPDATED_REMOVED",
"• Удалено: {count}",
).format(count=removed)
)
if not_found:
response_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_INVALID_ENTRIES",
"Не найдены: {values}",
).format(values=", ".join(not_found))
)
if skipped_self:
response_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_SELF_SKIPPED",
"Пропущены значения пользователя: {values}",
).format(values=", ".join(skipped_self))
)
if duplicate_tokens:
response_lines.append(
texts.t(
"ADMIN_USER_REFERRALS_DUPLICATES",
"Игнорированы дубли: {values}",
).format(values=", ".join(duplicate_tokens))
)
view = await _build_user_referrals_view(db, db_user.language, user_id)
message_id = data.get("referrals_message_id")
if view and message_id:
try:
await message.bot.edit_message_text(
view[0],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=view[1],
)
except TelegramBadRequest:
await message.answer(view[0], reply_markup=view[1])
elif view:
await message.answer(view[0], reply_markup=view[1])
await message.answer("\n".join(response_lines))
await state.clear()
async def _render_user_promo_group(
message: types.Message,
language: str,
user: User,
promo_groups: list
) -> None:
texts = get_texts(language)
# Get primary and all user groups
primary_group = user.get_primary_promo_group()
user_group_ids = [upg.promo_group_id for upg in user.user_promo_groups] if user.user_promo_groups else []
# Build current groups section
if primary_group:
current_line = texts.t(
"ADMIN_USER_PROMO_GROUPS_PRIMARY",
"⭐ Основная: {name} (Priority: {priority})",
).format(name=primary_group.name, priority=getattr(primary_group, "priority", 0))
discount_line = texts.ADMIN_USER_PROMO_GROUP_DISCOUNTS.format(
servers=primary_group.server_discount_percent,
traffic=primary_group.traffic_discount_percent,
devices=primary_group.device_discount_percent,
)
# Show additional groups if any
if len(user_group_ids) > 1:
additional_groups = [
upg.promo_group for upg in user.user_promo_groups
if upg.promo_group and upg.promo_group.id != primary_group.id
]
if additional_groups:
additional_line = "\n" + texts.t(
"ADMIN_USER_PROMO_GROUPS_ADDITIONAL",
"Дополнительные группы:",
) + "\n"
for group in additional_groups:
additional_line += f" • {group.name} (Priority: {getattr(group, 'priority', 0)})\n"
discount_line += additional_line
else:
current_line = texts.t(
"ADMIN_USER_PROMO_GROUPS_NONE",
"У пользователя нет промогрупп",
)
discount_line = ""
text = (
f"{texts.ADMIN_USER_PROMO_GROUP_TITLE}\n\n"
f"{current_line}\n"
f"{discount_line}\n\n"
f"{texts.ADMIN_USER_PROMO_GROUP_SELECT}"
)
await message.edit_text(
text,
reply_markup=get_user_promo_group_keyboard(
promo_groups,
user.id,
user_group_ids, # Pass list of all group IDs
language
)
)
@admin_required
@error_handler
async def show_user_promo_group(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
promo_groups = await get_promo_groups_with_counts(db)
if not promo_groups:
texts = get_texts(db_user.language)
await callback.answer(texts.ADMIN_PROMO_GROUPS_EMPTY, show_alert=True)
return
await _render_user_promo_group(callback.message, db_user.language, user, promo_groups)
await callback.answer()
@admin_required
@error_handler
async def set_user_promo_group(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
from app.database.crud.user_promo_group import (
has_user_promo_group,
add_user_to_promo_group,
remove_user_from_promo_group,
count_user_promo_groups
)
from app.database.crud.promo_group import get_promo_group_by_id
parts = callback.data.split('_')
user_id = int(parts[-2])
group_id = int(parts[-1])
texts = get_texts(db_user.language)
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
# Check if user already has this group
has_group = await has_user_promo_group(db, user_id, group_id)
if has_group:
# Remove group
# Check if it's the last group
groups_count = await count_user_promo_groups(db, user_id)
if groups_count <= 1:
await callback.answer(
texts.t(
"ADMIN_USER_PROMO_GROUP_CANNOT_REMOVE_LAST",
"❌ Нельзя удалить последнюю промогруппу",
),
show_alert=True
)
return
group = await get_promo_group_by_id(db, group_id)
await remove_user_from_promo_group(db, user_id, group_id)
await callback.answer(
texts.t(
"ADMIN_USER_PROMO_GROUP_REMOVED",
"🗑 Группа «{name}» удалена",
).format(name=group.name if group else ""),
show_alert=True
)
else:
# Add group
group = await get_promo_group_by_id(db, group_id)
if not group:
await callback.answer(texts.ADMIN_USER_PROMO_GROUP_ERROR, show_alert=True)
return
await add_user_to_promo_group(db, user_id, group_id, assigned_by="admin")
await callback.answer(
texts.t(
"ADMIN_USER_PROMO_GROUP_ADDED",
"✅ Группа «{name}» добавлена",
).format(name=group.name),
show_alert=True
)
# Refresh user data and show updated list
user = await get_user_by_id(db, user_id)
promo_groups = await get_promo_groups_with_counts(db)
await _render_user_promo_group(callback.message, db_user.language, user, promo_groups)
@admin_required
@error_handler
async def start_balance_edit(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
user_id = int(callback.data.split('_')[-1])
await state.update_data(editing_user_id=user_id)
await callback.message.edit_text(
"💰 Изменение баланса\n\n"
"Введите сумму для изменения баланса:\n"
"• Положительное число для пополнения\n"
"• Отрицательное число для списания\n"
"• Примеры: 100, -50, 25.5\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_manage_{user_id}")]
])
)
await state.set_state(AdminStates.editing_user_balance)
await callback.answer()
@admin_required
@error_handler
async def start_send_user_message(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext,
db: AsyncSession,
):
user_id = int(callback.data.split('_')[-1])
target_user = await get_user_by_id(db, user_id)
if not target_user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
await state.update_data(direct_message_user_id=user_id)
texts = get_texts(db_user.language)
prompt = (
texts.t("ADMIN_USER_SEND_MESSAGE_PROMPT",
"✉️ Отправка сообщения пользователю\n\n"
"Введите текст, который бот отправит пользователю."
"\n\nВы можете отменить действие командой /cancel или кнопкой ниже." )
)
await callback.message.edit_text(
prompt,
reply_markup=types.InlineKeyboardMarkup(
inline_keyboard=[
[types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_manage_{user_id}")]
]
),
parse_mode="HTML",
)
await state.set_state(AdminStates.sending_user_message)
await callback.answer()
@admin_required
@error_handler
async def process_send_user_message(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession,
):
texts = get_texts(db_user.language)
data = await state.get_data()
user_id = data.get("direct_message_user_id")
if not user_id:
await message.answer(texts.t("ADMIN_USER_SEND_MESSAGE_ERROR_NOT_FOUND", "❌ Пользователь для отправки сообщения не найден"))
await state.clear()
return
target_user = await get_user_by_id(db, int(user_id))
if not target_user:
await message.answer(texts.t("ADMIN_USER_SEND_MESSAGE_ERROR_NOT_FOUND", "❌ Пользователь не найден или был удалён"))
await state.clear()
return
text = (message.text or "").strip()
if not text:
await message.answer(texts.t("ADMIN_USER_SEND_MESSAGE_EMPTY", "❌ Пожалуйста, введите непустое сообщение"))
return
confirmation_keyboard = types.InlineKeyboardMarkup(
inline_keyboard=[[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]]
)
try:
await message.bot.send_message(target_user.telegram_id, text, parse_mode="HTML")
await message.answer(
texts.t("ADMIN_USER_SEND_MESSAGE_SUCCESS", "✅ Сообщение отправлено пользователю"),
reply_markup=confirmation_keyboard,
)
except TelegramForbiddenError:
await message.answer(
texts.t("ADMIN_USER_SEND_MESSAGE_FORBIDDEN", "⚠️ Пользователь заблокировал бота или не может получить сообщения."),
reply_markup=confirmation_keyboard,
)
except TelegramBadRequest as err:
logger.error("Ошибка отправки сообщения пользователю %s: %s", target_user.telegram_id, err)
await message.answer(
texts.t("ADMIN_USER_SEND_MESSAGE_BAD_REQUEST", "❌ Telegram отклонил сообщение. Проверьте текст и попробуйте ещё раз."),
reply_markup=confirmation_keyboard,
)
await state.clear()
return
except Exception as err:
logger.error("Неожиданная ошибка отправки сообщения пользователю %s: %s", target_user.telegram_id, err)
await message.answer(
texts.t("ADMIN_USER_SEND_MESSAGE_ERROR", "❌ Не удалось отправить сообщение. Попробуйте позже."),
reply_markup=confirmation_keyboard,
)
await state.clear()
return
await state.clear()
@admin_required
@error_handler
async def process_balance_edit(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
data = await state.get_data()
user_id = data.get("editing_user_id")
if not user_id:
await message.answer("❌ Ошибка: пользователь не найден")
await state.clear()
return
try:
amount_rubles = float(message.text.replace(',', '.'))
amount_kopeks = int(amount_rubles * 100)
if abs(amount_kopeks) > 10000000:
await message.answer("❌ Слишком большая сумма (максимум 100,000 ₽)")
return
user_service = UserService()
description = f"Изменение баланса администратором {db_user.full_name}"
if amount_kopeks > 0:
description = f"Пополнение администратором: +{int(amount_rubles)} ₽"
else:
description = f"Списание администратором: {int(amount_rubles)} ₽"
success = await user_service.update_user_balance(
db, user_id, amount_kopeks, description, db_user.id,
bot=message.bot, admin_name=db_user.full_name
)
if success:
action = "пополнен" if amount_kopeks > 0 else "списан"
await message.answer(
f"✅ Баланс пользователя {action} на {settings.format_price(abs(amount_kopeks))}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
else:
await message.answer("❌ Ошибка изменения баланса (возможно, недостаточно средств для списания)")
except ValueError:
await message.answer("❌ Введите корректную сумму (например: 100 или -50)")
return
await state.clear()
@admin_required
@error_handler
async def confirm_user_block(
callback: types.CallbackQuery,
db_user: User
):
user_id = int(callback.data.split('_')[-1])
await callback.message.edit_text(
"🚫 Блокировка пользователя\n\n"
"Вы уверены, что хотите заблокировать этого пользователя?\n"
"Пользователь потеряет доступ к боту.",
reply_markup=get_confirmation_keyboard(
f"admin_user_block_confirm_{user_id}",
f"admin_user_manage_{user_id}",
db_user.language
)
)
await callback.answer()
@admin_required
@error_handler
async def block_user(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
success = await user_service.block_user(
db, user_id, db_user.id, "Заблокирован администратором"
)
if success:
await callback.message.edit_text(
"✅ Пользователь заблокирован",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка блокировки пользователя",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
await callback.answer()
# ============ УПРАВЛЕНИЕ ОГРАНИЧЕНИЯМИ ПОЛЬЗОВАТЕЛЯ ============
@admin_required
@error_handler
async def show_user_restrictions(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Показать меню управления ограничениями пользователя."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("Пользователь не найден", show_alert=True)
return
texts = get_texts(db_user.language)
# Формируем текст с информацией об ограничениях
restriction_topup = getattr(user, 'restriction_topup', False)
restriction_subscription = getattr(user, 'restriction_subscription', False)
restriction_reason = getattr(user, 'restriction_reason', None)
text_lines = [
f"⚠️ Ограничения пользователя",
f"👤 {user.full_name}",
"",
f"✅ — разрешено, 🚫 — запрещено",
"",
f"{'🚫' if restriction_topup else '✅'} Пополнение баланса",
f"{'🚫' if restriction_subscription else '✅'} Продление/покупка подписки",
]
if restriction_reason:
text_lines.append("")
text_lines.append(f"📝 Причина: {restriction_reason}")
keyboard = get_user_restrictions_keyboard(
user_id=user_id,
restriction_topup=restriction_topup,
restriction_subscription=restriction_subscription,
language=db_user.language
)
await callback.message.edit_text(
"\n".join(text_lines),
reply_markup=keyboard
)
await callback.answer()
@admin_required
@error_handler
async def toggle_user_restriction_topup(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Переключить ограничение на пополнение баланса."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("Пользователь не найден", show_alert=True)
return
# Переключаем ограничение
current_value = getattr(user, 'restriction_topup', False)
user.restriction_topup = not current_value
await db.commit()
action = "установлено" if user.restriction_topup else "снято"
await callback.answer(f"Ограничение на пополнение {action}", show_alert=False)
# Обновляем меню
await show_user_restrictions(callback, db_user, db)
@admin_required
@error_handler
async def toggle_user_restriction_subscription(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Переключить ограничение на продление/покупку подписки."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("Пользователь не найден", show_alert=True)
return
# Переключаем ограничение
current_value = getattr(user, 'restriction_subscription', False)
user.restriction_subscription = not current_value
await db.commit()
action = "установлено" if user.restriction_subscription else "снято"
await callback.answer(f"Ограничение на подписку {action}", show_alert=False)
# Обновляем меню
await show_user_restrictions(callback, db_user, db)
@admin_required
@error_handler
async def ask_restriction_reason(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession,
state: FSMContext
):
"""Запросить ввод причины ограничения."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("Пользователь не найден", show_alert=True)
return
current_reason = getattr(user, 'restriction_reason', None) or ""
await state.set_state(AdminStates.editing_user_restriction_reason)
await state.update_data(restriction_user_id=user_id)
text = (
"📝 Введите причину ограничения\n\n"
"Эта причина будет показана пользователю при попытке "
"выполнить запрещённое действие.\n\n"
)
if current_reason:
text += f"Текущая причина: {current_reason}\n\n"
text += "Отправьте новую причину или /cancel для отмены:"
await callback.message.edit_text(
text,
reply_markup=InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_restrictions_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def save_restriction_reason(
message: types.Message,
db_user: User,
db: AsyncSession,
state: FSMContext
):
"""Сохранить причину ограничения."""
data = await state.get_data()
user_id = data.get("restriction_user_id")
if not user_id:
await message.answer("Ошибка: пользователь не найден")
await state.clear()
return
user = await get_user_by_id(db, user_id)
if not user:
await message.answer("Ошибка: пользователь не найден")
await state.clear()
return
reason = message.text.strip()[:500] # Ограничение 500 символов
user.restriction_reason = reason
await db.commit()
await state.clear()
# Формируем текст с обновлённой информацией
restriction_topup = getattr(user, 'restriction_topup', False)
restriction_subscription = getattr(user, 'restriction_subscription', False)
text_lines = [
f"✅ Причина ограничения сохранена",
"",
f"⚠️ Ограничения пользователя",
f"👤 {user.full_name}",
"",
f"{'🚫' if restriction_topup else '✅'} Пополнение баланса",
f"{'🚫' if restriction_subscription else '✅'} Продление/покупка подписки",
"",
f"📝 Причина: {reason}",
]
keyboard = get_user_restrictions_keyboard(
user_id=user_id,
restriction_topup=restriction_topup,
restriction_subscription=restriction_subscription,
language=db_user.language
)
await message.answer(
"\n".join(text_lines),
reply_markup=keyboard
)
@admin_required
@error_handler
async def clear_user_restrictions(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Снять все ограничения с пользователя."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("Пользователь не найден", show_alert=True)
return
# Снимаем все ограничения
user.restriction_topup = False
user.restriction_subscription = False
user.restriction_reason = None
await db.commit()
await callback.answer("Все ограничения сняты", show_alert=True)
# Обновляем меню
await show_user_restrictions(callback, db_user, db)
@admin_required
@error_handler
async def show_inactive_users(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_service = UserService()
from app.database.crud.user import get_inactive_users
inactive_users = await get_inactive_users(db, settings.INACTIVE_USER_DELETE_MONTHS)
if not inactive_users:
await callback.message.edit_text(
f"✅ Неактивных пользователей (более {settings.INACTIVE_USER_DELETE_MONTHS} месяцев) не найдено",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
])
)
await callback.answer()
return
text = f"🗑️ Неактивные пользователи\n"
text += f"Без активности более {settings.INACTIVE_USER_DELETE_MONTHS} месяцев: {len(inactive_users)}\n\n"
for user in inactive_users[:10]:
user_link = f'{user.full_name}'
text += f"👤 {user_link}\n"
text += f"🆔 {user.telegram_id}\n"
last_activity_display = (
format_time_ago(user.last_activity, db_user.language)
if user.last_activity
else "Никогда"
)
text += f"📅 {last_activity_display}\n\n"
if len(inactive_users) > 10:
text += f"... и еще {len(inactive_users) - 10} пользователей"
keyboard = [
[types.InlineKeyboardButton(text="🗑️ Очистить всех", callback_data="admin_cleanup_inactive")],
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
]
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def confirm_user_unblock(
callback: types.CallbackQuery,
db_user: User
):
user_id = int(callback.data.split('_')[-1])
await callback.message.edit_text(
"✅ Разблокировка пользователя\n\n"
"Вы уверены, что хотите разблокировать этого пользователя?\n"
"Пользователь снова получит доступ к боту.",
reply_markup=get_confirmation_keyboard(
f"admin_user_unblock_confirm_{user_id}",
f"admin_user_manage_{user_id}",
db_user.language
)
)
await callback.answer()
@admin_required
@error_handler
async def unblock_user(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
success = await user_service.unblock_user(db, user_id, db_user.id)
if success:
await callback.message.edit_text(
"✅ Пользователь разблокирован",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка разблокировки пользователя",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def show_user_statistics(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
user = profile["user"]
subscription = profile["subscription"]
referral_stats = await get_detailed_referral_stats(db, user.id)
campaign_registration = await get_campaign_registration_by_user(db, user.id)
campaign_stats = None
if campaign_registration:
campaign_stats = await get_campaign_statistics(db, campaign_registration.campaign_id)
text = f"📊 Статистика пользователя\n\n"
user_link = f'{user.full_name}'
text += f"👤 {user_link} (ID: {user.telegram_id})\n\n"
text += f"Основная информация:\n"
text += f"• Дней с регистрации: {profile['registration_days']}\n"
text += f"• Баланс: {settings.format_price(user.balance_kopeks)}\n"
text += f"• Транзакций: {profile['transactions_count']}\n"
text += f"• Язык: {user.language}\n\n"
text += f"Подписка:\n"
if subscription:
sub_status = "✅ Активна" if subscription.is_active else "❌ Неактивна"
sub_type = " (пробная)" if subscription.is_trial else " (платная)"
text += f"• Статус: {sub_status}{sub_type}\n"
text += f"• Трафик: {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
text += f"• Устройства: {subscription.device_limit}\n"
text += f"• Стран: {len(subscription.connected_squads)}\n"
else:
text += f"• Отсутствует\n"
text += f"\nРеферальная программа:\n"
if user.referred_by_id:
referrer = await get_user_by_id(db, user.referred_by_id)
if referrer:
text += f"• Пришел по реферальной ссылке от {referrer.full_name}\n"
else:
text += "• Пришел по реферальной ссылке (реферер не найден)\n"
if campaign_registration and campaign_registration.campaign:
text += (
"• Дополнительно зарегистрирован через кампанию "
f"{campaign_registration.campaign.name}\n"
)
elif campaign_registration and campaign_registration.campaign:
text += (
"• Регистрация через рекламную кампанию "
f"{campaign_registration.campaign.name}\n"
)
if campaign_registration.created_at:
text += (
"• Дата регистрации по кампании: "
f"{campaign_registration.created_at.strftime('%d.%m.%Y %H:%M')}\n"
)
else:
text += "• Прямая регистрация\n"
text += f"• Реферальный код: {user.referral_code}\n\n"
if campaign_registration and campaign_registration.campaign and campaign_stats:
text += "Рекламная кампания:\n"
text += (
"• Название: "
f"{campaign_registration.campaign.name}"
)
if campaign_registration.campaign.start_parameter:
text += (
" (параметр: "
f"{campaign_registration.campaign.start_parameter})"
)
text += "\n"
text += (
"• Всего регистраций: "
f"{campaign_stats['registrations']}\n"
)
text += (
"• Суммарный доход: "
f"{settings.format_price(campaign_stats['total_revenue_kopeks'])}\n"
)
text += (
"• Получили триал: "
f"{campaign_stats['trial_users_count']}"
f" (активно: {campaign_stats['active_trials_count']})\n"
)
text += (
"• Конверсий в оплату: "
f"{campaign_stats['conversion_count']}"
f" (оплативших пользователей: {campaign_stats['paid_users_count']})\n"
)
text += (
"• Конверсия в оплату: "
f"{campaign_stats['conversion_rate']:.1f}%\n"
)
text += (
"• Конверсия триала: "
f"{campaign_stats['trial_conversion_rate']:.1f}%\n"
)
text += (
"• Средний доход на пользователя: "
f"{settings.format_price(campaign_stats['avg_revenue_per_user_kopeks'])}\n"
)
text += (
"• Средний первый платеж: "
f"{settings.format_price(campaign_stats['avg_first_payment_kopeks'])}\n"
)
text += "\n"
if referral_stats['invited_count'] > 0:
text += f"Доходы от рефералов:\n"
text += f"• Всего приглашено: {referral_stats['invited_count']}\n"
text += f"• Активных рефералов: {referral_stats['active_referrals']}\n"
text += f"• Общий доход: {settings.format_price(referral_stats['total_earned_kopeks'])}\n"
text += f"• Доход за месяц: {settings.format_price(referral_stats['month_earned_kopeks'])}\n"
if referral_stats['referrals_detail']:
text += f"\nДетали по рефералам:\n"
for detail in referral_stats['referrals_detail'][:5]:
referral_name = detail['referral_name']
earned = settings.format_price(detail['total_earned_kopeks'])
status = "🟢" if detail['is_active'] else "🔴"
text += f"• {status} {referral_name}: {earned}\n"
if len(referral_stats['referrals_detail']) > 5:
text += f"• ... и еще {len(referral_stats['referrals_detail']) - 5} рефералов\n"
else:
text += f"Реферальная программа:\n"
text += f"• Рефералов нет\n"
text += f"• Доходов нет\n"
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")]
])
)
await callback.answer()
async def get_detailed_referral_stats(db: AsyncSession, user_id: int) -> dict:
from app.database.crud.referral import get_user_referral_stats, get_referral_earnings_by_user
from sqlalchemy import select, func
from sqlalchemy.orm import selectinload
base_stats = await get_user_referral_stats(db, user_id)
referrals_query = select(User).options(
selectinload(User.subscription)
).where(User.referred_by_id == user_id)
referrals_result = await db.execute(referrals_query)
referrals = referrals_result.scalars().all()
earnings_by_referral = {}
all_earnings = await get_referral_earnings_by_user(db, user_id)
for earning in all_earnings:
referral_id = earning.referral_id
if referral_id not in earnings_by_referral:
earnings_by_referral[referral_id] = 0
earnings_by_referral[referral_id] += earning.amount_kopeks
referrals_detail = []
current_time = datetime.utcnow()
for referral in referrals:
earned = earnings_by_referral.get(referral.id, 0)
is_active = False
if referral.subscription:
from app.database.models import SubscriptionStatus
is_active = (
referral.subscription.status == SubscriptionStatus.ACTIVE.value and
referral.subscription.end_date > current_time
)
referrals_detail.append({
'referral_id': referral.id,
'referral_name': referral.full_name,
'referral_telegram_id': referral.telegram_id,
'total_earned_kopeks': earned,
'is_active': is_active,
'registration_date': referral.created_at,
'has_subscription': bool(referral.subscription)
})
referrals_detail.sort(key=lambda x: x['total_earned_kopeks'], reverse=True)
return {
'invited_count': base_stats['invited_count'],
'active_referrals': base_stats['active_referrals'],
'total_earned_kopeks': base_stats['total_earned_kopeks'],
'month_earned_kopeks': base_stats['month_earned_kopeks'],
'referrals_detail': referrals_detail
}
@admin_required
@error_handler
async def extend_user_subscription(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
user_id = int(callback.data.split('_')[-1])
await state.update_data(extending_user_id=user_id)
await callback.message.edit_text(
"⏰ Продление подписки\n\n"
"Введите количество дней для изменения:\n"
"• Положительные значения продлят подписку\n"
"• Отрицательные сократят срок подписки\n"
"• Диапазон: от -365 до 365 дней (0 недопустимо)\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[
types.InlineKeyboardButton(text="-7 дней", callback_data=f"admin_sub_extend_days_{user_id}_-7"),
types.InlineKeyboardButton(text="-30 дней", callback_data=f"admin_sub_extend_days_{user_id}_-30")
],
[
types.InlineKeyboardButton(text="7 дней", callback_data=f"admin_sub_extend_days_{user_id}_7"),
types.InlineKeyboardButton(text="30 дней", callback_data=f"admin_sub_extend_days_{user_id}_30")
],
[
types.InlineKeyboardButton(text="90 дней", callback_data=f"admin_sub_extend_days_{user_id}_90"),
types.InlineKeyboardButton(text="180 дней", callback_data=f"admin_sub_extend_days_{user_id}_180")
],
[
types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
]
])
)
await state.set_state(AdminStates.extending_subscription)
await callback.answer()
@admin_required
@error_handler
async def process_subscription_extension_days(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[-2])
days = int(parts[-1])
if days == 0 or days < -365 or days > 365:
await callback.answer("❌ Количество дней должно быть от -365 до 365, исключая 0", show_alert=True)
return
success = await _extend_subscription_by_days(db, user_id, days, db_user.id)
if success:
if days > 0:
action_text = f"продлена на {days} дней"
else:
action_text = f"уменьшена на {abs(days)} дней"
await callback.message.edit_text(
f"✅ Подписка пользователя {action_text}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка продления подписки",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def process_subscription_extension_text(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
data = await state.get_data()
user_id = data.get("extending_user_id")
if not user_id:
await message.answer("❌ Ошибка: пользователь не найден")
await state.clear()
return
try:
days = int(message.text.strip())
if days == 0 or days < -365 or days > 365:
await message.answer("❌ Количество дней должно быть от -365 до 365, исключая 0")
return
success = await _extend_subscription_by_days(db, user_id, days, db_user.id)
if success:
if days > 0:
action_text = f"продлена на {days} дней"
else:
action_text = f"уменьшена на {abs(days)} дней"
await message.answer(
f"✅ Подписка пользователя {action_text}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await message.answer("❌ Ошибка продления подписки")
except ValueError:
await message.answer("❌ Введите корректное число дней")
return
await state.clear()
@admin_required
@error_handler
async def add_subscription_traffic(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
user_id = int(callback.data.split('_')[-1])
await state.update_data(traffic_user_id=user_id)
await callback.message.edit_text(
"📊 Добавление трафика\n\n"
"Введите количество ГБ для добавления:\n"
"• Например: 50, 100, 500\n"
"• Максимум: 10000 ГБ\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[
types.InlineKeyboardButton(text="50 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_50"),
types.InlineKeyboardButton(text="100 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_100")
],
[
types.InlineKeyboardButton(text="500 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_500"),
types.InlineKeyboardButton(text="1000 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_1000")
],
[
types.InlineKeyboardButton(text="♾️ Безлимит", callback_data=f"admin_sub_traffic_add_{user_id}_0"),
],
[
types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
]
])
)
await state.set_state(AdminStates.adding_traffic)
await callback.answer()
@admin_required
@error_handler
async def process_traffic_addition_button(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[-2])
gb = int(parts[-1])
success = await _add_subscription_traffic(db, user_id, gb, db_user.id)
if success:
traffic_text = "♾️ безлимитный" if gb == 0 else f"{gb} ГБ"
await callback.message.edit_text(
f"✅ К подписке пользователя добавлен трафик: {traffic_text}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка добавления трафика",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def process_traffic_addition_text(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
data = await state.get_data()
user_id = data.get("traffic_user_id")
if not user_id:
await message.answer("❌ Ошибка: пользователь не найден")
await state.clear()
return
try:
gb = int(message.text.strip())
if gb < 0 or gb > 10000:
await message.answer("❌ Количество ГБ должно быть от 0 до 10000 (0 = безлимит)")
return
success = await _add_subscription_traffic(db, user_id, gb, db_user.id)
if success:
traffic_text = "♾️ безлимитный" if gb == 0 else f"{gb} ГБ"
await message.answer(
f"✅ К подписке пользователя добавлен трафик: {traffic_text}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await message.answer("❌ Ошибка добавления трафика")
except ValueError:
await message.answer("❌ Введите корректное число ГБ")
return
await state.clear()
@admin_required
@error_handler
async def deactivate_user_subscription(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
await callback.message.edit_text(
"🚫 Деактивация подписки\n\n"
"Вы уверены, что хотите деактивировать подписку этого пользователя?\n"
"Пользователь потеряет доступ к сервису.",
reply_markup=get_confirmation_keyboard(
f"admin_sub_deactivate_confirm_{user_id}",
f"admin_user_subscription_{user_id}",
db_user.language
)
)
await callback.answer()
@admin_required
@error_handler
async def confirm_subscription_deactivation(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
success = await _deactivate_user_subscription(db, user_id, db_user.id)
if success:
await callback.message.edit_text(
"✅ Подписка пользователя деактивирована",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка деактивации подписки",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def activate_user_subscription(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
success = await _activate_user_subscription(db, user_id, db_user.id)
if success:
await callback.message.edit_text(
"✅ Подписка пользователя активирована",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка активации подписки",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def grant_trial_subscription(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
success = await _grant_trial_subscription(db, user_id, db_user.id)
if success:
await callback.message.edit_text(
"✅ Пользователю выдан триальный период",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка выдачи триального периода",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def grant_paid_subscription(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
user_id = int(callback.data.split('_')[-1])
await state.update_data(granting_user_id=user_id)
await callback.message.edit_text(
"💎 Выдача подписки\n\n"
"Введите количество дней подписки:\n"
"• Например: 30, 90, 180, 365\n"
"• Максимум: 730 дней\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[
types.InlineKeyboardButton(text="30 дней", callback_data=f"admin_sub_grant_days_{user_id}_30"),
types.InlineKeyboardButton(text="90 дней", callback_data=f"admin_sub_grant_days_{user_id}_90")
],
[
types.InlineKeyboardButton(text="180 дней", callback_data=f"admin_sub_grant_days_{user_id}_180"),
types.InlineKeyboardButton(text="365 дней", callback_data=f"admin_sub_grant_days_{user_id}_365")
],
[
types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
]
])
)
await state.set_state(AdminStates.granting_subscription)
await callback.answer()
@admin_required
@error_handler
async def process_subscription_grant_days(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[-2])
days = int(parts[-1])
success = await _grant_paid_subscription(db, user_id, days, db_user.id)
if success:
await callback.message.edit_text(
f"✅ Пользователю выдана подписка на {days} дней",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка выдачи подписки",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def process_subscription_grant_text(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
data = await state.get_data()
user_id = data.get("granting_user_id")
if not user_id:
await message.answer("❌ Ошибка: пользователь не найден")
await state.clear()
return
try:
days = int(message.text.strip())
if days <= 0 or days > 730:
await message.answer("❌ Количество дней должно быть от 1 до 730")
return
success = await _grant_paid_subscription(db, user_id, days, db_user.id)
if success:
await message.answer(
f"✅ Пользователю выдана подписка на {days} дней",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await message.answer("❌ Ошибка выдачи подписки")
except ValueError:
await message.answer("❌ Введите корректное число дней")
return
await state.clear()
@admin_required
@error_handler
async def show_user_servers_management(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
if await _render_user_subscription_overview(callback, db, user_id):
await callback.answer()
@admin_required
@error_handler
async def show_server_selection(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
await _show_servers_for_user(callback, user_id, db)
await callback.answer()
async def _show_servers_for_user(
callback: types.CallbackQuery,
user_id: int,
db: AsyncSession
):
try:
user = await get_user_by_id(db, user_id)
current_squads = []
if user and user.subscription:
current_squads = user.subscription.connected_squads or []
all_servers, _ = await get_all_server_squads(db, available_only=False)
servers_to_show = []
for server in all_servers:
if server.is_available or server.squad_uuid in current_squads:
servers_to_show.append(server)
if not servers_to_show:
await callback.message.edit_text(
"❌ Доступные серверы не найдены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")]
])
)
return
text = f"🌍 Управление серверами\n\n"
text += f"Нажмите на сервер чтобы добавить/убрать:\n"
text += f"✅ - выбранный сервер\n"
text += f"⚪ - доступный сервер\n"
text += f"🔒 - неактивный (только для уже назначенных)\n\n"
keyboard = []
selected_servers = [s for s in servers_to_show if s.squad_uuid in current_squads]
available_servers = [s for s in servers_to_show if s.squad_uuid not in current_squads and s.is_available]
inactive_servers = [s for s in servers_to_show if s.squad_uuid not in current_squads and not s.is_available]
sorted_servers = selected_servers + available_servers + inactive_servers
for server in sorted_servers[:20]:
is_selected = server.squad_uuid in current_squads
if is_selected:
emoji = "✅"
elif server.is_available:
emoji = "⚪"
else:
emoji = "🔒"
display_name = server.display_name
if not server.is_available and not is_selected:
display_name += " (неактивный)"
keyboard.append([
types.InlineKeyboardButton(
text=f"{emoji} {display_name}",
callback_data=f"admin_user_toggle_server_{user_id}_{server.id}"
)
])
if len(servers_to_show) > 20:
text += f"\n📝 Показано первых 20 из {len(servers_to_show)} серверов"
keyboard.append([
types.InlineKeyboardButton(text="✅ Готово", callback_data=f"admin_user_subscription_{user_id}"),
types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
except Exception as e:
logger.error(f"Ошибка показа серверов: {e}")
@admin_required
@error_handler
async def toggle_user_server(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[4])
server_id = int(parts[5])
try:
user = await get_user_by_id(db, user_id)
if not user or not user.subscription:
await callback.answer("❌ Пользователь или подписка не найдены", show_alert=True)
return
server = await get_server_squad_by_id(db, server_id)
if not server:
await callback.answer("❌ Сервер не найден", show_alert=True)
return
subscription = user.subscription
current_squads = list(subscription.connected_squads or [])
if server.squad_uuid in current_squads:
current_squads.remove(server.squad_uuid)
action_text = "удален"
else:
current_squads.append(server.squad_uuid)
action_text = "добавлен"
subscription.connected_squads = current_squads
subscription.updated_at = datetime.utcnow()
await db.commit()
await db.refresh(subscription)
if user.remnawave_uuid:
try:
remnawave_service = RemnaWaveService()
async with remnawave_service.get_api_client() as api:
await api.update_user(
uuid=user.remnawave_uuid,
active_internal_squads=current_squads,
description=settings.format_remnawave_user_description(
full_name=user.full_name,
username=user.username,
telegram_id=user.telegram_id
)
)
logger.info(f"✅ Обновлены серверы в RemnaWave для пользователя {user.telegram_id}")
except Exception as rw_error:
logger.error(f"❌ Ошибка обновления RemnaWave: {rw_error}")
logger.info(f"Админ {db_user.id}: сервер {server.display_name} {action_text} для пользователя {user_id}")
await refresh_server_selection_screen(callback, user_id, db_user, db)
except Exception as e:
logger.error(f"Ошибка переключения сервера: {e}")
await callback.answer("❌ Ошибка изменения сервера", show_alert=True)
async def refresh_server_selection_screen(
callback: types.CallbackQuery,
user_id: int,
db_user: User,
db: AsyncSession
):
try:
user = await get_user_by_id(db, user_id)
current_squads = []
if user and user.subscription:
current_squads = user.subscription.connected_squads or []
servers, _ = await get_all_server_squads(db, available_only=True)
if not servers:
await callback.message.edit_text(
"❌ Доступные серверы не найдены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")]
])
)
return
text = f"🌍 Управление серверами\n\n"
text += f"Нажмите на сервер чтобы добавить/убрать:\n\n"
keyboard = []
for server in servers[:15]:
is_selected = server.squad_uuid in current_squads
emoji = "✅" if is_selected else "⚪"
keyboard.append([
types.InlineKeyboardButton(
text=f"{emoji} {server.display_name}",
callback_data=f"admin_user_toggle_server_{user_id}_{server.id}"
)
])
if len(servers) > 15:
text += f"\n📝 Показано первых 15 из {len(servers)} серверов"
keyboard.append([
types.InlineKeyboardButton(text="✅ Готово", callback_data=f"admin_user_subscription_{user_id}"),
types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
except Exception as e:
logger.error(f"Ошибка обновления экрана серверов: {e}")
@admin_required
@error_handler
async def start_devices_edit(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
user_id = int(callback.data.split('_')[-1])
await state.update_data(editing_devices_user_id=user_id)
await callback.message.edit_text(
"📱 Изменение количества устройств\n\n"
"Введите новое количество устройств (от 1 до 10):\n"
"• Текущее значение будет заменено\n"
"• Примеры: 1, 2, 5, 10\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[
types.InlineKeyboardButton(text="1", callback_data=f"admin_user_devices_set_{user_id}_1"),
types.InlineKeyboardButton(text="2", callback_data=f"admin_user_devices_set_{user_id}_2"),
types.InlineKeyboardButton(text="3", callback_data=f"admin_user_devices_set_{user_id}_3")
],
[
types.InlineKeyboardButton(text="5", callback_data=f"admin_user_devices_set_{user_id}_5"),
types.InlineKeyboardButton(text="10", callback_data=f"admin_user_devices_set_{user_id}_10")
],
[
types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
]
])
)
await state.set_state(AdminStates.editing_user_devices)
await callback.answer()
@admin_required
@error_handler
async def set_user_devices_button(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[-2])
devices = int(parts[-1])
success = await _update_user_devices(db, user_id, devices, db_user.id)
if success:
await callback.message.edit_text(
f"✅ Количество устройств изменено на: {devices}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка изменения количества устройств",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def toggle_user_modem(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Переключение модема для пользователя в админке."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
subscription = user.subscription
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
modem_enabled = getattr(subscription, 'modem_enabled', False) or False
if modem_enabled:
# Отключаем модем
subscription.modem_enabled = False
if subscription.device_limit and subscription.device_limit > 1:
subscription.device_limit = subscription.device_limit - 1
action_text = "отключен"
else:
# Включаем модем
subscription.modem_enabled = True
subscription.device_limit = (subscription.device_limit or 1) + 1
action_text = "подключен"
subscription.updated_at = datetime.utcnow()
await db.commit()
# Обновляем в RemnaWave
try:
subscription_service = SubscriptionService()
await subscription_service.update_remnawave_user(db, subscription)
except Exception as e:
logger.error(f"Ошибка обновления RemnaWave при переключении модема: {e}")
await db.refresh(subscription)
modem_status = "✅ Подключен" if subscription.modem_enabled else "❌ Отключен"
await callback.message.edit_text(
f"📡 Модем {action_text}\n\n"
f"Статус модема: {modem_status}\n"
f"Лимит устройств: {subscription.device_limit}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
]),
parse_mode="HTML"
)
logger.info(f"Админ {db_user.telegram_id} {action_text} модем для пользователя {user_id}")
await callback.answer()
@admin_required
@error_handler
async def process_devices_edit_text(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
data = await state.get_data()
user_id = data.get("editing_devices_user_id")
if not user_id:
await message.answer("❌ Ошибка: пользователь не найден")
await state.clear()
return
try:
devices = int(message.text.strip())
if devices <= 0 or devices > 10:
await message.answer("❌ Количество устройств должно быть от 1 до 10")
return
success = await _update_user_devices(db, user_id, devices, db_user.id)
if success:
await message.answer(
f"✅ Количество устройств изменено на: {devices}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await message.answer("❌ Ошибка изменения количества устройств")
except ValueError:
await message.answer("❌ Введите корректное число устройств")
return
await state.clear()
@admin_required
@error_handler
async def start_traffic_edit(
callback: types.CallbackQuery,
db_user: User,
state: FSMContext
):
user_id = int(callback.data.split('_')[-1])
await state.update_data(editing_traffic_user_id=user_id)
await callback.message.edit_text(
"📊 Изменение лимита трафика\n\n"
"Введите новый лимит трафика в ГБ:\n"
"• 0 - безлимитный трафик\n"
"• Примеры: 50, 100, 500, 1000\n"
"• Максимум: 10000 ГБ\n\n"
"Или нажмите /cancel для отмены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[
types.InlineKeyboardButton(text="50 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_50"),
types.InlineKeyboardButton(text="100 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_100")
],
[
types.InlineKeyboardButton(text="500 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_500"),
types.InlineKeyboardButton(text="1000 ГБ", callback_data=f"admin_user_traffic_set_{user_id}_1000")
],
[
types.InlineKeyboardButton(text="♾️ Безлимит", callback_data=f"admin_user_traffic_set_{user_id}_0")
],
[
types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
]
])
)
await state.set_state(AdminStates.editing_user_traffic)
await callback.answer()
@admin_required
@error_handler
async def set_user_traffic_button(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[-2])
traffic_gb = int(parts[-1])
success = await _update_user_traffic(db, user_id, traffic_gb, db_user.id)
if success:
traffic_text = "♾️ безлимитный" if traffic_gb == 0 else f"{traffic_gb} ГБ"
await callback.message.edit_text(
f"✅ Лимит трафика изменен на: {traffic_text}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка изменения лимита трафика",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
@admin_required
@error_handler
async def process_traffic_edit_text(
message: types.Message,
db_user: User,
state: FSMContext,
db: AsyncSession
):
data = await state.get_data()
user_id = data.get("editing_traffic_user_id")
if not user_id:
await message.answer("❌ Ошибка: пользователь не найден")
await state.clear()
return
try:
traffic_gb = int(message.text.strip())
if traffic_gb < 0 or traffic_gb > 10000:
await message.answer("❌ Лимит трафика должен быть от 0 до 10000 ГБ (0 = безлимит)")
return
success = await _update_user_traffic(db, user_id, traffic_gb, db_user.id)
if success:
traffic_text = "♾️ безлимитный" if traffic_gb == 0 else f"{traffic_gb} ГБ"
await message.answer(
f"✅ Лимит трафика изменен на: {traffic_text}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await message.answer("❌ Ошибка изменения лимита трафика")
except ValueError:
await message.answer("❌ Введите корректное число ГБ")
return
await state.clear()
@admin_required
@error_handler
async def confirm_reset_devices(
callback: types.CallbackQuery,
db_user: User
):
user_id = int(callback.data.split('_')[-1])
await callback.message.edit_text(
"🔄 Сброс устройств пользователя\n\n"
"⚠️ ВНИМАНИЕ!\n"
"Вы уверены, что хотите сбросить все HWID устройства этого пользователя?\n\n"
"Это действие:\n"
"• Удалит все привязанные устройства\n"
"• Пользователь сможет заново подключить устройства\n"
"• Действие необратимо!\n\n"
"Продолжить?",
reply_markup=get_confirmation_keyboard(
f"admin_user_reset_devices_confirm_{user_id}",
f"admin_user_subscription_{user_id}",
db_user.language
)
)
await callback.answer()
@admin_required
@error_handler
async def reset_user_devices(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
try:
user = await get_user_by_id(db, user_id)
if not user or not user.remnawave_uuid:
await callback.answer("❌ Пользователь не найден или не связан с RemnaWave", show_alert=True)
return
remnawave_service = RemnaWaveService()
async with remnawave_service.get_api_client() as api:
success = await api.reset_user_devices(user.remnawave_uuid)
if success:
await callback.message.edit_text(
"✅ Устройства пользователя успешно сброшены",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
logger.info(f"Админ {db_user.id} сбросил устройства пользователя {user_id}")
else:
await callback.message.edit_text(
"❌ Ошибка сброса устройств",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 Подписка и настройки", callback_data=f"admin_user_subscription_{user_id}")]
])
)
except Exception as e:
logger.error(f"Ошибка сброса устройств: {e}")
await callback.answer("❌ Ошибка сброса устройств", show_alert=True)
async def _update_user_devices(db: AsyncSession, user_id: int, devices: int, admin_id: int) -> bool:
try:
user = await get_user_by_id(db, user_id)
if not user or not user.subscription:
logger.error(f"Пользователь {user_id} или подписка не найдены")
return False
subscription = user.subscription
old_devices = subscription.device_limit
subscription.device_limit = devices
subscription.updated_at = datetime.utcnow()
await db.commit()
if user.remnawave_uuid:
try:
remnawave_service = RemnaWaveService()
async with remnawave_service.get_api_client() as api:
await api.update_user(
uuid=user.remnawave_uuid,
hwid_device_limit=devices,
description=settings.format_remnawave_user_description(
full_name=user.full_name,
username=user.username,
telegram_id=user.telegram_id
)
)
logger.info(f"✅ Обновлен лимит устройств в RemnaWave для пользователя {user.telegram_id}")
except Exception as rw_error:
logger.error(f"❌ Ошибка обновления лимита устройств в RemnaWave: {rw_error}")
logger.info(f"Админ {admin_id} изменил лимит устройств пользователя {user_id}: {old_devices} -> {devices}")
return True
except Exception as e:
logger.error(f"Ошибка обновления лимита устройств: {e}")
await db.rollback()
return False
async def _update_user_traffic(db: AsyncSession, user_id: int, traffic_gb: int, admin_id: int) -> bool:
try:
user = await get_user_by_id(db, user_id)
if not user or not user.subscription:
logger.error(f"Пользователь {user_id} или подписка не найдены")
return False
subscription = user.subscription
old_traffic = subscription.traffic_limit_gb
subscription.traffic_limit_gb = traffic_gb
subscription.updated_at = datetime.utcnow()
await db.commit()
if user.remnawave_uuid:
try:
from app.external.remnawave_api import TrafficLimitStrategy
remnawave_service = RemnaWaveService()
async with remnawave_service.get_api_client() as api:
await api.update_user(
uuid=user.remnawave_uuid,
traffic_limit_bytes=traffic_gb * (1024**3) if traffic_gb > 0 else 0,
traffic_limit_strategy=TrafficLimitStrategy.MONTH,
description=settings.format_remnawave_user_description(
full_name=user.full_name,
username=user.username,
telegram_id=user.telegram_id
)
)
logger.info(f"✅ Обновлен лимит трафика в RemnaWave для пользователя {user.telegram_id}")
except Exception as rw_error:
logger.error(f"❌ Ошибка обновления лимита трафика в RemnaWave: {rw_error}")
traffic_text_old = "безлимитный" if old_traffic == 0 else f"{old_traffic} ГБ"
traffic_text_new = "безлимитный" if traffic_gb == 0 else f"{traffic_gb} ГБ"
logger.info(f"Админ {admin_id} изменил лимит трафика пользователя {user_id}: {traffic_text_old} -> {traffic_text_new}")
return True
except Exception as e:
logger.error(f"Ошибка обновления лимита трафика: {e}")
await db.rollback()
return False
async def _extend_subscription_by_days(db: AsyncSession, user_id: int, days: int, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id, extend_subscription
from app.services.subscription_service import SubscriptionService
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
logger.error(f"Подписка не найдена для пользователя {user_id}")
return False
await extend_subscription(db, subscription, days)
subscription_service = SubscriptionService()
await subscription_service.update_remnawave_user(db, subscription)
if days > 0:
logger.info(f"Админ {admin_id} продлил подписку пользователя {user_id} на {days} дней")
else:
logger.info(f"Админ {admin_id} сократил подписку пользователя {user_id} на {abs(days)} дней")
return True
except Exception as e:
logger.error(f"Ошибка продления подписки: {e}")
return False
async def _add_subscription_traffic(db: AsyncSession, user_id: int, gb: int, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id, add_subscription_traffic
from app.services.subscription_service import SubscriptionService
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
logger.error(f"Подписка не найдена для пользователя {user_id}")
return False
if gb == 0:
subscription.traffic_limit_gb = 0
await db.commit()
else:
await add_subscription_traffic(db, subscription, gb)
subscription_service = SubscriptionService()
await subscription_service.update_remnawave_user(db, subscription)
traffic_text = "безлимитный" if gb == 0 else f"{gb} ГБ"
logger.info(f"Админ {admin_id} добавил трафик {traffic_text} пользователю {user_id}")
return True
except Exception as e:
logger.error(f"Ошибка добавления трафика: {e}")
return False
async def _deactivate_user_subscription(db: AsyncSession, user_id: int, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id, deactivate_subscription
from app.services.subscription_service import SubscriptionService
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
logger.error(f"Подписка не найдена для пользователя {user_id}")
return False
await deactivate_subscription(db, subscription)
user = await get_user_by_id(db, user_id)
if user and user.remnawave_uuid:
subscription_service = SubscriptionService()
await subscription_service.disable_remnawave_user(user.remnawave_uuid)
logger.info(f"Админ {admin_id} деактивировал подписку пользователя {user_id}")
return True
except Exception as e:
logger.error(f"Ошибка деактивации подписки: {e}")
return False
async def _activate_user_subscription(db: AsyncSession, user_id: int, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id
from app.services.subscription_service import SubscriptionService
from app.database.models import SubscriptionStatus
from datetime import datetime
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
logger.error(f"Подписка не найдена для пользователя {user_id}")
return False
subscription.status = SubscriptionStatus.ACTIVE.value
if subscription.end_date <= datetime.utcnow():
subscription.end_date = datetime.utcnow() + timedelta(days=1)
await db.commit()
await db.refresh(subscription)
subscription_service = SubscriptionService()
await subscription_service.update_remnawave_user(db, subscription)
logger.info(f"Админ {admin_id} активировал подписку пользователя {user_id}")
return True
except Exception as e:
logger.error(f"Ошибка активации подписки: {e}")
return False
async def _grant_trial_subscription(db: AsyncSession, user_id: int, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id, create_trial_subscription
from app.services.subscription_service import SubscriptionService
existing_subscription = await get_subscription_by_user_id(db, user_id)
if existing_subscription:
logger.error(f"У пользователя {user_id} уже есть подписка")
return False
forced_devices = None
if not settings.is_devices_selection_enabled():
forced_devices = settings.get_disabled_mode_device_limit()
subscription = await create_trial_subscription(
db,
user_id,
device_limit=forced_devices,
)
subscription_service = SubscriptionService()
await subscription_service.create_remnawave_user(db, subscription)
logger.info(f"Админ {admin_id} выдал триальную подписку пользователю {user_id}")
return True
except Exception as e:
logger.error(f"Ошибка выдачи триальной подписки: {e}")
return False
async def _grant_paid_subscription(db: AsyncSession, user_id: int, days: int, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id, create_paid_subscription
from app.services.subscription_service import SubscriptionService
from app.config import settings
existing_subscription = await get_subscription_by_user_id(db, user_id)
if existing_subscription:
logger.error(f"У пользователя {user_id} уже есть подписка")
return False
trial_squads: list[str] = []
try:
from app.database.crud.server_squad import get_random_trial_squad_uuid
trial_uuid = await get_random_trial_squad_uuid(db)
if trial_uuid:
trial_squads = [trial_uuid]
except Exception as error:
logger.error(
"Не удалось подобрать сквад при выдаче подписки админом %s: %s",
admin_id,
error,
)
forced_devices = None
if not settings.is_devices_selection_enabled():
forced_devices = settings.get_disabled_mode_device_limit()
device_limit = settings.DEFAULT_DEVICE_LIMIT
if forced_devices is not None:
device_limit = forced_devices
subscription = await create_paid_subscription(
db=db,
user_id=user_id,
duration_days=days,
traffic_limit_gb=settings.DEFAULT_TRAFFIC_LIMIT_GB,
device_limit=device_limit,
connected_squads=trial_squads,
update_server_counters=True,
)
subscription_service = SubscriptionService()
await subscription_service.create_remnawave_user(db, subscription)
logger.info(f"Админ {admin_id} выдал платную подписку на {days} дней пользователю {user_id}")
return True
except Exception as e:
logger.error(f"Ошибка выдачи платной подписки: {e}")
return False
async def _calculate_subscription_period_price(
db: AsyncSession,
target_user: User,
subscription: Subscription,
period_days: int,
subscription_service: Optional[SubscriptionService] = None,
) -> int:
"""Рассчитывает стоимость подписки для администратора с учётом всех параметров."""
service = subscription_service or SubscriptionService()
connected_squads = list(subscription.connected_squads or [])
server_ids = []
if connected_squads:
try:
server_ids = await get_server_ids_by_uuids(db, connected_squads)
if len(server_ids) != len(connected_squads):
logger.warning(
"Не удалось сопоставить все сервера подписки пользователя %s для расчёта цены",
target_user.telegram_id,
)
except Exception as e:
logger.error(
"Не удалось получить идентификаторы серверов для расчёта цены подписки пользователя %s: %s",
target_user.telegram_id,
e,
)
server_ids = []
traffic_limit_gb = subscription.traffic_limit_gb
if traffic_limit_gb is None:
traffic_limit_gb = settings.DEFAULT_TRAFFIC_LIMIT_GB
device_limit = subscription.device_limit
if not device_limit or device_limit < 0:
device_limit = settings.DEFAULT_DEVICE_LIMIT
total_price, _ = await service.calculate_subscription_price(
period_days=period_days,
traffic_gb=traffic_limit_gb,
server_squad_ids=server_ids,
devices=device_limit,
db=db,
user=target_user,
promo_group=target_user.promo_group,
)
return total_price
@admin_required
@error_handler
async def cleanup_inactive_users(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_service = UserService()
deleted_count = await user_service.cleanup_inactive_users(db)
await callback.message.edit_text(
f"✅ Очистка завершена\n\n"
f"Удалено неактивных пользователей: {deleted_count}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
])
)
await callback.answer()
@admin_required
@error_handler
async def change_subscription_type(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile or not profile["subscription"]:
await callback.answer("❌ Пользователь или подписка не найдены", show_alert=True)
return
subscription = profile["subscription"]
current_type = "🎁 Триал" if subscription.is_trial else "💎 Платная"
text = f"🔄 Смена типа подписки\n\n"
text += f"👤 {profile['user'].full_name}\n"
text += f"📱 Текущий тип: {current_type}\n\n"
text += f"Выберите новый тип подписки:"
keyboard = []
if subscription.is_trial:
keyboard.append([
InlineKeyboardButton(
text="💎 Сделать платной",
callback_data=f"admin_sub_type_paid_{user_id}"
)
])
else:
keyboard.append([
InlineKeyboardButton(
text="🎁 Сделать триальной",
callback_data=f"admin_sub_type_trial_{user_id}"
)
])
keyboard.append([
InlineKeyboardButton(
text="⬅️ Назад",
callback_data=f"admin_user_subscription_{user_id}"
)
])
await callback.message.edit_text(
text,
reply_markup=InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def admin_buy_subscription(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
subscription = profile["subscription"]
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
available_periods = settings.get_available_subscription_periods()
subscription_service = SubscriptionService()
period_buttons = []
for period in available_periods:
try:
price_kopeks = await _calculate_subscription_period_price(
db,
target_user,
subscription,
period,
subscription_service=subscription_service,
)
except Exception as e:
logger.error(
"Ошибка расчёта стоимости подписки для пользователя %s и периода %s дней: %s",
target_user.telegram_id,
period,
e,
)
continue
period_buttons.append([
types.InlineKeyboardButton(
text=f"{period} дней ({settings.format_price(price_kopeks)})",
callback_data=f"admin_buy_sub_confirm_{user_id}_{period}_{price_kopeks}"
)
])
if not period_buttons:
await callback.answer("❌ Не удалось рассчитать стоимость подписки", show_alert=True)
return
period_buttons.append([
types.InlineKeyboardButton(
text="❌ Отмена",
callback_data=f"admin_user_subscription_{user_id}"
)
])
text = f"💳 Покупка подписки для пользователя\n\n"
target_user_link = f'{target_user.full_name}'
text += f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
text += f"💰 Баланс пользователя: {settings.format_price(target_user.balance_kopeks)}\n\n"
traffic_text = "Безлимит" if (subscription.traffic_limit_gb or 0) <= 0 else f"{subscription.traffic_limit_gb} ГБ"
devices_limit = subscription.device_limit
if devices_limit is None:
devices_limit = settings.DEFAULT_DEVICE_LIMIT
servers_count = len(subscription.connected_squads or [])
text += f"📶 Трафик: {traffic_text}\n"
text += f"📱 Устройства: {devices_limit}\n"
text += f"🌐 Серверов: {servers_count}\n\n"
text += "Выберите период подписки:\n"
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=period_buttons)
)
await callback.answer()
@admin_required
@error_handler
async def admin_buy_subscription_confirm(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[4])
period_days = int(parts[5])
price_kopeks_from_callback = int(parts[6]) if len(parts) > 6 else None
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
subscription = profile["subscription"]
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
subscription_service = SubscriptionService()
try:
price_kopeks = await _calculate_subscription_period_price(
db,
target_user,
subscription,
period_days,
subscription_service=subscription_service,
)
except Exception as e:
logger.error(
"Ошибка расчёта стоимости подписки при подтверждении админом для пользователя %s: %s",
target_user.telegram_id,
e,
)
await callback.answer("❌ Не удалось рассчитать стоимость подписки", show_alert=True)
return
if price_kopeks_from_callback is not None and price_kopeks_from_callback != price_kopeks:
logger.info(
"Стоимость подписки для пользователя %s изменилась с %s до %s при подтверждении",
target_user.telegram_id,
price_kopeks_from_callback,
price_kopeks,
)
if target_user.balance_kopeks < price_kopeks:
missing_kopeks = price_kopeks - target_user.balance_kopeks
await callback.message.edit_text(
f"❌ Недостаточно средств на балансе пользователя\n\n"
f"💰 Баланс пользователя: {settings.format_price(target_user.balance_kopeks)}\n"
f"💳 Стоимость подписки: {settings.format_price(price_kopeks)}\n"
f"📉 Не хватает: {settings.format_price(missing_kopeks)}\n\n"
f"Пополните баланс пользователя перед покупкой.",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(
text="⬅️ Назад к подписке",
callback_data=f"admin_user_subscription_{user_id}"
)]
])
)
await callback.answer()
return
text = f"💳 Подтверждение покупки подписки\n\n"
target_user_link = f'{target_user.full_name}'
text += f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
text += f"📅 Период подписки: {period_days} дней\n"
text += f"💰 Стоимость: {settings.format_price(price_kopeks)}\n"
text += f"💰 Баланс пользователя: {settings.format_price(target_user.balance_kopeks)}\n\n"
traffic_text = "Безлимит" if (subscription.traffic_limit_gb or 0) <= 0 else f"{subscription.traffic_limit_gb} ГБ"
devices_limit = subscription.device_limit
if devices_limit is None:
devices_limit = settings.DEFAULT_DEVICE_LIMIT
servers_count = len(subscription.connected_squads or [])
text += f"📶 Трафик: {traffic_text}\n"
text += f"📱 Устройства: {devices_limit}\n"
text += f"🌐 Серверов: {servers_count}\n\n"
text += "Вы уверены, что хотите купить подписку для этого пользователя?"
keyboard = [
[
types.InlineKeyboardButton(
text="✅ Подтвердить",
callback_data=f"admin_buy_sub_execute_{user_id}_{period_days}_{price_kopeks}"
)
],
[
types.InlineKeyboardButton(
text="❌ Отмена",
callback_data=f"admin_sub_buy_{user_id}"
)
]
]
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def admin_buy_subscription_execute(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
user_id = int(parts[4])
period_days = int(parts[5])
price_kopeks_from_callback = int(parts[6]) if len(parts) > 6 else None
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
subscription = profile["subscription"]
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
subscription_service = SubscriptionService()
try:
price_kopeks = await _calculate_subscription_period_price(
db,
target_user,
subscription,
period_days,
subscription_service=subscription_service,
)
except Exception as e:
logger.error(
"Ошибка расчёта стоимости подписки при списании средств админом для пользователя %s: %s",
target_user.telegram_id,
e,
)
await callback.answer("❌ Не удалось рассчитать стоимость подписки", show_alert=True)
return
if price_kopeks_from_callback is not None and price_kopeks_from_callback != price_kopeks:
logger.info(
"Стоимость подписки для пользователя %s изменилась с %s до %s перед списанием",
target_user.telegram_id,
price_kopeks_from_callback,
price_kopeks,
)
if target_user.balance_kopeks < price_kopeks:
await callback.answer("❌ Недостаточно средств на балансе пользователя", show_alert=True)
return
try:
from app.database.crud.user import subtract_user_balance
success = await subtract_user_balance(
db, target_user, price_kopeks,
f"Покупка подписки на {period_days} дней (администратор)"
)
if not success:
await callback.answer("❌ Ошибка списания средств", show_alert=True)
return
if subscription:
current_time = datetime.utcnow()
bonus_period = timedelta()
if (
subscription.is_trial
and settings.TRIAL_ADD_REMAINING_DAYS_TO_PAID
and subscription.end_date
):
remaining_trial_delta = subscription.end_date - current_time
if remaining_trial_delta.total_seconds() > 0:
bonus_period = remaining_trial_delta
logger.info(
"Админ продлевает подписку: добавляем оставшееся время триала (%s) пользователю %s",
bonus_period,
target_user.telegram_id,
)
extension_base_date = current_time
if subscription.end_date and subscription.end_date > current_time:
extension_base_date = subscription.end_date
else:
subscription.start_date = current_time
subscription.end_date = extension_base_date + timedelta(days=period_days) + bonus_period
subscription.status = SubscriptionStatus.ACTIVE.value
subscription.updated_at = current_time
if subscription.is_trial or not subscription.is_active:
was_trial = subscription.is_trial
subscription.is_trial = False
if subscription.traffic_limit_gb != 0:
subscription.traffic_limit_gb = 0
subscription.device_limit = settings.DEFAULT_DEVICE_LIMIT
if was_trial:
subscription.traffic_used_gb = 0.0
await db.commit()
await db.refresh(subscription)
from app.database.crud.transaction import create_transaction
transaction = await create_transaction(
db=db,
user_id=target_user.id,
type=TransactionType.SUBSCRIPTION_PAYMENT,
amount_kopeks=price_kopeks,
description=f"Продление подписки на {period_days} дней (администратор)"
)
try:
from app.services.remnawave_service import RemnaWaveService
from app.external.remnawave_api import UserStatus, TrafficLimitStrategy
remnawave_service = RemnaWaveService()
hwid_limit = resolve_hwid_device_limit_for_payload(subscription)
if target_user.remnawave_uuid:
async with remnawave_service.get_api_client() as api:
update_kwargs = dict(
uuid=target_user.remnawave_uuid,
status=UserStatus.ACTIVE if subscription.is_active else UserStatus.EXPIRED,
expire_at=subscription.end_date,
traffic_limit_bytes=subscription.traffic_limit_gb * (1024**3) if subscription.traffic_limit_gb > 0 else 0,
traffic_limit_strategy=TrafficLimitStrategy.MONTH,
description=settings.format_remnawave_user_description(
full_name=target_user.full_name,
username=target_user.username,
telegram_id=target_user.telegram_id
),
active_internal_squads=subscription.connected_squads,
)
if hwid_limit is not None:
update_kwargs['hwid_device_limit'] = hwid_limit
remnawave_user = await api.update_user(**update_kwargs)
else:
username = settings.format_remnawave_username(
full_name=target_user.full_name,
username=target_user.username,
telegram_id=target_user.telegram_id,
)
async with remnawave_service.get_api_client() as api:
create_kwargs = dict(
username=username,
expire_at=subscription.end_date,
status=UserStatus.ACTIVE if subscription.is_active else UserStatus.EXPIRED,
traffic_limit_bytes=subscription.traffic_limit_gb * (1024**3) if subscription.traffic_limit_gb > 0 else 0,
traffic_limit_strategy=TrafficLimitStrategy.MONTH,
telegram_id=target_user.telegram_id,
description=settings.format_remnawave_user_description(
full_name=target_user.full_name,
username=target_user.username,
telegram_id=target_user.telegram_id
),
active_internal_squads=subscription.connected_squads,
)
if hwid_limit is not None:
create_kwargs['hwid_device_limit'] = hwid_limit
remnawave_user = await api.create_user(**create_kwargs)
if remnawave_user and hasattr(remnawave_user, 'uuid'):
target_user.remnawave_uuid = remnawave_user.uuid
await db.commit()
if remnawave_user:
logger.info(f"Пользователь {target_user.telegram_id} успешно обновлен в RemnaWave")
else:
logger.error(f"Ошибка обновления пользователя {target_user.telegram_id} в RemnaWave")
except Exception as e:
logger.error(f"Ошибка работы с RemnaWave для пользователя {target_user.telegram_id}: {e}")
message = f"✅ Подписка пользователя продлена на {period_days} дней"
else:
message = "❌ Ошибка: у пользователя нет существующей подписки"
target_user_link = f'{target_user.full_name}'
await callback.message.edit_text(
f"{message}\n\n"
f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
f"💰 Списано: {settings.format_price(price_kopeks)}\n"
f"📅 Подписка действительна до: {format_datetime(subscription.end_date)}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(
text="⬅️ Назад к подписке",
callback_data=f"admin_user_subscription_{user_id}"
)]
]),
parse_mode="HTML"
)
try:
if callback.bot:
await callback.bot.send_message(
chat_id=target_user.telegram_id,
text=f"💳 Администратор продлил вашу подписку\n\n"
f"📅 Подписка продлена на {period_days} дней\n"
f"💰 Списано с баланса: {settings.format_price(price_kopeks)}\n"
f"📅 Подписка действительна до: {format_datetime(subscription.end_date)}",
parse_mode="HTML"
)
except Exception as e:
logger.error(f"Ошибка отправки уведомления пользователю {target_user.telegram_id}: {e}")
await callback.answer()
except Exception as e:
logger.error(f"Ошибка покупки подписки администратором: {e}")
await callback.answer("❌ Ошибка при покупке подписки", show_alert=True)
await db.rollback()
# ==================== Покупка тарифа администратором ====================
@admin_required
@error_handler
async def admin_buy_tariff(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Показывает список тарифов для покупки админом."""
user_id = int(callback.data.split('_')[-1])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
# Получаем доступные тарифы
from app.database.crud.tariff import get_tariffs_for_user
tariffs = await get_tariffs_for_user(db, target_user)
if not tariffs:
await callback.message.edit_text(
"❌ Нет доступных тарифов\n\n"
"Создайте тарифы в разделе управления тарифами.",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
return
target_user_link = f'{target_user.full_name}'
text = f"💳 Покупка тарифа для пользователя\n\n"
text += f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
text += f"💰 Баланс: {settings.format_price(target_user.balance_kopeks)}\n\n"
text += "📦 Выберите тариф:\n\n"
for tariff in tariffs:
traffic = "♾️" if tariff.traffic_limit_gb == 0 else f"{tariff.traffic_limit_gb} ГБ"
prices = tariff.period_prices or {}
min_price = min(prices.values()) if prices else 0
text += f"{tariff.name} — {traffic}/{tariff.device_limit}📱 от {settings.format_price(min_price)}\n"
keyboard = []
for tariff in tariffs:
keyboard.append([
types.InlineKeyboardButton(
text=tariff.name,
callback_data=f"admin_tariff_buy_select_{user_id}_{tariff.id}"
)
])
keyboard.append([
types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
parse_mode="HTML"
)
await callback.answer()
@admin_required
@error_handler
async def admin_buy_tariff_period(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Показывает выбор периода для тарифа."""
parts = callback.data.split('_')
user_id = int(parts[4])
tariff_id = int(parts[5])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
from app.database.crud.tariff import get_tariff_by_id
tariff = await get_tariff_by_id(db, tariff_id)
if not tariff or not tariff.is_active:
await callback.answer("❌ Тариф недоступен", show_alert=True)
return
target_user_link = f'{target_user.full_name}'
traffic = "♾️ Безлимит" if tariff.traffic_limit_gb == 0 else f"{tariff.traffic_limit_gb} ГБ"
text = f"💳 Покупка тарифа для пользователя\n\n"
text += f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
text += f"💰 Баланс: {settings.format_price(target_user.balance_kopeks)}\n\n"
text += f"📦 Тариф: {tariff.name}\n"
text += f"📊 Трафик: {traffic}\n"
text += f"📱 Устройств: {tariff.device_limit}\n"
text += f"🌐 Серверов: {len(tariff.allowed_squads) if tariff.allowed_squads else 0}\n\n"
text += "Выберите период:"
prices = tariff.period_prices or {}
keyboard = []
for period_str, price in sorted(prices.items(), key=lambda x: int(x[0])):
period = int(period_str)
keyboard.append([
types.InlineKeyboardButton(
text=f"{period} дней — {settings.format_price(price)}",
callback_data=f"admin_tariff_buy_confirm_{user_id}_{tariff_id}_{period}_{price}"
)
])
keyboard.append([
types.InlineKeyboardButton(text="⬅️ К тарифам", callback_data=f"admin_tariff_buy_{user_id}")
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
parse_mode="HTML"
)
await callback.answer()
@admin_required
@error_handler
async def admin_buy_tariff_confirm(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Подтверждение покупки тарифа."""
parts = callback.data.split('_')
user_id = int(parts[4])
tariff_id = int(parts[5])
period = int(parts[6])
price_kopeks = int(parts[7])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
from app.database.crud.tariff import get_tariff_by_id
tariff = await get_tariff_by_id(db, tariff_id)
if not tariff or not tariff.is_active:
await callback.answer("❌ Тариф недоступен", show_alert=True)
return
# Проверяем баланс
if target_user.balance_kopeks < price_kopeks:
missing = price_kopeks - target_user.balance_kopeks
await callback.message.edit_text(
f"❌ Недостаточно средств\n\n"
f"💰 Баланс: {settings.format_price(target_user.balance_kopeks)}\n"
f"💳 Стоимость: {settings.format_price(price_kopeks)}\n"
f"📉 Не хватает: {settings.format_price(missing)}\n\n"
f"Пополните баланс пользователя перед покупкой.",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_tariff_buy_select_{user_id}_{tariff_id}")]
]),
parse_mode="HTML"
)
await callback.answer()
return
target_user_link = f'{target_user.full_name}'
traffic = "♾️ Безлимит" if tariff.traffic_limit_gb == 0 else f"{tariff.traffic_limit_gb} ГБ"
text = f"💳 Подтверждение покупки тарифа\n\n"
text += f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
text += f"💰 Баланс: {settings.format_price(target_user.balance_kopeks)}\n\n"
text += f"📦 Тариф: {tariff.name}\n"
text += f"📊 Трафик: {traffic}\n"
text += f"📱 Устройств: {tariff.device_limit}\n"
text += f"📅 Период: {period} дней\n"
text += f"💰 Стоимость: {settings.format_price(price_kopeks)}\n\n"
text += "Подтвердить покупку?"
keyboard = [
[
types.InlineKeyboardButton(
text="✅ Подтвердить",
callback_data=f"admin_tariff_buy_exec_{user_id}_{tariff_id}_{period}_{price_kopeks}"
)
],
[
types.InlineKeyboardButton(
text="❌ Отмена",
callback_data=f"admin_tariff_buy_select_{user_id}_{tariff_id}"
)
]
]
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
parse_mode="HTML"
)
await callback.answer()
@admin_required
@error_handler
async def admin_buy_tariff_execute(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Выполняет покупку тарифа для пользователя."""
parts = callback.data.split('_')
user_id = int(parts[4])
tariff_id = int(parts[5])
period = int(parts[6])
price_kopeks = int(parts[7])
user_service = UserService()
profile = await user_service.get_user_profile(db, user_id)
if not profile:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
target_user = profile["user"]
from app.database.crud.tariff import get_tariff_by_id
tariff = await get_tariff_by_id(db, tariff_id)
if not tariff or not tariff.is_active:
await callback.answer("❌ Тариф недоступен", show_alert=True)
return
# Проверяем баланс ещё раз
if target_user.balance_kopeks < price_kopeks:
await callback.answer("❌ Недостаточно средств на балансе", show_alert=True)
return
try:
from app.database.crud.user import subtract_user_balance
from app.database.crud.subscription import extend_subscription, create_paid_subscription, get_subscription_by_user_id
from app.database.crud.transaction import create_transaction
from app.services.subscription_service import SubscriptionService
# Списываем баланс
success = await subtract_user_balance(
db, target_user, price_kopeks,
f"Покупка тарифа {tariff.name} на {period} дней (администратор)"
)
if not success:
await callback.answer("❌ Ошибка списания средств", show_alert=True)
return
# Получаем серверы из тарифа
squads = tariff.allowed_squads or []
# Проверяем есть ли подписка
existing_subscription = await get_subscription_by_user_id(db, target_user.id)
if existing_subscription:
# Продлеваем существующую подписку
subscription = await extend_subscription(
db,
existing_subscription,
days=period,
tariff_id=tariff.id,
traffic_limit_gb=tariff.traffic_limit_gb,
device_limit=tariff.device_limit,
connected_squads=squads,
)
else:
# Создаем новую подписку
subscription = await create_paid_subscription(
db=db,
user_id=target_user.id,
duration_days=period,
traffic_limit_gb=tariff.traffic_limit_gb,
device_limit=tariff.device_limit,
connected_squads=squads,
tariff_id=tariff.id,
)
# Обновляем в Remnawave
try:
subscription_service = SubscriptionService()
await subscription_service.create_remnawave_user(
db,
subscription,
reset_traffic=settings.RESET_TRAFFIC_ON_PAYMENT,
reset_reason="покупка тарифа (администратор)",
)
except Exception as e:
logger.error(f"Ошибка обновления Remnawave: {e}")
# Создаем транзакцию
await create_transaction(
db,
user_id=target_user.id,
type=TransactionType.SUBSCRIPTION_PAYMENT,
amount_kopeks=-price_kopeks,
description=f"Покупка тарифа {tariff.name} на {period} дней (администратор)",
)
target_user_link = f'{target_user.full_name}'
traffic = "♾️ Безлимит" if tariff.traffic_limit_gb == 0 else f"{tariff.traffic_limit_gb} ГБ"
await callback.message.edit_text(
f"✅ Тариф успешно куплен!\n\n"
f"👤 {target_user_link} (ID: {target_user.telegram_id})\n"
f"📦 Тариф: {tariff.name}\n"
f"📊 Трафик: {traffic}\n"
f"📱 Устройств: {tariff.device_limit}\n"
f"📅 Период: {period} дней\n"
f"💰 Списано: {settings.format_price(price_kopeks)}\n"
f"📅 Действует до: {format_datetime(subscription.end_date)}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
]),
parse_mode="HTML"
)
# Уведомляем пользователя
try:
if callback.bot:
await callback.bot.send_message(
chat_id=target_user.telegram_id,
text=f"💳 Администратор оформил вам тариф\n\n"
f"📦 Тариф: {tariff.name}\n"
f"📊 Трафик: {traffic}\n"
f"📱 Устройств: {tariff.device_limit}\n"
f"📅 Период: {period} дней\n"
f"💰 Списано с баланса: {settings.format_price(price_kopeks)}\n"
f"📅 Действует до: {format_datetime(subscription.end_date)}",
parse_mode="HTML"
)
except Exception as e:
logger.error(f"Ошибка отправки уведомления пользователю: {e}")
await callback.answer("✅ Тариф куплен!", show_alert=True)
except Exception as e:
logger.error(f"Ошибка покупки тарифа администратором: {e}", exc_info=True)
await callback.answer("❌ Ошибка при покупке тарифа", show_alert=True)
await db.rollback()
@admin_required
@error_handler
async def change_subscription_type_confirm(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
parts = callback.data.split('_')
new_type = parts[-2] # 'paid' или 'trial'
user_id = int(parts[-1])
success = await _change_subscription_type(db, user_id, new_type, db_user.id)
if success:
type_text = "платной" if new_type == "paid" else "триальной"
await callback.message.edit_text(
f"✅ Тип подписки успешно изменен на {type_text}",
reply_markup=InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
else:
await callback.message.edit_text(
"❌ Ошибка изменения типа подписки",
reply_markup=InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
async def _change_subscription_type(db: AsyncSession, user_id: int, new_type: str, admin_id: int) -> bool:
try:
from app.database.crud.subscription import get_subscription_by_user_id
from app.services.subscription_service import SubscriptionService
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
logger.error(f"Подписка не найдена для пользователя {user_id}")
return False
new_is_trial = (new_type == "trial")
if subscription.is_trial == new_is_trial:
logger.info(f"Тип подписки уже установлен корректно для пользователя {user_id}")
return True
old_type = "триальной" if subscription.is_trial else "платной"
new_type_text = "триальной" if new_is_trial else "платной"
subscription.is_trial = new_is_trial
subscription.updated_at = datetime.utcnow()
if not new_is_trial and subscription.is_trial:
user = await get_user_by_id(db, user_id)
if user:
user.has_had_paid_subscription = True
await db.commit()
subscription_service = SubscriptionService()
await subscription_service.update_remnawave_user(db, subscription)
logger.info(f"Админ {admin_id} изменил тип подписки пользователя {user_id}: {old_type} -> {new_type_text}")
return True
except Exception as e:
logger.error(f"Ошибка изменения типа подписки: {e}")
await db.rollback()
return False
# =============================================================================
# Смена тарифа пользователя администратором
# =============================================================================
@admin_required
@error_handler
async def show_admin_tariff_change(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Показывает список доступных тарифов для смены."""
user_id = int(callback.data.split('_')[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
from app.database.crud.subscription import get_subscription_by_user_id
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
# Получаем все активные тарифы
tariffs = await get_all_tariffs(db, include_inactive=False)
if not tariffs:
await callback.message.edit_text(
"❌ Нет доступных тарифов\n\n"
"Создайте тарифы в разделе управления тарифами.",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
return
# Текущий тариф
current_tariff = None
if subscription.tariff_id:
current_tariff = await get_tariff_by_id(db, subscription.tariff_id)
text = "📦 Смена тарифа пользователя\n\n"
user_link = f'{user.full_name}'
text += f"👤 {user_link}\n\n"
if current_tariff:
text += f"Текущий тариф: {current_tariff.name}\n\n"
else:
text += "Текущий тариф: не установлен\n\n"
text += "Выберите новый тариф:\n"
keyboard = []
for tariff in tariffs:
# Отмечаем текущий тариф
prefix = "✅ " if current_tariff and tariff.id == current_tariff.id else ""
# Описание тарифа
traffic_str = "♾️" if tariff.traffic_limit_gb == 0 else f"{tariff.traffic_limit_gb} ГБ"
servers_count = len(tariff.allowed_squads) if tariff.allowed_squads else 0
button_text = f"{prefix}{tariff.name} ({tariff.device_limit} устр., {traffic_str}, {servers_count} серв.)"
keyboard.append([
types.InlineKeyboardButton(
text=button_text,
callback_data=f"admin_sub_tariff_select_{tariff.id}_{user_id}"
)
])
keyboard.append([
types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"admin_user_subscription_{user_id}")
])
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def select_admin_tariff_change(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Подтверждение выбора тарифа."""
parts = callback.data.split('_')
tariff_id = int(parts[-2])
user_id = int(parts[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
tariff = await get_tariff_by_id(db, tariff_id)
if not tariff:
await callback.answer("❌ Тариф не найден", show_alert=True)
return
from app.database.crud.subscription import get_subscription_by_user_id
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
# Проверяем, если это тот же тариф
if subscription.tariff_id == tariff_id:
await callback.answer("ℹ️ Этот тариф уже установлен", show_alert=True)
return
traffic_str = "♾️" if tariff.traffic_limit_gb == 0 else f"{tariff.traffic_limit_gb} ГБ"
servers_count = len(tariff.allowed_squads) if tariff.allowed_squads else 0
text = f"📦 Подтверждение смены тарифа\n\n"
user_link = f'{user.full_name}'
text += f"👤 {user_link}\n\n"
text += f"Новый тариф: {tariff.name}\n"
text += f"• Устройства: {tariff.device_limit}\n"
text += f"• Трафик: {traffic_str}\n"
text += f"• Серверы: {servers_count}\n\n"
text += "⚠️ Параметры подписки будут обновлены в соответствии с тарифом.\n"
text += "Дата окончания подписки не изменится."
keyboard = [
[
types.InlineKeyboardButton(
text="✅ Подтвердить",
callback_data=f"admin_sub_tariff_confirm_{tariff_id}_{user_id}"
),
types.InlineKeyboardButton(
text="❌ Отмена",
callback_data=f"admin_sub_change_tariff_{user_id}"
)
]
]
await callback.message.edit_text(
text,
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
)
await callback.answer()
@admin_required
@error_handler
async def confirm_admin_tariff_change(
callback: types.CallbackQuery,
db_user: User,
db: AsyncSession
):
"""Применяет смену тарифа."""
parts = callback.data.split('_')
tariff_id = int(parts[-2])
user_id = int(parts[-1])
user = await get_user_by_id(db, user_id)
if not user:
await callback.answer("❌ Пользователь не найден", show_alert=True)
return
tariff = await get_tariff_by_id(db, tariff_id)
if not tariff:
await callback.answer("❌ Тариф не найден", show_alert=True)
return
from app.database.crud.subscription import get_subscription_by_user_id
subscription = await get_subscription_by_user_id(db, user_id)
if not subscription:
await callback.answer("❌ У пользователя нет подписки", show_alert=True)
return
try:
old_tariff_id = subscription.tariff_id
# Обновляем параметры подписки в соответствии с тарифом
subscription.tariff_id = tariff.id
subscription.device_limit = tariff.device_limit
subscription.traffic_limit_gb = tariff.traffic_limit_gb
subscription.connected_squads = tariff.allowed_squads or []
subscription.updated_at = datetime.utcnow()
# Сбрасываем докупленный трафик при смене тарифа
from app.database.models import TrafficPurchase
from sqlalchemy import delete as sql_delete
await db.execute(sql_delete(TrafficPurchase).where(TrafficPurchase.subscription_id == subscription.id))
subscription.purchased_traffic_gb = 0
subscription.traffic_reset_at = None
await db.commit()
# Синхронизируем с RemnaWave
subscription_service = SubscriptionService()
await subscription_service.update_remnawave_user(db, subscription)
logger.info(
f"Админ {db_user.id} изменил тариф пользователя {user_id}: "
f"{old_tariff_id} -> {tariff_id} ({tariff.name})"
)
await callback.message.edit_text(
f"✅ Тариф успешно изменен\n\n"
f"Новый тариф: {tariff.name}\n"
f"• Устройства: {tariff.device_limit}\n"
f"• Трафик: {'♾️' if tariff.traffic_limit_gb == 0 else f'{tariff.traffic_limit_gb} ГБ'}\n"
f"• Серверы: {len(tariff.allowed_squads) if tariff.allowed_squads else 0}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
except Exception as e:
logger.error(f"Ошибка смены тарифа: {e}")
await db.rollback()
await callback.message.edit_text(
"❌ Ошибка смены тарифа\n\n"
f"Детали: {str(e)}",
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
])
)
await callback.answer()
def register_handlers(dp: Dispatcher):
dp.callback_query.register(
show_users_menu,
F.data == "admin_users"
)
dp.callback_query.register(
show_users_list,
F.data == "admin_users_list"
)
dp.callback_query.register(
show_users_statistics,
F.data == "admin_users_stats"
)
dp.callback_query.register(
show_user_subscription,
F.data.startswith("admin_user_subscription_")
)
dp.callback_query.register(
show_user_transactions,
F.data.startswith("admin_user_transactions_")
)
dp.callback_query.register(
show_user_statistics,
F.data.startswith("admin_user_statistics_")
)
dp.callback_query.register(
block_user,
F.data.startswith("admin_user_block_confirm_")
)
dp.callback_query.register(
delete_user_account,
F.data.startswith("admin_user_delete_confirm_")
)
dp.callback_query.register(
confirm_user_block,
F.data.startswith("admin_user_block_") & ~F.data.contains("confirm")
)
dp.callback_query.register(
unblock_user,
F.data.startswith("admin_user_unblock_confirm_")
)
dp.callback_query.register(
confirm_user_unblock,
F.data.startswith("admin_user_unblock_") & ~F.data.contains("confirm")
)
dp.callback_query.register(
confirm_user_delete,
F.data.startswith("admin_user_delete_") & ~F.data.contains("confirm")
)
# Регистрация хендлеров ограничений пользователя
dp.callback_query.register(
show_user_restrictions,
F.data.startswith("admin_user_restrictions_")
)
dp.callback_query.register(
toggle_user_restriction_topup,
F.data.startswith("admin_user_restriction_toggle_topup_")
)
dp.callback_query.register(
toggle_user_restriction_subscription,
F.data.startswith("admin_user_restriction_toggle_sub_")
)
dp.callback_query.register(
ask_restriction_reason,
F.data.startswith("admin_user_restriction_reason_")
)
dp.callback_query.register(
clear_user_restrictions,
F.data.startswith("admin_user_restriction_clear_")
)
dp.message.register(
save_restriction_reason,
AdminStates.editing_user_restriction_reason
)
dp.callback_query.register(
handle_users_list_pagination_fixed,
F.data.startswith("admin_users_list_page_")
)
dp.callback_query.register(
handle_users_balance_list_pagination,
F.data.startswith("admin_users_balance_list_page_")
)
dp.callback_query.register(
handle_users_traffic_list_pagination,
F.data.startswith("admin_users_traffic_list_page_")
)
dp.callback_query.register(
handle_users_activity_list_pagination,
F.data.startswith("admin_users_activity_list_page_")
)
dp.callback_query.register(
handle_users_spending_list_pagination,
F.data.startswith("admin_users_spending_list_page_")
)
dp.callback_query.register(
handle_users_purchases_list_pagination,
F.data.startswith("admin_users_purchases_list_page_")
)
dp.callback_query.register(
handle_users_ready_to_renew_pagination,
F.data.startswith("admin_users_ready_to_renew_list_page_")
)
dp.callback_query.register(
handle_users_campaign_list_pagination,
F.data.startswith("admin_users_campaign_list_page_")
)
dp.callback_query.register(
start_user_search,
F.data == "admin_users_search"
)
dp.message.register(
process_user_search,
AdminStates.waiting_for_user_search
)
dp.callback_query.register(
show_user_management,
F.data.startswith("admin_user_manage_")
)
dp.callback_query.register(
show_user_promo_group,
F.data.startswith("admin_user_promo_group_") & ~F.data.contains("_set_") & ~F.data.contains("_toggle_")
)
dp.callback_query.register(
set_user_promo_group,
F.data.startswith("admin_user_promo_group_toggle_")
)
dp.callback_query.register(
start_balance_edit,
F.data.startswith("admin_user_balance_")
)
dp.message.register(
process_balance_edit,
AdminStates.editing_user_balance
)
dp.callback_query.register(
show_user_referrals,
F.data.startswith("admin_user_referrals_") & ~F.data.contains("_edit")
)
dp.callback_query.register(
start_edit_referral_percent,
F.data.startswith("admin_user_referral_percent_")
& ~F.data.contains("_set_")
& ~F.data.contains("_reset")
)
dp.callback_query.register(
set_referral_percent_button,
F.data.startswith("admin_user_referral_percent_set_")
| F.data.startswith("admin_user_referral_percent_reset_")
)
dp.message.register(
process_referral_percent_input,
AdminStates.editing_user_referral_percent,
)
dp.callback_query.register(
start_edit_user_referrals,
F.data.startswith("admin_user_referrals_edit_")
)
dp.message.register(
process_edit_user_referrals,
AdminStates.editing_user_referrals
)
dp.callback_query.register(
start_send_user_message,
F.data.startswith("admin_user_send_message_")
)
dp.message.register(
process_send_user_message,
AdminStates.sending_user_message
)
dp.callback_query.register(
show_inactive_users,
F.data == "admin_users_inactive"
)
dp.callback_query.register(
cleanup_inactive_users,
F.data == "admin_cleanup_inactive"
)
dp.callback_query.register(
extend_user_subscription,
F.data.startswith("admin_sub_extend_") & ~F.data.contains("days") & ~F.data.contains("confirm")
)
dp.callback_query.register(
process_subscription_extension_days,
F.data.startswith("admin_sub_extend_days_")
)
dp.message.register(
process_subscription_extension_text,
AdminStates.extending_subscription
)
dp.callback_query.register(
add_subscription_traffic,
F.data.startswith("admin_sub_traffic_") & ~F.data.contains("add")
)
dp.callback_query.register(
process_traffic_addition_button,
F.data.startswith("admin_sub_traffic_add_")
)
dp.message.register(
process_traffic_addition_text,
AdminStates.adding_traffic
)
dp.callback_query.register(
deactivate_user_subscription,
F.data.startswith("admin_sub_deactivate_") & ~F.data.contains("confirm")
)
dp.callback_query.register(
confirm_subscription_deactivation,
F.data.startswith("admin_sub_deactivate_confirm_")
)
dp.callback_query.register(
activate_user_subscription,
F.data.startswith("admin_sub_activate_")
)
dp.callback_query.register(
grant_trial_subscription,
F.data.startswith("admin_sub_grant_trial_")
)
dp.callback_query.register(
grant_paid_subscription,
F.data.startswith("admin_sub_grant_") & ~F.data.contains("trial") & ~F.data.contains("days")
)
dp.callback_query.register(
process_subscription_grant_days,
F.data.startswith("admin_sub_grant_days_")
)
dp.message.register(
process_subscription_grant_text,
AdminStates.granting_subscription
)
dp.callback_query.register(
show_user_servers_management,
F.data.startswith("admin_user_servers_")
)
dp.callback_query.register(
show_server_selection,
F.data.startswith("admin_user_change_server_")
)
dp.callback_query.register(
toggle_user_server,
F.data.startswith("admin_user_toggle_server_") & ~F.data.endswith("_add") & ~F.data.endswith("_remove")
)
dp.callback_query.register(
start_devices_edit,
F.data.startswith("admin_user_devices_") & ~F.data.contains("set")
)
dp.callback_query.register(
set_user_devices_button,
F.data.startswith("admin_user_devices_set_")
)
dp.callback_query.register(
toggle_user_modem,
F.data.startswith("admin_user_modem_")
)
# Смена тарифа пользователя
dp.callback_query.register(
show_admin_tariff_change,
F.data.startswith("admin_sub_change_tariff_")
)
dp.callback_query.register(
select_admin_tariff_change,
F.data.startswith("admin_sub_tariff_select_")
)
dp.callback_query.register(
confirm_admin_tariff_change,
F.data.startswith("admin_sub_tariff_confirm_")
)
dp.message.register(
process_devices_edit_text,
AdminStates.editing_user_devices
)
dp.callback_query.register(
start_traffic_edit,
F.data.startswith("admin_user_traffic_") & ~F.data.contains("set")
)
dp.callback_query.register(
set_user_traffic_button,
F.data.startswith("admin_user_traffic_set_")
)
dp.message.register(
process_traffic_edit_text,
AdminStates.editing_user_traffic
)
dp.callback_query.register(
confirm_reset_devices,
F.data.startswith("admin_user_reset_devices_") & ~F.data.contains("confirm")
)
dp.callback_query.register(
reset_user_devices,
F.data.startswith("admin_user_reset_devices_confirm_")
)
dp.callback_query.register(
change_subscription_type,
F.data.startswith("admin_sub_change_type_")
)
dp.callback_query.register(
change_subscription_type_confirm,
F.data.startswith("admin_sub_type_")
)
# Регистрация обработчика покупки подписки администратором
dp.callback_query.register(
admin_buy_subscription,
F.data.startswith("admin_sub_buy_")
)
# Регистрация дополнительных обработчиков для покупки подписки
dp.callback_query.register(
admin_buy_subscription_confirm,
F.data.startswith("admin_buy_sub_confirm_")
)
dp.callback_query.register(
admin_buy_subscription_execute,
F.data.startswith("admin_buy_sub_execute_")
)
# Регистрация обработчиков для покупки тарифа администратором
dp.callback_query.register(
admin_buy_tariff,
F.data.startswith("admin_tariff_buy_") & ~F.data.startswith("admin_tariff_buy_select_") & ~F.data.startswith("admin_tariff_buy_confirm_") & ~F.data.startswith("admin_tariff_buy_exec_")
)
dp.callback_query.register(
admin_buy_tariff_period,
F.data.startswith("admin_tariff_buy_select_")
)
dp.callback_query.register(
admin_buy_tariff_confirm,
F.data.startswith("admin_tariff_buy_confirm_")
)
dp.callback_query.register(
admin_buy_tariff_execute,
F.data.startswith("admin_tariff_buy_exec_")
)
# Регистрация обработчиков для фильтрации пользователей
dp.callback_query.register(
show_users_filters,
F.data == "admin_users_filters"
)
dp.callback_query.register(
show_users_list_by_balance,
F.data == "admin_users_balance_filter"
)
dp.callback_query.register(
show_users_list_by_traffic,
F.data == "admin_users_traffic_filter"
)
dp.callback_query.register(
show_users_list_by_last_activity,
F.data == "admin_users_activity_filter"
)
dp.callback_query.register(
show_users_list_by_spending,
F.data == "admin_users_spending_filter"
)
dp.callback_query.register(
show_users_list_by_purchases,
F.data == "admin_users_purchases_filter"
)
dp.callback_query.register(
show_users_ready_to_renew,
F.data == "admin_users_ready_to_renew_filter"
)
dp.callback_query.register(
show_users_list_by_campaign,
F.data == "admin_users_campaign_filter"
)