Merge pull request #116 from JeanAEckelberg/restructure-database

Restructure database

server/crud/crud_group_run.py

@@ -1,8 +1,7 @@
 from sqlalchemy.orm import Session
-from sqlalchemy import and_
 
 from server.models.group_run import GroupRun
-from server.schemas.group_run_schema import GroupRunSchema, GroupRunBase
+from server.schemas.group_run.group_run_schema import GroupRunBase
 
 
 def create(db: Session, group_run: GroupRunBase) -> GroupRun:

server/crud/crud_group_teams.py

@@ -0,0 +1,54 @@
+from sqlalchemy.orm import Session
+
+from server.models.group_teams import GroupTeams
+from server.schemas.group_teams.group_teams_schema import GroupTeamsBase
+
+
+def create(db: Session, group_teams: GroupTeamsBase) -> GroupTeams:
+    db_group_teams: GroupTeams = GroupTeams(**group_teams.model_dump(exclude={'group_teams_id'}))
+    db.add(db_group_teams)
+    db.commit()
+    db.refresh(db_group_teams)
+    return db_group_teams
+
+
+def read(db: Session, id: int) -> GroupTeams | None:
+    return (db.query(GroupTeams)
+            .filter(GroupTeams.group_teams_id == id)
+            .first())
+
+
+def read_all(db: Session) -> [GroupTeams]:
+    return db.query(GroupTeams).all()
+
+
+def read_all_W_filter(db: Session, **kwargs) -> [GroupTeams]:
+    return (db.query(GroupTeams)
+            .filter_by(**kwargs)
+            .all())
+
+
+def update(db: Session, id: int, group_teams: GroupTeamsBase) -> GroupTeams | None:
+    db_group_teams: GroupTeams | None = (db.query(GroupTeams)
+                                         .filter(GroupTeams.group_teams_id == id)
+                                         .one_or_none())
+    if db_group_teams is None:
+        return
+
+    for key, value in group_teams.model_dump().items():
+        setattr(db_group_teams, key, value) if value is not None else None
+
+    db.commit()
+    db.refresh(db_group_teams)
+    return db_group_teams
+
+
+def delete(db: Session, id: int, group_teams: GroupTeamsBase) -> None:
+    db_group_teams: GroupTeams | None = (db.query(GroupTeams)
+                                         .filter(GroupTeams.group_teams_id == id)
+                                         .one_or_none())
+    if db_group_teams is None:
+        return
+
+    db.delete(db_group_teams)
+    db.commit()

server/crud/crud_run.py

@@ -1,8 +1,7 @@
 from sqlalchemy.orm import Session
-from sqlalchemy import and_
 
 from server.models.run import Run
-from server.schemas.run_schema import RunBase, RunSchema
+from server.schemas.run.run_schema import RunBase
 
 
 def create(db: Session, run: RunBase) -> Run:

server/crud/crud_submission.py

@@ -5,7 +5,7 @@
 from sqlalchemy import and_
 
 from server.models.submission import Submission
-from server.schemas.submission_schema import SubmissionBase, SubmissionWTeam, SubmissionSchema
+from server.schemas.submission.submission_w_team import SubmissionWTeam
 
 
 def create(db: Session, submission: SubmissionWTeam) -> Submission:
@@ -24,7 +24,7 @@ def read(db: Session, id: int) -> Submission | None:
 
 def read_all_by_team_id(db: Session, team_uuid: uuid) -> list[Type[Submission]]:
     return (db.query(Submission)
-            .filter(Submission.team_id_uuid == team_uuid)
+            .filter(Submission.team_uuid == team_uuid)
             .all())
 
 
@@ -37,7 +37,7 @@ def read_all_W_filter(db: Session, **kwargs) -> [Submission]:
 def update(db: Session, id: int, submission: SubmissionWTeam) -> Submission | None:
     db_submission: Submission | None = (db.query(Submission)
                                         .filter(and_(Submission.submission_id == id,
-                                                     Submission.team_id_uuid == submission.team_id_uuid))
+                                                     Submission.team_uuid == submission.team_id_uuid))
                                         .one_or_none())
     if db_submission is None:
         return
@@ -53,7 +53,7 @@ def update(db: Session, id: int, submission: SubmissionWTeam) -> Submission | No
 def delete(db: Session, id: int, submission: SubmissionWTeam) -> None:
     db_submission: Submission | None = (db.query(Submission)
                                         .filter(and_(Submission.submission_id == id,
-                                                     Submission.team_id_uuid == submission.team_id_uuid))
+                                                     Submission.team_uuid == submission.team_id_uuid))
                                         .one_or_none())
     if db_submission is None:
         return

server/crud/crud_submission_run_info.py

