Add courts functionality (#256)

Author: evroon

backend/alembic/versions/3469289a7e06_create_courts_table.py

@@ -0,0 +1,52 @@
+"""create courts table
+
+Revision ID: 3469289a7e06
+Revises: 6458e0bc3e9d
+Create Date: 2023-09-11 13:36:28.464161
+
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str | None = '3469289a7e06'
+down_revision: str | None = '6458e0bc3e9d'
+branch_labels: str | None = None
+depends_on: str | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        'courts',
+        sa.Column('id', sa.BigInteger(), nullable=False),
+        sa.Column('name', sa.Text(), nullable=False),
+        sa.Column('created', sa.DateTime(timezone=True), nullable=False),
+        sa.Column('tournament_id', sa.BigInteger(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ['tournament_id'],
+            ['tournaments.id'],
+        ),
+        sa.PrimaryKeyConstraint('id'),
+    )
+    op.create_index(op.f('ix_courts_id'), 'courts', ['id'], unique=False)
+    op.add_column('matches', sa.Column('court_id', sa.BigInteger(), nullable=True))
+    op.create_foreign_key('matches_courts_fkey', 'matches', 'courts', ['court_id'], ['id'])
+    op.create_index(op.f('ix_courts_tournament_id'), 'courts', ['tournament_id'], unique=False)
+    op.add_column(
+        'tournaments',
+        sa.Column('auto_assign_courts', sa.Boolean(), server_default='f', nullable=False),
+    )
+    op.drop_column('matches', 'label')
+
+
+def downgrade() -> None:
+    op.add_column('matches', sa.Column('label', sa.Text(), nullable=True, server_default=''))
+    op.alter_column('matches', 'label', server_default=None)
+    op.drop_column('tournaments', 'auto_assign_courts')
+    op.drop_index(op.f('ix_courts_tournament_id'), table_name='courts')
+    op.drop_constraint('matches_courts_fkey', 'matches', type_='foreignkey')
+    op.drop_column('matches', 'court_id')
+    op.drop_index(op.f('ix_courts_id'), table_name='courts')
+    op.drop_table('courts')

backend/bracket/app.py

@@ -7,7 +7,18 @@
 
 from bracket.config import Environment, config, environment, init_sentry
 from bracket.database import database, init_db_when_empty
-from bracket.routes import auth, clubs, matches, players, rounds, stages, teams, tournaments, users
+from bracket.routes import (
+    auth,
+    clubs,
+    courts,
+    matches,
+    players,
+    rounds,
+    stages,
+    teams,
+    tournaments,
+    users,
+)
 
 init_sentry()
 
@@ -68,4 +79,5 @@ async def generic_exception_handler(request: Request, exc: Exception) -> JSONRes
 app.include_router(matches.router, tags=['matches'])
 app.include_router(stages.router, tags=['stages'])
 app.include_router(teams.router, tags=['teams'])
+app.include_router(courts.router, tags=['courts'])
 app.include_router(users.router, tags=['users'])

backend/bracket/config.py

@@ -66,7 +66,7 @@ class Config:
         env_file = 'demo.env'
 
 
-environment = Environment(os.getenv('ENVIRONMENT', 'CI'))
+environment = Environment(os.getenv('ENVIRONMENT', 'CI').upper())
 config: Config
 
 match environment:

backend/bracket/models/db/court.py

@@ -0,0 +1,23 @@
+from heliclockter import datetime_utc
+
+from bracket.models.db.shared import BaseModelORM
+
+
+class Court(BaseModelORM):
+    id: int | None = None
+    name: str
+    created: datetime_utc
+    tournament_id: int
+
+
+class CourtInDB(Court):
+    id: int
+
+
+class CourtBody(BaseModelORM):
+    name: str
+
+
+class CourtToInsert(CourtBody):
+    created: datetime_utc
+    tournament_id: int

backend/bracket/models/db/match.py

@@ -3,6 +3,7 @@
 from heliclockter import datetime_utc
 from pydantic import BaseModel
 
+from bracket.models.db.court import Court
 from bracket.models.db.shared import BaseModelORM
 from bracket.models.db.team import FullTeamWithPlayers, TeamWithPlayers
 from bracket.utils.types import assert_some
@@ -16,17 +17,18 @@ class Match(BaseModelORM):
     team2_id: int
     team1_score: int
     team2_score: int
-    label: str
+    court_id: int | None
 
 
 class UpcomingMatch(BaseModel):
     team1_id: int
     team2_id: int
 
 
-class MatchWithTeamDetails(Match):
+class MatchWithDetails(Match):
     team1: FullTeamWithPlayers
     team2: FullTeamWithPlayers
+    court: Court | None
 
     @property
     def teams(self) -> list[FullTeamWithPlayers]:
@@ -45,14 +47,14 @@ class MatchBody(BaseModelORM):
     round_id: int
     team1_score: int = 0
     team2_score: int = 0
-    label: str
+    court_id: int | None
 
 
 class MatchCreateBody(BaseModelORM):
     round_id: int
     team1_id: int
     team2_id: int
-    label: str
+    court_id: int | None
 
 
 class MatchToInsert(MatchCreateBody):

backend/bracket/models/db/round.py

@@ -4,7 +4,7 @@
 from heliclockter import datetime_utc
 from pydantic import root_validator, validator
 
-from bracket.models.db.match import Match, MatchWithTeamDetails
+from bracket.models.db.match import Match, MatchWithDetails
 from bracket.models.db.shared import BaseModelORM
 from bracket.models.db.stage import Stage, StageType
 from bracket.utils.types import assert_some
@@ -20,7 +20,7 @@ class Round(BaseModelORM):
 
 
 class RoundWithMatches(Round):
-    matches: list[MatchWithTeamDetails]
+    matches: list[MatchWithDetails]
 
     @validator('matches', pre=True)
     def handle_matches(values: list[Match]) -> list[Match]:  # type: ignore[misc]

backend/bracket/models/db/tournament.py

@@ -11,12 +11,14 @@ class Tournament(BaseModelORM):
     dashboard_public: bool
     logo_path: str | None
     players_can_be_in_multiple_teams: bool
+    auto_assign_courts: bool
 
 
 class TournamentUpdateBody(BaseModelORM):
     name: str
     dashboard_public: bool
     players_can_be_in_multiple_teams: bool
+    auto_assign_courts: bool
 
 
 class TournamentBody(TournamentUpdateBody):

backend/bracket/routes/courts.py

@@ -0,0 +1,86 @@
+from fastapi import APIRouter, Depends
+from heliclockter import datetime_utc
+
+from bracket.database import database
+from bracket.models.db.court import Court, CourtBody, CourtToInsert
+from bracket.models.db.user import UserPublic
+from bracket.routes.auth import user_authenticated_for_tournament
+from bracket.routes.models import CourtsResponse, SingleCourtResponse, SuccessResponse
+from bracket.schema import courts
+from bracket.sql.courts import get_all_courts_in_tournament, update_court
+from bracket.utils.db import fetch_one_parsed
+from bracket.utils.types import assert_some
+
+router = APIRouter()
+
+
+@router.get("/tournaments/{tournament_id}/courts", response_model=CourtsResponse)
+async def get_courts(
+    tournament_id: int,
+    _: UserPublic = Depends(user_authenticated_for_tournament),
+) -> CourtsResponse:
+    return CourtsResponse(data=await get_all_courts_in_tournament(tournament_id))
+
+
+@router.patch("/tournaments/{tournament_id}/courts/{court_id}", response_model=SingleCourtResponse)
+async def update_court_by_id(
+    tournament_id: int,
+    court_id: int,
+    court_body: CourtBody,
+    _: UserPublic = Depends(user_authenticated_for_tournament),
+) -> SingleCourtResponse:
+    await update_court(
+        tournament_id=tournament_id,
+        court_id=court_id,
+        court_body=court_body,
+    )
+    return SingleCourtResponse(
+        data=assert_some(
+            await fetch_one_parsed(
+                database,
+                Court,
+                courts.select().where(
+                    (courts.c.id == court_id) & (courts.c.tournament_id == tournament_id)
+                ),
+            )
+        )
+    )
+
+
+@router.delete("/tournaments/{tournament_id}/courts/{court_id}", response_model=SuccessResponse)
+async def delete_court(
+    tournament_id: int, court_id: int, _: UserPublic = Depends(user_authenticated_for_tournament)
+) -> SuccessResponse:
+    await database.execute(
+        query=courts.delete().where(
+            courts.c.id == court_id and courts.c.tournament_id == tournament_id
+        ),
+    )
+    return SuccessResponse()
+
+
+@router.post("/tournaments/{tournament_id}/courts", response_model=SingleCourtResponse)
+async def create_court(
+    court_body: CourtBody,
+    tournament_id: int,
+    _: UserPublic = Depends(user_authenticated_for_tournament),
+) -> SingleCourtResponse:
+    last_record_id = await database.execute(
+        query=courts.insert(),
+        values=CourtToInsert(
+            **court_body.dict(),
+            created=datetime_utc.now(),
+            tournament_id=tournament_id,
+        ).dict(),
+    )
+    return SingleCourtResponse(
+        data=assert_some(
+            await fetch_one_parsed(
+                database,
+                Court,
+                courts.select().where(
+                    courts.c.id == last_record_id and courts.c.tournament_id == tournament_id
+                ),
+            )
+        )
+    )

backend/bracket/routes/matches.py

@@ -1,6 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException
 
-from bracket.database import database
 from bracket.logic.elo import recalculate_elo_for_tournament_id
 from bracket.logic.scheduling.ladder_players_iter import get_possible_upcoming_matches_for_players
 from bracket.logic.scheduling.round_robin import get_possible_upcoming_matches_round_robin
@@ -11,8 +10,7 @@
 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
-from bracket.schema import matches
-from bracket.sql.matches import sql_create_match, sql_delete_match
+from bracket.sql.matches import sql_create_match, sql_delete_match, sql_update_match
 from bracket.sql.stages import get_stages_with_rounds_and_matches
 from bracket.utils.types import assert_some
 
@@ -87,9 +85,7 @@ async def update_match_by_id(
     _: UserPublic = Depends(user_authenticated_for_tournament),
     match: Match = Depends(match_dependency),
 ) -> SuccessResponse:
-    await database.execute(
-        query=matches.update().where(matches.c.id == match.id),
-        values=match_body.dict(),
-    )
+    assert match.id
+    await sql_update_match(match.id, match_body)
     await recalculate_elo_for_tournament_id(tournament_id)
     return SuccessResponse()

backend/bracket/routes/models.py

@@ -4,6 +4,7 @@
 from pydantic.generics import GenericModel
 
 from bracket.models.db.club import Club
+from bracket.models.db.court import Court
 from bracket.models.db.match import Match, SuggestedMatch
 from bracket.models.db.player import Player
 from bracket.models.db.round import Round, StageWithRounds
@@ -81,3 +82,11 @@ class UserPublicResponse(DataResponse[UserPublic]):
 
 class TokenResponse(DataResponse[Token]):
     pass
+
+
+class CourtsResponse(DataResponse[list[Court]]):
+    pass
+
+
+class SingleCourtResponse(DataResponse[Court]):
+    pass