Feature: archived tournaments (#1112)

fixes #690

Author: evroon

backend/alembic/versions/c1ab44651e79_add_tournaments_status.py

@@ -0,0 +1,32 @@
+"""add tournaments.status
+
+Revision ID: c1ab44651e79
+Revises: e6e2718365dc
+Create Date: 2025-02-09 11:06:32.622324
+
+"""
+
+import sqlalchemy as sa
+from sqlalchemy.dialects.postgresql import ENUM
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str | None = "c1ab44651e79"
+down_revision: str | None = "e6e2718365dc"
+branch_labels: str | None = None
+depends_on: str | None = None
+
+enum = ENUM("OPEN", "ARCHIVED", name="tournament_status", create_type=True)
+
+
+def upgrade() -> None:
+    enum.create(op.get_bind(), checkfirst=True)
+    op.add_column(
+        "tournaments", sa.Column("status", enum, server_default="OPEN", nullable=False, index=True)
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("tournaments", "status")
+    enum.drop(op.get_bind())

backend/bracket/models/db/tournament.py

@@ -1,9 +1,17 @@
+from enum import auto
+
 from heliclockter import datetime_utc
 from pydantic import Field
 
 from bracket.models.db.shared import BaseModelORM
 from bracket.utils.id_types import ClubId, TournamentId
 from bracket.utils.pydantic import EmptyStrToNone
+from bracket.utils.types import EnumAutoStr
+
+
+class TournamentStatus(EnumAutoStr):
+    OPEN = auto()
+    ARCHIVED = auto()
 
 
 class TournamentInsertable(BaseModelORM):
@@ -18,6 +26,7 @@ class TournamentInsertable(BaseModelORM):
     logo_path: str | None = None
     players_can_be_in_multiple_teams: bool
     auto_assign_courts: bool
+    status: TournamentStatus = TournamentStatus.OPEN
 
 
 class Tournament(TournamentInsertable):
@@ -35,5 +44,9 @@ class TournamentUpdateBody(BaseModelORM):
     margin_minutes: int = Field(..., ge=0)
 
 
+class TournamentChangeStatusBody(BaseModelORM):
+    status: TournamentStatus
+
+
 class TournamentBody(TournamentUpdateBody):
     club_id: ClubId

backend/bracket/routes/courts.py

@@ -5,12 +5,14 @@
 from bracket.database import database
 from bracket.logic.subscriptions import check_requirement
 from bracket.models.db.court import Court, CourtBody, CourtToInsert
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.routes.auth import (
     user_authenticated_for_tournament,
     user_authenticated_or_public_dashboard,
 )
 from bracket.routes.models import CourtsResponse, SingleCourtResponse, SuccessResponse
+from bracket.routes.util import disallow_archived_tournament
 from bracket.schema import courts
 from bracket.sql.courts import get_all_courts_in_tournament, sql_delete_court, update_court
 from bracket.sql.stages import get_full_tournament_details
@@ -35,6 +37,7 @@ async def update_court_by_id(
     court_id: CourtId,
     court_body: CourtBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SingleCourtResponse:
     await update_court(
         tournament_id=tournament_id,
@@ -59,6 +62,7 @@ async def delete_court(
     tournament_id: TournamentId,
     court_id: CourtId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     stages = await get_full_tournament_details(tournament_id, no_draft_rounds=False)
     used_in_matches_count = 0
@@ -84,6 +88,7 @@ async def create_court(
     court_body: CourtBody,
     tournament_id: TournamentId,
     user: UserPublic = Depends(user_authenticated_for_tournament),
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SingleCourtResponse:
     existing_courts = await get_all_courts_in_tournament(tournament_id)
     check_requirement(existing_courts, user, "max_courts")

backend/bracket/routes/matches.py

@@ -25,10 +25,11 @@
     MatchRescheduleBody,
 )
 from bracket.models.db.stage_item import StageType
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.routes.auth import user_authenticated_for_tournament
 from bracket.routes.models import SingleMatchResponse, SuccessResponse, UpcomingMatchesResponse
-from bracket.routes.util import match_dependency
+from bracket.routes.util import disallow_archived_tournament, match_dependency
 from bracket.sql.courts import get_all_courts_in_tournament
 from bracket.sql.matches import sql_create_match, sql_delete_match, sql_update_match
 from bracket.sql.rounds import get_round_by_id
@@ -76,6 +77,7 @@ async def get_matches_to_schedule(
 async def delete_match(
     tournament_id: TournamentId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
     match: Match = Depends(match_dependency),
 ) -> SuccessResponse:
     round_ = await get_round_by_id(tournament_id, match.round_id)
@@ -100,6 +102,7 @@ async def create_match(
     tournament_id: TournamentId,
     match_body: MatchCreateBodyFrontend,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SingleMatchResponse:
     await check_foreign_keys_belong_to_tournament(match_body, tournament_id)
 
@@ -126,6 +129,7 @@ async def create_match(
 async def schedule_matches(
     tournament_id: TournamentId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     stages = await get_full_tournament_details(tournament_id)
     await schedule_all_unscheduled_matches(tournament_id, stages)
@@ -140,6 +144,7 @@ async def reschedule_match(
     match_id: MatchId,
     body: MatchRescheduleBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     await check_foreign_keys_belong_to_tournament(body, tournament_id)
     await handle_match_reschedule(tournament_id, body, match_id)
@@ -153,6 +158,7 @@ async def update_match_by_id(
     match_id: MatchId,
     match_body: MatchBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
     match: Match = Depends(match_dependency),
 ) -> SuccessResponse:
     await check_foreign_keys_belong_to_tournament(match_body, tournament_id)

backend/bracket/routes/players.py

@@ -3,6 +3,7 @@
 from bracket.database import database
 from bracket.logic.subscriptions import check_requirement
 from bracket.models.db.player import Player, PlayerBody, PlayerMultiBody
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.routes.auth import user_authenticated_for_tournament
 from bracket.routes.models import (
@@ -11,6 +12,7 @@
     SinglePlayerResponse,
     SuccessResponse,
 )
+from bracket.routes.util import disallow_archived_tournament
 from bracket.schema import players
 from bracket.sql.players import (
     get_all_players_in_tournament,
@@ -49,6 +51,7 @@ async def update_player_by_id(
     player_id: PlayerId,
     player_body: PlayerBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SinglePlayerResponse:
     await database.execute(
         query=players.update().where(
@@ -74,6 +77,7 @@ async def delete_player(
     tournament_id: TournamentId,
     player_id: PlayerId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     await sql_delete_player(tournament_id, player_id)
     return SuccessResponse()
@@ -84,6 +88,7 @@ async def create_single_player(
     player_body: PlayerBody,
     tournament_id: TournamentId,
     user: UserPublic = Depends(user_authenticated_for_tournament),
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     existing_players = await get_all_players_in_tournament(tournament_id)
     check_requirement(existing_players, user, "max_players")
@@ -96,6 +101,7 @@ async def create_multiple_players(
     player_body: PlayerMultiBody,
     tournament_id: TournamentId,
     user: UserPublic = Depends(user_authenticated_for_tournament),
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     player_names = [player.strip() for player in player_body.names.split("\n") if len(player) > 0]
     existing_players = await get_all_players_in_tournament(tournament_id)

backend/bracket/routes/rankings.py

@@ -7,6 +7,7 @@
 from bracket.logic.subscriptions import check_requirement
 from bracket.models.db.ranking import RankingBody, RankingCreateBody
 from bracket.models.db.stage_item import StageType
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.routes.auth import (
     user_authenticated_for_tournament,
@@ -16,6 +17,7 @@
     RankingsResponse,
     SuccessResponse,
 )
+from bracket.routes.util import disallow_archived_tournament
 from bracket.sql.rankings import (
     get_all_rankings_in_tournament,
     sql_create_ranking,
@@ -43,6 +45,7 @@ async def update_ranking_by_id(
     ranking_id: RankingId,
     ranking_body: RankingBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     await sql_update_ranking(
         tournament_id=tournament_id,
@@ -64,6 +67,7 @@ async def delete_ranking(
     tournament_id: TournamentId,
     ranking_id: RankingId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     await sql_delete_ranking(tournament_id, ranking_id)
     return SuccessResponse()
@@ -74,6 +78,7 @@ async def create_ranking(
     ranking_body: RankingCreateBody,
     tournament_id: TournamentId,
     user: UserPublic = Depends(user_authenticated_for_tournament),
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     existing_rankings = await get_all_rankings_in_tournament(tournament_id)
     check_requirement(existing_rankings, user, "max_rankings")

backend/bracket/routes/rounds.py

@@ -12,11 +12,13 @@
     RoundInsertable,
     RoundUpdateBody,
 )
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.models.db.util import RoundWithMatches
 from bracket.routes.auth import user_authenticated_for_tournament
 from bracket.routes.models import SuccessResponse
 from bracket.routes.util import (
+    disallow_archived_tournament,
     round_dependency,
     round_with_matches_dependency,
 )
@@ -41,6 +43,7 @@ async def delete_round(
     tournament_id: TournamentId,
     round_id: RoundId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
     round_with_matches: RoundWithMatches = Depends(round_with_matches_dependency),
 ) -> SuccessResponse:
     for match in round_with_matches.matches:
@@ -58,6 +61,7 @@ async def create_round(
     tournament_id: TournamentId,
     round_body: RoundCreateBody,
     user: UserPublic = Depends(user_authenticated_for_tournament),
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     await check_foreign_keys_belong_to_tournament(round_body, tournament_id)
 
@@ -98,6 +102,7 @@ async def update_round_by_id(
     round_body: RoundUpdateBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
     __: Round = Depends(round_dependency),
+    ___: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     query = """
         UPDATE rounds

backend/bracket/routes/stage_item_inputs.py

@@ -8,13 +8,14 @@
     StageItemInputUpdateBodyFinal,
     StageItemInputUpdateBodyTentative,
 )
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.models.db.util import StageItemWithRounds
 from bracket.routes.auth import (
     user_authenticated_for_tournament,
 )
 from bracket.routes.models import SuccessResponse
-from bracket.routes.util import stage_item_dependency
+from bracket.routes.util import disallow_archived_tournament, stage_item_dependency
 from bracket.sql.stage_item_inputs import get_stage_item_input_by_id
 from bracket.sql.stages import get_full_tournament_details
 from bracket.sql.teams import get_team_by_id
@@ -72,6 +73,7 @@ async def update_stage_item_input(
     stage_item_body: StageItemInputUpdateBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
     __: StageItemWithRounds = Depends(stage_item_dependency),
+    ___: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     stage_item_input = await get_stage_item_input_by_id(tournament_id, stage_item_input_id)
     await validate_stage_item_update(stage_item_input, stage_item_body, tournament_id)

backend/bracket/routes/stage_items.py

@@ -27,13 +27,14 @@
     StageItemUpdateBody,
     StageType,
 )
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.models.db.util import StageItemWithRounds
 from bracket.routes.auth import (
     user_authenticated_for_tournament,
 )
 from bracket.routes.models import SuccessResponse
-from bracket.routes.util import stage_item_dependency
+from bracket.routes.util import disallow_archived_tournament, stage_item_dependency
 from bracket.sql.courts import get_all_courts_in_tournament
 from bracket.sql.matches import sql_create_match
 from bracket.sql.rounds import (
@@ -101,6 +102,7 @@ async def update_stage_item(
     stage_item_id: StageItemId,
     stage_item_body: StageItemUpdateBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
     stage_item: StageItemWithRounds = Depends(stage_item_dependency),
 ) -> SuccessResponse:
     if stage_item is None:
@@ -137,6 +139,7 @@ async def start_next_round(
     elo_diff_threshold: int = 200,
     iterations: int = 2_000,
     only_recommended: bool = False,
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     draft_round = get_draft_round(stage_item)
     if draft_round is not None:

backend/bracket/routes/stages.py

@@ -10,6 +10,7 @@
 )
 from bracket.logic.subscriptions import check_requirement
 from bracket.models.db.stage import Stage, StageActivateBody, StageUpdateBody
+from bracket.models.db.tournament import Tournament
 from bracket.models.db.user import UserPublic
 from bracket.models.db.util import StageWithStageItems
 from bracket.routes.auth import (
@@ -22,7 +23,7 @@
     StagesWithStageItemsResponse,
     SuccessResponse,
 )
-from bracket.routes.util import stage_dependency
+from bracket.routes.util import disallow_archived_tournament, stage_dependency
 from bracket.sql.stages import (
     get_full_tournament_details,
     get_next_stage_in_tournament,
@@ -57,6 +58,7 @@ async def delete_stage(
     tournament_id: TournamentId,
     stage_id: StageId,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
     stage: StageWithStageItems = Depends(stage_dependency),
 ) -> SuccessResponse:
     if len(stage.stage_items) > 0:
@@ -80,6 +82,7 @@ async def delete_stage(
 async def create_stage(
     tournament_id: TournamentId,
     user: UserPublic = Depends(user_authenticated_for_tournament),
+    _: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     existing_stages = await get_full_tournament_details(tournament_id)
     check_requirement(existing_stages, user, "max_stages")
@@ -94,6 +97,7 @@ async def update_stage(
     stage_id: StageId,
     stage_body: StageUpdateBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
     stage: Stage = Depends(stage_dependency),  # pylint: disable=redefined-builtin
 ) -> SuccessResponse:
     values = {"tournament_id": tournament_id, "stage_id": stage_id}
@@ -115,6 +119,7 @@ async def activate_next_stage(
     tournament_id: TournamentId,
     stage_body: StageActivateBody,
     _: UserPublic = Depends(user_authenticated_for_tournament),
+    __: Tournament = Depends(disallow_archived_tournament),
 ) -> SuccessResponse:
     new_active_stage_id = await get_next_stage_in_tournament(tournament_id, stage_body.direction)
     if new_active_stage_id is None: