Update old schemas and routes to use new ORM layout

Author: ChrisLovering

api/models/schemas/old/infraction.py

@@ -1,27 +1,27 @@
-from enum import Enum
+from pydantic import BaseModel, validator
 
-from pydantic import BaseModel
+from api.models.orm.infraction import InfractionType
+from api.models.schemas.utils import discord_ids_must_be_snowflake
 
 
-class InfractionType(str, Enum):
-    """An enumeration of codejam infraction types."""
-
-    note = "note"
-    ban = "ban"
-    warning = "warning"
-
-
-class Infraction(BaseModel):
-    """A model representing an infraction."""
+class InfractionBase(BaseModel):
+    """Base model for all infraction types."""
 
     user_id: int
     jam_id: int
     reason: str
     infraction_type: InfractionType
 
+    # validators
+    _ensure_valid_discord_id = validator("user_id", allow_reuse=True)(discord_ids_must_be_snowflake)
 
-class InfractionResponse(Infraction):
-    """Response model representing an infraction."""
+
+class InfractionCreate(InfractionBase):
+    """The expected fields to create a new infraction."""
+
+
+class Infraction(InfractionBase):
+    """A model representing an infraction."""
 
     id: int
 

api/models/schemas/old/jam.py

@@ -3,20 +3,23 @@
 from api.models.schemas.old import infraction, team, winner
 
 
-class CodeJam(BaseModel):
-    """A model representing a codejam."""
+class CodeJamBase(BaseModel):
+    """A Base model representing a codejam."""
 
     name: str
     teams: list[team.Team]
     ongoing: bool = False
 
 
-class CodeJamResponse(CodeJam):
+class CodeJamCreate(CodeJamBase):
+    """The expected fields to create a new Code Jam."""
+
+
+class CodeJam(CodeJamBase):
     """Response model representing a code jam."""
 
     id: int
-    teams: list[team.TeamResponse]
-    infractions: list[infraction.InfractionResponse]
+    infractions: list[infraction.Infraction]
     winners: list[winner.Winner]
 
     class Config:

api/models/schemas/old/team.py

@@ -5,16 +5,16 @@
 from api.models.schemas.old import user
 
 
-class Team(BaseModel):
-    """A model representing a team for a codejam."""
+class TeamBase(BaseModel):
+    """A Base model representing a team for a codejam."""
 
     name: str
     users: list[user.User]
     discord_role_id: Optional[int] = None
     discord_channel_id: Optional[int] = None
 
 
-class TeamResponse(Team):
+class Team(TeamBase):
     """Response model representing a team."""
 
     id: int
@@ -24,16 +24,3 @@ class Config:
         """Sets ORM mode to true so that pydantic will validate the objects returned by SQLAlchemy."""
 
         orm_mode = True
-
-
-class UserTeamResponse(BaseModel):
-    """Response model representing user and team relationship."""
-
-    user_id: int
-    team: TeamResponse
-    is_leader: bool
-
-    class Config:
-        """Sets ORM mode to true so that pydantic will validate the objects returned by SQLAlchemy."""
-
-        orm_mode = True

api/models/schemas/old/user.py

@@ -23,7 +23,7 @@ class ParticipationHistory(BaseModel):
     first_place: bool
     team_id: int
     is_leader: bool
-    infractions: list[infraction.InfractionResponse]
+    infractions: list[infraction.Infraction]
 
     class Config:
         """Sets ORM mode to true so that pydantic will validate the objects returned by SQLAlchemy."""

api/models/schemas/utils.py

@@ -0,0 +1,5 @@
+def discord_ids_must_be_snowflake(field_to_check: int) -> int:
+    """Ensure the ids are valid Discord snowflakes."""
+    if field_to_check and field_to_check.bit_length() > 64:
+        raise ValueError("Field must fit within a 64 bit int.")
+    return field_to_check

api/routers/old/__init__.py

@@ -1,10 +1,10 @@
 from fastapi import APIRouter
 
-from api.routers.old import codejams, infractions, teams, users, winners
+from api.routers.old import codejams  # , infractions, teams, users, winners
 
 old_routes_router = APIRouter()
 old_routes_router.include_router(codejams.router)
-old_routes_router.include_router(infractions.router)
-old_routes_router.include_router(teams.router)
-old_routes_router.include_router(users.router)
-old_routes_router.include_router(winners.router)
+# old_routes_router.include_router(infractions.router)
+# old_routes_router.include_router(teams.router)
+# old_routes_router.include_router(users.router)
+# old_routes_router.include_router(winners.router)

