359 lines
12 KiB
Python
359 lines
12 KiB
Python
from datetime import timedelta
|
|
import secrets
|
|
from fastapi import APIRouter, HTTPException, status
|
|
from sqlalchemy import select, func
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from app.api.deps import DbSession, CurrentUser
|
|
from app.models import Marathon, Participant, MarathonStatus, Game, Assignment, AssignmentStatus, Activity, ActivityType
|
|
from app.schemas import (
|
|
MarathonCreate,
|
|
MarathonUpdate,
|
|
MarathonResponse,
|
|
MarathonListItem,
|
|
JoinMarathon,
|
|
ParticipantInfo,
|
|
ParticipantWithUser,
|
|
LeaderboardEntry,
|
|
MessageResponse,
|
|
UserPublic,
|
|
)
|
|
|
|
router = APIRouter(prefix="/marathons", tags=["marathons"])
|
|
|
|
|
|
def generate_invite_code() -> str:
|
|
return secrets.token_urlsafe(8)
|
|
|
|
|
|
async def get_marathon_or_404(db, marathon_id: int) -> Marathon:
|
|
result = await db.execute(
|
|
select(Marathon)
|
|
.options(selectinload(Marathon.organizer))
|
|
.where(Marathon.id == marathon_id)
|
|
)
|
|
marathon = result.scalar_one_or_none()
|
|
if not marathon:
|
|
raise HTTPException(status_code=404, detail="Marathon not found")
|
|
return marathon
|
|
|
|
|
|
async def get_participation(db, user_id: int, marathon_id: int) -> Participant | None:
|
|
result = await db.execute(
|
|
select(Participant).where(
|
|
Participant.user_id == user_id,
|
|
Participant.marathon_id == marathon_id,
|
|
)
|
|
)
|
|
return result.scalar_one_or_none()
|
|
|
|
|
|
@router.get("", response_model=list[MarathonListItem])
|
|
async def list_marathons(current_user: CurrentUser, db: DbSession):
|
|
"""Get all marathons where user is participant or organizer"""
|
|
result = await db.execute(
|
|
select(Marathon, func.count(Participant.id).label("participants_count"))
|
|
.outerjoin(Participant)
|
|
.where(
|
|
(Marathon.organizer_id == current_user.id) |
|
|
(Participant.user_id == current_user.id)
|
|
)
|
|
.group_by(Marathon.id)
|
|
.order_by(Marathon.created_at.desc())
|
|
)
|
|
|
|
marathons = []
|
|
for row in result.all():
|
|
marathon = row[0]
|
|
marathons.append(MarathonListItem(
|
|
id=marathon.id,
|
|
title=marathon.title,
|
|
status=marathon.status,
|
|
participants_count=row[1],
|
|
start_date=marathon.start_date,
|
|
end_date=marathon.end_date,
|
|
))
|
|
|
|
return marathons
|
|
|
|
|
|
@router.post("", response_model=MarathonResponse)
|
|
async def create_marathon(
|
|
data: MarathonCreate,
|
|
current_user: CurrentUser,
|
|
db: DbSession,
|
|
):
|
|
# Strip timezone info for naive datetime columns
|
|
start_date = data.start_date.replace(tzinfo=None) if data.start_date.tzinfo else data.start_date
|
|
end_date = start_date + timedelta(days=data.duration_days)
|
|
|
|
marathon = Marathon(
|
|
title=data.title,
|
|
description=data.description,
|
|
organizer_id=current_user.id,
|
|
invite_code=generate_invite_code(),
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
)
|
|
db.add(marathon)
|
|
await db.flush()
|
|
|
|
# Auto-add organizer as participant
|
|
participant = Participant(
|
|
user_id=current_user.id,
|
|
marathon_id=marathon.id,
|
|
)
|
|
db.add(participant)
|
|
|
|
await db.commit()
|
|
await db.refresh(marathon)
|
|
|
|
return MarathonResponse(
|
|
id=marathon.id,
|
|
title=marathon.title,
|
|
description=marathon.description,
|
|
organizer=UserPublic.model_validate(current_user),
|
|
status=marathon.status,
|
|
invite_code=marathon.invite_code,
|
|
start_date=marathon.start_date,
|
|
end_date=marathon.end_date,
|
|
participants_count=1,
|
|
games_count=0,
|
|
created_at=marathon.created_at,
|
|
my_participation=ParticipantInfo.model_validate(participant),
|
|
)
|
|
|
|
|
|
@router.get("/{marathon_id}", response_model=MarathonResponse)
|
|
async def get_marathon(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
marathon = await get_marathon_or_404(db, marathon_id)
|
|
|
|
# Count participants and games
|
|
participants_count = await db.scalar(
|
|
select(func.count()).select_from(Participant).where(Participant.marathon_id == marathon_id)
|
|
)
|
|
games_count = await db.scalar(
|
|
select(func.count()).select_from(Game).where(Game.marathon_id == marathon_id)
|
|
)
|
|
|
|
# Get user's participation
|
|
participation = await get_participation(db, current_user.id, marathon_id)
|
|
|
|
return MarathonResponse(
|
|
id=marathon.id,
|
|
title=marathon.title,
|
|
description=marathon.description,
|
|
organizer=UserPublic.model_validate(marathon.organizer),
|
|
status=marathon.status,
|
|
invite_code=marathon.invite_code,
|
|
start_date=marathon.start_date,
|
|
end_date=marathon.end_date,
|
|
participants_count=participants_count,
|
|
games_count=games_count,
|
|
created_at=marathon.created_at,
|
|
my_participation=ParticipantInfo.model_validate(participation) if participation else None,
|
|
)
|
|
|
|
|
|
@router.patch("/{marathon_id}", response_model=MarathonResponse)
|
|
async def update_marathon(
|
|
marathon_id: int,
|
|
data: MarathonUpdate,
|
|
current_user: CurrentUser,
|
|
db: DbSession,
|
|
):
|
|
marathon = await get_marathon_or_404(db, marathon_id)
|
|
|
|
if marathon.organizer_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="Only organizer can update marathon")
|
|
|
|
if marathon.status != MarathonStatus.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Cannot update active or finished marathon")
|
|
|
|
if data.title is not None:
|
|
marathon.title = data.title
|
|
if data.description is not None:
|
|
marathon.description = data.description
|
|
if data.start_date is not None:
|
|
# Strip timezone info for naive datetime columns
|
|
marathon.start_date = data.start_date.replace(tzinfo=None) if data.start_date.tzinfo else data.start_date
|
|
|
|
await db.commit()
|
|
|
|
return await get_marathon(marathon_id, current_user, db)
|
|
|
|
|
|
@router.delete("/{marathon_id}", response_model=MessageResponse)
|
|
async def delete_marathon(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
marathon = await get_marathon_or_404(db, marathon_id)
|
|
|
|
if marathon.organizer_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="Only organizer can delete marathon")
|
|
|
|
await db.delete(marathon)
|
|
await db.commit()
|
|
|
|
return MessageResponse(message="Marathon deleted")
|
|
|
|
|
|
@router.post("/{marathon_id}/start", response_model=MarathonResponse)
|
|
async def start_marathon(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
marathon = await get_marathon_or_404(db, marathon_id)
|
|
|
|
if marathon.organizer_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="Only organizer can start marathon")
|
|
|
|
if marathon.status != MarathonStatus.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Marathon is not in preparing state")
|
|
|
|
# Check if there are games with challenges
|
|
games_count = await db.scalar(
|
|
select(func.count()).select_from(Game).where(Game.marathon_id == marathon_id)
|
|
)
|
|
if games_count == 0:
|
|
raise HTTPException(status_code=400, detail="Add at least one game before starting")
|
|
|
|
marathon.status = MarathonStatus.ACTIVE.value
|
|
|
|
# Log activity
|
|
activity = Activity(
|
|
marathon_id=marathon_id,
|
|
user_id=current_user.id,
|
|
type=ActivityType.START_MARATHON.value,
|
|
data={"title": marathon.title},
|
|
)
|
|
db.add(activity)
|
|
|
|
await db.commit()
|
|
|
|
return await get_marathon(marathon_id, current_user, db)
|
|
|
|
|
|
@router.post("/{marathon_id}/finish", response_model=MarathonResponse)
|
|
async def finish_marathon(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
marathon = await get_marathon_or_404(db, marathon_id)
|
|
|
|
if marathon.organizer_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="Only organizer can finish marathon")
|
|
|
|
if marathon.status != MarathonStatus.ACTIVE.value:
|
|
raise HTTPException(status_code=400, detail="Marathon is not active")
|
|
|
|
marathon.status = MarathonStatus.FINISHED.value
|
|
|
|
# Log activity
|
|
activity = Activity(
|
|
marathon_id=marathon_id,
|
|
user_id=current_user.id,
|
|
type=ActivityType.FINISH_MARATHON.value,
|
|
data={"title": marathon.title},
|
|
)
|
|
db.add(activity)
|
|
|
|
await db.commit()
|
|
|
|
return await get_marathon(marathon_id, current_user, db)
|
|
|
|
|
|
@router.post("/join", response_model=MarathonResponse)
|
|
async def join_marathon(data: JoinMarathon, current_user: CurrentUser, db: DbSession):
|
|
result = await db.execute(
|
|
select(Marathon).where(Marathon.invite_code == data.invite_code)
|
|
)
|
|
marathon = result.scalar_one_or_none()
|
|
|
|
if not marathon:
|
|
raise HTTPException(status_code=404, detail="Invalid invite code")
|
|
|
|
if marathon.status == MarathonStatus.FINISHED.value:
|
|
raise HTTPException(status_code=400, detail="Marathon has already finished")
|
|
|
|
# Check if already participant
|
|
existing = await get_participation(db, current_user.id, marathon.id)
|
|
if existing:
|
|
raise HTTPException(status_code=400, detail="Already joined this marathon")
|
|
|
|
participant = Participant(
|
|
user_id=current_user.id,
|
|
marathon_id=marathon.id,
|
|
)
|
|
db.add(participant)
|
|
|
|
# Log activity
|
|
activity = Activity(
|
|
marathon_id=marathon.id,
|
|
user_id=current_user.id,
|
|
type=ActivityType.JOIN.value,
|
|
data={"nickname": current_user.nickname},
|
|
)
|
|
db.add(activity)
|
|
|
|
await db.commit()
|
|
|
|
return await get_marathon(marathon.id, current_user, db)
|
|
|
|
|
|
@router.get("/{marathon_id}/participants", response_model=list[ParticipantWithUser])
|
|
async def get_participants(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
await get_marathon_or_404(db, marathon_id)
|
|
|
|
result = await db.execute(
|
|
select(Participant)
|
|
.options(selectinload(Participant.user))
|
|
.where(Participant.marathon_id == marathon_id)
|
|
.order_by(Participant.joined_at)
|
|
)
|
|
participants = result.scalars().all()
|
|
|
|
return [
|
|
ParticipantWithUser(
|
|
id=p.id,
|
|
total_points=p.total_points,
|
|
current_streak=p.current_streak,
|
|
drop_count=p.drop_count,
|
|
joined_at=p.joined_at,
|
|
user=UserPublic.model_validate(p.user),
|
|
)
|
|
for p in participants
|
|
]
|
|
|
|
|
|
@router.get("/{marathon_id}/leaderboard", response_model=list[LeaderboardEntry])
|
|
async def get_leaderboard(marathon_id: int, db: DbSession):
|
|
await get_marathon_or_404(db, marathon_id)
|
|
|
|
result = await db.execute(
|
|
select(Participant)
|
|
.options(selectinload(Participant.user))
|
|
.where(Participant.marathon_id == marathon_id)
|
|
.order_by(Participant.total_points.desc())
|
|
)
|
|
participants = result.scalars().all()
|
|
|
|
leaderboard = []
|
|
for rank, p in enumerate(participants, 1):
|
|
# Count completed and dropped assignments
|
|
completed = await db.scalar(
|
|
select(func.count()).select_from(Assignment).where(
|
|
Assignment.participant_id == p.id,
|
|
Assignment.status == AssignmentStatus.COMPLETED.value,
|
|
)
|
|
)
|
|
dropped = await db.scalar(
|
|
select(func.count()).select_from(Assignment).where(
|
|
Assignment.participant_id == p.id,
|
|
Assignment.status == AssignmentStatus.DROPPED.value,
|
|
)
|
|
)
|
|
|
|
leaderboard.append(LeaderboardEntry(
|
|
rank=rank,
|
|
user=UserPublic.model_validate(p.user),
|
|
total_points=p.total_points,
|
|
current_streak=p.current_streak,
|
|
completed_count=completed,
|
|
dropped_count=dropped,
|
|
))
|
|
|
|
return leaderboard
|