Exam mode: Allow instructors to extend exam time

src/main/java/de/tum/in/www1/artemis/config/Constants.java

@@ -281,6 +281,8 @@ public final class Constants {
      */
     public static final int GROUP_CONVERSATION_HUMAN_READABLE_NAME_LIMIT = 100;
 
+    public static final String WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC = "/topic/studentExams/%s/working-time-change-during-conduction";
+
     private Constants() {
     }
 }

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

@@ -1,5 +1,6 @@
 package de.tum.in.www1.artemis.domain.exam;
 
+import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -192,6 +193,14 @@ public void setEndDate(@NotNull ZonedDateTime endDate) {
         this.endDate = endDate;
     }
 
+    /**
+     * @return the duration of the exam in seconds
+     */
+    @JsonIgnore
+    public int getDuration() {
+        return Math.toIntExact(Duration.between(getStartDate(), getEndDate()).toSeconds());
+    }
+
     public ZonedDateTime getPublishResultsDate() {
         return publishResultsDate;
     }

src/main/java/de/tum/in/www1/artemis/service/exam/StudentExamService.java

@@ -51,8 +51,6 @@ public class StudentExamService {
 
     private static final String EXAM_EXERCISE_START_STATUS_TOPIC = "/topic/exams/%s/exercise-start-status";
 
-    private static final String WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC = "/topic/studentExams/%s/working-time-change-during-conduction";
-
     private final Logger log = LoggerFactory.getLogger(StudentExamService.class);
 
     private final ParticipationService participationService;
@@ -805,8 +803,4 @@ private StudentExam generateIndividualStudentExam(Exam exam, User student) {
         userHashSet.add(student);
         return studentExamRepository.createRandomStudentExams(exam, userHashSet).get(0);
     }
-
-    public void notifyStudentAboutWorkingTimeChangeDuringConduction(StudentExam studentExam) {
-        websocketMessagingService.sendMessage(WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC.formatted(studentExam.getId()), studentExam.getWorkingTime());
-    }
 }

src/main/java/de/tum/in/www1/artemis/web/rest/ExamResource.java

@@ -1,5 +1,6 @@
 package de.tum.in.www1.artemis.web.rest;
 
+import static de.tum.in.www1.artemis.config.Constants.WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC;
 import static de.tum.in.www1.artemis.service.util.TimeLogUtil.formatDurationFrom;
 import static java.time.ZonedDateTime.now;
 
@@ -9,12 +10,12 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.file.Path;
-import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.*;
 
 import javax.validation.constraints.NotNull;
+import javax.ws.rs.BadRequestException;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -42,10 +43,7 @@
 import de.tum.in.www1.artemis.repository.metis.conversation.ChannelRepository;
 import de.tum.in.www1.artemis.security.Role;
 import de.tum.in.www1.artemis.security.annotations.*;
-import de.tum.in.www1.artemis.service.AssessmentDashboardService;
-import de.tum.in.www1.artemis.service.AuthorizationCheckService;
-import de.tum.in.www1.artemis.service.ProfileService;
-import de.tum.in.www1.artemis.service.SubmissionService;
+import de.tum.in.www1.artemis.service.*;
 import de.tum.in.www1.artemis.service.dto.StudentDTO;
 import de.tum.in.www1.artemis.service.exam.*;
 import de.tum.in.www1.artemis.service.feature.Feature;
