group_run (#112)

* fixed crud error stuff

* group run

* group_run

* fixed stuff

server/crud/crud_errors.py

@@ -22,10 +22,20 @@ def read(db: Session, id: int) -> Errors | None:
             .first())
 
 
+def read_all(db: Session) -> [Errors]:
+    return db.query(Errors).all()
+
+
+def read_all_W_filter(db: Session, **kwargs) -> [Errors]:
+    return (db.query(Errors)
+            .filter_by(**kwargs)
+            .all())
+
+
 def update(db: Session, id: int, errors: ErrorsBase) -> Errors | None:
     db_errors: Errors | None = (db.query(Errors)
-                                        .filter(Errors.error_id == id)
-                                        .one_or_none())
+                                .filter(Errors.error_id == id)
+                                .one_or_none())
     if db_errors is None:
         return
 
@@ -39,8 +49,8 @@ def update(db: Session, id: int, errors: ErrorsBase) -> Errors | None:
 
 def delete(db: Session, id: int, errors: ErrorsBase) -> None:
     db_errors: Errors | None = (db.query(Errors)
-                                        .filter(Errors.error_id == id)
-                                        .one_or_none())
+                                .filter(Errors.error_id == id)
+                                .one_or_none())
     if db_errors is None:
         return
 

server/crud/crud_group_run.py

@@ -0,0 +1,55 @@
+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
+
+
+def create(db: Session, group_run: GroupRunBase) -> GroupRun:
+    db_group_run: GroupRun = GroupRun(**group_run.model_dump(exclude={'group_run_id'}))
+    db.add(db_group_run)
+    db.commit()
+    db.refresh(db_group_run)
+    return db_group_run
+
+
+def read(db: Session, id: int) -> GroupRun | None:
+    return (db.query(GroupRun)
+            .filter(GroupRun.group_run_id == id)
+            .first())
+
+
+def read_all(db: Session) -> [GroupRun]:
+    return db.query(GroupRun).all()
+
+
+def read_all_W_filter(db: Session, **kwargs) -> [GroupRun]:
+    return (db.query(GroupRun)
+            .filter_by(**kwargs)
+            .all())
+
+
+def update(db: Session, id: int, group_run: GroupRunBase) -> GroupRun | None:
+    db_group_run: GroupRun | None = (db.query(GroupRun)
+                                     .filter(GroupRun.group_run_id == id)
+                                     .one_or_none())
+    if db_group_run is None:
+        return
+
+    for key, value in group_run.model_dump().items():
+        setattr(db_group_run, key, value) if value is not None else None
+
+    db.commit()
+    db.refresh(db_group_run)
+    return db_group_run
+
+
+def delete(db: Session, id: int, group_run: GroupRunBase) -> None:
+    db_group_run: GroupRun | None = (db.query(GroupRun)
+                                     .filter(GroupRun.group_run_id == id)
+                                     .one_or_none())
+    if db_group_run is None:
+        return
+
+    db.delete(db_group_run)
+    db.commit()

server/crud/crud_submission.py

@@ -28,6 +28,12 @@ def read_all_by_team_id(db: Session, team_uuid: uuid) -> list[Type[Submission]]:
             .all())
 
 
+def read_all_W_filter(db: Session, **kwargs) -> [Submission]:
+    return (db.query(Submission)
+            .filter_by(**kwargs)
+            .all())
+
+
 def update(db: Session, id: int, submission: SubmissionWTeam) -> Submission | None:
     db_submission: Submission | None = (db.query(Submission)
                                         .filter(and_(Submission.submission_id == id,

server/models/group_run.py

@@ -4,7 +4,6 @@
 from sqlalchemy.orm import relationship, Mapped, mapped_column
 
 from .base import Base
-from .run import Run
 
 
 class GroupRun(Base):
@@ -15,4 +14,4 @@ class GroupRun(Base):
     launcher_version: Mapped[str] = mapped_column(String(10), nullable=False)
     runs_per_client: Mapped[int] = mapped_column(Integer(), nullable=False)
     is_finished: Mapped[bool] = mapped_column(Boolean(), default=False, nullable=False)
-    runs: Mapped[list[Run]] = relationship(back_populates='group_run')
+    runs: Mapped[list['Run']] = relationship(back_populates='group_run')

server/schemas/errors_schema.py

@@ -13,6 +13,14 @@ class Config:
         from_attributes = True
 
 
+class ErrorsWRun(ErrorsBase):
+    run: run_schema.RunBase
+
+
+class ErrorsWSubmission(ErrorsBase):
+    submission: submission_schema.SubmissionBase
+
+
 class ErrorsSchema(ErrorsBase):
     run: run_schema.RunBase
     submission: submission_schema.SubmissionBase

server/schemas/run_schema.py

@@ -18,5 +18,5 @@ class Config:
 
 class RunSchema(RunBase):
     group_run: group_run_schema.GroupRunBase
-    errors: errors_schema.ErrorsBase
+    errors: errors_schema.ErrorsWSubmission
     turn_tables: list[turn_table_schema.TurnTableBase] = []

server/schemas/submission_schema.py

@@ -18,4 +18,4 @@ class SubmissionWTeam(SubmissionBase):
 
 class SubmissionSchema(SubmissionWTeam):
     team: team_schema.TeamBase
-    error: errors_schema.ErrorsBase
+    error: errors_schema.ErrorsWRun