Exam mode: Enable students to participate in the test exam multiple times

src/main/java/de/tum/in/www1/artemis/domain/Exercise.java

@@ -369,6 +369,11 @@ public boolean isExamExercise() {
         return this.exerciseGroup != null;
     }
 
+    @JsonIgnore
+    public boolean isTestExamExercise() {
+        return isExamExercise() && this.getExam().isTestExam();
+    }
+
     /**
      * Utility method to get the course. Get the course over the exerciseGroup, if one was set, otherwise return
      * the course class member

src/main/java/de/tum/in/www1/artemis/domain/exam/StudentExam.java

@@ -31,6 +31,7 @@
 import de.tum.in.www1.artemis.domain.AbstractAuditingEntity;
 import de.tum.in.www1.artemis.domain.Exercise;
 import de.tum.in.www1.artemis.domain.User;
+import de.tum.in.www1.artemis.domain.participation.StudentParticipation;
 import de.tum.in.www1.artemis.domain.quiz.QuizQuestion;
 
 @Entity
@@ -84,6 +85,12 @@ public class StudentExam extends AbstractAuditingEntity {
     @JoinTable(name = "student_exam_quiz_question", joinColumns = @JoinColumn(name = "student_exam_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "quiz_question_id", referencedColumnName = "id"))
     private List<QuizQuestion> quizQuestions = new ArrayList<>();
 
+    @ManyToMany
+    @JoinTable(name = "student_exam_participation", joinColumns = @JoinColumn(name = "student_exam_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "participation_id", referencedColumnName = "id"))
+    @OrderColumn(name = "participation_order")
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    private List<StudentParticipation> studentParticipations = new ArrayList<>();
+
     public Boolean isSubmitted() {
         return submitted;
     }
@@ -199,6 +206,14 @@ public void setQuizQuestions(List<QuizQuestion> quizQuestions) {
         this.quizQuestions = quizQuestions;
     }
 
+    public List<StudentParticipation> getStudentParticipations() {
+        return studentParticipations;
+    }
+
+    public void setStudentParticipations(List<StudentParticipation> studentParticipations) {
+        this.studentParticipations = studentParticipations;
+    }
+
     /**
      * Adds the given exam session to the student exam
      *
@@ -231,6 +246,16 @@ public Boolean isEnded() {
         return ZonedDateTime.now().isAfter(getIndividualEndDate());
     }
 
+    /**
+     * Check if the individual student exam is finished
+     * A student exam is finished if it's started and either submitted or the time has passed
+     *
+     * @return true if the exam is finished, otherwise false
+     */
+    public boolean isFinished() {
+        return Boolean.TRUE.equals(this.isStarted()) && (Boolean.TRUE.equals(this.isEnded()) || Boolean.TRUE.equals(this.isSubmitted()));
+    }
+
     /**
      * Returns the individual exam end date taking the working time of this student exam into account.
      * For test exams, the startedDate needs to be defined as this is not equal to exam.startDate

src/main/java/de/tum/in/www1/artemis/domain/participation/Participation.java

@@ -116,6 +116,17 @@ public abstract class Participation extends DomainObject implements Participatio
     @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
     private Set<Submission> submissions = new HashSet<>();
 
+    /**
+     * Graded course exercises, practice mode course exercises and real exam exercises always have only one parcitipation per exercise
+     * In case of a test exam, there are multiple participations possible for one exercise
+     * This field is necessary to preserve the constraint of one partipation per exercise, while allowing multiple particpiations per exercise for test exams
+     * The value is 0 for graded course exercises and exercises in the real exams
+     * The value is 1 for practice mode course exercises
+     * The value is 0-255 for test exam exercises. For each subsequent participation the number is increased by one
+     */
+    @Column(name = "attempt")
+    private int attempt = 0;
+
     /**
      * This property stores the total number of submissions in this participation. Not stored in the database, computed dynamically and used in showing statistics to the user in
      * the exercise view.
@@ -242,6 +253,14 @@ public void setSubmissions(Set<Submission> submissions) {
         this.submissions = submissions;
     }
 
+    public int getAttempt() {
+        return attempt;
+    }
+
+    public void setAttempt(int index) {
+        this.attempt = index;
+    }
+
     // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
 
     /**
@@ -353,4 +372,5 @@ public String toString() {
 
     @JsonIgnore
     public abstract String getType();
+
 }

src/main/java/de/tum/in/www1/artemis/repository/ExamRepository.java

@@ -508,4 +508,11 @@ private static Map<Long, Integer> convertListOfCountsIntoMap(List<long[]> examId
                 AND registeredUsers.user.id = :userId
             """)
     Set<Exam> findActiveExams(@Param("courseIds") Set<Long> courseIds, @Param("userId") long userId, @Param("visible") ZonedDateTime visible, @Param("end") ZonedDateTime end);
+
+    @Query("""
+            SELECT e.testExam
+            FROM Exam e
+            WHERE e.id = :examId
+            """)
+    boolean isTestExam(@Param("examId") long examId);
 }

src/main/java/de/tum/in/www1/artemis/repository/ProgrammingExerciseStudentParticipationRepository.java

@@ -74,21 +74,44 @@ Optional<ProgrammingExerciseStudentParticipation> findByIdWithAllResultsAndRelat
 
     Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndStudentLogin(long exerciseId, String username);
 
+    Optional<ProgrammingExerciseStudentParticipation> findFirstByExerciseIdAndStudentLoginOrderByIdDesc(long exerciseId, String username);
+
     List<ProgrammingExerciseStudentParticipation> findAllByExerciseIdAndStudentLogin(long exerciseId, String username);
 
     default ProgrammingExerciseStudentParticipation findByExerciseIdAndStudentLoginOrThrow(long exerciseId, String username) {
         return getValueElseThrow(findByExerciseIdAndStudentLogin(exerciseId, username));
     }
 
+    default ProgrammingExerciseStudentParticipation findFirstByExerciseIdAndStudentLoginOrThrow(long exerciseId, String username) {
+        return getValueElseThrow(findFirstByExerciseIdAndStudentLoginOrderByIdDesc(exerciseId, username));
+    }
+
     @EntityGraph(type = LOAD, attributePaths = { "submissions" })
     Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsByExerciseIdAndStudentLogin(long exerciseId, String username);
 
+    @Query("""
+            SELECT participation
+            FROM ProgrammingExerciseStudentParticipation participation
+                LEFT JOIN FETCH participation.submissions s
+            WHERE participation.exercise.id = :exerciseId
+                AND participation.student.login = :username
+            ORDER BY participation.id DESC
+            """)
+    List<ProgrammingExerciseStudentParticipation> findFirstWithSubmissionsByExerciseIdAndStudentLoginOrderByIdDesc(@Param("exerciseId") long exerciseId,
+            @Param("username") String username);
+
     default ProgrammingExerciseStudentParticipation findWithSubmissionsByExerciseIdAndStudentLoginOrThrow(long exerciseId, String username) {
         return getValueElseThrow(findWithSubmissionsByExerciseIdAndStudentLogin(exerciseId, username));
     }
 
+    default ProgrammingExerciseStudentParticipation findFirstWithSubmissionsByExerciseIdAndStudentLoginOrThrow(long exerciseId, String username) {
+        return getValueElseThrow(findFirstWithSubmissionsByExerciseIdAndStudentLoginOrderByIdDesc(exerciseId, username).stream().findFirst());
+    }
+
     Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndStudentLoginAndTestRun(long exerciseId, String username, boolean testRun);
 
+    Optional<ProgrammingExerciseStudentParticipation> findFirstByExerciseIdAndStudentLoginAndTestRunOrderByIdDesc(long exerciseId, String username, boolean testRun);
+
     @EntityGraph(type = LOAD, attributePaths = { "team.students" })
     Optional<ProgrammingExerciseStudentParticipation> findByExerciseIdAndTeamId(long exerciseId, long teamId);
 
@@ -164,6 +187,22 @@ List<ProgrammingExerciseStudentParticipation> findWithSubmissionsByExerciseIdAnd
     Optional<ProgrammingExerciseStudentParticipation> findWithSubmissionsByExerciseIdAndStudentLoginAndTestRun(@Param("exerciseId") long exerciseId,
             @Param("username") String username, @Param("testRun") boolean testRun);
 
+    @Query("""
+            SELECT participation
+            FROM ProgrammingExerciseStudentParticipation participation
+                LEFT JOIN FETCH participation.submissions s
+            WHERE participation.exercise.id = :exerciseId
+                AND participation.student.login = :username
+                AND participation.testRun = :testRun
+            ORDER BY participation.id DESC
+            """)
+    List<ProgrammingExerciseStudentParticipation> findFirstWithSubmissionsByExerciseIdAndStudentLoginAndTestRunOrderByIdDesc(@Param("exerciseId") long exerciseId,
+            @Param("username") String username, @Param("testRun") boolean testRun);
+
+    default Optional<ProgrammingExerciseStudentParticipation> findFirstWithSubmissionsByExerciseIdAndStudentLoginAndTestRun(long exerciseId, String username, boolean testRun) {
+        return findFirstWithSubmissionsByExerciseIdAndStudentLoginAndTestRunOrderByIdDesc(exerciseId, username, testRun).stream().findFirst();
+    }
+
     @Query("""
             SELECT participation
             FROM ProgrammingExerciseStudentParticipation participation

src/main/java/de/tum/in/www1/artemis/repository/StudentExamRepository.java

@@ -42,15 +42,18 @@ public interface StudentExamRepository extends ArtemisJpaRepository<StudentExam,
     @EntityGraph(type = LOAD, attributePaths = { "exercises" })
     Optional<StudentExam> findWithExercisesById(Long studentExamId);
 
+    @EntityGraph(type = LOAD, attributePaths = { "exercises", "studentParticipations" })
+    Optional<StudentExam> findWithExercisesAndStudentParticipationsById(Long studentExamId);
+
     @Query("""
             SELECT se
             FROM StudentExam se
                 LEFT JOIN FETCH se.exercises e
-                LEFT JOIN FETCH e.submissionPolicy
                 LEFT JOIN FETCH se.examSessions
+                LEFT JOIN FETCH se.studentParticipations
             WHERE se.id = :studentExamId
             """)
-    Optional<StudentExam> findWithExercisesSubmissionPolicyAndSessionsById(@Param("studentExamId") long studentExamId);
+    Optional<StudentExam> findWithExercisesAndSessionsById(@Param("studentExamId") long studentExamId);
 
     @Query("""
             SELECT DISTINCT se
@@ -215,6 +218,38 @@ SELECT COUNT(se)
             """)
     Optional<StudentExam> findByExamIdAndUserId(@Param("examId") long examId, @Param("userId") long userId);
 
+    Optional<StudentExam> findFirstByExamIdAndUserIdOrderByIdDesc(long examId, long userId);
+
+    @Query("""
+            SELECT se
+            FROM StudentExam se
+            JOIN se.studentParticipations p
+            WHERE se.exam.id = :examId
+                AND p.id = :participationId
+            """)
+    Optional<StudentExam> findByExamIdAndParticipationId(@Param("examId") long examId, @Param("participationId") long participationId);
+
+    /**
+     * Return the StudentExam for the given examId and userId, if possible. For test exams, the latest Student Exam is returned.
+     *
+     * @param examId   id of the exam
+     * @param userId   id of the user
+     * @param testExam boolean indicating if the exam is a test exam
+     * @return the student exam
+     * @throws EntityNotFoundException if no student exams could be found
+     */
+    default StudentExam findOneByExamIdAndUserIdElseThrow(long examId, long userId, boolean testExam) {
+        Optional<StudentExam> studentExam;
+        if (testExam) {
+            studentExam = this.findFirstByExamIdAndUserIdOrderByIdDesc(examId, userId);
+        }
+        else {
+            studentExam = this.findByExamIdAndUserId(examId, userId);
+        }
+
+        return getValueElseThrow(studentExam);
+    }
+
     /**
      * Checks if any StudentExam exists for the given user (student) id in the given course.
      *
@@ -280,7 +315,17 @@ SELECT MAX(se.workingTime)
                 AND se.exam.testExam = TRUE
                 AND se.testRun = FALSE
             """)
-    List<StudentExam> findStudentExamForTestExamsByUserIdAndCourseId(@Param("userId") Long userId, @Param("courseId") Long courseId);
+    List<StudentExam> findStudentExamsForTestExamsByUserIdAndCourseId(@Param("userId") Long userId, @Param("courseId") Long courseId);
+
+    @Query("""
+            SELECT DISTINCT se
+            FROM StudentExam se
+            WHERE se.user.id = :userId
+                AND se.exam.id = :examId
+                AND se.exam.testExam = TRUE
+                AND se.testRun = FALSE
+            """)
+    List<StudentExam> findStudentExamsForTestExamsByUserIdAndExamId(@Param("userId") Long userId, @Param("examId") Long examId);
 
     @Query("""
             SELECT DISTINCT se
@@ -340,15 +385,20 @@ default StudentExam findByIdWithExercisesElseThrow(Long studentExamId) {
         return getValueElseThrow(findWithExercisesById(studentExamId), studentExamId);
     }
 
+    @NotNull
+    default StudentExam findByIdWithExercisesAndStudentParticipationsElseThrow(Long studentExamId) {
+        return getValueElseThrow(findWithExercisesAndStudentParticipationsById(studentExamId));
+    }
+
     /**
-     * Get one student exam by id with exercises, programming exercise submission policy and sessions
+     * Get one student exam by id with exercises and sessions
      *
      * @param studentExamId the id of the student exam
      * @return the student exam with exercises
      */
     @NotNull
