Exam mode: Improve exam validation (#11960)

Author: krusche

src/main/java/de/tum/cit/aet/artemis/exam/web/ExamResource.java

@@ -410,6 +410,7 @@ public ResponseEntity<Exam> importExamWithExercises(@PathVariable Long courseId,
     private void checkForExamConflictsElseThrow(Long courseId, Exam exam) {
         checkExamCourseIdElseThrow(courseId, exam);
         checkExamForDatesConflictsElseThrow(exam);
+        checkExamNumericFieldLimitsElseThrow(exam);
         checkExamForWorkingTimeConflictsElseThrow(exam);
         checkExamPointsAndCorrectionRoundsElseThrow(exam);
 
@@ -432,6 +433,40 @@ private void checkExamCourseIdElseThrow(Long courseId, Exam exam) {
         }
     }
 
+    /**
+     * Validates numeric field limits for exam configuration.
+     * Maximum values:
+     * - Working time: 2592000 seconds (30 days)
+     * - Grace period: 3600 seconds (1 hour)
+     * - Exam max points: 9999
+     * - Number of exercises: 100
+     *
+     * @param exam the exam to be checked
+     */
+    private void checkExamNumericFieldLimitsElseThrow(Exam exam) {
+        // Max working time: 30 days = 2592000 seconds
+        final int maxWorkingTimeSeconds = 2_592_000;
+        final int workingTimeToCheck = exam.isTestExam() ? exam.getWorkingTime() : exam.getDuration();
+        if (workingTimeToCheck > maxWorkingTimeSeconds) {
+            throw new BadRequestAlertException("The working time is too long. Maximum allowed is 30 days (43200 minutes).", ENTITY_NAME, "examWorkingTimeTooHigh");
+        }
+
+        // Grace period: max 1 hour = 3600 seconds
+        if (exam.getGracePeriod() != null && exam.getGracePeriod() > 3600) {
+            throw new BadRequestAlertException("The grace period is too long. Maximum allowed is 3600 seconds.", ENTITY_NAME, "examGracePeriodTooHigh");
+        }
+
+        // Max points: max 9999
+        if (exam.getExamMaxPoints() > 9999) {
+            throw new BadRequestAlertException("The maximum points value is too high. Maximum allowed is 9999.", ENTITY_NAME, "examMaxPointsTooHigh");
+        }
+
+        // Number of exercises: max 100
+        if (exam.getNumberOfExercisesInExam() != null && exam.getNumberOfExercisesInExam() > 100) {
+            throw new BadRequestAlertException("The number of exercises is too high. Maximum allowed is 100.", ENTITY_NAME, "examNumberOfExercisesTooHigh");
+        }
+    }
+
     /**
      * Checks that the visible/start/end-dates are present and in the correct order.
      * For real exams: visibleDate < startDate < endDate

src/main/webapp/app/exam/manage/exams/update/exam-update.component.html

@@ -17,12 +17,10 @@ <h4 jhiTranslate="artemisApp.examManagement.editExam"></h4>
             <div>
                 <hr />
                 <h5 class="pb-1" jhiTranslate="artemisApp.examManagement.sections.configuration"></h5>
-                <label class="form-check-label" jhiTranslate="artemisApp.examManagement.examTitle"></label>
                 <jhi-title-channel-name
                     [(title)]="exam.title"
                     [(channelName)]="exam.channelName"
                     channelNamePrefix="exam-"
-                    [hideTitleLabel]="true"
                     [hideChannelName]="hideChannelNameInput"
                     [initChannelName]="isImport || exam.id === undefined"
                 />
@@ -127,6 +125,9 @@ <h5 class="pb-1" jhiTranslate="artemisApp.examManagement.sections.conduction"></
                     <jhi-help-icon [text]="'artemisApp.examManagement' + (exam.testExam ? '.testExam' : '') + '.workingTimeTooltip'" />
                     @if (!exam.testExam) {
                         <input readonly disabled type="text" class="form-control" [value]="workingTimeInMinutesRounded" />
+                        @if (isWorkingTimeTooHigh) {
+                            <div class="alert alert-danger" jhiTranslate="error.examWorkingTimeTooHigh"></div>
+                        }
                     }
                     @if (exam.testExam) {
                         <input
@@ -139,13 +140,20 @@ <h5 class="pb-1" jhiTranslate="artemisApp.examManagement.sections.conduction"></
                             [(ngModel)]="workingTimeInMinutes"
                             (focusin)="roundWorkingTime()"
                             (focusout)="roundWorkingTime()"
+                            #workingTimeInput="ngModel"
                         />
+                        @if (workingTimeInput.errors?.['max'] || isWorkingTimeTooHigh) {
+                            <div class="alert alert-danger" jhiTranslate="error.examWorkingTimeTooHigh"></div>
+                        }
                     }
                 </div>
                 <div class="col-sm-6">
                     <label class="form-check-label" for="gracePeriod" jhiTranslate="artemisApp.examManagement.gracePeriod"></label>
                     <jhi-help-icon text="artemisApp.examManagement.gracePeriodTooltip" />
-                    <input id="gracePeriod" name="gracePeriod" class="form-control" type="number" min="0" [(ngModel)]="exam.gracePeriod" />
+                    <input id="gracePeriod" name="gracePeriod" class="form-control" type="number" min="0" max="3600" [(ngModel)]="exam.gracePeriod" #gracePeriodInput="ngModel" />
+                    @if (gracePeriodInput.errors?.['max']) {
+                        <div class="alert alert-danger" jhiTranslate="error.examGracePeriodTooHigh"></div>
+                    }
                 </div>
             </div>
             <hr />
@@ -155,14 +163,38 @@ <h5 class="pb-1" jhiTranslate="artemisApp.examManagement.sections.exercises"></h
                 <div class="col-sm-6">
                     <label class="form-check-label" for="examMaxPoints" jhiTranslate="artemisApp.examManagement.maxPoints.title"></label>
                     <fa-icon [icon]="faExclamationTriangle" class="text-warning" ngbTooltip="{{ 'artemisApp.examManagement.maxPoints.warning' | artemisTranslate }}" />
-                    <input id="examMaxPoints" name="examMaxPoints" class="form-control" type="number" min="1" [(ngModel)]="exam.examMaxPoints" />
+                    <input
+                        id="examMaxPoints"
+                        name="examMaxPoints"
+                        class="form-control"
+                        type="number"
+                        min="1"
+                        max="9999"
+                        [(ngModel)]="exam.examMaxPoints"
+                        #examMaxPointsInput="ngModel"
+                    />
+                    @if (examMaxPointsInput.errors?.['max']) {
+                        <div class="alert alert-danger" jhiTranslate="error.examMaxPointsTooHigh"></div>
+                    }
                 </div>
                 <div class="col-sm-6">
                     <label class="form-check-label" for="numberOfExercisesInExam" jhiTranslate="artemisApp.examManagement.numberOfExercisesInExam"
                         >Number of Exercises in Exam</label
                     >
                     <jhi-help-icon [text]="'artemisApp.examManagement.numberOfExercisesInExamTooltip'" />
-                    <input id="numberOfExercisesInExam" name="numberOfExercisesInExam" class="form-control" type="number" min="1" [(ngModel)]="exam.numberOfExercisesInExam" />
+                    <input
+                        id="numberOfExercisesInExam"
+                        name="numberOfExercisesInExam"
+                        class="form-control"
+                        type="number"
+                        min="1"
+                        max="100"
+                        [(ngModel)]="exam.numberOfExercisesInExam"
+                        #numberOfExercisesInput="ngModel"
+                    />
+                    @if (numberOfExercisesInput.errors?.['max']) {
+                        <div class="alert alert-danger" jhiTranslate="error.examNumberOfExercisesTooHigh"></div>
+                    }
                 </div>
             </div>
             <div class="form-check mb-3">

src/main/webapp/app/exam/manage/exams/update/exam-update.component.spec.ts

@@ -575,6 +575,79 @@ describe('ExamUpdateComponent', () => {
             fixture.changeDetectorRef.detectChanges();
             expect(component.exam.numberOfExercisesInExam).toBe(40);
             expect(component.isValidNumberOfExercises).toBeTrue();
+
+            // Test max limit of 100
+            examWithoutExercises.numberOfExercisesInExam = 100;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.numberOfExercisesInExam).toBe(100);
+            expect(component.isValidNumberOfExercises).toBeTrue();
+
+            examWithoutExercises.numberOfExercisesInExam = 101;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.numberOfExercisesInExam).toBe(101);
+            expect(component.isValidNumberOfExercises).toBeFalse();
+        });
+
+        it('should correctly validate max points with upper limit of 9999', () => {
+            fixture.detectChanges();
+
+            examWithoutExercises.examMaxPoints = 100;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.examMaxPoints).toBe(100);
+            expect(component.isValidMaxPoints).toBeTrue();
+
+            examWithoutExercises.examMaxPoints = 9999;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.examMaxPoints).toBe(9999);
+            expect(component.isValidMaxPoints).toBeTrue();
+
+            examWithoutExercises.examMaxPoints = 10000;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.examMaxPoints).toBe(10000);
+            expect(component.isValidMaxPoints).toBeFalse();
+        });
+
+        it('should correctly validate grace period with upper limit of 3600 seconds', () => {
+            fixture.detectChanges();
+
+            examWithoutExercises.gracePeriod = 180;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.gracePeriod).toBe(180);
+            expect(component.isValidGracePeriod).toBeTrue();
+
+            examWithoutExercises.gracePeriod = 3600;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.gracePeriod).toBe(3600);
+            expect(component.isValidGracePeriod).toBeTrue();
+
+            examWithoutExercises.gracePeriod = 3601;
+            fixture.changeDetectorRef.detectChanges();
+            expect(component.exam.gracePeriod).toBe(3601);
+            expect(component.isValidGracePeriod).toBeFalse();
+        });
+
+        it('should correctly validate working time with upper limit of 30 days (2592000 seconds)', () => {
+            fixture.detectChanges();
+
+            // Set up exam as a test exam with a long exam window
+            examWithoutExercises.testExam = true;
+            examWithoutExercises.startDate = dayjs().add(0, 'hours');
+            examWithoutExercises.endDate = dayjs().add(35, 'days'); // Long exam window
+
+            // Valid working time
+            examWithoutExercises.workingTime = 86400; // 1 day
+            expect(component.exam.workingTime).toBe(86400);
+            expect(component.validateWorkingTime).toBeTrue();
+
+            // Working time at limit (30 days = 2592000 seconds)
+            examWithoutExercises.workingTime = 2592000;
+            expect(component.exam.workingTime).toBe(2592000);
+            expect(component.validateWorkingTime).toBeTrue();
+
+            // Working time exceeds limit
+            examWithoutExercises.workingTime = 2592001;
+            expect(component.exam.workingTime).toBe(2592001);
+            expect(component.validateWorkingTime).toBeFalse();
         });
 
         it('should bind correct title into jhi-button and compute correct save title text', () => {

src/main/webapp/app/exam/manage/exams/update/exam-update.component.ts

@@ -115,6 +115,11 @@ export class ExamUpdateComponent implements OnInit, OnDestroy, AfterViewInit {
                 this.course = data.course;
                 this.exam.course = data.course;
 
+                // Prefill course name with course title for new exams
+                if (!this.exam.id && !this.exam.courseName && this.course.title) {
+                    this.exam.courseName = this.course.title;
+                }
+
                 if (!this.exam.startText) {
                     this.exam.startText = this.examDefaultStartText;
                 }
@@ -356,25 +361,30 @@ export class ExamUpdateComponent implements OnInit, OnDestroy, AfterViewInit {
         const examValidWorkingTime = this.validateWorkingTime;
         const examValidExampleSolutionPublicationDate = this.isValidExampleSolutionPublicationDate;
         const examValidNumberOfExercises = this.isValidNumberOfExercises;
+        const examValidGracePeriod = this.isValidGracePeriod;
         return (
             examConductionDatesValid &&
             examReviewDatesValid &&
             examNumberOfCorrectionsValid &&
             examMaxPointsValid &&
             examValidWorkingTime &&
             examValidExampleSolutionPublicationDate &&
-            examValidNumberOfExercises
+            examValidNumberOfExercises &&
+            examValidGracePeriod
         );
     }
 
     /**
      * Returns a boolean indicating whether the exam's number of exercises is valid.
-     * The number of exercises is valid if it's not set, or if it's at least 1.
+     * The number of exercises is valid if it's not set, or if it's between 1 and 100.
      *
      * @returns {boolean} `true` if the exam's number of exercises is valid, `false` otherwise.
      */
     get isValidNumberOfExercises(): boolean {
-        return this.exam.numberOfExercisesInExam === undefined || this.exam.numberOfExercisesInExam === null || this.exam.numberOfExercisesInExam! >= 1;
+        if (this.exam.numberOfExercisesInExam === undefined || this.exam.numberOfExercisesInExam === null) {
+            return true;
+        }
+        return this.exam.numberOfExercisesInExam >= 1 && this.exam.numberOfExercisesInExam <= 100;
     }
 
     /**
@@ -405,7 +415,20 @@ export class ExamUpdateComponent implements OnInit, OnDestroy, AfterViewInit {
     }
 
     get isValidMaxPoints(): boolean {
-        return !!this.exam?.examMaxPoints && this.exam?.examMaxPoints > 0;
+        return !!this.exam?.examMaxPoints && this.exam?.examMaxPoints > 0 && this.exam?.examMaxPoints <= 9999;
+    }
+
+    /**
+     * Returns a boolean indicating whether the exam's grace period is valid.
+     * The grace period is valid if it's not set, or if it's between 0 and 3600 seconds.
+     *
+     * @returns {boolean} `true` if the exam's grace period is valid, `false` otherwise.
+     */
+    get isValidGracePeriod(): boolean {
+        if (this.exam.gracePeriod === undefined || this.exam.gracePeriod === null) {
+            return true;
+        }
+        return this.exam.gracePeriod >= 0 && this.exam.gracePeriod <= 3600;
     }
 
     /**
@@ -470,27 +493,52 @@ export class ExamUpdateComponent implements OnInit, OnDestroy, AfterViewInit {
         return true;
     }
 
+    /**
+     * Maximum working time in seconds (30 days).
+     */
+    readonly maxWorkingTimeSeconds = 2592000;
+
     /**
      * Validates the WorkingTime.
-     * For test exams, the WorkingTime should be at least 1 and smaller / equal to the working window
-     * For real exams, the WorkingTime is calculated based on the startDate and EndDate and should match the time difference.
+     * For test exams, the WorkingTime should be at least 1 and smaller / equal to the working window,
+     * and must not exceed 30 days (2592000 seconds).
+     * For real exams, the WorkingTime is calculated based on the startDate and EndDate and should match the time difference,
+     * and must not exceed 30 days (2592000 seconds).
      */
     get validateWorkingTime(): boolean {
         if (this.exam.testExam) {
             if (this.exam.workingTime === undefined || this.exam.workingTime < 1) {
                 return false;
             }
+            // Check 30-day limit
+            if (this.exam.workingTime > this.maxWorkingTimeSeconds) {
+                return false;
+            }
             if (this.exam.startDate && this.exam.endDate) {
                 return this.exam.workingTime <= dayjs(this.exam.endDate).diff(this.exam.startDate, 's');
             }
             return false;
         }
         if (this.exam.workingTime && this.exam.startDate && this.exam.endDate) {
+            // Check 30-day limit for real exams as well
+            if (this.exam.workingTime > this.maxWorkingTimeSeconds) {
+                return false;
+            }
             return this.exam.workingTime === dayjs(this.exam.endDate).diff(this.exam.startDate, 's');
         }
         return false;
     }
 
+    /**
+     * Returns true if the working time exceeds the maximum allowed limit of 30 days.
+     */
+    get isWorkingTimeTooHigh(): boolean {
+        if (this.exam.workingTime === undefined || this.exam.workingTime === null) {
+            return false;
+        }
+        return this.exam.workingTime > this.maxWorkingTimeSeconds;
+    }
+
     get isValidPublishResultsDate(): boolean {
         // allow instructors to set publishResultsDate later
         if (!this.exam.publishResultsDate) {

src/main/webapp/i18n/de/error.json

@@ -204,6 +204,16 @@
             "courseIdMissing": "Die Kurs ID ist erforderlich.",
             "forbidChangeCourseId": "Die Übungskurs-ID stimmt nicht mit der gespeicherten Kurs-ID überein"
         },
+        "noCourse": "Eine Klausur muss zu einem Kurs gehören.",
+        "wrongCourseId": "Die Kurs-ID stimmt nicht mit dem Kurs der Klausur überein.",
+        "examTimes": "Ungültige Klausurzeiten: Bitte stelle sicher, dass das Sichtbarkeitsdatum vor dem Startdatum liegt, das Startdatum vor dem Enddatum liegt und das Veröffentlichungsdatum der Beispiellösung (falls gesetzt) nach dem Enddatum liegt.",
+        "negativePoints": "Die maximale Punktzahl einer Klausur muss größer als 0 sein.",
+        "correctionRoundViolation": "Ungültige Anzahl an Korrekturläufen: Testklausuren müssen 0 Korrekturläufe haben, echte Klausuren müssen 1 oder 2 Korrekturläufe haben.",
+        "attendanceCheckViolation": "Testklausuren können keine Anwesenheitskontrolle haben.",
+        "examWorkingTimeTooHigh": "Die Bearbeitungszeit ist zu lang. Das Maximum beträgt 43200 Minuten (30 Tage). Bitte passe den Start und/oder das Ende der Bearbeitungszeit an.",
+        "examGracePeriodTooHigh": "Die Nachfrist ist zu lang. Bitte gib einen Wert zwischen 0 und 3600 Sekunden ein.",
+        "examMaxPointsTooHigh": "Die maximale Punktzahl ist zu hoch. Bitte gib einen Wert zwischen 1 und 9999 ein.",
+        "examNumberOfExercisesTooHigh": "Die Anzahl der Aufgaben ist zu hoch. Bitte gib einen Wert zwischen 1 und 100 ein.",
         "userManagement": {
             "onlySuperAdminCanCreateSuperAdmin": "Du bist kein Super-Administrator und kannst daher keinen Super-Administrator-Account erstellen.",
             "onlySuperAdminCanManageSuperAdmins": "Du bist kein Super-Administrator und kannst daher keine Super-Administratoren-Accounts verwalten."