Refactor training day submissions to use managing contest participation

cms/db/submission.py

@@ -39,7 +39,7 @@
 
 from cmscommon.datetime import make_datetime
 from . import Filename, FilenameSchema, Digest, Base, Participation, Task, \
-    Dataset, Testcase
+    Dataset, Testcase, TrainingDay
 
 
 class Submission(Base):
@@ -85,6 +85,21 @@ class Submission(Base):
         Task,
         back_populates="submissions")
 
+    # Training day (id and object) that this submission was submitted via.
+    # If None, the submission was made directly to the task archive or
+    # via a regular contest (not a training day).
+    # When set, the submission was made via a training day's contest interface,
+    # but the participation points to the managing contest's participation.
+    training_day_id: int | None = Column(
+        Integer,
+        ForeignKey(TrainingDay.id,
+                   onupdate="CASCADE", ondelete="SET NULL"),
+        nullable=True,
+        index=True)
+    training_day: TrainingDay | None = relationship(
+        TrainingDay,
+        back_populates="submissions")
+
     # Time of the submission.
     timestamp: datetime = Column(
         DateTime,

cms/db/training_day.py

@@ -23,14 +23,41 @@
 
 import typing
 
-from sqlalchemy.orm import relationship
+from sqlalchemy.orm import relationship, Session
 from sqlalchemy.schema import Column, ForeignKey, UniqueConstraint
 from sqlalchemy.types import Integer
 
 from . import Base
 
 if typing.TYPE_CHECKING:
-    from . import Contest, TrainingProgram, Task, TrainingDayGroup
+    from . import Contest, TrainingProgram, Task, TrainingDayGroup, Submission, Participation, User
+
+
+def get_managing_participation(
+    session: Session,
+    training_day: "TrainingDay",
+    user: "User",
+) -> "Participation | None":
+    """Get the managing contest participation for a user in a training day.
+
+    Training day submissions are stored with the managing contest's participation,
+    not the training day's participation. This helper finds the managing contest
+    participation for a given user.
+
+    session: the database session.
+    training_day: the training day.
+    user: the user to look up.
+
+    return: the Participation in the managing contest, or None if not found.
+    """
+    from . import Participation
+    managing_contest = training_day.training_program.managing_contest
+    return (
+        session.query(Participation)
+        .filter(Participation.contest_id == managing_contest.id)
+        .filter(Participation.user_id == user.id)
+        .first()
+    )
 
 
 class TrainingDay(Base):
@@ -88,3 +115,9 @@ class TrainingDay(Base):
         back_populates="training_day",
         cascade="all, delete-orphan",
     )
+
+    submissions: list["Submission"] = relationship(
+        "Submission",
+        back_populates="training_day",
+        passive_deletes=True,
+    )

cms/grading/scorecache.py

@@ -732,7 +732,41 @@ def _get_sorted_official_submissions(
     participation: Participation,
     task: Task,
 ) -> list[Submission]:
