mirror of
https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot.git
synced 2026-01-20 03:40:26 +00:00
86dd18fbe7
Рефакторинг архитектуры ежедневных конкурсов: - Создан модуль app/services/contests/ с новой архитектурой: - enums.py: GameType, RoundStatus, PrizeType enum классы - games.py: паттерн Стратегия для 7 типов игр - attempt_service.py: ContestAttemptService для атомарных операций - Упрощён handlers/contests.py: - Удалены отдельные _render_* функции (заменены на стратегии) - Логика обработки попыток вынесена в ContestAttemptService - Уменьшено с 523 до 342 строк (-35%) - Обновлён contest_rotation_service.py: - Заменена if-elif цепочка на get_game_strategy().build_payload() - Используются enum классы вместо магических строк - Исправлен handlers/admin/daily_contests.py: - prize_days → prize_type/prize_value (соответствие модели БД) - Обновлены EDITABLE_FIELDS и отображение приза 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
342 lines
11 KiB
Python
342 lines
11 KiB
Python
"""Contest handlers for daily games."""
|
||
|
||
import logging
|
||
from datetime import datetime
|
||
from typing import Optional
|
||
|
||
from aiogram import Dispatcher, F, types
|
||
from aiogram.filters import Command
|
||
from aiogram.fsm.context import FSMContext
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.database.crud.contest import get_active_rounds, get_attempt
|
||
from app.database.crud.subscription import get_subscription_by_user_id
|
||
from app.database.database import AsyncSessionLocal
|
||
from app.database.models import ContestRound, SubscriptionStatus
|
||
from app.keyboards.inline import get_back_keyboard
|
||
from app.localization.texts import get_texts
|
||
from app.services.contests import (
|
||
ContestAttemptService,
|
||
GameType,
|
||
get_game_strategy,
|
||
)
|
||
from app.states import ContestStates
|
||
from app.utils.decorators import auth_required, error_handler
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# Rate limiting storage
|
||
_rate_limits: dict = {}
|
||
|
||
# Service instance
|
||
_attempt_service = ContestAttemptService()
|
||
|
||
|
||
def _check_rate_limit(user_id: int, action: str, limit: int = 1, window_seconds: int = 5) -> bool:
|
||
"""Check if user exceeds rate limit for contest actions."""
|
||
key = f"{user_id}_{action}"
|
||
now = datetime.utcnow().timestamp()
|
||
|
||
if key not in _rate_limits:
|
||
_rate_limits[key] = []
|
||
|
||
# Clean old entries
|
||
_rate_limits[key] = [t for t in _rate_limits[key] if now - t < window_seconds]
|
||
|
||
if len(_rate_limits[key]) >= limit:
|
||
return False
|
||
|
||
_rate_limits[key].append(now)
|
||
return True
|
||
|
||
|
||
def _validate_callback_data(data: str) -> Optional[list]:
|
||
"""Validate and parse callback data safely."""
|
||
if not data or not isinstance(data, str):
|
||
return None
|
||
|
||
parts = data.split("_")
|
||
if len(parts) < 2 or parts[0] != "contest":
|
||
return None
|
||
|
||
for part in parts:
|
||
if not part or len(part) > 50:
|
||
return None
|
||
|
||
return parts
|
||
|
||
|
||
def _user_allowed(subscription) -> bool:
|
||
"""Check if user has active or trial subscription."""
|
||
if not subscription:
|
||
return False
|
||
return subscription.status in {
|
||
SubscriptionStatus.ACTIVE.value,
|
||
SubscriptionStatus.TRIAL.value,
|
||
}
|
||
|
||
|
||
async def _reply_not_eligible(callback: types.CallbackQuery, language: str):
|
||
"""Reply that user is not eligible to play."""
|
||
texts = get_texts(language)
|
||
await callback.answer(
|
||
texts.t("CONTEST_NOT_ELIGIBLE", "Игры доступны только с активной или триальной подпиской."),
|
||
show_alert=True,
|
||
)
|
||
|
||
|
||
# ---------- Handlers ----------
|
||
|
||
|
||
@auth_required
|
||
@error_handler
|
||
async def show_contests_menu(callback: types.CallbackQuery, db_user, db: AsyncSession):
|
||
"""Show menu with available contest games."""
|
||
texts = get_texts(db_user.language)
|
||
|
||
subscription = await get_subscription_by_user_id(db, db_user.id)
|
||
if not _user_allowed(subscription):
|
||
await _reply_not_eligible(callback, db_user.language)
|
||
return
|
||
|
||
active_rounds = await get_active_rounds(db)
|
||
|
||
# Group by template, take one round per template
|
||
unique_templates = {}
|
||
for rnd in active_rounds:
|
||
if not rnd.template or not rnd.template.is_enabled:
|
||
continue
|
||
tpl_slug = rnd.template.slug if rnd.template else ""
|
||
if tpl_slug not in unique_templates:
|
||
unique_templates[tpl_slug] = rnd
|
||
|
||
buttons = []
|
||
for tpl_slug, rnd in unique_templates.items():
|
||
title = rnd.template.name if rnd.template else tpl_slug
|
||
buttons.append([
|
||
types.InlineKeyboardButton(
|
||
text=f"▶️ {title}",
|
||
callback_data=f"contest_play_{tpl_slug}_{rnd.id}",
|
||
)
|
||
])
|
||
|
||
if not buttons:
|
||
buttons.append([
|
||
types.InlineKeyboardButton(
|
||
text=texts.t("CONTEST_EMPTY", "Сейчас игр нет"),
|
||
callback_data="noop",
|
||
)
|
||
])
|
||
|
||
buttons.append([
|
||
types.InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
|
||
])
|
||
|
||
await callback.message.edit_text(
|
||
texts.t("CONTEST_MENU_TITLE", "🎲 <b>Игры/Конкурсы</b>\nВыберите игру:"),
|
||
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=buttons),
|
||
)
|
||
await callback.answer()
|
||
|
||
|
||
@auth_required
|
||
@error_handler
|
||
async def play_contest(callback: types.CallbackQuery, state: FSMContext, db_user, db: AsyncSession):
|
||
"""Start playing a specific contest."""
|
||
texts = get_texts(db_user.language)
|
||
|
||
subscription = await get_subscription_by_user_id(db, db_user.id)
|
||
if not _user_allowed(subscription):
|
||
await _reply_not_eligible(callback, db_user.language)
|
||
return
|
||
|
||
# Rate limit check
|
||
if not _check_rate_limit(db_user.id, "contest_play", limit=2, window_seconds=10):
|
||
await callback.answer(
|
||
texts.t("CONTEST_TOO_FAST", "Слишком быстро! Подождите."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
# Validate callback data
|
||
parts = _validate_callback_data(callback.data)
|
||
if not parts or len(parts) < 4 or parts[1] != "play":
|
||
await callback.answer("Некорректные данные", show_alert=True)
|
||
return
|
||
|
||
round_id_str = parts[-1]
|
||
try:
|
||
round_id = int(round_id_str)
|
||
except ValueError:
|
||
await callback.answer("Некорректные данные", show_alert=True)
|
||
return
|
||
|
||
# Get round with template
|
||
async with AsyncSessionLocal() as db2:
|
||
active_rounds = await get_active_rounds(db2)
|
||
round_obj = next((r for r in active_rounds if r.id == round_id), None)
|
||
|
||
if not round_obj:
|
||
await callback.answer(
|
||
texts.t("CONTEST_ROUND_FINISHED", "Раунд завершён или недоступен."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
if not round_obj.template or not round_obj.template.is_enabled:
|
||
await callback.answer(
|
||
texts.t("CONTEST_DISABLED", "Игра отключена."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
# Check if user already played
|
||
attempt = await get_attempt(db2, round_id, db_user.id)
|
||
if attempt:
|
||
await callback.answer(
|
||
texts.t("CONTEST_ALREADY_PLAYED", "У вас уже была попытка в этом раунде."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
# Get game strategy and render
|
||
tpl = round_obj.template
|
||
strategy = get_game_strategy(tpl.slug)
|
||
|
||
if not strategy:
|
||
await callback.answer(
|
||
texts.t("CONTEST_UNKNOWN", "Тип конкурса не поддерживается."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
render_result = strategy.render(
|
||
round_id=round_obj.id,
|
||
payload=round_obj.payload or {},
|
||
language=db_user.language,
|
||
)
|
||
|
||
# For text input games, create pending attempt and set FSM state
|
||
if render_result.requires_text_input:
|
||
await _attempt_service.create_pending_attempt(db2, round_obj.id, db_user.id)
|
||
await state.set_state(ContestStates.waiting_for_answer)
|
||
await state.update_data(contest_round_id=round_obj.id)
|
||
|
||
await callback.message.edit_text(
|
||
render_result.text,
|
||
reply_markup=render_result.keyboard,
|
||
)
|
||
await callback.answer()
|
||
|
||
|
||
@auth_required
|
||
@error_handler
|
||
async def handle_pick(callback: types.CallbackQuery, db_user, db: AsyncSession):
|
||
"""Handle button pick in contest games."""
|
||
texts = get_texts(db_user.language)
|
||
|
||
# Rate limit check
|
||
if not _check_rate_limit(db_user.id, "contest_pick", limit=1, window_seconds=3):
|
||
await callback.answer(
|
||
texts.t("CONTEST_TOO_FAST", "Слишком быстро! Подождите."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
# Validate callback data
|
||
parts = _validate_callback_data(callback.data)
|
||
if not parts or len(parts) < 4 or parts[1] != "pick":
|
||
await callback.answer("Некорректные данные", show_alert=True)
|
||
return
|
||
|
||
round_id_str = parts[2]
|
||
pick = "_".join(parts[3:])
|
||
|
||
try:
|
||
round_id = int(round_id_str)
|
||
except ValueError:
|
||
await callback.answer("Некорректные данные", show_alert=True)
|
||
return
|
||
|
||
# Re-check subscription
|
||
subscription = await get_subscription_by_user_id(db, db_user.id)
|
||
if not _user_allowed(subscription):
|
||
await callback.answer(
|
||
texts.t("CONTEST_NOT_ELIGIBLE", "Игра недоступна без активной подписки."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
async with AsyncSessionLocal() as db2:
|
||
active_rounds = await get_active_rounds(db2)
|
||
round_obj = next((r for r in active_rounds if r.id == round_id), None)
|
||
|
||
if not round_obj:
|
||
await callback.answer(
|
||
texts.t("CONTEST_ROUND_FINISHED", "Раунд завершён."),
|
||
show_alert=True,
|
||
)
|
||
return
|
||
|
||
# Process attempt using service
|
||
result = await _attempt_service.process_button_attempt(
|
||
db=db2,
|
||
round_obj=round_obj,
|
||
user_id=db_user.id,
|
||
pick=pick,
|
||
language=db_user.language,
|
||
)
|
||
|
||
await callback.answer(result.message, show_alert=True)
|
||
|
||
|
||
@auth_required
|
||
@error_handler
|
||
async def handle_text_answer(message: types.Message, state: FSMContext, db_user, db: AsyncSession):
|
||
"""Handle text answer in contest games."""
|
||
texts = get_texts(db_user.language)
|
||
|
||
data = await state.get_data()
|
||
round_id = data.get("contest_round_id")
|
||
if not round_id:
|
||
await state.clear()
|
||
return
|
||
|
||
async with AsyncSessionLocal() as db2:
|
||
active_rounds = await get_active_rounds(db2)
|
||
round_obj = next((r for r in active_rounds if r.id == round_id), None)
|
||
|
||
if not round_obj:
|
||
await message.answer(
|
||
texts.t("CONTEST_ROUND_FINISHED", "Раунд завершён."),
|
||
reply_markup=get_back_keyboard(db_user.language),
|
||
)
|
||
await state.clear()
|
||
return
|
||
|
||
# Process attempt using service
|
||
text_answer = (message.text or "").strip()
|
||
result = await _attempt_service.process_text_attempt(
|
||
db=db2,
|
||
round_obj=round_obj,
|
||
user_id=db_user.id,
|
||
text_answer=text_answer,
|
||
language=db_user.language,
|
||
)
|
||
|
||
await message.answer(
|
||
result.message,
|
||
reply_markup=get_back_keyboard(db_user.language),
|
||
)
|
||
|
||
await state.clear()
|
||
|
||
|
||
def register_handlers(dp: Dispatcher):
|
||
"""Register contest handlers."""
|
||
dp.callback_query.register(show_contests_menu, F.data == "contests_menu")
|
||
dp.callback_query.register(play_contest, F.data.startswith("contest_play_"))
|
||
dp.callback_query.register(handle_pick, F.data.startswith("contest_pick_"))
|
||
dp.message.register(handle_text_answer, ContestStates.waiting_for_answer)
|
||
dp.message.register(lambda message: None, Command("contests")) # placeholder
|