@@ -0,0 +1,55 @@
+from sqlalchemy.orm import Session
+
+from server.models.submission_run_info import SubmissionRunInfo
+from server.schemas.submission_run_info.submission_run_info_schema import SubmissionRunInfoBase
+
+
+def create(db: Session, submission_run_info: SubmissionRunInfoBase) -> SubmissionRunInfo:
+    db_submission_run_info: SubmissionRunInfo = SubmissionRunInfo(**submission_run_info.model_dump(
+        exclude={'submission_run_info_id'}))
+    db.add(db_submission_run_info)
+    db.commit()
+    db.refresh(db_submission_run_info)
+    return db_submission_run_info
+
+
+def read(db: Session, id: int) -> SubmissionRunInfo | None:
+    return (db.query(SubmissionRunInfo)
+            .filter(SubmissionRunInfo.submission_run_info_id == id)
+            .first())
+
+
+def read_all(db: Session) -> [SubmissionRunInfo]:
+    return db.query(SubmissionRunInfo).all()
+
+
+def read_all_W_filter(db: Session, **kwargs) -> [SubmissionRunInfo]:
+    return (db.query(SubmissionRunInfo)
+            .filter_by(**kwargs)
+            .all())
+
+
+def update(db: Session, id: int, submission_run_info: SubmissionRunInfoBase) -> SubmissionRunInfo | None:
+    db_submission_run_info: SubmissionRunInfo | None = (db.query(SubmissionRunInfo)
+                                                        .filter(SubmissionRunInfo.submission_run_info_id == id)
+                                                        .one_or_none())
+    if db_submission_run_info is None:
+        return
+
+    for key, value in submission_run_info.model_dump().items():
+        setattr(db_submission_run_info, key, value) if value is not None else None
+
+    db.commit()
+    db.refresh(db_submission_run_info)
+    return db_submission_run_info
+
+
+def delete(db: Session, id: int, submission_run_info: SubmissionRunInfoBase) -> None:
+    db_submission_run_info: SubmissionRunInfo | None = (db.query(SubmissionRunInfo)
+                                                        .filter(SubmissionRunInfo.submission_run_info_id == id)
+                                                        .one_or_none())
+    if db_submission_run_info is None:
+        return
+
+    db.delete(db_submission_run_info)
+    db.commit()

server/crud/crud_team.py

@@ -0,0 +1,54 @@
+from sqlalchemy.orm import Session
+
+from server.models.team import Team
+from server.schemas.team.team_schema import TeamBase
+
+
+def create(db: Session, team: TeamBase) -> Team:
+    db_team: Team = Team(**team.model_dump(exclude={'team_id'}))
+    db.add(db_team)
+    db.commit()
+    db.refresh(db_team)
+    return db_team
+
+
+def read(db: Session, id: int) -> Team | None:
+    return (db.query(Team)
+            .filter(Team.team_uuid == id)
+            .first())
+
+
+def read_all(db: Session) -> [Team]:
+    return db.query(Team).all()
+
+
+def read_all_W_filter(db: Session, **kwargs) -> [Team]:
+    return (db.query(Team)
+            .filter_by(**kwargs)
+            .all())
+
+
+def update(db: Session, id: int, team: TeamBase) -> Team | None:
+    db_team: Team | None = (db.query(Team)
+                            .filter(Team.team_uuid == id)
+                            .one_or_none())
+    if db_team is None:
+        return
+
+    for key, value in team.model_dump().items():
+        setattr(db_team, key, value) if value is not None else None
+
+    db.commit()
+    db.refresh(db_team)
+    return db_team
+
+
+def delete(db: Session, id: int, team: TeamBase) -> None:
+    db_team: Team | None = (db.query(Team)
+                                        .filter(Team.team_uuid == id)
+                                        .one_or_none())
+    if db_team is None:
+        return
+
+    db.delete(db_team)
+    db.commit()

server/crud/crud_team_type.py

@@ -1,8 +1,7 @@
 from sqlalchemy.orm import Session
-from sqlalchemy import and_
 
 from server.models.team_type import TeamType
-from server.schemas.team_type_schema import TeamTypeBase, TeamTypeSchema
+from server.schemas.team_type.team_type_schema import TeamTypeBase
 
 
 def create(db: Session, team_type: TeamTypeBase) -> TeamType:

server/crud/crud_turn_table.py

@@ -1,8 +1,7 @@
 from sqlalchemy.orm import Session
-from sqlalchemy import and_
 
 from server.models.turn_table import TurnTable
-from server.schemas.turn_table_schema import TurnTableBase, TurnTableSchema
+from server.schemas.turn_table.turn_table_schema import TurnTableBase
 
 
 def create(db: Session, turn_table: TurnTableBase) -> TurnTable:
@@ -12,6 +11,7 @@ def create(db: Session, turn_table: TurnTableBase) -> TurnTable:
     db.refresh(db_turn_table)
     return db_turn_table
 
+
 def create_all(db: Session, turn_tables: [TurnTableBase]) -> None:
     inserts: list[TurnTable] = [TurnTable(**turn_table.model_dump(exclude={'turn_id'})) for turn_table in turn_tables]
     db.add_all(inserts)

server/crud/crud_university.py

@@ -1,8 +1,7 @@
 from sqlalchemy.orm import Session
-from sqlalchemy import and_
 
 from server.models.university import University
-from server.schemas.university_schema import UniversityBase, UniversitySchema
+from server.schemas.university.university_schema import UniversityBase
 
 
 def create(db: Session, university: UniversityBase) -> University: