Update database models for new requirements

api/__init__.py

@@ -1,12 +1,12 @@
 import logging
 
-from api import constants
+from api import settings
 
 format_string = "[%(asctime)s] [%(process)d] [%(levelname)s] %(name)s - %(message)s"
 date_format_string = "%Y-%m-%d %H:%M:%S %z"
 
 logging.basicConfig(
-    format=format_string, datefmt=date_format_string, level=getattr(logging, constants.Config.LOG_LEVEL.upper())
+    format=format_string, datefmt=date_format_string, level=getattr(logging, settings.Server.LOG_LEVEL.upper())
 )
 
 logging.getLogger().info("Logging initialization complete")

api/main.py

@@ -1,20 +1,16 @@
 from fastapi import FastAPI
 from starlette.middleware.authentication import AuthenticationMiddleware
 
-from api.constants import Config
 from api.middleware import TokenAuthentication, on_auth_error
-from api.routers import codejams, infractions, teams, users, winners
+from api.routers.v1 import v1_routes_router
+from api.settings import Server
 
 app = FastAPI(redoc_url="/", docs_url="/swagger")
 
 app.add_middleware(
     AuthenticationMiddleware,
-    backend=TokenAuthentication(token=Config.TOKEN),
+    backend=TokenAuthentication(token=Server.API_TOKEN.get_secret_value()),
     on_error=on_auth_error,
 )
 
-app.include_router(codejams.router)
-app.include_router(infractions.router)
-app.include_router(teams.router)
-app.include_router(users.router)
-app.include_router(winners.router)
+app.include_router(v1_routes_router)

api/middleware.py

@@ -3,7 +3,7 @@
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 
-from api.constants import Config
+from api.settings import Server
 
 NO_AUTHORIZATION_HEADER = "no `Authorization` header in request."
 INVALID_CREDENTIALS = "invalid credentials."
@@ -17,7 +17,7 @@ def __init__(self, token: str) -> None:
 
     async def authenticate(self, request: Request) -> tuple[AuthCredentials, SimpleUser]:
         """Authenticate the request based on the Authorization header."""
-        if Config.DEBUG:
+        if Server.DEBUG:
             credentials = AuthCredentials(scopes=["debug"])
             user = SimpleUser(username="api_client")
             return credentials, user

api/models/orm/__init__.py

@@ -0,0 +1,6 @@
+"""Database models."""
+
+from .infraction import Infraction  # noqa: F401
+from .jam import Jam  # noqa: F401
+from .team import Team  # noqa: F401
+from .user import JamSpecificDetail, User  # noqa: F401

api/models/orm/base.py

@@ -0,0 +1,25 @@
+"""The base classes for ORM models."""
+
+from pydantic import BaseModel
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.schema import MetaData
+
+# See https://docs.sqlalchemy.org/en/14/core/constraints.html#constraint-naming-conventions
+NAMING_CONVENTIONS = {
+    "ix": "%(column_0_label)s_ix",
+    "uq": "%(table_name)s_%(column_0_name)s_uq",
+    "ck": "%(table_name)s_%(constraint_name)s_ck",
+    "fk": "%(table_name)s_%(column_0_name)s_%(referred_table_name)s_fk",
+    "pk": "%(table_name)s_pk",
+}
+
+
+class Base(DeclarativeBase):
+    """Classes that inherit this class will be automatically mapped using declarative mapping."""
+
+    metadata = MetaData(naming_convention=NAMING_CONVENTIONS)
+
+    def patch_from_pydantic(self, pydantic_model: BaseModel) -> None:
+        """Patch this model using the given pydantic model, unspecified attributes remain the same."""
+        for key, value in pydantic_model.dict(exclude_unset=True).items():
+            setattr(self, key, value)

api/models/orm/infraction.py

@@ -0,0 +1,23 @@
+from typing import Literal
+
+from sqlalchemy import Enum, ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from api.models.orm.base import Base
+
+InfractionType = Literal["note", "ban", "warning"]
+
+
+class Infraction(Base):
+    """An infraction that was applied to a user."""
+
+    __tablename__ = "infractions"
+
+    infraction_id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    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"),
+        nullable=False,
+    )
+    reason: Mapped[str] = mapped_column(String(), nullable=False)