Fix paths of swiss endpoints

backend/bracket/logic/scheduling/upcoming_matches.py

@@ -3,26 +3,43 @@
 from bracket.logic.scheduling.ladder_teams import get_possible_upcoming_matches_for_swiss
 from bracket.models.db.match import MatchFilter, SuggestedMatch
 from bracket.models.db.round import Round
-from bracket.models.db.stage_item import StageType
+from bracket.models.db.stage_item import StageItem, StageType
+from bracket.models.db.util import RoundWithMatches, StageItemWithRounds
 from bracket.sql.rounds import get_rounds_for_stage_item
 from bracket.sql.stages import get_full_tournament_details
 from bracket.sql.teams import get_teams_with_members
-from bracket.utils.id_types import TournamentId
+from bracket.utils.id_types import StageItemId, TournamentId
 from bracket.utils.types import assert_some
 
 
-async def get_upcoming_matches_for_swiss_round(
- match_filter: MatchFilter, round_: Round, tournament_id: TournamentId
-) -> list[SuggestedMatch]:
- [stage] = await get_full_tournament_details(
- tournament_id, stage_item_ids={round_.stage_item_id}
+async def get_draft_round_in_stage_item(
+ tournament_id: TournamentId,
+ stage_item_id: StageItemId,
+) -> tuple[RoundWithMatches, StageItemWithRounds]:
+ [stage] = await get_full_tournament_details(tournament_id, stage_item_ids={stage_item_id})
+ draft_round, stage_item = next(
+ (
+ (round_, stage_item)
+ for stage_item in stage.stage_items
+ for round_ in stage_item.rounds
+ if round_.is_draft
+ ),
+ (None, None),
  )
- assert len(stage.stage_items) == 1
- [stage_item] = stage.stage_items
+ if draft_round is None or stage_item is None:
+ raise HTTPException(400, "Expected stage item to be of type SWISS.")
+ return draft_round, stage_item
+
 
+async def get_upcoming_matches_for_swiss_round(
+ match_filter: MatchFilter, stage_item: StageItem, round_: Round, tournament_id: TournamentId
+) -> list[SuggestedMatch]:
  if stage_item.type is not StageType.SWISS:
  raise HTTPException(400, "Expected stage item to be of type SWISS.")
 
+ if not round_.is_draft:
+ raise HTTPException(400, "There is no draft round, so no matches can be scheduled.")
+
  rounds = await get_rounds_for_stage_item(tournament_id, assert_some(stage_item.id))
  teams = await get_teams_with_members(tournament_id, only_active_teams=True)
 

backend/bracket/routes/matches.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends
 
 from bracket.logic.planning.matches import (
  get_scheduled_matches,
@@ -10,6 +10,7 @@
  recalculate_ranking_for_stage_item_id,
 )
 from bracket.logic.scheduling.upcoming_matches import (
+ get_draft_round_in_stage_item,
  get_upcoming_matches_for_swiss_round,
 )
 from bracket.models.db.match import (
@@ -21,36 +22,34 @@
  MatchRescheduleBody,
  SuggestedMatch,
 )
-from bracket.models.db.round import Round
 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 SingleMatchResponse, SuccessResponse, UpcomingMatchesResponse
-from bracket.routes.util import match_dependency, round_dependency, round_with_matches_dependency
+from bracket.routes.util import 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
 from bracket.sql.stages import get_full_tournament_details
 from bracket.sql.tournaments import sql_get_tournament
 from bracket.sql.validation import check_foreign_keys_belong_to_tournament
-from bracket.utils.id_types import MatchId, TournamentId
+from bracket.utils.id_types import MatchId, StageItemId, TournamentId
 from bracket.utils.types import assert_some
 
 router = APIRouter()
 
 
 @router.get(
- "/tournaments/{tournament_id}/rounds/{round_id}/upcoming_matches",
+ "/tournaments/{tournament_id}/stage_items/{stage_item_id}/upcoming_matches",
  response_model=UpcomingMatchesResponse,
 )
 async def get_matches_to_schedule(
  tournament_id: TournamentId,
+ stage_item_id: StageItemId,
  elo_diff_threshold: int = 200,
  iterations: int = 200,
  only_recommended: bool = False,
  limit: int = 50,
  _: UserPublic = Depends(user_authenticated_for_tournament),
- round_: Round = Depends(round_dependency),
 ) -> UpcomingMatchesResponse:
  match_filter = MatchFilter(
  elo_diff_threshold=elo_diff_threshold,
@@ -59,11 +58,12 @@ async def get_matches_to_schedule(
  iterations=iterations,
  )
 
- if not round_.is_draft:
- raise HTTPException(400, "There is no draft round, so no matches can be scheduled.")
+ draft_round, stage_item = await get_draft_round_in_stage_item(tournament_id, stage_item_id)
 
  return UpcomingMatchesResponse(
- data=await get_upcoming_matches_for_swiss_round(match_filter, round_, tournament_id)
+ data=await get_upcoming_matches_for_swiss_round(
+ match_filter, stage_item, draft_round, tournament_id
+ )
  )
 
 
@@ -123,45 +123,43 @@ async def reschedule_match(
 
 
 @router.post(
- "/tournaments/{tournament_id}/rounds/{round_id}/schedule_auto",
+ "/tournaments/{tournament_id}/stage_items/{stage_item_id}/schedule_auto",
  response_model=SuccessResponse,
 )
 async def create_matches_automatically(
  tournament_id: TournamentId,
+ stage_item_id: StageItemId,
  elo_diff_threshold: int = 100,
  iterations: int = 200,
  only_recommended: bool = False,
  _: UserPublic = Depends(user_authenticated_for_tournament),
- round_: RoundWithMatches = Depends(round_with_matches_dependency),
 ) -> SuccessResponse:
- if not round_.is_draft:
- raise HTTPException(400, "There is no draft round, so no matches can be scheduled.")
-
  match_filter = MatchFilter(
  elo_diff_threshold=elo_diff_threshold,
  only_recommended=only_recommended,
  limit=1,
  iterations=iterations,
  )
 
+ draft_round, stage_item = await get_draft_round_in_stage_item(tournament_id, stage_item_id)
  courts = await get_all_courts_in_tournament(tournament_id)
  tournament = await sql_get_tournament(tournament_id)
 
- limit = len(courts) - len(round_.matches)
+ limit = len(courts) - len(draft_round.matches)
  for __ in range(limit):
  all_matches_to_schedule = await get_upcoming_matches_for_swiss_round(
- match_filter, round_, tournament_id
+ match_filter, stage_item, draft_round, tournament_id
  )
  if len(all_matches_to_schedule) < 1:
  break
 
  match = all_matches_to_schedule[0]
  assert isinstance(match, SuggestedMatch)
 
- assert round_.id and match.team1.id and match.team2.id
+ assert draft_round.id and match.team1.id and match.team2.id
  await sql_create_match(
  MatchCreateBody(
- round_id=round_.id,
+ round_id=draft_round.id,
  team1_id=match.team1.id,
  team2_id=match.team2.id,
  court_id=None,

backend/tests/integration_tests/api/auto_scheduling_matches_test.py

@@ -66,13 +66,13 @@ async def test_schedule_matches_auto(
  ],
  ),
  )
- round_1_id = await sql_create_round(
+ await sql_create_round(
  RoundToInsert(stage_item_id=stage_item_1.id, name="", is_draft=True, is_active=False),
  )
 
  response = await send_tournament_request(
  HTTPMethod.POST,
- f"rounds/{round_1_id}/schedule_auto",
+ f"stage_items/{stage_item_1.id}/schedule_auto",
  auth_context,
  )
  stages = await get_full_tournament_details(tournament_id)

backend/tests/integration_tests/api/matches_test.py

@@ -271,7 +271,7 @@ async def test_upcoming_matches_endpoint(
  "stage_item_id": stage_item_inserted.id,
  }
  )
- ) as round_inserted,
+ ),
  inserted_team(
  DUMMY_TEAM1.model_copy(
  update={"tournament_id": auth_context.tournament.id, "elo_score": Decimal("1150.0")}
@@ -308,7 +308,10 @@ async def test_upcoming_matches_endpoint(
  ) as player_inserted_4,
  ):
  json_response = await send_tournament_request(
- HTTPMethod.GET, f"rounds/{round_inserted.id}/upcoming_matches", auth_context, {}
+ HTTPMethod.GET,
+ f"stage_items/{stage_item_inserted.id}/upcoming_matches",
+ auth_context,
+ {},
  )
  assert json_response == {
  "data": [

frontend/src/components/buttons/create_matches_auto.tsx

@@ -12,19 +12,16 @@ export function AutoCreateMatchesButton({
  tournamentData,
  swrStagesResponse,
  swrUpcomingMatchesResponse,
- roundId,
+ stageItemId,
  schedulerSettings,
 }: {
  schedulerSettings: SchedulerSettings;
- roundId: number;
+ stageItemId: number;
  tournamentData: Tournament;
  swrStagesResponse: SWRResponse;
  swrUpcomingMatchesResponse: SWRResponse;
 }) {
  const { t } = useTranslation();
- if (roundId == null) {
- return null;
- }
  return (
  <Button
  size="md"
@@ -35,7 +32,7 @@ export function AutoCreateMatchesButton({
  onClick={async () => {
  await createMatchesAuto(
  tournamentData.id,
- roundId,
+ stageItemId,
  schedulerSettings.eloThreshold,
  schedulerSettings.onlyRecommended,
  schedulerSettings.iterations

frontend/src/components/scheduling/scheduling.tsx

@@ -6,6 +6,7 @@ import { BracketDisplaySettings } from '../../interfaces/brackets';
 import { SchedulerSettings } from '../../interfaces/match';
 import { RoundInterface } from '../../interfaces/round';
 import { StageWithStageItems } from '../../interfaces/stage';
+import { StageItemWithRounds } from '../../interfaces/stage_item';
 import { Tournament } from '../../interfaces/tournament';
 import { AutoCreateMatchesButton } from '../buttons/create_matches_auto';
 import UpcomingMatchesTable from '../tables/upcoming_matches';
@@ -40,6 +41,7 @@ function SchedulingSystem({
 
 export default function Scheduler({
  activeStage,
+ stageItem,
  tournamentData,
  draftRound,
  swrRoundsResponse,
@@ -48,6 +50,7 @@ export default function Scheduler({
  displaySettings,
 }: {
  activeStage: StageWithStageItems;
+ stageItem: StageItemWithRounds;
  draftRound: RoundInterface;
  tournamentData: Tournament;
  swrRoundsResponse: SWRResponse;
@@ -70,7 +73,7 @@ export default function Scheduler({
  swrStagesResponse={swrRoundsResponse}
  swrUpcomingMatchesResponse={swrUpcomingMatchesResponse}
  tournamentData={tournamentData}
- roundId={draftRound.id}
+ stageItemId={stageItem.id}
  schedulerSettings={schedulerSettings}
  />
  </Group>

frontend/src/pages/tournaments/[id]/swiss/[stage_item_id].tsx

@@ -90,7 +90,7 @@ export default function TournamentPage() {
  }
  }
 
- const swrUpcomingMatchesResponse = getUpcomingMatches(id, draftRound?.id, schedulerSettings);
+ const swrUpcomingMatchesResponse = getUpcomingMatches(id, stageItemId, schedulerSettings);
  const scheduler =
  draftRound != null &&
  stageItem != null &&
@@ -100,6 +100,7 @@ export default function TournamentPage() {
  <>
  <Scheduler
  activeStage={activeStage}
+ stageItem={stageItem}
  draftRound={draftRound}
  tournamentData={tournamentDataFull}
  swrRoundsResponse={swrStagesResponse}

frontend/src/services/adapter.tsx

@@ -197,13 +197,13 @@ export function getUser(): SWRResponse {
 
 export function getUpcomingMatches(
  tournament_id: number,
- round_id: number,
+ stage_item_id: number,
  schedulerSettings: SchedulerSettings
 ): SWRResponse {
  return useSWR(
- round_id == null
+ stage_item_id == null
  ? null
- : `tournaments/${tournament_id}/rounds/${round_id}/upcoming_matches?elo_diff_threshold=${schedulerSettings.eloThreshold}&only_recommended=${schedulerSettings.onlyRecommended}&limit=${schedulerSettings.limit}&iterations=${schedulerSettings.iterations}`,
+ : `tournaments/${tournament_id}/stage_items/${stage_item_id}/upcoming_matches?elo_diff_threshold=${schedulerSettings.eloThreshold}&only_recommended=${schedulerSettings.onlyRecommended}&limit=${schedulerSettings.limit}&iterations=${schedulerSettings.iterations}`,
  fetcher
  );
 }

frontend/src/services/round.tsx

@@ -11,13 +11,13 @@ export async function createRound(tournament_id: number, stage_item_id: number)
 
 export async function createMatchesAuto(
  tournament_id: number,
- round_id: number,
+ stage_item_id: number,
  elo_diff_threshold: number,
  only_recommended: string,
  iterations: number
 ) {
  return createAxios()
- .post(`tournaments/${tournament_id}/rounds/${round_id}/schedule_auto`, {
+ .post(`tournaments/${tournament_id}/stage_items/${stage_item_id}/schedule_auto`, {
  elo_diff_threshold,
  only_recommended,
  iterations,