Update old schemas and routes to use new ORM layout

Author: ChrisLovering

api/main.py

@@ -2,7 +2,7 @@
 from starlette.middleware.authentication import AuthenticationMiddleware
 
 from api.middleware import TokenAuthentication, on_auth_error
-from api.routers.old import old_routes_router
+from api.routers.v1 import v1_routes_router
 from api.settings import Server
 
 app = FastAPI(redoc_url="/", docs_url="/swagger")
@@ -13,4 +13,4 @@
     on_error=on_auth_error,
 )
 
-app.include_router(old_routes_router)
+app.include_router(v1_routes_router)

api/models/orm/infraction.py

@@ -17,7 +17,7 @@ class Infraction(Base):
     user_id: Mapped[int] = mapped_column(ForeignKey("users.user_id"))
     issued_in_jam_id: Mapped[int] = mapped_column(ForeignKey("jams.jam_id"))
     infraction_type: Mapped[InfractionType] = mapped_column(
-        Enum(*InfractionType.__args__, name="infraction_type_enum"),
+        Enum(*InfractionType.__args__, name="infraction_type"),
         nullable=False,
     )
     reason: Mapped[str] = mapped_column(String(), nullable=False)

api/models/schemas/old/infraction.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/models/schemas/utils.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, validator
+
+from api.models.orm.infraction import InfractionType
+from api.models.schemas.utils import discord_ids_must_be_snowflake
+
+
+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 InfractionCreate(InfractionBase):
+    """The expected fields to create a new infraction."""
+
+
+class Infraction(InfractionBase):
+    """A model representing an infraction."""
+
+    id: int
+
+    class Config:
+        """Sets ORM mode to true so that pydantic will validate the objects returned by SQLAlchemy."""
+
+        orm_mode = True

api/models/schemas/v1/infraction.py

@@ -1,22 +1,25 @@
 from pydantic import BaseModel
 
-from api.models.schemas.old import infraction, team, winner
+from api.models.schemas.v1 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/jam.py renamed to api/models/schemas/v1/jam.py

@@ -2,19 +2,19 @@
 
 from pydantic import BaseModel
 
-from api.models.schemas.old import user
+from api.models.schemas.v1 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
@@ -26,11 +26,11 @@ class Config:
         orm_mode = True
 
 
-class UserTeamResponse(BaseModel):
-    """Response model representing user and team relationship."""
+class UserTeam(BaseModel):
+    """A model representing user and team relationship."""
 
     user_id: int
-    team: TeamResponse
+    team: Team
     is_leader: bool
 
     class Config:

api/models/schemas/old/team.py renamed to api/models/schemas/v1/team.py

@@ -1,18 +1,6 @@
 from pydantic import BaseModel
 
-from api.models.schemas.old import infraction
-
-
-class User(BaseModel):
-    """A model representing a user for a codejam."""
-
-    user_id: int
-    is_leader: bool
-
-    class Config:
-        """Sets ORM mode to true so that pydantic will validate the objects returned by SQLAlchemy."""
-
-        orm_mode = True
+from api.models.schemas.v1 import infraction
 
 
 class ParticipationHistory(BaseModel):
