Vladless
638 lines
24 KiB
Python
638 lines
24 KiB
Python
import html
|
|
import re
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
import pytz
|
|
|
|
from aiogram import F, Router
|
|
from aiogram.types import CallbackQuery, Message
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from audit import list_audit_events
|
|
from core.cache_config import AUDIT_HISTORY_CACHE_TTL_SEC
|
|
from core.redis_cache import cache_get, cache_key, cache_set
|
|
from database.models import User
|
|
from filters.admin import IsAdminFilter
|
|
|
|
from .keyboard import AdminUserEditorCallback, build_user_audit_kb
|
|
|
|
|
|
MOSCOW_TZ = pytz.timezone("Europe/Moscow")
|
|
PAGE_SIZE = 10
|
|
LOGS_DIR = Path(__file__).resolve().parents[3] / "logs"
|
|
BALANCE_LOG_PATTERN = re.compile(
|
|
r"^(?P<ts>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) \| [^|]+ \| [^|]+ \| .*?\[DB\] Баланс пользователя "
|
|
r"(?P<tg_id>\d+) обновлён: (?P<old>-?\d+(?:\.\d+)?) → (?P<new>-?\d+(?:\.\d+)?)$"
|
|
)
|
|
router = Router()
|
|
|
|
|
|
def _serialize_audit_events(events: list) -> list[dict]:
|
|
"""Для кэша Redis: список событий в JSON-сериализуемый вид."""
|
|
out = []
|
|
for e in events:
|
|
out.append({
|
|
"event_type": e.event_type,
|
|
"channel": e.channel,
|
|
"path_or_handler": getattr(e, "path_or_handler", None) or "",
|
|
"actor_identity_id": getattr(e, "actor_identity_id", None),
|
|
"actor_tg_id": getattr(e, "actor_tg_id", None),
|
|
"entity_type": getattr(e, "entity_type", None),
|
|
"entity_id": getattr(e, "entity_id", None),
|
|
"result": getattr(e, "result", "success"),
|
|
"reason": getattr(e, "reason", None),
|
|
"metadata_": getattr(e, "metadata_", None),
|
|
"request_id": getattr(e, "request_id", None),
|
|
"created_at": e.created_at.isoformat() if e.created_at else None,
|
|
})
|
|
return out
|
|
|
|
|
|
def _deserialize_audit_events(cached: list[dict]) -> list:
|
|
"""Из кэша: список dict → объекты с атрибутами как у AuditEvent."""
|
|
out = []
|
|
for d in cached:
|
|
created = d.get("created_at")
|
|
if isinstance(created, str):
|
|
try:
|
|
created = datetime.fromisoformat(created.replace("Z", "+00:00"))
|
|
except Exception:
|
|
created = None
|
|
out.append(SimpleNamespace(
|
|
event_type=d.get("event_type", ""),
|
|
channel=d.get("channel", "telegram"),
|
|
path_or_handler=d.get("path_or_handler") or "",
|
|
actor_identity_id=d.get("actor_identity_id"),
|
|
actor_tg_id=d.get("actor_tg_id"),
|
|
entity_type=d.get("entity_type"),
|
|
entity_id=d.get("entity_id"),
|
|
result=d.get("result", "success"),
|
|
reason=d.get("reason"),
|
|
metadata_=d.get("metadata_"),
|
|
request_id=d.get("request_id"),
|
|
created_at=created,
|
|
))
|
|
return out
|
|
|
|
|
|
def _event_created_at(event) -> datetime:
|
|
created = getattr(event, "created_at", None)
|
|
if created is None:
|
|
return datetime.min
|
|
if created.tzinfo is not None:
|
|
return created.astimezone(pytz.UTC).replace(tzinfo=None)
|
|
return created
|
|
|
|
|
|
def _event_created_at_moscow(event) -> datetime | None:
|
|
created = getattr(event, "created_at", None)
|
|
if created is None:
|
|
return None
|
|
if getattr(event, "event_type", "") == "balance_changed" and created.tzinfo is None:
|
|
return MOSCOW_TZ.localize(created)
|
|
if created.tzinfo is None:
|
|
return pytz.UTC.localize(created).astimezone(MOSCOW_TZ)
|
|
return created.astimezone(MOSCOW_TZ)
|
|
|
|
|
|
def _load_balance_log_events(tg_id: int, limit: int) -> list:
|
|
if limit <= 0 or not LOGS_DIR.is_dir():
|
|
return []
|
|
|
|
files = [path for path in LOGS_DIR.iterdir() if path.is_file() and path.name.startswith("logging")]
|
|
files.sort(key=lambda path: path.stat().st_mtime, reverse=True)
|
|
|
|
events = []
|
|
for path in files:
|
|
try:
|
|
with open(path, encoding="utf-8", errors="ignore") as file:
|
|
lines = file.read().splitlines()
|
|
except Exception:
|
|
continue
|
|
|
|
for line in reversed(lines):
|
|
match = BALANCE_LOG_PATTERN.match(line.strip())
|
|
if not match:
|
|
continue
|
|
if int(match.group("tg_id")) != tg_id:
|
|
continue
|
|
|
|
old_balance = float(match.group("old"))
|
|
new_balance = float(match.group("new"))
|
|
amount = new_balance - old_balance
|
|
if amount == 0:
|
|
continue
|
|
|
|
try:
|
|
created_at = MOSCOW_TZ.localize(datetime.strptime(match.group("ts"), "%Y-%m-%d %H:%M:%S"))
|
|
except ValueError:
|
|
continue
|
|
|
|
events.append(SimpleNamespace(
|
|
event_type="balance_changed",
|
|
channel="system",
|
|
path_or_handler="logger:balance",
|
|
actor_identity_id=None,
|
|
actor_tg_id=tg_id,
|
|
entity_type="telegram_user",
|
|
entity_id=tg_id,
|
|
result="success",
|
|
reason=None,
|
|
metadata_={
|
|
"amount": amount,
|
|
"balance_before": old_balance,
|
|
"balance_after": new_balance,
|
|
},
|
|
request_id=None,
|
|
created_at=created_at,
|
|
))
|
|
if len(events) >= limit:
|
|
break
|
|
if len(events) >= limit:
|
|
break
|
|
|
|
events.sort(key=_event_created_at, reverse=True)
|
|
return events[:limit]
|
|
|
|
EVENT_CATEGORY_MAP = {
|
|
"balance": {
|
|
"balance_changed",
|
|
},
|
|
"auth": {
|
|
"register_success",
|
|
"register_failed",
|
|
"login_success",
|
|
"login_failed",
|
|
"login_code_sent",
|
|
"login_code_send_failed",
|
|
"login_by_code_success",
|
|
"login_by_code_failed",
|
|
"telegram_login_success",
|
|
"telegram_login_failed",
|
|
"telegram_link_success",
|
|
"telegram_link_failed",
|
|
},
|
|
"payments": {
|
|
"payment_menu_opened",
|
|
"payment_currency_selected",
|
|
"balance_screen_opened",
|
|
"balance_history_opened",
|
|
"payment_link_created",
|
|
"payment_link_create_failed",
|
|
"coupon_activation_success",
|
|
"coupon_activation_failed",
|
|
"coupon_renewal_success",
|
|
"coupon_renewal_failed",
|
|
"coupon_key_selection_opened",
|
|
},
|
|
"subscriptions": {
|
|
"trial_requested",
|
|
"key_purchase_started",
|
|
"keys_list_opened",
|
|
"key_view_opened",
|
|
"key_alias_updated",
|
|
"key_hwid_reset",
|
|
"key_renew_requested",
|
|
"key_renew_blocked",
|
|
"key_renew_insufficient_funds",
|
|
"key_renew_completed",
|
|
"key_renew_failed",
|
|
},
|
|
"marketing": {
|
|
"start_link_opened",
|
|
"coupon_link_opened",
|
|
"gift_link_opened",
|
|
"referral_link_opened",
|
|
"referral_link_applied",
|
|
"referral_link_failed",
|
|
"referral_screen_opened",
|
|
"referral_qr_opened",
|
|
"top_referrals_opened",
|
|
"utm_link_opened",
|
|
"utm_link_failed",
|
|
},
|
|
}
|
|
|
|
EVENT_TYPE_LABELS = {
|
|
"balance_changed": "Движение баланса",
|
|
"start_entry_opened": "Старт бота",
|
|
"start_link_opened": "Переход по ссылке",
|
|
"register_success": "Регистрация (успех)",
|
|
"register_failed": "Регистрация (ошибка)",
|
|
"login_success": "Вход по паролю",
|
|
"login_failed": "Вход (ошибка)",
|
|
"login_code_sent": "Код входа отправлен",
|
|
"login_code_send_failed": "Код входа не отправлен",
|
|
"login_by_code_success": "Вход по коду",
|
|
"login_by_code_failed": "Вход по коду (ошибка)",
|
|
"telegram_login_success": "Вход через Telegram",
|
|
"telegram_login_failed": "Вход через Telegram (ошибка)",
|
|
"telegram_link_success": "Привязка Telegram",
|
|
"telegram_link_failed": "Привязка Telegram (ошибка)",
|
|
"payment_menu_opened": "Меню оплаты",
|
|
"payment_currency_selected": "Выбор валюты",
|
|
"balance_screen_opened": "Экран баланса",
|
|
"balance_history_opened": "История пополнений",
|
|
"payment_link_created": "Создана платёжная ссылка",
|
|
"payment_link_create_failed": "Ошибка создания ссылки",
|
|
"coupon_activation_success": "Купон активирован",
|
|
"coupon_activation_failed": "Купон не активирован",
|
|
"coupon_renewal_success": "Продление по купону",
|
|
"coupon_renewal_failed": "Продление по купону (ошибка)",
|
|
"coupon_key_selection_opened": "Выбор ключа для купона",
|
|
"coupon_link_opened": "Переход по ссылке купона",
|
|
"trial_requested": "Запрос триала",
|
|
"key_purchase_started": "Начало покупки подписки",
|
|
"keys_list_opened": "Список подписок",
|
|
"key_view_opened": "Карточка подписки",
|
|
"key_alias_updated": "Переименование подписки",
|
|
"key_hwid_reset": "Сброс устройств (HWID)",
|
|
"key_renew_requested": "Запрос продления",
|
|
"key_renew_blocked": "Продление ещё недоступно",
|
|
"key_renew_insufficient_funds": "Не хватило баланса на продление",
|
|
"key_renew_completed": "Подписка продлена",
|
|
"key_renew_failed": "Ошибка продления",
|
|
"gift_link_opened": "Переход по подарочной ссылке",
|
|
"referral_link_opened": "Переход по реферальной ссылке",
|
|
"referral_link_applied": "Реферал применён",
|
|
"referral_link_failed": "Реферальная ссылка (ошибка)",
|
|
"referral_screen_opened": "Экран рефералов",
|
|
"referral_qr_opened": "QR реферальной ссылки",
|
|
"top_referrals_opened": "Топ рефералов",
|
|
"utm_link_opened": "Переход по UTM",
|
|
"utm_link_failed": "UTM не найден",
|
|
}
|
|
|
|
|
|
def _parse_filter_page(raw_data: str | int | None) -> tuple[str, str, int]:
|
|
if isinstance(raw_data, str):
|
|
parts = raw_data.split("|")
|
|
if len(parts) == 3:
|
|
channel_filter, category_filter, page_str = parts
|
|
elif len(parts) == 2:
|
|
channel_filter, page_str = parts
|
|
category_filter = "all"
|
|
else:
|
|
return "all", "all", 0
|
|
if channel_filter not in {"all", "api", "telegram"}:
|
|
channel_filter = "all"
|
|
if category_filter not in {"all", "balance", "auth", "payments", "subscriptions", "marketing"}:
|
|
category_filter = "all"
|
|
if page_str.isdigit():
|
|
return channel_filter, category_filter, int(page_str)
|
|
return channel_filter, category_filter, 0
|
|
return "all", "all", 0
|
|
|
|
|
|
def _resolve_event_types(category_filter: str) -> list[str] | None:
|
|
if category_filter == "all":
|
|
return None
|
|
category_events = EVENT_CATEGORY_MAP.get(category_filter)
|
|
if not category_events:
|
|
return None
|
|
return sorted(category_events)
|
|
|
|
|
|
CATEGORY_BLOCK_ORDER = ("balance", "auth", "subscriptions", "payments", "marketing", "other")
|
|
CATEGORY_BLOCK_LABELS = {
|
|
"balance": "Баланс",
|
|
"auth": "Авторизация",
|
|
"payments": "Платежи",
|
|
"subscriptions": "Подписки",
|
|
"marketing": "Маркетинг",
|
|
"other": "Другое",
|
|
}
|
|
|
|
|
|
def _event_category(event) -> str:
|
|
"""Определяет категорию события для группировки (при выборке «все»)."""
|
|
path = (getattr(event, "path_or_handler", None) or "").lower()
|
|
etype = (getattr(event, "event_type", None) or "").lower()
|
|
if etype == "balance_changed":
|
|
return "balance"
|
|
if etype != "telegram_access":
|
|
for cat, event_types in EVENT_CATEGORY_MAP.items():
|
|
if etype in event_types:
|
|
return cat
|
|
return "other"
|
|
if "handlers.keys" in path or "key_view" in path or "key_create" in path or "key_renew" in path or "tariffs" in path or "key_tariffs" in path or "addon" in path or "key_addons" in path:
|
|
return "subscriptions"
|
|
if "handlers.payments" in path or "pay" in path or "balance" in path or "handlers.coupons" in path or "payment" in path:
|
|
return "payments"
|
|
if "handlers.refferal" in path or "referral" in path or "gift" in path or "utm" in path:
|
|
return "marketing"
|
|
if "handlers.start" in path or "start_entry" in path or "process_start" in path:
|
|
return "marketing"
|
|
if "auth" in path or "login" in path or "register" in path:
|
|
return "auth"
|
|
return "other"
|
|
|
|
|
|
def _format_metadata(metadata: dict | None) -> str | None:
|
|
if not metadata:
|
|
return None
|
|
items = []
|
|
for key in sorted(metadata.keys()):
|
|
value = metadata[key]
|
|
if value is None or value == "":
|
|
continue
|
|
items.append(f"{key}={value}")
|
|
if len(items) >= 3:
|
|
break
|
|
if not items:
|
|
return None
|
|
return ", ".join(items)
|
|
|
|
|
|
def _event_label(event_type: str) -> str:
|
|
return EVENT_TYPE_LABELS.get(event_type, event_type)
|
|
|
|
|
|
_FLOW_INDENT = " "
|
|
|
|
|
|
def _fmt_money(value) -> str:
|
|
try:
|
|
number = float(value)
|
|
except (TypeError, ValueError):
|
|
return str(value)
|
|
if number.is_integer():
|
|
return str(int(number))
|
|
return f"{number:.2f}".rstrip("0").rstrip(".")
|
|
|
|
|
|
def _format_balance_event(event) -> str:
|
|
metadata = getattr(event, "metadata_", None) or {}
|
|
amount = metadata.get("amount", 0)
|
|
before = metadata.get("balance_before")
|
|
after = metadata.get("balance_after")
|
|
amount_value = float(amount) if isinstance(amount, (int, float)) else 0.0
|
|
title = "Пополнение" if amount_value > 0 else "Списание" if amount_value < 0 else "Изменение баланса"
|
|
direction = "+" if amount_value > 0 else ""
|
|
|
|
lines = [f"{html.escape(title)}: <code>{direction}{html.escape(_fmt_money(amount))} RUB</code>"]
|
|
if before is not None and after is not None:
|
|
lines.append(
|
|
f"{_FLOW_INDENT}Баланс: <code>{html.escape(_fmt_money(before))}</code> → "
|
|
f"<code>{html.escape(_fmt_money(after))}</code>"
|
|
)
|
|
if event.reason:
|
|
lines.append(f"{_FLOW_INDENT}{html.escape(str(event.reason)[:100])}")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def _humanize_path(path: str) -> str:
|
|
"""Сокращает типичные callback для админки до читаемого вида."""
|
|
if not path or "callback:" not in path:
|
|
return path
|
|
if "users_audit:" in path:
|
|
rest = path.split("users_audit:", 1)[-1].strip()
|
|
parts = [p.strip() for p in rest.split("|")[:2] if p.strip()]
|
|
if len(parts) >= 2:
|
|
ch, cat = parts[0].split(":")[-1] if ":" in parts[0] else parts[0], parts[1]
|
|
return f"История: {ch}, {cat}"
|
|
return "История"
|
|
if "users_editor:" in path:
|
|
return "Карточка пользователя"
|
|
if "admin_panel:search_user" in path:
|
|
return "Поиск пользователя"
|
|
if "admin_panel:admin" in path:
|
|
return "Админ-панель"
|
|
if "message:" in path:
|
|
text = path.split("message:", 1)[-1].strip()
|
|
if text and text != "-":
|
|
return f"Сообщение: {text[:40]}{'…' if len(text) > 40 else ''}"
|
|
return path[:55] + ("…" if len(path) > 55 else "")
|
|
|
|
|
|
def _format_event_line(
|
|
event, show_request_id: bool = False, inside_block: bool = False, skip_time: bool = False
|
|
) -> str:
|
|
"""Строка события. Если skip_time=True — только описание (время уже в строке статуса)."""
|
|
created_dt = _event_created_at_moscow(event)
|
|
created_at = created_dt.strftime("%d.%m %H:%M:%S") if created_dt is not None else "unknown"
|
|
if event.event_type == "balance_changed":
|
|
time_part = "" if skip_time else f"<code>{created_at}</code> "
|
|
return f"{time_part}{_format_balance_event(event)}"
|
|
if event.event_type == "telegram_access":
|
|
raw_path = (event.path_or_handler or "—").strip()
|
|
event_name = html.escape(_humanize_path(raw_path))
|
|
if event_name == raw_path and len(raw_path) > 55:
|
|
event_name = html.escape(raw_path[:55] + "…")
|
|
else:
|
|
event_name = html.escape(_event_label(event.event_type))
|
|
req_part = ""
|
|
if show_request_id and not inside_block and getattr(event, "request_id", None):
|
|
short_id = (event.request_id or "")[:8]
|
|
if short_id:
|
|
req_part = f" <code>[{short_id}]</code>"
|
|
entity = ""
|
|
if event.entity_type or event.entity_id:
|
|
etype = html.escape(str(event.entity_type or "entity"))
|
|
raw_id = str(event.entity_id or "")
|
|
eid = html.escape(raw_id[:40] + ("…" if len(raw_id) > 40 else ""))
|
|
if event.entity_type == "telegram_user" and raw_id.isdigit():
|
|
entity = f"\n{_FLOW_INDENT}tg_id: <code>{eid}</code>"
|
|
else:
|
|
entity = f"\n{_FLOW_INDENT}{etype}: <code>{eid}</code>"
|
|
|
|
metadata_line = _format_metadata(event.metadata_)
|
|
if metadata_line:
|
|
metadata_line = f"\n{_FLOW_INDENT}{html.escape(metadata_line)}"
|
|
else:
|
|
metadata_line = ""
|
|
|
|
reason_line = ""
|
|
if event.reason:
|
|
reason_line = f"\n{_FLOW_INDENT}{html.escape(str(event.reason)[:100])}"
|
|
|
|
time_part = "" if skip_time else f"<code>{created_at}</code> "
|
|
return f"{time_part}{event_name}{req_part}{entity}{metadata_line}{reason_line}"
|
|
|
|
|
|
def _format_event_status(event) -> str:
|
|
"""Только время и результат (ок/ошибка)."""
|
|
created_dt = _event_created_at_moscow(event)
|
|
created_at = created_dt.strftime("%d.%m %H:%M:%S") if created_dt is not None else "unknown"
|
|
result_text = "ок" if event.result == "success" else "ошибка"
|
|
return f"<code>{created_at}</code> {result_text}"
|
|
|
|
|
|
_FLOW_SEP = "—"
|
|
|
|
def _render_events_as_flow(events: list) -> list[str]:
|
|
"""Флоу: успешные действия (ок) тянутся через ⤷; если не ок — отдельный блок с │. Между блоками — разделитель."""
|
|
if not events:
|
|
return []
|
|
lines = []
|
|
for i, event in enumerate(events):
|
|
n = i + 1
|
|
is_ok = event.result == "success"
|
|
prefix = "⤷ " if is_ok else "│ "
|
|
if not is_ok and i > 0:
|
|
lines.append(_FLOW_SEP)
|
|
status_line = f"{prefix}<b>{n}.</b> {_format_event_status(event)}"
|
|
body = _format_event_line(event, show_request_id=False, inside_block=True, skip_time=True)
|
|
quoted_body = f"<blockquote>{body}</blockquote>"
|
|
lines.append(status_line)
|
|
lines.append(quoted_body)
|
|
if i < len(events) - 1:
|
|
lines.append(_FLOW_SEP)
|
|
return lines
|
|
|
|
|
|
async def _render_user_audit(
|
|
message: Message,
|
|
session: AsyncSession,
|
|
tg_id: int,
|
|
*,
|
|
channel_filter: str = "all",
|
|
category_filter: str = "all",
|
|
page: int = 0,
|
|
) -> None:
|
|
page = max(0, page)
|
|
user_identity_id = await session.scalar(select(User.identity_id).where(User.tg_id == tg_id))
|
|
channel = None if channel_filter == "all" else channel_filter
|
|
event_types = _resolve_event_types(category_filter)
|
|
include_balance_logs = channel_filter == "all" and category_filter in {"all", "balance"}
|
|
combined_limit = (page + 1) * PAGE_SIZE + 1
|
|
|
|
cache_key_str = cache_key(
|
|
"audit_history",
|
|
tg_id,
|
|
user_identity_id or "",
|
|
channel_filter,
|
|
category_filter,
|
|
page,
|
|
)
|
|
cached = None if include_balance_logs else await cache_get(cache_key_str)
|
|
if cached is not None and isinstance(cached, list):
|
|
raw_events = _deserialize_audit_events(cached)
|
|
has_prev = page > 0
|
|
has_next = len(raw_events) > PAGE_SIZE
|
|
events = raw_events[:PAGE_SIZE]
|
|
else:
|
|
if include_balance_logs:
|
|
audit_events = []
|
|
if category_filter != "balance":
|
|
audit_events = await list_audit_events(
|
|
session,
|
|
tg_id=tg_id,
|
|
identity_id=user_identity_id,
|
|
channel=channel,
|
|
event_types=event_types,
|
|
limit=combined_limit,
|
|
offset=0,
|
|
)
|
|
balance_events = _load_balance_log_events(tg_id, combined_limit)
|
|
merged_events = sorted(audit_events + balance_events, key=_event_created_at, reverse=True)
|
|
start = page * PAGE_SIZE
|
|
stop = start + PAGE_SIZE
|
|
has_prev = page > 0
|
|
has_next = len(merged_events) > stop
|
|
events = merged_events[start:stop]
|
|
else:
|
|
raw_events = await list_audit_events(
|
|
session,
|
|
tg_id=tg_id,
|
|
identity_id=user_identity_id,
|
|
channel=channel,
|
|
event_types=event_types,
|
|
limit=PAGE_SIZE + 1,
|
|
offset=page * PAGE_SIZE,
|
|
)
|
|
has_prev = page > 0
|
|
has_next = len(raw_events) > PAGE_SIZE
|
|
events = raw_events[:PAGE_SIZE]
|
|
if raw_events:
|
|
await cache_set(
|
|
cache_key_str,
|
|
_serialize_audit_events(raw_events),
|
|
AUDIT_HISTORY_CACHE_TTL_SEC,
|
|
)
|
|
|
|
full_flow = channel_filter == "all" and category_filter == "all"
|
|
lines = [f"🕘 <b>История действий клиента</b> <code>{tg_id}</code>"]
|
|
if full_flow:
|
|
lines.append("📋 <i>Вся хронология. Цифра — номер действия, черта — граница между действиями.</i>")
|
|
lines.append(
|
|
f"📎 Канал: <b>{html.escape(channel_filter)}</b> | Категория: <b>{html.escape(category_filter)}</b>"
|
|
)
|
|
if user_identity_id:
|
|
lines.append(f"🆔 Identity: <code>{html.escape(user_identity_id)}</code>")
|
|
|
|
if not events:
|
|
lines.append("\n<i>Событий пока нет.</i>")
|
|
else:
|
|
lines.append("")
|
|
rev = list(reversed(events))
|
|
if full_flow and not any(getattr(event, "event_type", "") == "balance_changed" for event in rev):
|
|
by_cat: dict[str, list] = {}
|
|
for e in rev:
|
|
c = _event_category(e)
|
|
by_cat.setdefault(c, []).append(e)
|
|
visible_cats = [c for c in CATEGORY_BLOCK_ORDER if c in by_cat]
|
|
for idx, cat in enumerate(visible_cats):
|
|
lines.append(f"<b>▸ {CATEGORY_BLOCK_LABELS[cat]}</b>")
|
|
lines.extend(_render_events_as_flow(by_cat[cat]))
|
|
if idx < len(visible_cats) - 1:
|
|
lines.append(_FLOW_SEP)
|
|
else:
|
|
lines.extend(_render_events_as_flow(rev))
|
|
|
|
await message.edit_text(
|
|
text="\n".join(lines).strip(),
|
|
reply_markup=build_user_audit_kb(
|
|
tg_id=tg_id,
|
|
channel_filter=channel_filter,
|
|
category_filter=category_filter,
|
|
page=page,
|
|
has_prev=has_prev,
|
|
has_next=has_next,
|
|
),
|
|
disable_web_page_preview=True,
|
|
)
|
|
|
|
|
|
@router.callback_query(
|
|
AdminUserEditorCallback.filter(F.action == "users_audit"),
|
|
IsAdminFilter(),
|
|
)
|
|
async def handle_user_audit(
|
|
callback_query: CallbackQuery,
|
|
callback_data: AdminUserEditorCallback,
|
|
session: AsyncSession,
|
|
):
|
|
channel_filter, category_filter, page = _parse_filter_page(callback_data.data)
|
|
await _render_user_audit(
|
|
callback_query.message,
|
|
session,
|
|
callback_data.tg_id,
|
|
channel_filter=channel_filter,
|
|
category_filter=category_filter,
|
|
page=page,
|
|
)
|
|
|
|
|
|
@router.callback_query(
|
|
AdminUserEditorCallback.filter(F.action == "users_audit_page"),
|
|
IsAdminFilter(),
|
|
)
|
|
async def handle_user_audit_page(
|
|
callback_query: CallbackQuery,
|
|
callback_data: AdminUserEditorCallback,
|
|
session: AsyncSession,
|
|
):
|
|
channel_filter, category_filter, page = _parse_filter_page(callback_data.data)
|
|
await _render_user_audit(
|
|
callback_query.message,
|
|
session,
|
|
callback_data.tg_id,
|
|
channel_filter=channel_filter,
|
|
category_filter=category_filter,
|
|
page=page,
|
|
)
|