refactor: move scoreboard promotion out of lobby view

fupogfakta/payloads.py

@@ -113,6 +113,16 @@ def build_start_next_round_phase_event(
     }
 
 
+def build_scoreboard_phase_event(session: GameSession, leaderboard: list[dict] | None = None) -> dict:
+    return {
+        "name": "phase.scoreboard",
+        "payload": {
+            "leaderboard": leaderboard if leaderboard is not None else build_leaderboard(session),
+            "current_round": session.current_round,
+        },
+    }
+
+
 def build_finish_game_phase_event(session: GameSession) -> dict:
     leaderboard = build_leaderboard(session)
     winner = leaderboard[0] if leaderboard else None

fupogfakta/services.py

@@ -20,6 +20,13 @@ class FinishGameResult:
     should_broadcast: bool
 
 
+@dataclass(frozen=True)
+class ScoreboardTransitionResult:
+    session: GameSession
+    leaderboard: list[dict]
+    should_broadcast: bool
+
+
 def get_current_round_question(session: GameSession) -> RoundQuestion | None:
     return (
         RoundQuestion.objects.filter(session=session, round_number=session.current_round)
@@ -165,6 +172,63 @@ def finish_game(session: GameSession) -> FinishGameResult:
 
 
 
+def promote_reveal_to_scoreboard(session: GameSession) -> ScoreboardTransitionResult:
+    if session.status != GameSession.Status.REVEAL:
+        leaderboard = list(
+            Player.objects.filter(session=session)
+            .order_by("-score", "nickname")
+            .values("id", "nickname", "score")
+        )
+        return ScoreboardTransitionResult(session=session, leaderboard=leaderboard, should_broadcast=False)
+
+    current_round_question = get_current_round_question(session)
+    if current_round_question is None:
+        leaderboard = list(
+            Player.objects.filter(session=session)
+            .order_by("-score", "nickname")
+            .values("id", "nickname", "score")
+        )
+        return ScoreboardTransitionResult(session=session, leaderboard=leaderboard, should_broadcast=False)
+
+    players_count = Player.objects.filter(session=session).count()
+    guess_count = Guess.objects.filter(round_question=current_round_question).count()
+    has_score_events = ScoreEvent.objects.filter(
+        session=session,
+        meta__round_question_id=current_round_question.id,
+    ).exists()
+    reveal_is_resolved = has_score_events or (players_count > 0 and guess_count >= players_count)
+    if not reveal_is_resolved:
+        leaderboard = list(
+            Player.objects.filter(session=session)
+            .order_by("-score", "nickname")
+            .values("id", "nickname", "score")
+        )
+        return ScoreboardTransitionResult(session=session, leaderboard=leaderboard, should_broadcast=False)
+
+    with transaction.atomic():
+        locked_session = GameSession.objects.select_for_update().get(pk=session.pk)
+        if locked_session.status != GameSession.Status.REVEAL:
+            scoreboard_session = locked_session
+            should_broadcast = False
+        else:
+            locked_session.status = GameSession.Status.SCOREBOARD
+            locked_session.save(update_fields=["status"])
+            scoreboard_session = locked_session
+            should_broadcast = True
+
+    leaderboard = list(
+        Player.objects.filter(session=scoreboard_session)
+        .order_by("-score", "nickname")
+        .values("id", "nickname", "score")
+    )
+    return ScoreboardTransitionResult(
+        session=scoreboard_session,
+        leaderboard=leaderboard,
+        should_broadcast=should_broadcast,
+    )
+
+
+
 def resolve_scores(
     session: GameSession,
     round_question: RoundQuestion,

fupogfakta/tests.py

@@ -9,6 +9,7 @@ from fupogfakta.services import (
     finish_game,
     get_current_round_question,
     prepare_mixed_answers,
+    promote_reveal_to_scoreboard,
     resolve_scores,
     select_round_question,
     start_next_round,
@@ -110,6 +111,41 @@ class FupOgFaktaExtractionSliceTests(TestCase):
         self.assertEqual(result.session.status, GameSession.Status.FINISHED)
         self.assertEqual(self.session.status, GameSession.Status.FINISHED)
 
+    def test_promote_reveal_to_scoreboard_moves_transition_into_service(self):
+        round_question = RoundQuestion.objects.create(
+            session=self.session,
+            round_number=1,
+            question=self.question_one,
+            correct_answer=self.question_one.correct_answer,
+        )
+        self.session.status = GameSession.Status.REVEAL
+        self.session.save(update_fields=["status"])
+
+        LieAnswer.objects.create(round_question=round_question, player=self.alice, text="Elbil")
+        Guess.objects.create(
+            round_question=round_question,
+            player=self.bob,
+            selected_text="Elbil",
+            is_correct=False,
+            fooled_player=self.alice,
+        )
+        ScoreEvent.objects.create(
+            session=self.session,
+            player=self.alice,
+            delta=5,
+            reason="bluff_success",
+            meta={"round_question_id": round_question.id},
+        )
+        self.alice.score = 5
+        self.alice.save(update_fields=["score"])
+
+        result = promote_reveal_to_scoreboard(self.session)
+
+        self.session.refresh_from_db()
+        self.assertTrue(result.should_broadcast)
+        self.assertEqual(result.session.status, GameSession.Status.SCOREBOARD)
+        self.assertEqual(result.leaderboard[0]["nickname"], self.alice.nickname)
+
     def test_resolve_scores_applies_correct_and_bluff_points(self):
         round_question = RoundQuestion.objects.create(
             session=self.session,