@@ -23,18 +11,23 @@ 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."""
 
         orm_mode = True
 
 
-class UserResponse(BaseModel):
-    """Response model representing a user."""
+class UserBase(BaseModel):
+    """A Base model representing core data about a user."""
 
     id: int
+
+
+class User(UserBase):
+    """Response model representing everything about a user."""
+
     participation_history: list[ParticipationHistory]
 
     class Config:

api/models/schemas/old/user.py renamed to api/models/schemas/v1/user.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from api.routers.v1 import codejams, infractions, teams, users, winners
+
+v1_routes_router = APIRouter()
+v1_routes_router.include_router(codejams.router)
+v1_routes_router.include_router(infractions.router)
+v1_routes_router.include_router(teams.router)
+v1_routes_router.include_router(users.router)
+v1_routes_router.include_router(winners.router)

api/models/schemas/old/winner.py renamed to api/models/schemas/v1/winner.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.v1 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/__init__.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.v1.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()

api/routers/v1/__init__.py

@@ -5,17 +5,18 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
-from api.models import TeamResponse, User
-from api.models.orm import Jam, Team
+from api.models.orm import Jam
+from api.models.orm import Team as DbTeam
 from api.models.orm import User as DbUser
+from api.models.schemas.v1 import team, user
 from api.settings import DBSession
 
 router = APIRouter(prefix="/teams", tags=["teams"])
 
 
-async def ensure_team_exists(team_id: int, session: AsyncSession) -> Team:
+async def ensure_team_exists(team_id: int, session: AsyncSession) -> DbTeam:
     """Ensure that a team with the given ID exists and return it."""
-    teams = await session.execute(select(Team).where(Team.id == team_id))
+    teams = await session.execute(select(DbTeam).where(DbTeam.team_id == team_id))
     teams.unique()
 
     if not (team := teams.scalars().one_or_none()):
@@ -26,7 +27,7 @@ async def ensure_team_exists(team_id: int, session: AsyncSession) -> Team:
 
 async def ensure_user_exists(user_id: int, session: AsyncSession) -> DbUser:
     """Ensure that a user with the given ID exists and return it."""
-    users = await session.execute(select(DbUser).where(DbUser.id == user_id))
+    users = await session.execute(select(DbUser).where(DbUser.user_id == user_id))
     users.unique()
 
     if not (user := users.scalars().one_or_none()):
@@ -36,12 +37,12 @@ async def ensure_user_exists(user_id: int, session: AsyncSession) -> DbUser:
 
 
 @router.get("/")
-async def get_teams(session: DBSession, current_jam: bool = False) -> list[TeamResponse]:
+async def get_teams(session: DBSession, current_jam: bool = False) -> list[team.Team]:
     """Get every code jam team in the database."""
     if not current_jam:
-        teams = await session.execute(select(Team))
+        teams = await session.execute(select(DbTeam))
     else:
-        teams = await session.execute(select(Team).join_from(Team, Jam).where(Jam.ongoing == True))
+        teams = await session.execute(select(DbTeam).join_from(DbTeam, Jam).where(Jam.ongoing == True))
 
     teams.unique()
     return teams.scalars().all()
@@ -52,15 +53,17 @@ async def find_team_by_name(
     name: str,
     session: DBSession,
     jam_id: Optional[int] = None,
-) -> TeamResponse:
+) -> team.Team:
     """Get a specific code jam team by name."""
     if jam_id is None:
         teams = await session.execute(
-            select(Team).join(Team.jam).where((func.lower(Team.name) == func.lower(name)) & (Jam.ongoing == True))
+            select(DbTeam)
+            .join(DbTeam.__annotations__)
+            .where((func.lower(DbTeam.name) == func.lower(name)) & (Jam.ongoing == True))
         )
     else:
         teams = await session.execute(
-            select(Team).where((func.lower(Team.name) == func.lower(name)) & (Team.jam_id == jam_id))
+            select(DbTeam).where((func.lower(DbTeam.name) == func.lower(name)) & (DbTeam.jam_id == jam_id))
         )
 
     teams.unique()
@@ -72,20 +75,20 @@ async def find_team_by_name(
 
 
 @router.get("/{team_id}", responses={404: {"description": "Team could not be found."}})
-async def get_team(team_id: int, session: DBSession) -> TeamResponse:
+async def get_team(team_id: int, session: DBSession) -> team.Team:
     """Get a specific code jam team in the database by ID."""
     return await ensure_team_exists(team_id, session)
 
 
 @router.get("/{team_id}/users", responses={404: {"description": "Team could not be found."}})
-async def get_team_users(team_id: int, session: DBSession) -> list[User]:
+async def get_team_users(team_id: int, session: DBSession) -> list[user.User]:
     """Get the users of a specific code jam team in the database."""
     await ensure_team_exists(team_id, session)
 
-    team_users = await session.execute(select(TeamUser).where(TeamUser.team_id == team_id))
-    team_users.unique()
+    # team_users = await session.execute(select(TeamUser).where(TeamUser.team_id == team_id))
+    # team_users.unique()
 
-    return team_users.scalars().all()
+    # return team_users.scalars().all()
 
 
 @router.post(
@@ -97,24 +100,24 @@ async def get_team_users(team_id: int, session: DBSession) -> list[User]:
         400: {"description": "This user is already on the team."},
     },
 )
-async def add_user_to_team(team_id: int, user_id: int, session: DBSession, is_leader: bool = False) -> User:
+async def add_user_to_team(team_id: int, user_id: int, session: DBSession, is_leader: bool = False) -> user.User:
     """Add a user to a specific code jam team in the database."""
     await ensure_team_exists(team_id, session)
     await ensure_user_exists(user_id, session)
 
     team_users = await session.execute(
-        select(TeamUser).where((TeamUser.team_id == team_id) & (TeamUser.user_id == user_id))
+        # select(TeamUser).where((TeamUser.team_id == team_id) & (TeamUser.user_id == user_id))
     )
     team_users.unique()
 
     if team_users.scalars().one_or_none():
         raise HTTPException(status_code=400, detail="This user is already on this team.")
 
-    team_user = TeamUser(team_id=team_id, user_id=user_id, is_leader=is_leader)
-    session.add(team_user)
+    # team_user = TeamUser(team_id=team_id, user_id=user_id, is_leader=is_leader)
+    # session.add(team_user)
     await session.flush()
 
-    return team_user
+    # return team_user
 
 
 @router.delete(
@@ -136,7 +139,7 @@ async def remove_user_from_team(
     await ensure_team_exists(team_id, session)
 
     team_users = await session.execute(
-        select(TeamUser).where((TeamUser.team_id == team_id) & (TeamUser.user_id == user_id))
+        # select(TeamUser).where((TeamUser.team_id == team_id) & (TeamUser.user_id == user_id))
     )
     team_users.unique()
 

api/routers/old/codejams.py renamed to api/routers/v1/codejams.py

@@ -4,8 +4,9 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
-from api.models import UserResponse, UserTeamResponse
-from api.models.orm import Jam, User
+from api.models.orm import jam
+from api.models.orm import user as dbuser
+from api.models.schemas.v1 import team, user
 from api.settings import DBSession
 
 router = APIRouter(prefix="/users", tags=["users"])
@@ -16,7 +17,7 @@ async def get_user_data(session: AsyncSession, user_id: int) -> dict[str, Any]:
     user: dict[str, Any] = {"id": user_id}
     participation_history = []
 
-    user_teams = await session.execute(select(TeamUser).where(TeamUser.user_id == user_id))
+    user_teams = None  # await session.execute(select(TeamUser).where(TeamUser.user_id == user_id))
     user_teams.unique()
 
     for user_team in user_teams.scalars().all():
@@ -48,18 +49,18 @@ async def get_user_data(session: AsyncSession, user_id: int) -> dict[str, Any]:
 
 
 @router.get("/")
-async def get_users(session: DBSession) -> list[UserResponse]:
+async def get_users(session: DBSession) -> list[user.User]:
     """Get information about all the users stored in the database."""
-    users = await session.execute(select(User.id))
+    users = await session.execute(select(dbuser.User.id))
     users.unique()
 
     return [await get_user_data(session, user) for user in users.scalars().all()]
 
 
 @router.get("/{user_id}", responses={404: {"description": "User could not be found."}})
-async def get_user(user_id: int, session: DBSession) -> UserResponse:
+async def get_user(user_id: int, session: DBSession) -> user.User:
     """Get a specific user stored in the database by ID."""
-    user = await session.execute(select(User).where(User.id == user_id))
+    user = await session.execute(select(dbuser.User).where(dbuser.User.id == user_id))
     user.unique()
 
     if not user.scalars().one_or_none():
@@ -69,15 +70,15 @@ async def get_user(user_id: int, session: DBSession) -> UserResponse:
 
 
 @router.post("/{user_id}", responses={400: {"description": "User already exists."}})
-async def create_user(user_id: int, session: DBSession) -> UserResponse:
+async def create_user(user_id: int, session: DBSession) -> user.User:
     """Create a new user with the specified ID to the database."""
-    user = await session.execute(select(User).where(User.id == user_id))
+    user = await session.execute(select(dbuser.User).where(dbuser.User.id == user_id))
     user.unique()
 
     if user.scalars().one_or_none():
         raise HTTPException(status_code=400, detail="User with specified ID already exists.")
 
-    user = User(id=user_id)
+    user = dbuser.User(id=user_id)
     session.add(user)
     await session.flush()
 
@@ -94,20 +95,24 @@ async def create_user(user_id: int, session: DBSession) -> UserResponse:
         }
     },
 )
-async def get_current_team(user_id: int, session: DBSession) -> UserTeamResponse:
+async def get_current_team(user_id: int, session: DBSession) -> team.UserTeam:
     """Get a user's current team information."""
