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

src/main/java/de/tum/cit/aet/artemis/assessment/service/ResultService.java

@@ -337,9 +337,8 @@ private void filterSensitiveFeedbackInCourseExercise(Participation participation
     private void filterSensitiveFeedbacksInExamExercise(Participation participation, Collection<Result> results, Exercise exercise) {
         Exam exam = exercise.getExerciseGroup().getExam();
         boolean shouldResultsBePublished = exam.resultsPublished();
-        if (!shouldResultsBePublished && exam.isTestExam() && participation instanceof StudentParticipation studentParticipation) {
-            var participant = studentParticipation.getParticipant();
-            var studentExamOptional = studentExamRepository.findByExamIdAndUserId(exam.getId(), participant.getId());
+        if (!shouldResultsBePublished && exam.isTestExam() && participation instanceof StudentParticipation) {
+            var studentExamOptional = studentExamRepository.findByExamIdAndParticipationId(exam.getId(), participation.getId());
             if (studentExamOptional.isPresent()) {
                 shouldResultsBePublished = studentExamOptional.get().areResultsPublishedYet();
             }

src/main/java/de/tum/cit/aet/artemis/exam/domain/StudentExam.java

@@ -31,6 +31,7 @@
 import de.tum.cit.aet.artemis.core.domain.AbstractAuditingEntity;
 import de.tum.cit.aet.artemis.core.domain.User;
 import de.tum.cit.aet.artemis.exercise.domain.Exercise;
+import de.tum.cit.aet.artemis.exercise.domain.participation.StudentParticipation;
 import de.tum.cit.aet.artemis.quiz.domain.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/cit/aet/artemis/exam/repository/ExamRepository.java

@@ -508,4 +508,5 @@ 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);
+
 }

src/main/java/de/tum/cit/aet/artemis/exam/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> findWithExercisesAndSessionsAndStudentParticipationsById(@Param("studentExamId") long studentExamId);
 
     @Query("""
             SELECT DISTINCT se
@@ -190,6 +193,29 @@ 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
+     * @return the student exam
+     * @throws EntityNotFoundException if no student exams could be found
+     */
+    default StudentExam findOneByExamIdAndUserIdElseThrow(long examId, long userId) {
+        return getValueElseThrow(this.findFirstByExamIdAndUserIdOrderByIdDesc(examId, userId));
+    }
+
     /**
      * Checks if any StudentExam exists for the given user (student) id in the given course.
      *
@@ -253,7 +279,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
@@ -313,15 +349,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, sessions and student participations
      *
      * @param studentExamId the id of the student exam
-     * @return the student exam with exercises
+     * @return the student exam with exercises, sessions and student participations
      */
     @NotNull
-    default StudentExam findByIdWithExercisesSubmissionPolicyAndSessionsElseThrow(Long studentExamId) {
-        return getValueElseThrow(findWithExercisesSubmissionPolicyAndSessionsById(studentExamId), studentExamId);
+    default StudentExam findByIdWithExercisesAndSessionsAndStudentParticipationsElseThrow(Long studentExamId) {
+        return getValueElseThrow(findWithExercisesAndSessionsAndStudentParticipationsById(studentExamId), studentExamId);
     }
 
     /**

src/main/java/de/tum/cit/aet/artemis/exam/service/ExamAccessService.java

@@ -3,6 +3,7 @@
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 
 import java.time.ZonedDateTime;
+import java.util.List;
 import java.util.Optional;
 
 import org.springframework.context.annotation.Profile;
@@ -48,15 +49,19 @@ public class ExamAccessService {
 
     private final StudentExamService studentExamService;
 
+    private final ExamDateService examDateService;
+
     public ExamAccessService(ExamRepository examRepository, StudentExamRepository studentExamRepository, AuthorizationCheckService authorizationCheckService,
-            UserRepository userRepository, CourseRepository courseRepository, ExamRegistrationService examRegistrationService, StudentExamService studentExamService) {
+            UserRepository userRepository, CourseRepository courseRepository, ExamRegistrationService examRegistrationService, StudentExamService studentExamService,
+            ExamDateService examDateService) {
         this.examRepository = examRepository;
         this.studentExamRepository = studentExamRepository;
         this.authorizationCheckService = authorizationCheckService;
         this.userRepository = userRepository;
         this.courseRepository = courseRepository;
         this.examRegistrationService = examRegistrationService;
         this.studentExamService = studentExamService;
+        this.examDateService = examDateService;
     }
 
     /**
@@ -67,38 +72,14 @@ public ExamAccessService(ExamRepository examRepository, StudentExamRepository st
      * @param examId   The id of the exam
      * @return a ResponseEntity with the exam
      */
+
     public StudentExam getExamInCourseElseThrow(Long courseId, Long examId) {
         User currentUser = userRepository.getUserWithGroupsAndAuthorities();
-
-        // TODO: we should distinguish the whole method between test exam and real exam to improve the readability of the code
         // Check that the current user is at least student in the course.
         Course course = courseRepository.findByIdElseThrow(courseId);
         authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, currentUser);
 
-        // Check that the student exam exists
-        Optional<StudentExam> optionalStudentExam = studentExamRepository.findByExamIdAndUserId(examId, currentUser.getId());
-
-        StudentExam studentExam;
-        // If an studentExam can be fund, we can proceed
-        if (optionalStudentExam.isPresent()) {
-            studentExam = optionalStudentExam.get();
-        }
-        else {
-            // Only Test Exams can be self-created by the user.
-            Exam examWithExerciseGroupsAndExercises = examRepository.findWithExerciseGroupsAndExercisesByIdOrElseThrow(examId);
-
-            if (!examWithExerciseGroupsAndExercises.isTestExam()) {
-                // We skip the alert since this can happen when a tutor sees the exam card or the user did not participate yet is registered for the exam
-                throw new BadRequestAlertException("The requested Exam is no test exam and thus no student exam can be created", ENTITY_NAME,
-                        "StudentExamGenerationOnlyForTestExams", true);
-            }
-            studentExam = studentExamService.generateTestExam(examWithExerciseGroupsAndExercises, currentUser);
-            // For the start of the exam, the exercises are not needed. They are later loaded via StudentExamResource
-            studentExam.setExercises(null);
-        }
-
-        Exam exam = studentExam.getExam();
-
+        Exam exam = examRepository.findWithExerciseGroupsAndExercisesByIdOrElseThrow(examId);
         checkExamBelongsToCourseElseThrow(courseId, exam);
 
         if (!examId.equals(exam.getId())) {
@@ -111,14 +92,71 @@ public StudentExam getExamInCourseElseThrow(Long courseId, Long examId) {
         }
 
         if (exam.isTestExam()) {
-            // Check that the current user is registered for the test exam. Otherwise, the student can self-register
-            examRegistrationService.checkRegistrationOrRegisterStudentToTestExam(course, exam.getId(), currentUser);
+            return getOrGenerateTestExam(exam, course, currentUser);
+        }
+        else {
+            return getNormalExam(examId, currentUser.getId());
         }
         // NOTE: the check examRepository.isUserRegisteredForExam is not necessary because we already checked before that there is a student exam in this case for the current user
+    }
 
+    /**
+     * Fetches an unfinished StudentExam for a test exam if one exists. If no unfinished StudentExam exists, generates a new one.
+     *
+     * @param exam   The exam which StudentExam belongs to
+     * @param course The course which the exam belongs to
+     * @return the StudentExam
+     * @throws BadRequestAlertException If the exam had already ended
+     * @throws IllegalStateException    If the user has more than one unfinished student exam
+     */
+    private StudentExam getOrGenerateTestExam(Exam exam, Course course, User currentUser) {
+        StudentExam studentExam;
+
+        if (this.examDateService.isExamOver(exam)) {
+            throw new BadRequestAlertException("Test exam has already ended", ENTITY_NAME, "examHasAlreadyEnded", true);
+        }
+
+        List<StudentExam> unfinishedStudentExams = studentExamRepository.findStudentExamsForTestExamsByUserIdAndExamId(currentUser.getId(), exam.getId()).stream()
+                .filter(attempt -> !attempt.isFinished()).toList();
+
+        if (unfinishedStudentExams.isEmpty()) {
+            studentExam = studentExamService.generateTestExam(exam, currentUser);
+            // For the start of the exam, the exercises are not needed. They are later loaded via StudentExamResource
+            studentExam.setExercises(null);
+        }
+        else if (unfinishedStudentExams.size() == 1) {
+            studentExam = unfinishedStudentExams.getFirst();
+        }
+        else {
+            throw new IllegalStateException(
+                    "User " + currentUser.getId() + " has " + unfinishedStudentExams.size() + " unfinished test exams for exam " + exam.getId() + " in course " + course.getId());
+        }
+        // Check that the current user is registered for the test exam. Otherwise, the student can self-register
+        examRegistrationService.checkRegistrationOrRegisterStudentToTestExam(course, exam.getId(), currentUser);
         return studentExam;
     }
 
+    /**
+     * Fetches a real exam for the given examId and userId.
+     *
+     * @param examId the id of the Exam
+     * @param userId the id of the User
+     * @return the StudentExam
+     */
+    private StudentExam getNormalExam(Long examId, Long userId) {
+        // Check that the student exam exists
+        Optional<StudentExam> optionalStudentExam = studentExamRepository.findByExamIdAndUserId(examId, userId);
+        // If an studentExam can be found, we can proceed
+        if (optionalStudentExam.isPresent()) {
+            return optionalStudentExam.get();
+        }
+        else {
+            // We skip the alert since this can happen when a tutor sees the exam card or the user did not participate yet is registered for the exam
+            throw new BadRequestAlertException("The requested Exam is no test exam and thus no student exam can be created", ENTITY_NAME, "StudentExamGenerationOnlyForTestExams",
+                    true);
+        }
+    }
+
     /**
      * Checks if the current user is allowed to manage exams of the given course.
      *

src/main/java/de/tum/cit/aet/artemis/exam/service/ExamDateService.java

@@ -5,6 +5,7 @@
 
 import java.time.ZonedDateTime;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -35,6 +36,16 @@ public ExamDateService(ExamRepository examRepository, StudentExamRepository stud
         this.studentExamRepository = studentExamRepository;
     }
 
+    /**
+     * Returns if the exam is over by checking if the exam end date has passed.
+     *
+     * @param exam the exam
+     * @return true if the exam is over
+     */
+    public boolean isExamOver(Exam exam) {
+        return exam.getEndDate().isBefore(ZonedDateTime.now());
+    }
+
     /**
      * Returns if the exam is over by checking if the latest individual exam end date plus grace period has passed.
      * See {@link ExamDateService#getLatestIndividualExamEndDate}
@@ -98,8 +109,11 @@ public boolean isIndividualExerciseWorkingPeriodOver(Exam exam, StudentParticipa
         if (studentParticipation.isTestRun()) {
             return false;
         }
+        // Students can participate in a test exam multiple times, meaning there can be multiple student exams for a single exam.
+        // For test exams, we aim to find the latest student exam.
+        // For real exams, we aim to find the only existing student exam.
+        Optional<StudentExam> optionalStudentExam = studentExamRepository.findFirstByExamIdAndUserIdOrderByIdDesc(exam.getId(), studentParticipation.getParticipant().getId());
 
-        var optionalStudentExam = studentExamRepository.findByExamIdAndUserId(exam.getId(), studentParticipation.getParticipant().getId());
         if (optionalStudentExam.isPresent()) {
             StudentExam studentExam = optionalStudentExam.get();
             return Boolean.TRUE.equals(studentExam.isSubmitted()) || studentExam.isEnded();

src/main/java/de/tum/cit/aet/artemis/exam/service/ExamService.java

@@ -562,6 +562,7 @@ public void fetchParticipationsSubmissionsAndResultsForExam(StudentExam studentE
     public void filterParticipationForExercise(StudentExam studentExam, Exercise exercise, List<StudentParticipation> participations, boolean isAtLeastInstructor) {
         // remove the unnecessary inner course attribute
         exercise.setCourse(null);
+
         if (!(exercise instanceof QuizExercise)) {
             // Note: quiz exercises are filtered below
             exercise.filterSensitiveInformation();

src/main/java/de/tum/cit/aet/artemis/exam/service/ExamSubmissionService.java

@@ -102,13 +102,17 @@ public boolean isAllowedToSubmitDuringExam(Exercise exercise, User user, boolean
     }
 
     private Optional<StudentExam> findStudentExamForUser(User user, Exam exam) {
-        // Step 1: Find real exam
-        Optional<StudentExam> optionalStudentExam = studentExamRepository.findWithExercisesByUserIdAndExamId(user.getId(), exam.getId(), false);
-        if (optionalStudentExam.isEmpty()) {
-            // Step 2: Find latest (=the highest id) unsubmitted test exam
+
+        Optional<StudentExam> optionalStudentExam;
+        // Since multiple student exams for a test exam might exist, find the latest (=the highest id) unsubmitted student exam
+        if (exam.isTestExam()) {
             optionalStudentExam = studentExamRepository.findUnsubmittedStudentExamsForTestExamsWithExercisesByExamIdAndUserId(exam.getId(), user.getId()).stream()
                     .max(Comparator.comparing(StudentExam::getId));
         }
+        else {
+            // for real exams, there's only one student exam per exam
+            optionalStudentExam = studentExamRepository.findWithExercisesByUserIdAndExamId(user.getId(), exam.getId(), false);
+        }
         return optionalStudentExam;
     }
 
@@ -148,8 +152,8 @@ private boolean isExamTestRunSubmission(Exercise exercise, User user, Exam exam)
      * @return the submission. If a submission already exists for the exercise we will set the id
      */
     public Submission preventMultipleSubmissions(Exercise exercise, Submission submission, User user) {
-        // Return immediately if it is not an exam submissions or if it is a programming exercise
-        if (!exercise.isExamExercise() || exercise instanceof ProgrammingExercise) {
+        // Return immediately if it is not an exam submission or if it is a programming exercise or if it is a test exam exercise
+        if (!exercise.isExamExercise() || exercise instanceof ProgrammingExercise || exercise.getExam().isTestExam()) {
             return submission;
         }