Stardream
610 lines
22 KiB
Python
610 lines
22 KiB
Python
import html
|
||
import uuid
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException
|
||
from pydantic import BaseModel
|
||
from sqlalchemy import func, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.api.deps import get_current_user
|
||
from app.api.schemas import LotteryCreate, LotteryResponse, LotteryUpdate, PrizeResponse, WinnerResponse
|
||
from app.core.database import get_db
|
||
from app.models.lottery import Lottery, LotteryStatus
|
||
from app.models.participant import Participant
|
||
from app.models.prize import Prize
|
||
from app.models.user import User
|
||
from app.models.winner import Winner
|
||
from app.services.draw_service import execute_draw
|
||
|
||
router = APIRouter(prefix="/lotteries", tags=["lotteries"])
|
||
|
||
|
||
async def _revoke_invite_links(db: AsyncSession, chat_ids: set[int]) -> None:
|
||
from app.bot.router import bot
|
||
from app.models.managed_chat import ManagedChat
|
||
for chat_id in chat_ids:
|
||
result = await db.execute(select(ManagedChat).where(ManagedChat.id == chat_id))
|
||
managed = result.scalar_one_or_none()
|
||
if managed and managed.invite_link:
|
||
try:
|
||
await bot.revoke_chat_invite_link(chat_id, managed.invite_link)
|
||
except Exception:
|
||
pass
|
||
managed.invite_link = None
|
||
await db.commit()
|
||
|
||
|
||
async def _build_lottery_response(
|
||
db: AsyncSession, lottery: Lottery, current_user_id: int | None = None
|
||
) -> LotteryResponse:
|
||
count_result = await db.execute(
|
||
select(func.count(Participant.id)).where(Participant.lottery_id == lottery.id)
|
||
)
|
||
participant_count = count_result.scalar() or 0
|
||
|
||
prize_result = await db.execute(
|
||
select(Prize).where(Prize.lottery_id == lottery.id).order_by(Prize.sort_order)
|
||
)
|
||
prizes = prize_result.scalars().all()
|
||
total_prizes = sum(p.quantity for p in prizes)
|
||
|
||
is_winner: bool | None = None
|
||
if current_user_id is not None and lottery.status == LotteryStatus.FINISHED:
|
||
w = await db.execute(
|
||
select(Winner).where(Winner.lottery_id == lottery.id, Winner.user_id == current_user_id).limit(1)
|
||
)
|
||
is_winner = w.scalar_one_or_none() is not None
|
||
|
||
return LotteryResponse(
|
||
id=lottery.id,
|
||
creator_id=lottery.creator_id,
|
||
title=lottery.title,
|
||
description=lottery.description,
|
||
contact_info=lottery.contact_info,
|
||
status=lottery.status,
|
||
target_chat_id=lottery.target_chat_id,
|
||
target_chat_title=lottery.target_chat_title,
|
||
require_membership=lottery.require_membership,
|
||
required_chat_ids=lottery.required_chat_ids or [],
|
||
required_chat_titles=lottery.required_chat_titles or [],
|
||
required_chat_types=lottery.required_chat_types or [],
|
||
required_chat_usernames=lottery.required_chat_usernames or [],
|
||
announcement_targets=lottery.announcement_targets or [],
|
||
allow_multiple_wins=lottery.allow_multiple_wins,
|
||
invite_link_chat_ids=lottery.invite_link_chat_ids or [],
|
||
required_chat_passphrases=lottery.required_chat_passphrases or [],
|
||
max_participants=lottery.max_participants,
|
||
draw_at=lottery.draw_at,
|
||
auto_draw_count=lottery.auto_draw_count,
|
||
creator_timezone=lottery.creator_timezone,
|
||
participant_count=participant_count,
|
||
prize_count=len(prizes),
|
||
total_prizes=total_prizes,
|
||
created_at=lottery.created_at,
|
||
drawn_at=lottery.drawn_at,
|
||
draw_trigger=lottery.draw_trigger,
|
||
prizes=[PrizeResponse.model_validate(p) for p in prizes],
|
||
is_winner=is_winner,
|
||
)
|
||
|
||
|
||
@router.get("", response_model=list[LotteryResponse])
|
||
async def list_my_lotteries(
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> list[LotteryResponse]:
|
||
result = await db.execute(
|
||
select(Lottery)
|
||
.where(Lottery.creator_id == current_user.id)
|
||
.order_by(Lottery.created_at.desc())
|
||
)
|
||
lotteries = result.scalars().all()
|
||
return [await _build_lottery_response(db, l, current_user.id) for l in lotteries]
|
||
|
||
|
||
@router.get("/joined", response_model=list[LotteryResponse])
|
||
async def list_joined_lotteries(
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> list[LotteryResponse]:
|
||
result = await db.execute(
|
||
select(Lottery)
|
||
.join(Participant, Participant.lottery_id == Lottery.id)
|
||
.where(Participant.user_id == current_user.id)
|
||
.order_by(Lottery.created_at.desc())
|
||
)
|
||
lotteries = result.scalars().all()
|
||
return [await _build_lottery_response(db, l, current_user.id) for l in lotteries]
|
||
|
||
|
||
@router.get("/active", response_model=list[LotteryResponse])
|
||
async def list_active_lotteries(
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> list[LotteryResponse]:
|
||
"""Active lotteries created by others that the user can join."""
|
||
result = await db.execute(
|
||
select(Lottery)
|
||
.where(Lottery.status == LotteryStatus.ACTIVE)
|
||
.where(Lottery.creator_id != current_user.id)
|
||
.order_by(Lottery.created_at.desc())
|
||
)
|
||
lotteries = result.scalars().all()
|
||
return [await _build_lottery_response(db, l) for l in lotteries]
|
||
|
||
|
||
@router.post("", response_model=LotteryResponse)
|
||
async def create_lottery(
|
||
data: LotteryCreate,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> LotteryResponse:
|
||
lottery = Lottery(creator_id=current_user.id, **data.model_dump())
|
||
db.add(lottery)
|
||
await db.commit()
|
||
await db.refresh(lottery)
|
||
return await _build_lottery_response(db, lottery)
|
||
|
||
|
||
@router.get("/{lottery_id}", response_model=LotteryResponse)
|
||
async def get_lottery(
|
||
lottery_id: uuid.UUID,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> LotteryResponse:
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
return await _build_lottery_response(db, lottery)
|
||
|
||
|
||
@router.put("/{lottery_id}", response_model=LotteryResponse)
|
||
async def update_lottery(
|
||
lottery_id: uuid.UUID,
|
||
data: LotteryUpdate,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> LotteryResponse:
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
if lottery.creator_id != current_user.id:
|
||
raise HTTPException(403, "Not authorized")
|
||
if lottery.status in (LotteryStatus.FINISHED, LotteryStatus.CANCELLED):
|
||
raise HTTPException(400, "Cannot edit a finished or cancelled lottery")
|
||
|
||
old_invite_ids: set[int] = set(lottery.invite_link_chat_ids or [])
|
||
|
||
for field, value in data.model_dump(exclude_unset=True).items():
|
||
setattr(lottery, field, value)
|
||
|
||
await db.commit()
|
||
await db.refresh(lottery)
|
||
|
||
new_invite_ids: set[int] = set(lottery.invite_link_chat_ids or [])
|
||
removed_ids = old_invite_ids - new_invite_ids
|
||
if removed_ids:
|
||
await _revoke_invite_links(db, removed_ids)
|
||
|
||
# Auto-sync announcement messages whenever the lottery is edited
|
||
if lottery.announcement_targets or lottery.announcement_message_id:
|
||
try:
|
||
await sync_announcement(db, lottery, force_send=False)
|
||
except Exception:
|
||
pass
|
||
|
||
return await _build_lottery_response(db, lottery)
|
||
|
||
|
||
@router.post("/{lottery_id}/activate", response_model=LotteryResponse)
|
||
async def activate_lottery(
|
||
lottery_id: uuid.UUID,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> LotteryResponse:
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
if lottery.creator_id != current_user.id:
|
||
raise HTTPException(403, "Not authorized")
|
||
if lottery.status != LotteryStatus.DRAFT:
|
||
raise HTTPException(400, "Lottery is already activated")
|
||
|
||
prize_result = await db.execute(
|
||
select(Prize).where(Prize.lottery_id == lottery_id).limit(1)
|
||
)
|
||
if prize_result.scalar_one_or_none() is None:
|
||
raise HTTPException(400, "Add at least one prize before activating")
|
||
|
||
lottery.status = LotteryStatus.ACTIVE
|
||
await db.commit()
|
||
await db.refresh(lottery)
|
||
return await _build_lottery_response(db, lottery)
|
||
|
||
|
||
@router.post("/{lottery_id}/draw", response_model=list[WinnerResponse])
|
||
async def draw_lottery(
|
||
lottery_id: uuid.UUID,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> list[WinnerResponse]:
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
if lottery.creator_id != current_user.id:
|
||
raise HTTPException(403, "Not authorized")
|
||
if lottery.status != LotteryStatus.ACTIVE:
|
||
raise HTTPException(400, "Lottery is not active")
|
||
|
||
try:
|
||
winners_data = await execute_draw(db, lottery_id, trigger="manual")
|
||
except ValueError as e:
|
||
raise HTTPException(400, str(e))
|
||
|
||
# Announce winners to all announcement targets
|
||
targets = lottery.announcement_targets or (
|
||
[{"chat_id": lottery.target_chat_id, "chat_title": lottery.target_chat_title or "", "message_id": lottery.announcement_message_id}]
|
||
if lottery.target_chat_id else []
|
||
)
|
||
if targets and winners_data:
|
||
from app.bot.router import bot
|
||
from aiogram.types import ReplyParameters
|
||
lines = []
|
||
for w in winners_data:
|
||
full_name = html.escape(
|
||
w["first_name"] + (f" {w['last_name']}" if w.get("last_name") else "")
|
||
)
|
||
safe_name = f'<a href="tg://user?id={w["user_id"]}">{full_name}</a>'
|
||
safe_prize = html.escape(w["prize_name"])
|
||
lines.append(f"🏆 {safe_name} - {safe_prize}")
|
||
text = (
|
||
f"🎉 <b>Draw Results: {html.escape(lottery.title)}</b>\n\n"
|
||
+ "\n".join(lines)
|
||
+ "\n\nCongratulations to all winners! 🎊"
|
||
)
|
||
for t in targets:
|
||
try:
|
||
reply = (
|
||
ReplyParameters(message_id=t["message_id"], allow_sending_without_reply=True)
|
||
if t.get("message_id")
|
||
else None
|
||
)
|
||
await bot.send_message(
|
||
t["chat_id"],
|
||
text,
|
||
parse_mode="HTML",
|
||
reply_parameters=reply,
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
if winners_data:
|
||
from app.services.scheduler import notify_winners
|
||
import asyncio
|
||
asyncio.create_task(notify_winners(lottery.title, winners_data, lottery.contact_info, lottery_id=lottery.id))
|
||
|
||
return [WinnerResponse(**w) for w in winners_data]
|
||
|
||
|
||
@router.get("/{lottery_id}/winners", response_model=list[WinnerResponse])
|
||
async def get_winners(
|
||
lottery_id: uuid.UUID,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> list[WinnerResponse]:
|
||
result = await db.execute(
|
||
select(Winner, User)
|
||
.join(User, Winner.user_id == User.id)
|
||
.where(Winner.lottery_id == lottery_id)
|
||
.order_by(Winner.drawn_at)
|
||
)
|
||
return [
|
||
WinnerResponse(
|
||
user_id=user.id,
|
||
username=user.username,
|
||
first_name=user.first_name,
|
||
last_name=user.last_name,
|
||
prize_name=winner.prize_name,
|
||
drawn_at=winner.drawn_at,
|
||
)
|
||
for winner, user in result.all()
|
||
]
|
||
|
||
|
||
async def _build_announce_text(db: AsyncSession, lottery: Lottery, include_count: bool = True) -> str:
|
||
prize_result = await db.execute(
|
||
select(Prize).where(Prize.lottery_id == lottery.id).order_by(Prize.sort_order)
|
||
)
|
||
prizes = prize_result.scalars().all()
|
||
count_result = await db.execute(
|
||
select(func.count(Participant.id)).where(Participant.lottery_id == lottery.id)
|
||
)
|
||
participant_count = count_result.scalar() or 0
|
||
|
||
text = f"🎰 <b>{html.escape(lottery.title)}</b>"
|
||
|
||
if lottery.description:
|
||
text += f"\n\n{html.escape(lottery.description)}"
|
||
|
||
# Membership requirements
|
||
required_ids = lottery.required_chat_ids or []
|
||
required_titles = lottery.required_chat_titles or []
|
||
required_usernames = lottery.required_chat_usernames or []
|
||
required_passphrases = lottery.required_chat_passphrases or []
|
||
invite_link_ids = set(lottery.invite_link_chat_ids or [])
|
||
|
||
if lottery.require_membership and required_ids:
|
||
from app.models.managed_chat import ManagedChat
|
||
mc_result = await db.execute(select(ManagedChat).where(ManagedChat.id.in_(required_ids)))
|
||
managed_chats = {mc.id: mc for mc in mc_result.scalars().all()}
|
||
|
||
text += "\n\n📮 <b>Requirements:</b>"
|
||
for i, chat_id in enumerate(required_ids):
|
||
title = required_titles[i] if i < len(required_titles) else str(chat_id)
|
||
username = required_usernames[i] if i < len(required_usernames) else None
|
||
mc = managed_chats.get(chat_id)
|
||
|
||
if chat_id in invite_link_ids and mc and mc.invite_link:
|
||
link: str | None = mc.invite_link
|
||
elif username:
|
||
link = f"https://t.me/{username}"
|
||
elif mc:
|
||
channel_id = str(abs(chat_id))[3:]
|
||
link = f"https://t.me/c/{channel_id}/{mc.last_message_id or 1}"
|
||
else:
|
||
link = None
|
||
|
||
label = f'<a href="{link}">{html.escape(title)}</a>' if link else html.escape(title)
|
||
text += f"\n 🎫 Join - {label}"
|
||
if i < len(required_passphrases) and required_passphrases[i]:
|
||
text += f"\n └ 🔑 Send passphrase ﹝<code>{html.escape(required_passphrases[i])}</code>﹞"
|
||
elif lottery.require_membership and lottery.target_chat_title:
|
||
text += f"\n\n📮 <b>Requirements:</b>\n 🎫 Join - {html.escape(lottery.target_chat_title)}"
|
||
|
||
# Prizes
|
||
prize_lines = "\n".join(f" - {html.escape(p.name)} ×{p.quantity}" for p in prizes)
|
||
text += f"\n\n🎁 <b>Prizes:</b>\n{prize_lines}"
|
||
|
||
# Participant count
|
||
if include_count:
|
||
text += f"\n\n👥 Participants: {participant_count}"
|
||
|
||
# Draw conditions
|
||
if lottery.draw_at:
|
||
from datetime import timezone as _tz
|
||
draw_dt = lottery.draw_at.replace(tzinfo=_tz.utc)
|
||
tz_label = "UTC"
|
||
if lottery.creator_timezone:
|
||
try:
|
||
from zoneinfo import ZoneInfo
|
||
draw_dt = draw_dt.astimezone(ZoneInfo(lottery.creator_timezone))
|
||
offset = draw_dt.utcoffset()
|
||
if offset is not None:
|
||
total_min = int(offset.total_seconds() / 60)
|
||
sign = "+" if total_min >= 0 else "-"
|
||
h, m = divmod(abs(total_min), 60)
|
||
tz_label = f"UTC{sign}{h}" if m == 0 else f"UTC{sign}{h}:{m:02d}"
|
||
except Exception:
|
||
pass
|
||
text += f"\n\n📅 <b>Draw time:</b> {draw_dt.strftime('%Y/%m/%d %H:%M')} ({tz_label})"
|
||
if lottery.auto_draw_count:
|
||
text += f"\n🎯 Auto-draw at {lottery.auto_draw_count} participants"
|
||
|
||
return text
|
||
|
||
|
||
async def _sync_single_target(
|
||
bot,
|
||
text: str,
|
||
keyboard,
|
||
target: dict,
|
||
force_send: bool,
|
||
) -> int | None:
|
||
"""Sync announcement to one chat. Returns the resulting message_id (or None)."""
|
||
from aiogram.exceptions import TelegramBadRequest
|
||
|
||
chat_id = target["chat_id"]
|
||
msg_id = target.get("message_id")
|
||
|
||
if msg_id:
|
||
try:
|
||
await bot.edit_message_text(
|
||
chat_id=chat_id,
|
||
message_id=msg_id,
|
||
text=text,
|
||
reply_markup=keyboard,
|
||
parse_mode="HTML",
|
||
)
|
||
return msg_id
|
||
except TelegramBadRequest as e:
|
||
if "message is not modified" in str(e).lower():
|
||
return msg_id
|
||
# Message deleted or inaccessible
|
||
if not force_send:
|
||
return msg_id # keep existing id, silently skip
|
||
msg_id = None # will resend below
|
||
|
||
if force_send:
|
||
msg = await bot.send_message(
|
||
chat_id,
|
||
text,
|
||
reply_markup=keyboard,
|
||
parse_mode="HTML",
|
||
)
|
||
await _update_chat_last_message(chat_id, msg.message_id)
|
||
return msg.message_id
|
||
|
||
return None
|
||
|
||
|
||
async def _update_chat_last_message(chat_id: int, message_id: int) -> None:
|
||
from app.core.database import AsyncSessionLocal
|
||
from app.models.managed_chat import ManagedChat
|
||
from sqlalchemy import select
|
||
async with AsyncSessionLocal() as db:
|
||
result = await db.execute(select(ManagedChat).where(ManagedChat.id == chat_id))
|
||
managed = result.scalar_one_or_none()
|
||
if managed and message_id > (managed.last_message_id or 0):
|
||
managed.last_message_id = message_id
|
||
await db.commit()
|
||
|
||
|
||
async def sync_announcement(db: AsyncSession, lottery: Lottery, force_send: bool = False) -> None:
|
||
"""Edit or send announcement messages to all announcement_targets."""
|
||
from app.bot.router import bot
|
||
from app.bot.keyboards.inline import lottery_announce_keyboard
|
||
|
||
# Build target list - backward compat with old single-target lotteries
|
||
targets: list[dict] = lottery.announcement_targets or []
|
||
if not targets and lottery.target_chat_id:
|
||
targets = [{
|
||
"chat_id": lottery.target_chat_id,
|
||
"chat_title": lottery.target_chat_title or "",
|
||
"message_id": lottery.announcement_message_id,
|
||
}]
|
||
|
||
if not targets:
|
||
return
|
||
|
||
text = await _build_announce_text(db, lottery)
|
||
keyboard = lottery_announce_keyboard(str(lottery.id))
|
||
|
||
updated: list[dict] = []
|
||
changed = False
|
||
for t in targets:
|
||
new_msg_id = await _sync_single_target(bot, text, keyboard, t, force_send)
|
||
updated.append({**t, "message_id": new_msg_id})
|
||
if new_msg_id != t.get("message_id"):
|
||
changed = True
|
||
|
||
if changed:
|
||
lottery.announcement_targets = updated
|
||
await db.commit()
|
||
|
||
|
||
class _AnnounceChatItem(BaseModel):
|
||
id: int
|
||
title: str
|
||
|
||
|
||
class _AnnounceRequest(BaseModel):
|
||
chats: list[_AnnounceChatItem]
|
||
|
||
|
||
@router.post("/{lottery_id}/announce")
|
||
async def announce_lottery(
|
||
lottery_id: uuid.UUID,
|
||
data: _AnnounceRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> dict:
|
||
from aiogram.exceptions import TelegramAPIError
|
||
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
if lottery.creator_id != current_user.id:
|
||
raise HTTPException(403, "Not authorized")
|
||
if not data.chats:
|
||
raise HTTPException(400, "Select at least one chat")
|
||
if lottery.status == LotteryStatus.CANCELLED:
|
||
raise HTTPException(400, "Cannot announce a cancelled lottery")
|
||
|
||
# Build new targets, preserving existing message_ids for same chats
|
||
existing = {t["chat_id"]: t for t in (lottery.announcement_targets or [])}
|
||
new_targets = [
|
||
{
|
||
"chat_id": c.id,
|
||
"chat_title": c.title,
|
||
"message_id": existing.get(c.id, {}).get("message_id"),
|
||
}
|
||
for c in data.chats
|
||
]
|
||
lottery.announcement_targets = new_targets
|
||
# Keep legacy target_chat_id pointing to first chat for draw-result compat
|
||
lottery.target_chat_id = data.chats[0].id
|
||
lottery.target_chat_title = data.chats[0].title
|
||
await db.commit()
|
||
await db.refresh(lottery)
|
||
|
||
try:
|
||
await sync_announcement(db, lottery, force_send=True)
|
||
except TelegramAPIError as e:
|
||
raise HTTPException(500, f"Failed to send message: {e}")
|
||
|
||
return {"status": "announced"}
|
||
|
||
|
||
@router.post("/{lottery_id}/prepare-share")
|
||
async def prepare_share(
|
||
lottery_id: uuid.UUID,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> dict:
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
if lottery.status == LotteryStatus.CANCELLED:
|
||
raise HTTPException(400, "Cannot share a cancelled lottery")
|
||
|
||
from app.bot.router import bot
|
||
from app.bot.keyboards.inline import lottery_announce_keyboard
|
||
from aiogram.types import InlineQueryResultArticle, InputTextMessageContent
|
||
|
||
text = await _build_announce_text(db, lottery, include_count=False)
|
||
keyboard = lottery_announce_keyboard(str(lottery.id))
|
||
|
||
try:
|
||
prepared = await bot.save_prepared_inline_message(
|
||
user_id=current_user.id,
|
||
result=InlineQueryResultArticle(
|
||
id=str(lottery.id),
|
||
title=lottery.title,
|
||
input_message_content=InputTextMessageContent(
|
||
message_text=text,
|
||
parse_mode="HTML",
|
||
),
|
||
reply_markup=keyboard,
|
||
),
|
||
allow_user_chats=True,
|
||
allow_bot_chats=False,
|
||
allow_group_chats=True,
|
||
allow_channel_chats=True,
|
||
)
|
||
except Exception as e:
|
||
raise HTTPException(500, str(e))
|
||
|
||
return {"prepared_message_id": prepared.id}
|
||
|
||
|
||
@router.delete("/{lottery_id}")
|
||
async def cancel_lottery(
|
||
lottery_id: uuid.UUID,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_current_user),
|
||
) -> dict:
|
||
result = await db.execute(select(Lottery).where(Lottery.id == lottery_id))
|
||
lottery = result.scalar_one_or_none()
|
||
|
||
if lottery is None:
|
||
raise HTTPException(404, "Lottery not found")
|
||
if lottery.creator_id != current_user.id:
|
||
raise HTTPException(403, "Not authorized")
|
||
if lottery.status == LotteryStatus.FINISHED:
|
||
raise HTTPException(400, "Cannot cancel a finished lottery")
|
||
|
||
lottery.status = LotteryStatus.CANCELLED
|
||
await db.commit()
|
||
return {"status": "cancelled"}
|