api/routers/old/codejams.py

@@ -4,17 +4,17 @@
 from sqlalchemy import desc, update
 from sqlalchemy.future import select
 
-from api.models import CodeJam, CodeJamResponse
 from api.models.orm import Jam, Team, User
+from api.models.schemas.old import jam
 from api.settings import DBSession
 
 router = APIRouter(prefix="/codejams", tags=["codejams"])
 
 
 @router.get("/")
-async def get_codejams(session: DBSession) -> list[CodeJamResponse]:
+async def get_codejams(session: DBSession) -> list[jam.CodeJam]:
     """Get all the codejams stored in the database."""
-    codejams = await session.execute(select(Jam).order_by(desc(Jam.id)))
+    codejams = await session.execute(select(Jam).order_by(desc(Jam.jam_id)))
     codejams.unique()
 
     return codejams.scalars().all()
@@ -24,7 +24,7 @@ async def get_codejams(session: DBSession) -> list[CodeJamResponse]:
     "/{codejam_id}",
     responses={404: {"description": "CodeJam could not be found or there is no ongoing code jam."}},
 )
-async def get_codejam(codejam_id: int, session: DBSession) -> CodeJamResponse:
+async def get_codejam(codejam_id: int, session: DBSession) -> jam.CodeJam:
     """
     Get a specific codejam stored in the database by ID.
 
@@ -39,7 +39,7 @@ async def get_codejam(codejam_id: int, session: DBSession) -> CodeJamResponse:
         # With the current implementation, there should only be one ongoing codejam.
         return ongoing_jams[0]
 
-    jam_result = await session.execute(select(Jam).where(Jam.id == codejam_id))
+    jam_result = await session.execute(select(Jam).where(Jam.jam_id == codejam_id))
     jam_result.unique()
 
     if not (jam := jam_result.scalars().one_or_none()):
@@ -54,23 +54,23 @@ async def modify_codejam(
     session: DBSession,
     name: Optional[str] = None,
     ongoing: Optional[bool] = None,
-) -> CodeJamResponse:
+) -> jam.CodeJam:
     """Modify the specified codejam to change its name and/or whether it's the ongoing code jam."""
-    codejam = await session.execute(select(Jam).where(Jam.id == codejam_id))
+    codejam = await session.execute(select(Jam).where(Jam.jam_id == codejam_id))
     codejam.unique()
 
     if not codejam.scalars().one_or_none():
         raise HTTPException(status_code=404, detail="Code Jam with specified ID does not exist.")
 
     if name is not None:
-        await session.execute(update(Jam).where(Jam.id == codejam_id).values(name=name))
+        await session.execute(update(Jam).where(Jam.jam_id == codejam_id).values(name=name))
 
     if ongoing is not None:
         # Make sure no other Jams are ongoing, and set the specified codejam to ongoing.
         await session.execute(update(Jam).where(Jam.ongoing == True).values(ongoing=False))
-        await session.execute(update(Jam).where(Jam.id == codejam_id).values(ongoing=True))
+        await session.execute(update(Jam).where(Jam.jam_id == codejam_id).values(ongoing=True))
 
-    jam_result = await session.execute(select(Jam).where(Jam.id == codejam_id))
+    jam_result = await session.execute(select(Jam).where(Jam.jam_id == codejam_id))
     jam_result.unique()
 
     jam = jam_result.scalars().one()