-    """Get official submissions for a task, sorted by timestamp."""
+    """Get official submissions for a task, sorted by timestamp.
+
+    For training day participations, submissions are stored with the managing
+    contest's participation, so we need to query from there and filter by
+    training_day_id.
+
+    Raises:
+        ValueError: When managing participation is None for training days
+    """
+    from cms.db.training_day import get_managing_participation
+
+    training_day = participation.contest.training_day
+    if training_day is not None:
+        # This is a training day participation - submissions are stored with
+        # the managing contest's participation
+        managing_participation = get_managing_participation(
+            session, training_day, participation.user
+        )
+
+        if managing_participation is None:
+            # User doesn't have a participation in the managing contest
+            # This indicates a configuration or data integrity issue
+            raise ValueError(
+                f"User {participation.user_id} does not have participation in managing contest "
+                f"{training_day.training_program.managing_contest_id} for training day {training_day.id}"
+            )
+
+        return session.query(Submission).filter(
+            Submission.participation_id == managing_participation.id,
+            Submission.task_id == task.id,
+            Submission.training_day_id == training_day.id,
+            Submission.official.is_(True)
+        ).order_by(Submission.timestamp.asc()).all()
+
+    # Regular contest - query submissions directly
     return session.query(Submission).filter(
         Submission.participation_id == participation.id,
         Submission.task_id == task.id,

cms/grading/scoring.py

@@ -27,7 +27,7 @@
 
 from sqlalchemy.orm import joinedload
 
-from cms.db import Submission, Dataset, Participation, Task
+from cms.db import Submission, Dataset, Participation, Task, TrainingDay
 from cmscommon.constants import \
     SCORE_MODE_MAX, SCORE_MODE_MAX_SUBTASK, SCORE_MODE_MAX_TOKENED_LAST
 
@@ -109,6 +109,7 @@ def task_score(
     public: bool = False,
     only_tokened: bool = False,
     rounded: bool = False,
+    training_day: TrainingDay | None = None,
 ) -> tuple[float, bool]:
     """Return the score of a contest's user on a task.
 
@@ -123,6 +124,8 @@ def task_score(
         would obtain if all non-tokened submissions scored 0.0, or equivalently
         had not been scored yet).
     rounded: if True, round the score to the task's score_precision.
+    training_day: if provided, only consider submissions made via this
+        training day (filters by training_day_id).
 
     return: the score of user on task, and True if not
         all submissions of the participation in the task have been scored.
@@ -144,6 +147,8 @@ def task_score(
 
     submissions = [s for s in participation.submissions
                    if s.task is task and s.official]
+    if training_day is not None:
+        submissions = [s for s in submissions if s.training_day_id == training_day.id]
     if len(submissions) == 0:
         return 0.0, False
 

cms/server/admin/handlers/__init__.py

@@ -104,7 +104,9 @@
 from .submissiondownload import \
     DownloadTaskSubmissionsHandler, \
     DownloadUserContestSubmissionsHandler, \
-    DownloadContestSubmissionsHandler
+    DownloadContestSubmissionsHandler, \
+    DownloadTrainingProgramSubmissionsHandler, \
+    DownloadTrainingProgramStudentSubmissionsHandler
 from .task import (
     AddTaskHandler,
     TaskHandler,
@@ -338,6 +340,8 @@
     (r"/training_program/([0-9]+)/ranking", TrainingProgramRankingHandler),
     (r"/training_program/([0-9]+)/ranking/([a-z]+)", TrainingProgramRankingHandler),
     (r"/training_program/([0-9]+)/submissions", TrainingProgramSubmissionsHandler),
+    (r"/training_program/([0-9]+)/submissions/download", DownloadTrainingProgramSubmissionsHandler),
+    (r"/training_program/([0-9]+)/student/([0-9]+)/submissions/download", DownloadTrainingProgramStudentSubmissionsHandler),
     (r"/training_program/([0-9]+)/announcements", TrainingProgramAnnouncementsHandler),
     (r"/training_program/([0-9]+)/announcement/([0-9]+)", TrainingProgramAnnouncementHandler),
     (r"/training_program/([0-9]+)/questions", TrainingProgramQuestionsHandler),

cms/server/admin/handlers/contestsubmission.py

@@ -39,18 +39,27 @@ def get(self, contest_id):
         contest = self.safe_get_item(Contest, contest_id)
         self.contest = contest
 
-        # For training day contests, tasks have training_day_id set
-        # but contest_id points to the managing contest.
-        # We need to filter by training_day_id for training day contests.
+        # Determine if this is a training program managing contest
+        is_training_program = contest.training_program is not None
+
+        # For training day contests, only show submissions made via that training day
+        # (submissions now have training_day_id set when submitted via a training day)
         if contest.training_day is not None:
-            query = self.sql_session.query(Submission).join(Task)\
-                .filter(Task.training_day_id == contest.training_day.id)
+            query = self.sql_session.query(Submission)\
+                .filter(Submission.training_day_id == contest.training_day.id)
         else:
+            # For regular contests and training program managing contests,
+            # show all submissions for tasks in this contest
             query = self.sql_session.query(Submission).join(Task)\
                 .filter(Task.contest == contest)
         page = int(self.get_query_argument("page", 0))
         self.render_params_for_submissions(query, page)
 
+        # Pass flag and training_program to template for training programs
+        self.r_params["is_training_program"] = is_training_program
+        if is_training_program:
+            self.r_params["training_program"] = contest.training_program
+
         self.render("contest_submissions.html", **self.r_params)