-    default StudentExam findByIdWithExercisesSubmissionPolicyAndSessionsElseThrow(Long studentExamId) {
-        return getValueElseThrow(findWithExercisesSubmissionPolicyAndSessionsById(studentExamId), studentExamId);
+    default StudentExam findByIdWithExercisesAndSessionsElseThrow(Long studentExamId) {
+        return getValueElseThrow(findWithExercisesAndSessionsById(studentExamId), studentExamId);
     }
 
     /**

src/main/java/de/tum/in/www1/artemis/repository/StudentParticipationRepository.java

@@ -116,6 +116,8 @@ SELECT COUNT(p.id) > 0
             """)
     Optional<StudentParticipation> findByExerciseIdAndStudentLogin(@Param("exerciseId") long exerciseId, @Param("username") String username);
 
+    Optional<StudentParticipation> findFirstByExerciseIdAndStudentLoginOrderByIdDesc(long exerciseId, String username);
+
     @Query("""
             SELECT DISTINCT p
             FROM StudentParticipation p
@@ -126,6 +128,21 @@ SELECT COUNT(p.id) > 0
             """)
     Optional<StudentParticipation> findWithEagerLegalSubmissionsByExerciseIdAndStudentLogin(@Param("exerciseId") long exerciseId, @Param("username") String username);
 
+    @Query("""
+            SELECT DISTINCT p
+            FROM StudentParticipation p
+                LEFT JOIN FETCH p.submissions s
+            WHERE p.id = (
+                SELECT MAX(p2.id)
+                FROM StudentParticipation p2
+                    LEFT JOIN p2.submissions s2
+                WHERE p2.exercise.id = :exerciseId
+                    AND p2.student.login = :username
+                    AND (s2.type <> de.tum.in.www1.artemis.domain.enumeration.SubmissionType.ILLEGAL OR s2.type IS NULL)
+            )
+            """)
+    Optional<StudentParticipation> findLatestWithEagerLegalSubmissionsByExerciseIdAndStudentLogin(@Param("exerciseId") long exerciseId, @Param("username") String username);
+
     @Query("""
             SELECT DISTINCT p
             FROM StudentParticipation p
@@ -426,7 +443,7 @@ default List<StudentParticipation> findByExerciseIdWithManualResultAndFeedbacksA
                 LEFT JOIN FETCH p.submissions
             WHERE p.exercise.id = :exerciseId
                 AND p.student.id = :studentId
-             """)
+            """)
     List<StudentParticipation> findByExerciseIdAndStudentIdWithEagerResultsAndSubmissions(@Param("exerciseId") long exerciseId, @Param("studentId") long studentId);
 
     @Query("""
@@ -766,6 +783,30 @@ List<StudentParticipation> findByStudentIdAndIndividualExercisesWithEagerSubmiss
     List<StudentParticipation> findByStudentIdAndIndividualExercisesWithEagerSubmissionsResultAndAssessorIgnoreTestRuns(@Param("studentId") long studentId,
             @Param("exercises") List<Exercise> exercises);
 
+    @Query("""
+            SELECT DISTINCT p
+            FROM StudentExam se
+                JOIN se.studentParticipations p
+                LEFT JOIN FETCH p.submissions s
+                LEFT JOIN FETCH s.results r
+                LEFT JOIN FETCH r.assessor
+            WHERE p.testRun = FALSE
+                AND se.id IN :studentExamId
+            """)
+    List<StudentParticipation> findTestExamParticipationsByStudentIdAndIndividualExercisesWithEagerSubmissionsResultAndAssessorIgnoreTestRuns(
+            @Param("studentExamId") long studentExamId);
+
+    @Query("""
+            SELECT DISTINCT p
+                FROM StudentExam se
+                    JOIN se.studentParticipations p
+                    LEFT JOIN FETCH p.submissions s
+                    LEFT JOIN FETCH s.results r
+                WHERE p.testRun = FALSE
+                    AND se.id IN :studentExamId
+            """)
+    List<StudentParticipation> findTestExamParticipationsByStudentIdAndIndividualExercisesWithEagerSubmissionsResultIgnoreTestRuns(@Param("studentExamId") long studentExamId);
+
     @Query("""
             SELECT DISTINCT p
             FROM StudentParticipation p
@@ -976,7 +1017,7 @@ private List<StudentParticipation> filterParticipationsWithRelevantResults(List<
 
     /**
      * Get all participations for the given studentExam and exercises combined with their submissions with a result.
-     * Distinguishes between student exams and test runs and only loads the respective participations
+     * Distinguishes between real exams, test exams and test runs and only loads the respective participations
      *
      * @param studentExam  studentExam with exercises loaded
      * @param withAssessor (only for non-test runs) if assessor should be loaded with the result
@@ -986,6 +1027,15 @@ default List<StudentParticipation> findByStudentExamWithEagerSubmissionsResult(S
         if (studentExam.isTestRun()) {
             return findTestRunParticipationsByStudentIdAndIndividualExercisesWithEagerSubmissionsResult(studentExam.getUser().getId(), studentExam.getExercises());
         }
+
+        if (studentExam.isTestExam()) {
+            if (withAssessor) {
+                return findTestExamParticipationsByStudentIdAndIndividualExercisesWithEagerSubmissionsResultAndAssessorIgnoreTestRuns(studentExam.getId());
+            }
+            else {
+                return findTestExamParticipationsByStudentIdAndIndividualExercisesWithEagerSubmissionsResultIgnoreTestRuns(studentExam.getId());
+            }
+        }
         else {
             if (withAssessor) {
                 return findByStudentIdAndIndividualExercisesWithEagerSubmissionsResultAndAssessorIgnoreTestRuns(studentExam.getUser().getId(), studentExam.getExercises());