@@ -79,7 +79,7 @@ async def modify_codejam(
 
 
 @router.post("/")
-async def create_codejam(codejam: CodeJam, session: DBSession) -> CodeJamResponse:
+async def create_codejam(codejam: jam.CodeJamCreate, session: DBSession) -> jam.CodeJam:
     """
     Create a new codejam and get back the one just created.
 
@@ -94,34 +94,37 @@ async def create_codejam(codejam: CodeJam, session: DBSession) -> CodeJamRespons
     await session.flush()
 
     for raw_team in codejam.teams:
-        team = Team(
-            jam_id=jam.id,
-            name=raw_team.name,
-            discord_role_id=raw_team.discord_role_id,
-            discord_channel_id=raw_team.discord_channel_id,
-        )
-        session.add(team)
-        # Flush here to receive team ID
-        await session.flush()
-
+        created_users = []
         for raw_user in raw_team.users:
+            if raw_user.is_leader:
+                team_leader_id = raw_user.user_id
             if (
-                not (await session.execute(select(User).where(User.id == raw_user.user_id)))
+                not (await session.execute(select(User).where(User.user_id == raw_user.user_id)))
                 .unique()
                 .scalars()
                 .one_or_none()
             ):
                 user = User(id=raw_user.user_id)
+                created_users.append(user)
                 session.add(user)
 
-            team_user = TeamUser(team_id=team.id, user_id=raw_user.user_id, is_leader=raw_user.is_leader)
-            session.add(team_user)
+        team = Team(
+            jam_id=jam.jam_id,
+            name=raw_team.name,
+            discord_role_id=raw_team.discord_role_id,
+            discord_channel_id=raw_team.discord_channel_id,
+            team_leader_id=team_leader_id,
+        )
+        team.users = created_users
+        session.add(team)
+        # Flush here to receive team ID
+        await session.flush()
 
     await session.flush()
 
     # Pydantic, what is synchronous, may attempt to call async methods if current jam
     # object is returned. To avoid this, fetch all data here, in async context.
-    jam_result = await session.execute(select(Jam).where(Jam.id == jam.id))
+    jam_result = await session.execute(select(Jam).where(Jam.jam_id == jam.jam_id))
     jam_result.unique()
 
     jam = jam_result.scalars().one()

api/routers/old/infractions.py

@@ -1,16 +1,16 @@
 from fastapi import APIRouter, HTTPException
 from sqlalchemy.future import select
 
-from api.models import Infraction, InfractionResponse
 from api.models.orm import Infraction as DbInfraction
 from api.models.orm import Jam, User
+from api.models.schemas.old.infraction import Infraction, InfractionCreate
 from api.settings import DBSession
 
 router = APIRouter(prefix="/infractions", tags=["infractions"])
 
 
 @router.get("/")
-async def get_infractions(session: DBSession) -> list[InfractionResponse]:
+async def get_infractions(session: DBSession) -> list[Infraction]:
     """Get every infraction stored in the database."""
     infractions = await session.execute(select(DbInfraction))
     infractions.unique()
@@ -22,9 +22,9 @@ async def get_infractions(session: DBSession) -> list[InfractionResponse]:
     "/{infraction_id}",
     responses={404: {"description": "Infraction could not be found."}},
 )
-async def get_infraction(infraction_id: int, session: DBSession) -> InfractionResponse:
+async def get_infraction(infraction_id: int, session: DBSession) -> Infraction:
     """Get a specific infraction stored in the database by ID."""
-    infraction_result = await session.execute(select(DbInfraction).where(DbInfraction.id == infraction_id))
+    infraction_result = await session.execute(select(DbInfraction).where(DbInfraction.infraction_id == infraction_id))
     infraction_result.unique()
 
     if not (infraction := infraction_result.scalars().one_or_none()):
@@ -38,16 +38,18 @@ async def get_infraction(infraction_id: int, session: DBSession) -> InfractionRe
     responses={404: {"Description": "Jam ID or User ID could not be found."}},
 )
 async def create_infraction(
-    infraction: Infraction,
+    infraction: InfractionCreate,
     session: DBSession,
-) -> InfractionResponse:
+) -> Infraction:
     """Add an infraction for a user to the database."""
-    jam_id = (await session.execute(select(Jam.id).where(Jam.id == infraction.jam_id))).scalars().one_or_none()
+    jam_id = (await session.execute(select(Jam.jam_id).where(Jam.jam_id == infraction.jam_id))).scalars().one_or_none()
 
     if jam_id is None:
         raise HTTPException(404, "Jam with specified ID could not be found.")
 
-    user_id = (await session.execute(select(User.id).where(User.id == infraction.user_id))).scalars().one_or_none()
+    user_id = (
+        (await session.execute(select(User.user_id).where(User.user_id == infraction.user_id))).scalars().one_or_none()
+    )
 
     if user_id is None:
         raise HTTPException(404, "User with specified ID could not be found.")
@@ -58,7 +60,7 @@ async def create_infraction(
     session.add(infraction)
     await session.flush()
 
-    infraction_result = await session.execute(select(DbInfraction).where(DbInfraction.id == infraction.id))
+    infraction_result = await session.execute(select(DbInfraction).where(DbInfraction.infraction_id == infraction.id))
     infraction_result.unique()
 
     return infraction_result.scalars().one()