-    user = await session.execute(select(User).where(User.id == user_id))
+    user = await session.execute(select(dbuser.User).where(dbuser.User.user_id == user_id))
     user.unique()
 
     if not user.scalars().one_or_none():
         raise HTTPException(status_code=404, detail="User with specified ID could not be found.")
 
-    ongoing_jam = (await session.execute(select(Jam).where(Jam.ongoing == True))).unique().scalars().one_or_none()
+    ongoing_jam = (
+        (await session.execute(select(jam.Jam).where(jam.Jam.ongoing == True))).unique().scalars().one_or_none()
+    )
 
     if not ongoing_jam:
         raise HTTPException(status_code=404, detail="There is no ongoing codejam.")
 
-    user_teams = (await session.execute(select(TeamUser).where(TeamUser.user_id == user_id))).unique().scalars().all()
+    user_teams = (
+        None  # (await session.execute(select(TeamUser).where(TeamUser.user_id == user_id))).unique().scalars().all()
+    )
 
     current_team = None
     for user_team in user_teams:

api/routers/old/infractions.py renamed to api/routers/v1/infractions.py

@@ -0,0 +1,190 @@
+"""New ORM models
+
+Revision ID: 698fc7687b7f
+Revises: 3bb5cc4b5d48
+Create Date: 2023-03-25 22:25:55.765694
+
+"""
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "698fc7687b7f"
+down_revision = "3bb5cc4b5d48"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.drop_constraint("infractions_user_id_users_fk", "infractions", type_="foreignkey")
+    op.drop_constraint("infractions_jam_id_jams_fk", "infractions", type_="foreignkey")
+    op.drop_constraint("teams_jam_id_jams_fk", "teams", type_="foreignkey")
+    op.drop_constraint("winners_jam_id_jams_fk", "winners", type_="foreignkey")
+    op.drop_constraint("winners_user_id_users_fk", "winners", type_="foreignkey")
+    op.drop_constraint("team_has_user_team_id_teams_fk", "team_has_user", type_="foreignkey")
+    op.drop_constraint("team_has_user_user_id_users_fk", "team_has_user", type_="foreignkey")
+
+    op.drop_constraint("infractions_pk", "infractions")
+    op.add_column("infractions", sa.Column("infraction_id", sa.Integer(), autoincrement=True, primary_key=True))
+    op.create_primary_key("infractions_pk", "infractions", ["infraction_id"])
+    op.execute("UPDATE infractions SET infraction_id = id")
+    op.add_column("infractions", sa.Column("issued_in_jam_id", sa.Integer()))
+    op.execute("UPDATE infractions SET issued_in_jam_id = jam_id")
+    op.alter_column("infractions", "issued_in_jam_id", existing_type=sa.Integer(), nullable=False)
+
+    op.drop_constraint("jams_pk", "jams")
+    op.add_column("jams", sa.Column("jam_id", sa.Integer(), autoincrement=True, primary_key=True))
+    op.execute("UPDATE jams SET jam_id = id")
+    op.create_primary_key("jams_pk", "jams", ["jam_id"])
+
+    op.drop_constraint("teams_pk", "teams")
+    op.add_column("teams", sa.Column("team_id", sa.Integer(), autoincrement=True, primary_key=True))
+    op.execute("UPDATE teams SET team_id = id")
+    op.create_primary_key("teams_pk", "teams", ["team_id"])
+
+    op.drop_constraint("users_pk", "users")
+    op.add_column(
+        "users",
+        sa.Column("user_id", sa.BigInteger(), autoincrement=False, primary_key=True, server_default=sa.func.random()),
+    )
+    op.execute("UPDATE users SET user_id = id")
+    op.alter_column("users", "user_id", existing_type=sa.BigInteger(), server_default=None)
+    op.create_primary_key("users_pk", "users", ["user_id"])
+
+    op.drop_column("infractions", "id")
+    op.drop_column("infractions", "jam_id")
+    op.create_foreign_key(op.f("infractions_user_id_users_fk"), "infractions", "users", ["user_id"], ["user_id"])
+    op.create_foreign_key(
+        op.f("infractions_issued_in_jam_id_jams_fk"), "infractions", "jams", ["issued_in_jam_id"], ["jam_id"]
+    )
+
+    op.alter_column("infractions", "user_id", existing_type=sa.BIGINT(), nullable=False)
+    op.alter_column("infractions", "reason", existing_type=sa.TEXT(), type_=sa.String(), existing_nullable=False)
+
+    op.alter_column("jams", "name", existing_type=sa.TEXT(), type_=sa.String(), existing_nullable=False)
+    op.alter_column("jams", "ongoing", existing_type=sa.BOOLEAN(), server_default=None, existing_nullable=False)
+
+    op.drop_column("jams", "id")
+
+    op.add_column("teams", sa.Column("leader_id", sa.BigInteger()))
+    op.execute(
+        "UPDATE teams SET leader_id = tu.user_id from teams t join team_has_user tu USING(team_id) where tu.is_leader"
+    )
+    op.alter_column("teams", "leader_id", existing_type=sa.Integer(), nullable=False)
+
+    op.add_column("teams", sa.Column("winner", sa.Boolean(), nullable=True))
+    op.add_column("teams", sa.Column("first_place_winner", sa.Boolean(), nullable=True))
+    op.alter_column("teams", "name", existing_type=sa.TEXT(), type_=sa.String(), existing_nullable=False)
+    op.alter_column("teams", "discord_role_id", existing_type=sa.BIGINT())
+    op.alter_column("teams", "discord_channel_id", existing_type=sa.BIGINT())
+    op.create_foreign_key(op.f("teams_jam_id_jams_fk"), "teams", "jams", ["jam_id"], ["jam_id"])
+    op.drop_column("teams", "id")
+    op.execute(
+        "UPDATE teams "
+        "SET winner = true, "
+        "first_place_winner = w.first_place "
+        "from teams t "
+        "join winners w USING(jam_id)"
+    )
+
+    op.drop_column("users", "id")
+    op.create_foreign_key(op.f("teams_leader_id_users_fk"), "teams", "users", ["leader_id"], ["user_id"])
+
+    op.create_table(
+        "jam_specific_details",
+        sa.Column("jam_specific_detail_id", sa.Integer(), nullable=False),
+        sa.Column("user_id", sa.BigInteger(), nullable=False),
+        sa.Column("jam_id", sa.Integer(), nullable=False),
+        sa.Column(
+            "experience_level_git",
+            sa.Enum("beginner", "decent", "expierienced", "very_expierienced", name="experience_level_git_enum"),
+            nullable=False,
+        ),
+        sa.Column(
+            "experience_level_python",
+            sa.Enum("beginner", "decent", "expierienced", "very_expierienced", name="experience_level_python_enum"),
+            nullable=False,
+        ),
+        sa.Column("time_zone", sa.String(), nullable=False),
+        sa.Column("willing_to_lead", sa.Boolean(), nullable=False),
+        sa.ForeignKeyConstraint(["jam_id"], ["jams.jam_id"], name=op.f("jam_specific_details_jam_id_jams_fk")),
+        sa.ForeignKeyConstraint(["user_id"], ["users.user_id"], name=op.f("jam_specific_details_user_id_users_fk")),
+        sa.PrimaryKeyConstraint("jam_specific_detail_id", name=op.f("jam_specific_details_pk")),
+    )
+
+    op.create_table(
+        "team_has_users",
+        sa.Column("team_id", sa.Integer(), nullable=False),
+        sa.Column("user_id", sa.BigInteger(), nullable=False),
+        sa.ForeignKeyConstraint(["team_id"], ["teams.team_id"], name=op.f("team_has_users_team_id_teams_fk")),
+        sa.ForeignKeyConstraint(["user_id"], ["users.user_id"], name=op.f("team_has_users_user_id_users_fk")),
+        sa.PrimaryKeyConstraint("team_id", "user_id", name=op.f("team_has_users_pk")),
+    )
+    op.execute("INSERT INTO team_has_users (team_id, user_id) " "SELECT team_id, user_id " "FROM team_has_user")
+
+    op.drop_table("winners")
+    op.drop_table("team_has_user")
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column("users", sa.Column("id", sa.BIGINT(), autoincrement=False, nullable=False))
+    op.drop_column("users", "user_id")
+    op.add_column("teams", sa.Column("id", sa.INTEGER(), autoincrement=True, nullable=False))
+    op.drop_constraint(op.f("teams_jam_id_jams_fk"), "teams", type_="foreignkey")
+    op.drop_constraint(op.f("teams_leader_id_users_fk"), "teams", type_="foreignkey")
+    op.create_foreign_key("teams_jam_id_jams_fk", "teams", "jams", ["jam_id"], ["id"])
+    op.alter_column("teams", "discord_channel_id", existing_type=sa.BIGINT(), nullable=True)
+    op.alter_column("teams", "discord_role_id", existing_type=sa.BIGINT(), nullable=True)
+    op.alter_column("teams", "name", existing_type=sa.String(), type_=sa.TEXT(), existing_nullable=False)
+    op.drop_column("teams", "first_place_winner")
+    op.drop_column("teams", "winner")
+    op.drop_column("teams", "leader_id")
+    op.drop_column("teams", "team_id")
+    op.add_column(
+        "jams",
+        sa.Column(
+            "id",
+            sa.INTEGER(),
+            server_default=sa.text("nextval('jams_id_seq'::regclass)"),
+            autoincrement=True,
+            nullable=False,
+        ),
+    )
+    op.alter_column(
+        "jams", "ongoing", existing_type=sa.BOOLEAN(), server_default=sa.text("false"), existing_nullable=False
+    )
+    op.alter_column("jams", "name", existing_type=sa.String(), type_=sa.TEXT(), existing_nullable=False)
+    op.drop_column("jams", "jam_id")
+    op.add_column("infractions", sa.Column("jam_id", sa.INTEGER(), autoincrement=False, nullable=True))
+    op.add_column("infractions", sa.Column("id", sa.INTEGER(), autoincrement=True, nullable=False))
+    op.drop_constraint(op.f("infractions_issued_in_jam_id_jams_fk"), "infractions", type_="foreignkey")
+    op.drop_constraint(op.f("infractions_user_id_users_fk"), "infractions", type_="foreignkey")
+    op.create_foreign_key("infractions_jam_id_jams_fk", "infractions", "jams", ["jam_id"], ["id"])
+    op.create_foreign_key("infractions_user_id_users_fk", "infractions", "users", ["user_id"], ["id"])
+    op.alter_column("infractions", "reason", existing_type=sa.String(), type_=sa.TEXT(), existing_nullable=False)
+    op.alter_column("infractions", "user_id", existing_type=sa.BIGINT(), nullable=True)
+    op.drop_column("infractions", "issued_in_jam_id")
+    op.drop_column("infractions", "infraction_id")
+    op.create_table(
+        "team_has_user",
+        sa.Column("team_id", sa.INTEGER(), autoincrement=False, nullable=False),
+        sa.Column("user_id", sa.BIGINT(), autoincrement=False, nullable=False),
+        sa.Column("is_leader", sa.BOOLEAN(), autoincrement=False, nullable=False),
+        sa.ForeignKeyConstraint(["team_id"], ["teams.id"], name="team_has_user_team_id_teams_fk"),
+        sa.ForeignKeyConstraint(["user_id"], ["users.id"], name="team_has_user_user_id_users_fk"),
+        sa.PrimaryKeyConstraint("team_id", "user_id", name="team_has_user_pk"),
+    )
+    op.create_table(
+        "winners",
+        sa.Column("jam_id", sa.INTEGER(), autoincrement=False, nullable=False),
+        sa.Column("user_id", sa.BIGINT(), autoincrement=False, nullable=False),
+        sa.Column("first_place", sa.BOOLEAN(), autoincrement=False, nullable=False),
+        sa.ForeignKeyConstraint(["jam_id"], ["jams.id"], name="winners_jam_id_jams_fk"),
+        sa.ForeignKeyConstraint(["user_id"], ["users.id"], name="winners_user_id_users_fk"),
+        sa.PrimaryKeyConstraint("jam_id", "user_id", name="winners_pk"),
+    )
+    op.drop_table("team_has_users")
+    op.drop_table("jam_specific_details")
+    # ### end Alembic commands ###