initial

2025-12-14 02:38:35 +07:00
commit 5343a8f2c3
84 changed files with 7406 additions and 0 deletions
--- a/backend/app/api/v1/wheel.py
+++ b/backend/app/api/v1/wheel.py
@@ -0,0 +1,404 @@
+import random
+from datetime import datetime
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from sqlalchemy import select, func
+from sqlalchemy.orm import selectinload
+import uuid
+from pathlib import Path
+
+from app.api.deps import DbSession, CurrentUser
+from app.core.config import settings
+from app.models import (
+    Marathon, MarathonStatus, Game, Challenge, Participant,
+    Assignment, AssignmentStatus, Activity, ActivityType
+)
+from app.schemas import (
+    SpinResult, AssignmentResponse, CompleteResult, DropResult,
+    GameResponse, ChallengeResponse, GameShort, UserPublic, MessageResponse
+)
+from app.services.points import PointsService
+
+router = APIRouter(tags=["wheel"])
+
+points_service = PointsService()
+
+
+async def get_participant_or_403(db, user_id: int, marathon_id: int) -> Participant:
+    result = await db.execute(
+        select(Participant).where(
+            Participant.user_id == user_id,
+            Participant.marathon_id == marathon_id,
+        )
+    )
+    participant = result.scalar_one_or_none()
+    if not participant:
+        raise HTTPException(status_code=403, detail="You are not a participant of this marathon")
+    return participant
+
+
+async def get_active_assignment(db, participant_id: int) -> Assignment | None:
+    result = await db.execute(
+        select(Assignment)
+        .options(
+            selectinload(Assignment.challenge).selectinload(Challenge.game)
+        )
+        .where(
+            Assignment.participant_id == participant_id,
+            Assignment.status == AssignmentStatus.ACTIVE.value,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+@router.post("/marathons/{marathon_id}/spin", response_model=SpinResult)
+async def spin_wheel(marathon_id: int, current_user: CurrentUser, db: DbSession):
+    """Spin the wheel to get a random game and challenge"""
+    # Check marathon is active
+    result = await db.execute(select(Marathon).where(Marathon.id == marathon_id))
+    marathon = result.scalar_one_or_none()
+    if not marathon:
+        raise HTTPException(status_code=404, detail="Marathon not found")
+
+    if marathon.status != MarathonStatus.ACTIVE.value:
+        raise HTTPException(status_code=400, detail="Marathon is not active")
+
+    participant = await get_participant_or_403(db, current_user.id, marathon_id)
+
+    # Check no active assignment
+    active = await get_active_assignment(db, participant.id)
+    if active:
+        raise HTTPException(status_code=400, detail="You already have an active assignment")
+
+    # Get all games with challenges
+    result = await db.execute(
+        select(Game)
+        .options(selectinload(Game.challenges))
+        .where(Game.marathon_id == marathon_id)
+    )
+    games = [g for g in result.scalars().all() if g.challenges]
+
+    if not games:
+        raise HTTPException(status_code=400, detail="No games with challenges available")
+
+    # Random selection
+    game = random.choice(games)
+    challenge = random.choice(game.challenges)
+
+    # Create assignment
+    assignment = Assignment(
+        participant_id=participant.id,
+        challenge_id=challenge.id,
+        status=AssignmentStatus.ACTIVE.value,
+    )
+    db.add(assignment)
+
+    # Log activity
+    activity = Activity(
+        marathon_id=marathon_id,
+        user_id=current_user.id,
+        type=ActivityType.SPIN.value,
+        data={
+            "game": game.title,
+            "challenge": challenge.title,
+        },
+    )
+    db.add(activity)
+
+    await db.commit()
+    await db.refresh(assignment)
+
+    # Calculate drop penalty
+    drop_penalty = points_service.calculate_drop_penalty(participant.drop_count)
+
+    return SpinResult(
+        assignment_id=assignment.id,
+        game=GameResponse(
+            id=game.id,
+            title=game.title,
+            cover_url=f"/uploads/covers/{game.cover_path.split('/')[-1]}" if game.cover_path else None,
+            download_url=game.download_url,
+            genre=game.genre,
+            added_by=None,
+            challenges_count=len(game.challenges),
+            created_at=game.created_at,
+        ),
+        challenge=ChallengeResponse(
+            id=challenge.id,
+            title=challenge.title,
+            description=challenge.description,
+            type=challenge.type,
+            difficulty=challenge.difficulty,
+            points=challenge.points,
+            estimated_time=challenge.estimated_time,
+            proof_type=challenge.proof_type,
+            proof_hint=challenge.proof_hint,
+            game=GameShort(id=game.id, title=game.title, cover_url=None),
+            is_generated=challenge.is_generated,
+            created_at=challenge.created_at,
+        ),
+        can_drop=True,
+        drop_penalty=drop_penalty,
+    )
+
+
+@router.get("/marathons/{marathon_id}/current-assignment", response_model=AssignmentResponse | None)
+async def get_current_assignment(marathon_id: int, current_user: CurrentUser, db: DbSession):
+    """Get current active assignment"""
+    participant = await get_participant_or_403(db, current_user.id, marathon_id)
+    assignment = await get_active_assignment(db, participant.id)
+
+    if not assignment:
+        return None
+
+    challenge = assignment.challenge
+    game = challenge.game
+
+    return AssignmentResponse(
+        id=assignment.id,
+        challenge=ChallengeResponse(
+            id=challenge.id,
+            title=challenge.title,
+            description=challenge.description,
+            type=challenge.type,
+            difficulty=challenge.difficulty,
+            points=challenge.points,
+            estimated_time=challenge.estimated_time,
+            proof_type=challenge.proof_type,
+            proof_hint=challenge.proof_hint,
+            game=GameShort(id=game.id, title=game.title, cover_url=None),
+            is_generated=challenge.is_generated,
+            created_at=challenge.created_at,
+        ),
+        status=assignment.status,
+        proof_url=f"/uploads/proofs/{assignment.proof_path.split('/')[-1]}" if assignment.proof_path else assignment.proof_url,
+        proof_comment=assignment.proof_comment,
+        points_earned=assignment.points_earned,
+        streak_at_completion=assignment.streak_at_completion,
+        started_at=assignment.started_at,
+        completed_at=assignment.completed_at,
+    )
+
+
+@router.post("/assignments/{assignment_id}/complete", response_model=CompleteResult)
+async def complete_assignment(
+    assignment_id: int,
+    current_user: CurrentUser,
+    db: DbSession,
+    proof_url: str | None = Form(None),
+    comment: str | None = Form(None),
+    proof_file: UploadFile | None = File(None),
+):
+    """Complete an assignment with proof"""
+    # Get assignment
+    result = await db.execute(
+        select(Assignment)
+        .options(
+            selectinload(Assignment.participant),
+            selectinload(Assignment.challenge),
+        )
+        .where(Assignment.id == assignment_id)
+    )
+    assignment = result.scalar_one_or_none()
+
+    if not assignment:
+        raise HTTPException(status_code=404, detail="Assignment not found")
+
+    if assignment.participant.user_id != current_user.id:
+        raise HTTPException(status_code=403, detail="This is not your assignment")
+
+    if assignment.status != AssignmentStatus.ACTIVE.value:
+        raise HTTPException(status_code=400, detail="Assignment is not active")
+
+    # Need either file or URL
+    if not proof_file and not proof_url:
+        raise HTTPException(status_code=400, detail="Proof is required (file or URL)")
+
+    # Handle file upload
+    if proof_file:
+        contents = await proof_file.read()
+        if len(contents) > settings.MAX_UPLOAD_SIZE:
+            raise HTTPException(
+                status_code=400,
+                detail=f"File too large. Maximum size is {settings.MAX_UPLOAD_SIZE // 1024 // 1024} MB",
+            )
+
+        ext = proof_file.filename.split(".")[-1].lower() if proof_file.filename else "jpg"
+        if ext not in settings.ALLOWED_EXTENSIONS:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid file type. Allowed: {settings.ALLOWED_EXTENSIONS}",
+            )
+
+        filename = f"{assignment_id}_{uuid.uuid4().hex}.{ext}"
+        filepath = Path(settings.UPLOAD_DIR) / "proofs" / filename
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(filepath, "wb") as f:
+            f.write(contents)
+
+        assignment.proof_path = str(filepath)
+    else:
+        assignment.proof_url = proof_url
+
+    assignment.proof_comment = comment
+
+    # Calculate points
+    participant = assignment.participant
+    challenge = assignment.challenge
+
+    total_points, streak_bonus = points_service.calculate_completion_points(
+        challenge.points, participant.current_streak
+    )
+
+    # Update assignment
+    assignment.status = AssignmentStatus.COMPLETED.value
+    assignment.points_earned = total_points
+    assignment.streak_at_completion = participant.current_streak + 1
+    assignment.completed_at = datetime.utcnow()
+
+    # Update participant
+    participant.total_points += total_points
+    participant.current_streak += 1
+    participant.drop_count = 0  # Reset drop counter on success
+
+    # Get marathon_id for activity
+    result = await db.execute(
+        select(Challenge).options(selectinload(Challenge.game)).where(Challenge.id == challenge.id)
+    )
+    full_challenge = result.scalar_one()
+
+    # Log activity
+    activity = Activity(
+        marathon_id=full_challenge.game.marathon_id,
+        user_id=current_user.id,
+        type=ActivityType.COMPLETE.value,
+        data={
+            "challenge": challenge.title,
+            "points": total_points,
+            "streak": participant.current_streak,
+        },
+    )
+    db.add(activity)
+
+    await db.commit()
+
+    return CompleteResult(
+        points_earned=total_points,
+        streak_bonus=streak_bonus,
+        total_points=participant.total_points,
+        new_streak=participant.current_streak,
+    )
+
+
+@router.post("/assignments/{assignment_id}/drop", response_model=DropResult)
+async def drop_assignment(assignment_id: int, current_user: CurrentUser, db: DbSession):
+    """Drop current assignment"""
+    # Get assignment
+    result = await db.execute(
+        select(Assignment)
+        .options(
+            selectinload(Assignment.participant),
+            selectinload(Assignment.challenge).selectinload(Challenge.game),
+        )
+        .where(Assignment.id == assignment_id)
+    )
+    assignment = result.scalar_one_or_none()
+
+    if not assignment:
+        raise HTTPException(status_code=404, detail="Assignment not found")
+
+    if assignment.participant.user_id != current_user.id:
+        raise HTTPException(status_code=403, detail="This is not your assignment")
+
+    if assignment.status != AssignmentStatus.ACTIVE.value:
+        raise HTTPException(status_code=400, detail="Assignment is not active")
+
+    participant = assignment.participant
+
+    # Calculate penalty
+    penalty = points_service.calculate_drop_penalty(participant.drop_count)
+
+    # Update assignment
+    assignment.status = AssignmentStatus.DROPPED.value
+    assignment.completed_at = datetime.utcnow()
+
+    # Update participant
+    participant.total_points = max(0, participant.total_points - penalty)
+    participant.current_streak = 0
+    participant.drop_count += 1
+
+    # Log activity
+    activity = Activity(
+        marathon_id=assignment.challenge.game.marathon_id,
+        user_id=current_user.id,
+        type=ActivityType.DROP.value,
+        data={
+            "challenge": assignment.challenge.title,
+            "penalty": penalty,
+        },
+    )
+    db.add(activity)
+
+    await db.commit()
+
+    return DropResult(
+        penalty=penalty,
+        total_points=participant.total_points,
+        new_drop_count=participant.drop_count,
+    )
+
+
+@router.get("/marathons/{marathon_id}/my-history", response_model=list[AssignmentResponse])
+async def get_my_history(
+    marathon_id: int,
+    current_user: CurrentUser,
+    db: DbSession,
+    limit: int = 20,
+    offset: int = 0,
+):
+    """Get history of user's assignments in marathon"""
+    participant = await get_participant_or_403(db, current_user.id, marathon_id)
+
+    result = await db.execute(
+        select(Assignment)
+        .options(
+            selectinload(Assignment.challenge).selectinload(Challenge.game)
+        )
+        .where(Assignment.participant_id == participant.id)
+        .order_by(Assignment.started_at.desc())
+        .limit(limit)
+        .offset(offset)
+    )
+    assignments = result.scalars().all()
+
+    return [
+        AssignmentResponse(
+            id=a.id,
+            challenge=ChallengeResponse(
+                id=a.challenge.id,
+                title=a.challenge.title,
+                description=a.challenge.description,
+                type=a.challenge.type,
+                difficulty=a.challenge.difficulty,
+                points=a.challenge.points,
+                estimated_time=a.challenge.estimated_time,
+                proof_type=a.challenge.proof_type,
+                proof_hint=a.challenge.proof_hint,
+                game=GameShort(
+                    id=a.challenge.game.id,
+                    title=a.challenge.game.title,
+                    cover_url=None
+                ),
+                is_generated=a.challenge.is_generated,
+                created_at=a.challenge.created_at,
+            ),
+            status=a.status,
+            proof_url=f"/uploads/proofs/{a.proof_path.split('/')[-1]}" if a.proof_path else a.proof_url,
+            proof_comment=a.proof_comment,
+            points_earned=a.points_earned,
+            streak_at_completion=a.streak_at_completion,
+            started_at=a.started_at,
+            completed_at=a.completed_at,
+        )
+        for a in assignments
+    ]