@@ -113,12 +111,14 @@ public class ExamResource {
 
     private final ChannelService channelService;
 
+    private final WebsocketMessagingService websocketMessagingService;
+
     public ExamResource(ProfileService profileService, UserRepository userRepository, CourseRepository courseRepository, ExamService examService,
             ExamDeletionService examDeletionService, ExamAccessService examAccessService, InstanceMessageSendService instanceMessageSendService, ExamRepository examRepository,
             SubmissionService submissionService, AuthorizationCheckService authCheckService, ExamDateService examDateService,
             TutorParticipationRepository tutorParticipationRepository, AssessmentDashboardService assessmentDashboardService, ExamRegistrationService examRegistrationService,
             StudentExamRepository studentExamRepository, ExamImportService examImportService, CustomAuditEventRepository auditEventRepository, ChannelService channelService,
-            ChannelRepository channelRepository) {
+            ChannelRepository channelRepository, WebsocketMessagingService websocketMessagingService) {
         this.profileService = profileService;
         this.userRepository = userRepository;
         this.courseRepository = courseRepository;
@@ -138,6 +138,7 @@ public ExamResource(ProfileService profileService, UserRepository userRepository
         this.auditEventRepository = auditEventRepository;
         this.channelService = channelService;
         this.channelRepository = channelRepository;
+        this.websocketMessagingService = websocketMessagingService;
     }
 
     /**
@@ -235,6 +236,60 @@ public ResponseEntity<Exam> updateExam(@PathVariable Long courseId, @RequestBody
         return ResponseEntity.ok(savedExam);
     }
 
+    /**
+     * PATCH /courses/{courseId}/exams/{examId}/student-exams/{studentExamId}/working-time : Update the working time of the student exam
+     *
+     * @param courseId          the course to which the student exams belong to
+     * @param examId            the exam to which the student exams belong to
+     * @param workingTimeChange the working time change in seconds (can be positive or negative, but must not be 0)
+     * @return the ResponseEntity with status 200 (OK) and with the updated student exam as body
+     */
+    @PatchMapping("/courses/{courseId}/exams/{examId}/student-exams/working-time")
+    @EnforceAtLeastInstructor
+    public ResponseEntity<Exam> updateExamWorkingTime(@PathVariable Long courseId, @PathVariable Long examId, @RequestBody Integer workingTimeChange) {
+        log.debug("REST request to update the working time of exam : {}", examId);
+
+        examAccessService.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
+
+        if (workingTimeChange == 0) {
+            throw new BadRequestException();
+        }
+        Exam exam = examService.findByIdWithExerciseGroupsAndExercisesElseThrow(examId);
+        var originalExamDuration = exam.getDuration();
+        // update the end date of the exam
+        exam.setEndDate(exam.getEndDate().plusSeconds(workingTimeChange));
+        examRepository.save(exam);
+
+        // re-calculate the working times of all student exams
+        var studentExams = studentExamRepository.findByExamId(examId);
+        for (var studentExam : studentExams) {
+            Integer originalStudentWorkingTime = studentExam.getWorkingTime();
+            int originalTimeExtension = originalStudentWorkingTime - originalExamDuration;
+            // NOTE: take the original working time extensions into account
+            if (originalTimeExtension == 0) {
+                studentExam.setWorkingTime(originalStudentWorkingTime + workingTimeChange);
+            }
+            else {
+                double relativeTimeExtension = (double) originalTimeExtension / (double) originalExamDuration;
+                int adjustedTimeExtension = Math.toIntExact(Math.round(relativeTimeExtension * workingTimeChange));
+                studentExam.setWorkingTime(originalStudentWorkingTime + adjustedTimeExtension);
+            }
+            var savedStudentExam = studentExamRepository.save(studentExam);
+            if (ZonedDateTime.now().isAfter(exam.getVisibleDate())) {
+                // TODO: this is probably not very efficient, instead we should re-calculate once for all student exams
+                instanceMessageSendService.sendExamWorkingTimeChangeDuringConduction(studentExam.getId());
+                websocketMessagingService.sendMessage(WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC.formatted(savedStudentExam.getId()), savedStudentExam.getWorkingTime());
+            }
+        }
+
+        if (ZonedDateTime.now().isBefore(examDateService.getLatestIndividualExamEndDate(exam)) && exam.getStartDate() != null
+                && ZonedDateTime.now().isBefore(exam.getStartDate().plusSeconds(workingTimeChange))) {
+            examService.scheduleModelingExercises(exam);
+        }
+
+        return ResponseEntity.ok(exam);
+    }
+
     /**
      * POST /courses/{courseId}/exam-import : Imports a new exam with exercises.
      *
@@ -333,19 +388,19 @@ else if (!exam.getVisibleDate().isBefore(exam.getStartDate()) || !exam.getStartD
      * @param exam the exam to be checked
      */
     private void checkExamForWorkingTimeConflictsElseThrow(Exam exam) {
-        int differenceStartEndDate = Math.toIntExact(Duration.between(exam.getStartDate(), exam.getEndDate()).toSeconds());
+        var examDuration = exam.getDuration();
 
         if (exam.isTestExam()) {
-            if (exam.getWorkingTime() > differenceStartEndDate || exam.getWorkingTime() < 1) {
+            if (exam.getWorkingTime() > examDuration || exam.getWorkingTime() < 1) {
                 throw new BadRequestAlertException("For TestExams, the working time must be at least 1 and at most the duration of the working window.", ENTITY_NAME, "examTimes");
             }
         }
-        else if (exam.getWorkingTime() != differenceStartEndDate) {
+        else if (exam.getWorkingTime() != examDuration) {
             /*
              * Set the working time to the time difference for real exams, if not done by the client. This can be an issue if the working time calculation in the client is not
              * performed (e.g. for Cypress-2E2-Tests). However, since the working time currently depends on the start- and end-date, we can do a server-side assignment
              */
-            exam.setWorkingTime(differenceStartEndDate);
+            exam.setWorkingTime(examDuration);
         }
     }
 

src/main/java/de/tum/in/www1/artemis/web/rest/StudentExamResource.java

@@ -1,6 +1,7 @@
 package de.tum.in.www1.artemis.web.rest;
 
 import static de.tum.in.www1.artemis.config.Constants.EXAM_START_WAIT_TIME_MINUTES;
+import static de.tum.in.www1.artemis.config.Constants.WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC;
 import static de.tum.in.www1.artemis.service.util.TimeLogUtil.formatDurationFrom;
 
 import java.time.ZonedDateTime;
@@ -85,6 +86,8 @@ public class StudentExamResource {
 
     private final WebsocketMessagingService messagingService;
 
+    private final WebsocketMessagingService websocketMessagingService;
+
     @Value("${info.student-exam-store-session-data:#{true}}")
     private boolean storeSessionDataInStudentExamSession;
 
@@ -98,7 +101,7 @@ public StudentExamResource(ExamAccessService examAccessService, ExamDeletionServ
             StudentExamRepository studentExamRepository, ExamDateService examDateService, ExamSessionService examSessionService,
             StudentParticipationRepository studentParticipationRepository, ExamRepository examRepository, SubmittedAnswerRepository submittedAnswerRepository,
             AuthorizationCheckService authorizationCheckService, ExamService examService, InstanceMessageSendService instanceMessageSendService,
-            WebsocketMessagingService messagingService) {
+            WebsocketMessagingService messagingService, WebsocketMessagingService websocketMessagingService) {
         this.examAccessService = examAccessService;
         this.examDeletionService = examDeletionService;
         this.studentExamService = studentExamService;
@@ -115,6 +118,7 @@ public StudentExamResource(ExamAccessService examAccessService, ExamDeletionServ
         this.examService = examService;
         this.instanceMessageSendService = instanceMessageSendService;
         this.messagingService = messagingService;
+        this.websocketMessagingService = websocketMessagingService;
     }
 
     /**
@@ -204,7 +208,7 @@ public ResponseEntity<StudentExam> updateWorkingTime(@PathVariable Long courseId
             Exam exam = examService.findByIdWithExerciseGroupsAndExercisesElseThrow(examId);
             if (ZonedDateTime.now().isAfter(exam.getVisibleDate())) {
                 instanceMessageSendService.sendExamWorkingTimeChangeDuringConduction(studentExamId);
-                studentExamService.notifyStudentAboutWorkingTimeChangeDuringConduction(savedStudentExam);
+                websocketMessagingService.sendMessage(WORKING_TIME_CHANGE_DURING_CONDUCTION_TOPIC.formatted(savedStudentExam.getId()), savedStudentExam.getWorkingTime());
             }
             if (ZonedDateTime.now().isBefore(examDateService.getLatestIndividualExamEndDate(exam)) && exam.getStartDate() != null
                     && ZonedDateTime.now().isBefore(exam.getStartDate().plusSeconds(workingTime))) {

src/test/java/de/tum/in/www1/artemis/exam/ExamUtilService.java

@@ -3,7 +3,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.net.URI;
-import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.util.*;
 
@@ -300,7 +299,7 @@ public Exam addExamWithUser(Course course, User user, boolean exerciseGroup, Zon
         exam.setVisibleDate(visibleDate);
         exam.setStartDate(startDate);
         exam.setEndDate(endDate);
-        exam.setWorkingTime((int) Duration.between(exam.getStartDate(), exam.getEndDate()).toSeconds());
+        exam.setWorkingTime(exam.getDuration());
         exam.setNumberOfCorrectionRoundsInExam(1);
         examRepository.save(exam);
         return exam;
@@ -331,7 +330,7 @@ public Exam addExam(Course course, ZonedDateTime visibleDate, ZonedDateTime star
         exam.setVisibleDate(visibleDate);
         exam.setStartDate(startDate);
         exam.setEndDate(endDate);
-        exam.setWorkingTime((int) Duration.between(startDate, endDate).toSeconds());
+        exam.setWorkingTime(exam.getDuration());
         exam.setGracePeriod(180);
         exam = examRepository.save(exam);
         return exam;
@@ -343,7 +342,7 @@ public Exam addExam(Course course, ZonedDateTime visibleDate, ZonedDateTime star
         exam.setStartDate(startDate);
         exam.setEndDate(endDate);
         exam.setPublishResultsDate(publishResultDate);
-        exam.setWorkingTime((int) Duration.between(startDate, endDate).toSeconds());
+        exam.setWorkingTime(exam.getDuration());
         exam.setGracePeriod(180);
         exam = examRepository.save(exam);
         return exam;
@@ -372,7 +371,7 @@ public Exam addActiveExamWithRegisteredUser(Course course, User user) {
         studentExam.setExam(exam);
         studentExam.setTestRun(false);
         studentExam.setUser(user);
-        studentExam.setWorkingTime((int) Duration.between(exam.getStartDate(), exam.getEndDate()).toSeconds());
+        studentExam.setWorkingTime(exam.getDuration());
         studentExamRepository.save(studentExam);
         return exam;
     }
@@ -437,7 +436,7 @@ public StudentExam addStudentExamWithUser(Exam exam, String user) {
     public StudentExam addStudentExamWithUser(Exam exam, User user) {
         StudentExam studentExam = ExamFactory.generateStudentExam(exam);
         studentExam.setUser(user);
-        studentExam.setWorkingTime((int) Duration.between(exam.getStartDate(), exam.getEndDate()).toSeconds());
+        studentExam.setWorkingTime(exam.getDuration());
         studentExam = studentExamRepository.save(studentExam);
         return studentExam;
     }
@@ -463,7 +462,7 @@ public StudentExam addStudentExamForTestExam(Exam exam, User user) {
     public StudentExam addStudentExamWithUser(Exam exam, User user, int additionalWorkingTime) {
         StudentExam studentExam = ExamFactory.generateStudentExam(exam);
         studentExam.setUser(user);
-        studentExam.setWorkingTime((int) Duration.between(exam.getStartDate(), exam.getEndDate()).toSeconds() + additionalWorkingTime);
+        studentExam.setWorkingTime(exam.getDuration() + additionalWorkingTime);
         studentExam = studentExamRepository.save(studentExam);
         return studentExam;
     }
@@ -674,7 +673,7 @@ public void setVisibleStartAndEndDateOfExam(Exam exam, ZonedDateTime visibleDate
         exam.setVisibleDate(visibleDate);
         exam.setStartDate(startDate);
         exam.setEndDate(endDate);
-        exam.setWorkingTime((int) Duration.between(startDate, endDate).toSeconds());
+        exam.setWorkingTime(exam.getDuration());
     }
 
     public StudentExam addExercisesWithParticipationsAndSubmissionsToStudentExam(Exam exam, StudentExam studentExam, String validModel, URI localRepoPath) {

src/test/java/de/tum/in/www1/artemis/exercise/programmingexercise/ProgrammingSubmissionAndResultBitbucketBambooIntegrationTest.java

@@ -1,6 +1,7 @@
 package de.tum.in.www1.artemis.exercise.programmingexercise;
 
-import static de.tum.in.www1.artemis.config.Constants.*;
+import static de.tum.in.www1.artemis.config.Constants.ASSIGNMENT_REPO_NAME;
+import static de.tum.in.www1.artemis.config.Constants.NEW_RESULT_TOPIC;
 import static de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage.C;
 import static de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage.JAVA;
 import static de.tum.in.www1.artemis.exercise.programmingexercise.ProgrammingSubmissionConstants.*;
@@ -9,7 +10,6 @@
 import static org.mockito.AdditionalAnswers.answer;
 import static org.mockito.Mockito.*;
 
-import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
@@ -53,7 +53,6 @@
 import de.tum.in.www1.artemis.exercise.ExerciseUtilService;
 import de.tum.in.www1.artemis.participation.ParticipationUtilService;
 import de.tum.in.www1.artemis.repository.*;
-import de.tum.in.www1.artemis.service.connectors.bamboo.dto.BambooBuildLogDTO;
 import de.tum.in.www1.artemis.service.connectors.bamboo.dto.BambooBuildResultNotificationDTO;
 import de.tum.in.www1.artemis.service.connectors.bamboo.dto.BambooBuildResultNotificationDTO.BambooTestJobDTO;
 import de.tum.in.www1.artemis.service.exam.ExamDateService;
@@ -683,8 +682,6 @@ void shouldSaveBuildLogsOnStudentParticipationWithoutResult(ProgrammingLanguage
         var submission = programmingExerciseUtilService.createProgrammingSubmission(participation, false);
 
         // Call programming-exercises/new-result which includes build log entries
-        final var buildLog = new BambooBuildLogDTO(ZonedDateTime.now().minusMinutes(1), "[ERROR] COMPILATION ERROR missing something",
-                "[ERROR] COMPILATION ERROR missing something");
         postResultWithBuildLogs(participation.getBuildPlanId(), HttpStatus.OK, false, false);
 
         var result = assertBuildError(participation.getId(), userLogin, programmingLanguage);
@@ -809,7 +806,7 @@ private StudentExam createEndedStudentExamWithGracePeriod(User user, Integer gra
         exam = examRepository.save(exam);
 
         var studentExam = studentExamRepository.findWithExercisesByUserIdAndExamId(user.getId(), exam.getId()).orElseThrow();
-        studentExam.setWorkingTime((int) Duration.between(exam.getStartDate(), exam.getEndDate()).getSeconds());
+        studentExam.setWorkingTime(exam.getDuration());
         studentExam.setExercises(new ArrayList<>(exam.getExerciseGroups().get(6).getExercises()));
         studentExam.setUser(user);
         studentExam = studentExamRepository.save(studentExam);
@@ -967,7 +964,7 @@ private Result assertBuildError(Long participationId, String userLogin, Programm
 
         // Assert that the build logs can be retrieved from the REST API
         userUtilService.changeUser(userLogin);
-        var receivedLogs = request.get("/api/repository/" + participationId + "/buildlogs", HttpStatus.OK, List.class);
+        var receivedLogs = request.getList("/api/repository/" + participationId + "/buildlogs", HttpStatus.OK, BuildLogEntry.class);
         assertThat(receivedLogs).isNotNull();
         assertThat(receivedLogs).hasSameSizeAs(submissionWithLogs.getBuildLogEntries());