404 lines
14 KiB
Python
404 lines
14 KiB
Python
from fastapi import APIRouter, HTTPException
|
|
from sqlalchemy import select
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from app.api.deps import DbSession, CurrentUser, require_participant, require_organizer, get_participant
|
|
from app.models import Marathon, MarathonStatus, Game, GameStatus, Challenge
|
|
from app.schemas import (
|
|
ChallengeCreate,
|
|
ChallengeUpdate,
|
|
ChallengeResponse,
|
|
MessageResponse,
|
|
GameShort,
|
|
ChallengePreview,
|
|
ChallengesPreviewResponse,
|
|
ChallengesSaveRequest,
|
|
)
|
|
from app.services.gpt import gpt_service
|
|
|
|
router = APIRouter(tags=["challenges"])
|
|
|
|
|
|
async def get_challenge_or_404(db, challenge_id: int) -> Challenge:
|
|
result = await db.execute(
|
|
select(Challenge)
|
|
.options(selectinload(Challenge.game))
|
|
.where(Challenge.id == challenge_id)
|
|
)
|
|
challenge = result.scalar_one_or_none()
|
|
if not challenge:
|
|
raise HTTPException(status_code=404, detail="Challenge not found")
|
|
return challenge
|
|
|
|
|
|
@router.get("/games/{game_id}/challenges", response_model=list[ChallengeResponse])
|
|
async def list_challenges(game_id: int, current_user: CurrentUser, db: DbSession):
|
|
"""List challenges for a game. Participants can view challenges for approved games only."""
|
|
# Get game and check access
|
|
result = await db.execute(
|
|
select(Game).where(Game.id == game_id)
|
|
)
|
|
game = result.scalar_one_or_none()
|
|
if not game:
|
|
raise HTTPException(status_code=404, detail="Game not found")
|
|
|
|
participant = await get_participant(db, current_user.id, game.marathon_id)
|
|
|
|
# Check access
|
|
if not current_user.is_admin:
|
|
if not participant:
|
|
raise HTTPException(status_code=403, detail="You are not a participant of this marathon")
|
|
# Regular participants can only see challenges for approved games or their own games
|
|
if not participant.is_organizer:
|
|
if game.status != GameStatus.APPROVED.value and game.proposed_by_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="Game not accessible")
|
|
|
|
result = await db.execute(
|
|
select(Challenge)
|
|
.where(Challenge.game_id == game_id)
|
|
.order_by(Challenge.difficulty, Challenge.created_at)
|
|
)
|
|
challenges = result.scalars().all()
|
|
|
|
return [
|
|
ChallengeResponse(
|
|
id=c.id,
|
|
title=c.title,
|
|
description=c.description,
|
|
type=c.type,
|
|
difficulty=c.difficulty,
|
|
points=c.points,
|
|
estimated_time=c.estimated_time,
|
|
proof_type=c.proof_type,
|
|
proof_hint=c.proof_hint,
|
|
game=GameShort(id=game.id, title=game.title, cover_url=None),
|
|
is_generated=c.is_generated,
|
|
created_at=c.created_at,
|
|
)
|
|
for c in challenges
|
|
]
|
|
|
|
|
|
@router.get("/marathons/{marathon_id}/challenges", response_model=list[ChallengeResponse])
|
|
async def list_marathon_challenges(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
"""List all challenges for a marathon (from all approved games). Participants only."""
|
|
# Check marathon exists
|
|
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")
|
|
|
|
# Check user is participant or admin
|
|
participant = await get_participant(db, current_user.id, marathon_id)
|
|
if not current_user.is_admin and not participant:
|
|
raise HTTPException(status_code=403, detail="You are not a participant of this marathon")
|
|
|
|
# Get all challenges from approved games in this marathon
|
|
result = await db.execute(
|
|
select(Challenge)
|
|
.join(Game, Challenge.game_id == Game.id)
|
|
.options(selectinload(Challenge.game))
|
|
.where(
|
|
Game.marathon_id == marathon_id,
|
|
Game.status == GameStatus.APPROVED.value,
|
|
)
|
|
.order_by(Game.title, Challenge.difficulty, Challenge.created_at)
|
|
)
|
|
challenges = result.scalars().all()
|
|
|
|
return [
|
|
ChallengeResponse(
|
|
id=c.id,
|
|
title=c.title,
|
|
description=c.description,
|
|
type=c.type,
|
|
difficulty=c.difficulty,
|
|
points=c.points,
|
|
estimated_time=c.estimated_time,
|
|
proof_type=c.proof_type,
|
|
proof_hint=c.proof_hint,
|
|
game=GameShort(id=c.game.id, title=c.game.title, cover_url=None),
|
|
is_generated=c.is_generated,
|
|
created_at=c.created_at,
|
|
)
|
|
for c in challenges
|
|
]
|
|
|
|
|
|
@router.post("/games/{game_id}/challenges", response_model=ChallengeResponse)
|
|
async def create_challenge(
|
|
game_id: int,
|
|
data: ChallengeCreate,
|
|
current_user: CurrentUser,
|
|
db: DbSession,
|
|
):
|
|
"""Create a challenge for a game. Organizers only."""
|
|
# Get game and check access
|
|
result = await db.execute(
|
|
select(Game).where(Game.id == game_id)
|
|
)
|
|
game = result.scalar_one_or_none()
|
|
if not game:
|
|
raise HTTPException(status_code=404, detail="Game not found")
|
|
|
|
# Check marathon is in preparing state
|
|
result = await db.execute(select(Marathon).where(Marathon.id == game.marathon_id))
|
|
marathon = result.scalar_one()
|
|
if marathon.status != MarathonStatus.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Cannot add challenges to active or finished marathon")
|
|
|
|
# Only organizers can add challenges
|
|
await require_organizer(db, current_user, game.marathon_id)
|
|
|
|
# Can only add challenges to approved games
|
|
if game.status != GameStatus.APPROVED.value:
|
|
raise HTTPException(status_code=400, detail="Can only add challenges to approved games")
|
|
|
|
challenge = Challenge(
|
|
game_id=game_id,
|
|
title=data.title,
|
|
description=data.description,
|
|
type=data.type.value,
|
|
difficulty=data.difficulty.value,
|
|
points=data.points,
|
|
estimated_time=data.estimated_time,
|
|
proof_type=data.proof_type.value,
|
|
proof_hint=data.proof_hint,
|
|
is_generated=False,
|
|
)
|
|
db.add(challenge)
|
|
await db.commit()
|
|
await db.refresh(challenge)
|
|
|
|
return 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,
|
|
)
|
|
|
|
|
|
@router.post("/marathons/{marathon_id}/preview-challenges", response_model=ChallengesPreviewResponse)
|
|
async def preview_challenges(marathon_id: int, current_user: CurrentUser, db: DbSession):
|
|
"""Generate challenges preview for approved games in marathon using GPT (without saving). Organizers only."""
|
|
# Check marathon
|
|
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.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Cannot generate challenges for active or finished marathon")
|
|
|
|
# Only organizers can generate challenges
|
|
await require_organizer(db, current_user, marathon_id)
|
|
|
|
# Get only APPROVED games
|
|
result = await db.execute(
|
|
select(Game).where(
|
|
Game.marathon_id == marathon_id,
|
|
Game.status == GameStatus.APPROVED.value,
|
|
)
|
|
)
|
|
games = result.scalars().all()
|
|
|
|
if not games:
|
|
raise HTTPException(status_code=400, detail="No approved games in marathon")
|
|
|
|
# Filter games that don't have challenges yet
|
|
games_to_generate = []
|
|
game_map = {}
|
|
for game in games:
|
|
existing = await db.scalar(
|
|
select(Challenge.id).where(Challenge.game_id == game.id).limit(1)
|
|
)
|
|
if not existing:
|
|
games_to_generate.append({
|
|
"id": game.id,
|
|
"title": game.title,
|
|
"genre": game.genre
|
|
})
|
|
game_map[game.id] = game.title
|
|
|
|
if not games_to_generate:
|
|
return ChallengesPreviewResponse(challenges=[])
|
|
|
|
# Generate challenges for all games in one API call
|
|
preview_challenges = []
|
|
try:
|
|
challenges_by_game = await gpt_service.generate_challenges(games_to_generate)
|
|
|
|
for game_id, challenges_data in challenges_by_game.items():
|
|
game_title = game_map.get(game_id, "Unknown")
|
|
for ch_data in challenges_data:
|
|
preview_challenges.append(ChallengePreview(
|
|
game_id=game_id,
|
|
game_title=game_title,
|
|
title=ch_data.title,
|
|
description=ch_data.description,
|
|
type=ch_data.type,
|
|
difficulty=ch_data.difficulty,
|
|
points=ch_data.points,
|
|
estimated_time=ch_data.estimated_time,
|
|
proof_type=ch_data.proof_type,
|
|
proof_hint=ch_data.proof_hint,
|
|
))
|
|
|
|
except Exception as e:
|
|
print(f"Error generating challenges: {e}")
|
|
|
|
return ChallengesPreviewResponse(challenges=preview_challenges)
|
|
|
|
|
|
@router.post("/marathons/{marathon_id}/save-challenges", response_model=MessageResponse)
|
|
async def save_challenges(
|
|
marathon_id: int,
|
|
data: ChallengesSaveRequest,
|
|
current_user: CurrentUser,
|
|
db: DbSession,
|
|
):
|
|
"""Save previewed challenges to database. Organizers only."""
|
|
# Check marathon
|
|
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.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Cannot add challenges to active or finished marathon")
|
|
|
|
# Only organizers can save challenges
|
|
await require_organizer(db, current_user, marathon_id)
|
|
|
|
# Verify all games belong to this marathon AND are approved
|
|
result = await db.execute(
|
|
select(Game.id).where(
|
|
Game.marathon_id == marathon_id,
|
|
Game.status == GameStatus.APPROVED.value,
|
|
)
|
|
)
|
|
valid_game_ids = set(row[0] for row in result.fetchall())
|
|
|
|
saved_count = 0
|
|
for ch_data in data.challenges:
|
|
if ch_data.game_id not in valid_game_ids:
|
|
continue # Skip challenges for invalid/unapproved games
|
|
|
|
# Validate type
|
|
ch_type = ch_data.type
|
|
if ch_type not in ["completion", "no_death", "speedrun", "collection", "achievement", "challenge_run"]:
|
|
ch_type = "completion"
|
|
|
|
# Validate difficulty
|
|
difficulty = ch_data.difficulty
|
|
if difficulty not in ["easy", "medium", "hard"]:
|
|
difficulty = "medium"
|
|
|
|
# Validate proof_type
|
|
proof_type = ch_data.proof_type
|
|
if proof_type not in ["screenshot", "video", "steam"]:
|
|
proof_type = "screenshot"
|
|
|
|
challenge = Challenge(
|
|
game_id=ch_data.game_id,
|
|
title=ch_data.title[:100],
|
|
description=ch_data.description,
|
|
type=ch_type,
|
|
difficulty=difficulty,
|
|
points=max(1, min(500, ch_data.points)),
|
|
estimated_time=ch_data.estimated_time,
|
|
proof_type=proof_type,
|
|
proof_hint=ch_data.proof_hint,
|
|
is_generated=True,
|
|
)
|
|
db.add(challenge)
|
|
saved_count += 1
|
|
|
|
await db.commit()
|
|
|
|
return MessageResponse(message=f"Сохранено {saved_count} заданий")
|
|
|
|
|
|
@router.patch("/challenges/{challenge_id}", response_model=ChallengeResponse)
|
|
async def update_challenge(
|
|
challenge_id: int,
|
|
data: ChallengeUpdate,
|
|
current_user: CurrentUser,
|
|
db: DbSession,
|
|
):
|
|
"""Update a challenge. Organizers only."""
|
|
challenge = await get_challenge_or_404(db, challenge_id)
|
|
|
|
# Check marathon is in preparing state
|
|
result = await db.execute(select(Marathon).where(Marathon.id == challenge.game.marathon_id))
|
|
marathon = result.scalar_one()
|
|
if marathon.status != MarathonStatus.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Cannot update challenges in active or finished marathon")
|
|
|
|
# Only organizers can update challenges
|
|
await require_organizer(db, current_user, challenge.game.marathon_id)
|
|
|
|
if data.title is not None:
|
|
challenge.title = data.title
|
|
if data.description is not None:
|
|
challenge.description = data.description
|
|
if data.type is not None:
|
|
challenge.type = data.type.value
|
|
if data.difficulty is not None:
|
|
challenge.difficulty = data.difficulty.value
|
|
if data.points is not None:
|
|
challenge.points = data.points
|
|
if data.estimated_time is not None:
|
|
challenge.estimated_time = data.estimated_time
|
|
if data.proof_type is not None:
|
|
challenge.proof_type = data.proof_type.value
|
|
if data.proof_hint is not None:
|
|
challenge.proof_hint = data.proof_hint
|
|
|
|
await db.commit()
|
|
await db.refresh(challenge)
|
|
|
|
game = challenge.game
|
|
return 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,
|
|
)
|
|
|
|
|
|
@router.delete("/challenges/{challenge_id}", response_model=MessageResponse)
|
|
async def delete_challenge(challenge_id: int, current_user: CurrentUser, db: DbSession):
|
|
"""Delete a challenge. Organizers only."""
|
|
challenge = await get_challenge_or_404(db, challenge_id)
|
|
|
|
# Check marathon is in preparing state
|
|
result = await db.execute(select(Marathon).where(Marathon.id == challenge.game.marathon_id))
|
|
marathon = result.scalar_one()
|
|
if marathon.status != MarathonStatus.PREPARING.value:
|
|
raise HTTPException(status_code=400, detail="Cannot delete challenges from active or finished marathon")
|
|
|
|
# Only organizers can delete challenges
|
|
await require_organizer(db, current_user, challenge.game.marathon_id)
|
|
|
|
await db.delete(challenge)
|
|
await db.commit()
|
|
|
|
return MessageResponse(message="Challenge deleted")
|