ls1intum · coolchock · May 13, 2024 · May 13, 2024 · May 13, 2024 · May 14, 2024
@@ -358,9 +358,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();
             }

@@ -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

@@ -510,4 +510,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);
+
 }
@@ -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.
      *
@@ -257,7 +283,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
@@ -317,15 +353,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);
     }
 
     /**

@@ -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;
     }
 
     /**
@@ -75,6 +80,30 @@ public StudentExam getOrCreateStudentExamElseThrow(Long courseId, Long examId) {
         Course course = courseRepository.findByIdElseThrow(courseId);
         authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, currentUser);
 
+        Exam exam = examRepository.findWithExerciseGroupsAndExercisesByIdOrElseThrow(examId);
+        checkExamBelongsToCourseElseThrow(courseId, exam);
+
+        // Check that the exam is visible
+        if (exam.getVisibleDate() != null && exam.getVisibleDate().isAfter(ZonedDateTime.now())) {
+            throw new AccessForbiddenException(ENTITY_NAME, examId);
+        }
+
+        StudentExam studentExam;
+        if (exam.isTestExam()) {
+            studentExam = getOrCreateTestExam(exam, course, currentUser);
+        }
+        else {
+            studentExam = getOrCreateNormalExam(examId, currentUser);
+        }
+
+        if (!examId.equals(studentExam.getExam().getId())) {
+            throw new ConflictException("The provided examId does not match with the examId of the studentExam", ENTITY_NAME, "examIdMismatch");
+        }
+
+        return studentExam;
+    }
+
+    private StudentExam getOrCreateNormalExam(Long examId, User currentUser) {
         // Check that the student exam exists
         Optional<StudentExam> optionalStudentExam = studentExamRepository.findByExamIdAndUserId(examId, currentUser.getId());
 
@@ -90,19 +119,18 @@ public StudentExam getOrCreateStudentExamElseThrow(Long courseId, Long examId) {
 
             // An exam can be started 5 minutes before the start time, which is when programming exercises are unlocked
             boolean canExamBeStarted = now.isAfter(unlockDate);
-            boolean isTestExam = exam.isTestExam();
             boolean isUserRegistered = examRegistrationService.isUserRegisteredForExam(examId, currentUser.getId());
             boolean isExamEnded = ZonedDateTime.now().isAfter(exam.getEndDate());
             // Generate a student exam if the following conditions are met:
             // 1. The exam has not ended.
-            // 2. The exam is either a test exam, OR it is a normal exam where the user is registered and can click the start button.
+            // 2. User is registered and can click the start button.
             // Allowing student exams to be generated only when students can click the start button prevents inconsistencies.
             // For example, this avoids a scenario where a student generates an exam and an instructor adds an exercise group afterward.
 
             if (isExamEnded) {
                 throw new BadRequestAlertException("The exam has already ended. Cannot generate student exam.", ENTITY_NAME, "examEnded", true);
             }
-            if (!isTestExam && !isUserRegistered) {
+            if (!isUserRegistered) {
                 throw new AccessForbiddenException("User is not registered for the exam. Cannot generate student exam.");
             }
             if (!canExamBeStarted) {
@@ -114,26 +142,33 @@ public StudentExam getOrCreateStudentExamElseThrow(Long courseId, Long examId) {
                 studentExam.setExercises(null);
             }
         }
+        return studentExam;
+    }
 
-        Exam exam = studentExam.getExam();
-
-        checkExamBelongsToCourseElseThrow(courseId, exam);
+    private StudentExam getOrCreateTestExam(Exam exam, Course course, User currentUser) {
+        StudentExam studentExam;
 
-        if (!examId.equals(exam.getId())) {
-            throw new ConflictException("The provided examId does not match with the examId of the studentExam", ENTITY_NAME, "examIdMismatch");
+        if (this.examDateService.isExamOver(exam)) {
+            throw new BadRequestAlertException("Test exam has already ended", ENTITY_NAME, "examHasAlreadyEnded", true);
         }
 
-        // Check that the exam is visible
-        if (exam.getVisibleDate() != null && exam.getVisibleDate().isAfter(ZonedDateTime.now())) {
-            throw new AccessForbiddenException(ENTITY_NAME, examId);
-        }
+        List<StudentExam> unfinishedStudentExams = studentExamRepository.findStudentExamsForTestExamsByUserIdAndExamId(currentUser.getId(), exam.getId()).stream()
+                .filter(attempt -> !attempt.isFinished()).toList();
 
-        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);
+        if (unfinishedStudentExams.isEmpty()) {
+            studentExam = studentExamService.generateIndividualStudentExam(exam, currentUser);
+            // For the start of the exam, the exercises are not needed. They are later loaded via StudentExamResource
+            studentExam.setExercises(null);
         }
-        // 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
-
+        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;
     }
 

@@ -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;
 
@@ -36,6 +37,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 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 exam end date has passed.
+     *
+     * @param exam the exam
+     * @return true if the exam is over
+     * @throws IllegalArgumentException if exam end date is null
+     */
+    public boolean isExamOver(Exam exam) {
+        if (exam.getEndDate() == null) {
+            throw new IllegalArgumentException("Exam end date must not be null");
+        }
+        var now = ZonedDateTime.now();
+        return exam.getEndDate().isBefore(now);
+    }
-    /**
-     * 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 exam end date has passed.
+     *
+     * @param exam the exam
+     * @return true if the exam is over
+     * @throws IllegalArgumentException if exam end date is null
+     */
+    public boolean isExamOver(Exam exam) {
+        if (exam.getEndDate() == null) {
+            throw new IllegalArgumentException("Exam end date must not be null");
+        }
+        var now = ZonedDateTime.now();
+        return exam.getEndDate().isBefore(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}
@@ -99,8 +110,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();

@@ -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();

@@ -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;
         }
-Original file line number
+Diff line change
@@ Expand Up @@
                     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);
     }