diff --git a/fupogfakta/services.py b/fupogfakta/services.py index 562d2bb..4b6d0e4 100644 --- a/fupogfakta/services.py +++ b/fupogfakta/services.py @@ -1,6 +1,23 @@ import random +from dataclasses import dataclass -from .models import GameSession, Player, Question, RoundConfig, RoundQuestion, ScoreEvent +from django.db import transaction + +from .models import GameSession, Guess, LieAnswer, Player, Question, RoundConfig, RoundQuestion, ScoreEvent + + +@dataclass(frozen=True) +class RoundTransitionResult: + session: GameSession + round_config: RoundConfig + round_question: RoundQuestion + should_broadcast: bool + + +@dataclass(frozen=True) +class FinishGameResult: + session: GameSession + should_broadcast: bool def get_current_round_question(session: GameSession) -> RoundQuestion | None: @@ -13,6 +30,16 @@ def get_current_round_question(session: GameSession) -> RoundQuestion | None: +def reset_round_question_bootstrap_state(round_question: RoundQuestion) -> RoundQuestion: + Guess.objects.filter(round_question=round_question).delete() + LieAnswer.objects.filter(round_question=round_question).delete() + if round_question.mixed_answers: + round_question.mixed_answers = [] + round_question.save(update_fields=["mixed_answers"]) + return round_question + + + def select_round_question(session: GameSession, round_config: RoundConfig) -> RoundQuestion: existing_round_question = get_current_round_question(session) if existing_round_question is not None: @@ -61,6 +88,83 @@ def prepare_mixed_answers(round_question: RoundQuestion) -> list[str]: +def start_next_round(session: GameSession) -> RoundTransitionResult: + with transaction.atomic(): + locked_session = GameSession.objects.select_for_update().get(pk=session.pk) + next_round_config = None + round_question = None + should_broadcast = False + + if locked_session.status == GameSession.Status.SCOREBOARD: + previous_round_config = RoundConfig.objects.filter( + session=locked_session, + number=locked_session.current_round, + ).select_related("category").first() + if previous_round_config is None: + raise ValueError("round_config_missing") + + next_round_number = locked_session.current_round + 1 + next_round_config = RoundConfig( + session=locked_session, + number=next_round_number, + category=previous_round_config.category, + lie_seconds=previous_round_config.lie_seconds, + guess_seconds=previous_round_config.guess_seconds, + points_correct=previous_round_config.points_correct, + points_bluff=previous_round_config.points_bluff, + started_from_scoreboard=True, + ) + locked_session.current_round = next_round_number + + round_question = reset_round_question_bootstrap_state(select_round_question(locked_session, next_round_config)) + + next_round_config.save() + locked_session.status = GameSession.Status.LIE + locked_session.save(update_fields=["current_round", "status"]) + should_broadcast = True + elif locked_session.status == GameSession.Status.LIE: + if locked_session.current_round <= 1: + raise ValueError("next_round_invalid_phase") + + next_round_config = RoundConfig.objects.filter( + session=locked_session, + number=locked_session.current_round, + ).select_related("category").first() + round_question = get_current_round_question(locked_session) + if ( + next_round_config is None + or not next_round_config.started_from_scoreboard + or round_question is None + ): + raise ValueError("next_round_invalid_phase") + else: + raise ValueError("next_round_invalid_phase") + + return RoundTransitionResult( + session=locked_session, + round_config=next_round_config, + round_question=round_question, + should_broadcast=should_broadcast, + ) + + + +def finish_game(session: GameSession) -> FinishGameResult: + with transaction.atomic(): + locked_session = GameSession.objects.select_for_update().get(pk=session.pk) + should_broadcast = False + + if locked_session.status == GameSession.Status.SCOREBOARD: + locked_session.status = GameSession.Status.FINISHED + locked_session.save(update_fields=["status"]) + should_broadcast = True + elif locked_session.status != GameSession.Status.FINISHED: + raise ValueError("finish_game_invalid_phase") + + return FinishGameResult(session=locked_session, should_broadcast=should_broadcast) + + + def resolve_scores( session: GameSession, round_question: RoundQuestion, diff --git a/fupogfakta/tests.py b/fupogfakta/tests.py index d64e10c..14fa115 100644 --- a/fupogfakta/tests.py +++ b/fupogfakta/tests.py @@ -5,7 +5,14 @@ from django.test import TestCase from fupogfakta.models import Category, GameSession, Guess, LieAnswer, Player, Question, RoundConfig, RoundQuestion, ScoreEvent from fupogfakta.payloads import build_lie_started_payload, build_reveal_payload -from fupogfakta.services import get_current_round_question, prepare_mixed_answers, resolve_scores, select_round_question +from fupogfakta.services import ( + finish_game, + get_current_round_question, + prepare_mixed_answers, + resolve_scores, + select_round_question, + start_next_round, +) User = get_user_model() @@ -63,6 +70,46 @@ class FupOgFaktaExtractionSliceTests(TestCase): round_question.refresh_from_db() self.assertEqual(round_question.mixed_answers, answers) + def test_start_next_round_moves_scoreboard_transition_into_service(self): + self.session.status = GameSession.Status.SCOREBOARD + self.session.save(update_fields=["status"]) + + result = start_next_round(self.session) + + self.session.refresh_from_db() + self.assertTrue(result.should_broadcast) + self.assertEqual(result.session.status, GameSession.Status.LIE) + self.assertEqual(result.session.current_round, 2) + self.assertEqual(result.round_config.number, 2) + self.assertTrue(result.round_config.started_from_scoreboard) + self.assertEqual(result.round_question.round_number, 2) + + def test_start_next_round_rejects_plain_lie_without_scoreboard_marker(self): + self.session.status = GameSession.Status.LIE + self.session.current_round = 2 + self.session.save(update_fields=["status", "current_round"]) + RoundConfig.objects.create(session=self.session, number=2, category=self.category, started_from_scoreboard=False) + RoundQuestion.objects.create( + session=self.session, + round_number=2, + question=self.question_two, + correct_answer=self.question_two.correct_answer, + ) + + with self.assertRaisesMessage(ValueError, "next_round_invalid_phase"): + start_next_round(self.session) + + def test_finish_game_moves_scoreboard_transition_into_service(self): + self.session.status = GameSession.Status.SCOREBOARD + self.session.save(update_fields=["status"]) + + result = finish_game(self.session) + + self.session.refresh_from_db() + self.assertTrue(result.should_broadcast) + self.assertEqual(result.session.status, GameSession.Status.FINISHED) + self.assertEqual(self.session.status, GameSession.Status.FINISHED) + def test_resolve_scores_applies_correct_and_bluff_points(self): round_question = RoundQuestion.objects.create( session=self.session, diff --git a/lobby/tests.py b/lobby/tests.py index 522f356..4df512f 100644 --- a/lobby/tests.py +++ b/lobby/tests.py @@ -34,6 +34,8 @@ class LobbyGameplayExtractionTests(TestCase): self.assertIs(lobby_views._select_round_question, gameplay_services.select_round_question) self.assertIs(lobby_views._prepare_mixed_answers, gameplay_services.prepare_mixed_answers) self.assertIs(lobby_views._resolve_scores, gameplay_services.resolve_scores) + self.assertIs(lobby_views._start_next_round, gameplay_services.start_next_round) + self.assertIs(lobby_views._finish_game, gameplay_services.finish_game) self.assertIs(lobby_views._build_start_next_round_response, gameplay_payloads.build_start_next_round_response) self.assertIs(lobby_views._build_finish_game_response, gameplay_payloads.build_finish_game_response) diff --git a/lobby/views.py b/lobby/views.py index 6ace7a4..2b87b62 100644 --- a/lobby/views.py +++ b/lobby/views.py @@ -17,10 +17,12 @@ from fupogfakta.payloads import ( build_start_next_round_response as _build_start_next_round_response, ) from fupogfakta.services import ( + finish_game as _finish_game, get_current_round_question as _get_current_round_question, prepare_mixed_answers as _prepare_mixed_answers, resolve_scores as _resolve_scores, select_round_question as _select_round_question, + start_next_round as _start_next_round, ) from realtime.broadcast import sync_broadcast_phase_event @@ -68,16 +70,6 @@ def _create_unique_session_code() -> str: -def _reset_round_question_bootstrap_state(round_question: RoundQuestion) -> RoundQuestion: - Guess.objects.filter(round_question=round_question).delete() - LieAnswer.objects.filter(round_question=round_question).delete() - if round_question.mixed_answers: - round_question.mixed_answers = [] - round_question.save(update_fields=["mixed_answers"]) - return round_question - - - def _maybe_promote_reveal_to_scoreboard(session: GameSession) -> GameSession: if session.status != GameSession.Status.REVEAL: return session @@ -930,71 +922,30 @@ def start_next_round(request: HttpRequest, code: str) -> JsonResponse: if session.host_id != request.user.id: return api_error(request, code="host_only_start_next_round", status=403) - should_broadcast = False - with transaction.atomic(): - locked_session = GameSession.objects.select_for_update().select_related("host").get(pk=session.pk) - next_round_config = None - round_question = None + try: + transition = _start_next_round(session) + except ValueError as exc: + return api_error(request, code=str(exc), status=400) - if locked_session.status == GameSession.Status.SCOREBOARD: - previous_round_config = RoundConfig.objects.filter( - session=locked_session, - number=locked_session.current_round, - ).select_related("category").first() - if previous_round_config is None: - return api_error(request, code="round_config_missing", status=400) - - next_round_number = locked_session.current_round + 1 - next_round_config = RoundConfig( - session=locked_session, - number=next_round_number, - category=previous_round_config.category, - lie_seconds=previous_round_config.lie_seconds, - guess_seconds=previous_round_config.guess_seconds, - points_correct=previous_round_config.points_correct, - points_bluff=previous_round_config.points_bluff, - started_from_scoreboard=True, - ) - locked_session.current_round = next_round_number - - try: - round_question = _reset_round_question_bootstrap_state( - _select_round_question(locked_session, next_round_config) - ) - except ValueError as exc: - return api_error(request, code=str(exc), status=400) - - next_round_config.save() - locked_session.status = GameSession.Status.LIE - locked_session.save(update_fields=["current_round", "status"]) - should_broadcast = True - elif locked_session.status == GameSession.Status.LIE: - if locked_session.current_round <= 1: - return api_error(request, code="next_round_invalid_phase", status=400) - - next_round_config = RoundConfig.objects.filter( - session=locked_session, - number=locked_session.current_round, - ).select_related("category").first() - round_question = _get_current_round_question(locked_session) - if ( - next_round_config is None - or not next_round_config.started_from_scoreboard - or round_question is None - ): - return api_error(request, code="next_round_invalid_phase", status=400) - else: - return api_error(request, code="next_round_invalid_phase", status=400) - - if should_broadcast: - lie_started_payload = _build_lie_started_payload(locked_session, next_round_config, round_question) + if transition.should_broadcast: + lie_started_payload = _build_lie_started_payload( + transition.session, + transition.round_config, + transition.round_question, + ) sync_broadcast_phase_event( - locked_session.code, + transition.session.code, "phase.lie_started", lie_started_payload, ) - return JsonResponse(_build_start_next_round_response(locked_session, next_round_config, round_question)) + return JsonResponse( + _build_start_next_round_response( + transition.session, + transition.round_config, + transition.round_question, + ) + ) @require_POST @login_required @@ -1009,26 +960,21 @@ def finish_game(request: HttpRequest, code: str) -> JsonResponse: if session.host_id != request.user.id: return api_error(request, code="host_only_finish_game", status=403) - should_broadcast = False - with transaction.atomic(): - locked_session = GameSession.objects.select_for_update().get(pk=session.pk) - if locked_session.status == GameSession.Status.SCOREBOARD: - locked_session.status = GameSession.Status.FINISHED - locked_session.save(update_fields=["status"]) - should_broadcast = True - elif locked_session.status != GameSession.Status.FINISHED: - return api_error(request, code="finish_game_invalid_phase", status=400) + try: + transition = _finish_game(session) + except ValueError as exc: + return api_error(request, code=str(exc), status=400) - if should_broadcast: - leaderboard = _build_leaderboard(locked_session) + if transition.should_broadcast: + leaderboard = _build_leaderboard(transition.session) winner = leaderboard[0] if leaderboard else None sync_broadcast_phase_event( - locked_session.code, + transition.session.code, "phase.game_over", {"winner": winner, "leaderboard": list(leaderboard)}, ) - return JsonResponse(_build_finish_game_response(locked_session)) + return JsonResponse(_build_finish_game_response(transition.session)) @require_POST