Tutor exam dashboard for the assessment of exams

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

@@ -49,4 +49,7 @@ public interface CourseRepository extends JpaRepository<Course, Long> {
     List<Course> findAllCurrentlyActiveAndNotOnlineAndEnabled(@Param("now") ZonedDateTime now);
 
     List<Course> findAllByShortName(String shortName);
+
+    Optional<Course> findById(long courseId);
+
 }

src/main/java/de/tum/in/www1/artemis/service/CourseService.java

@@ -1,7 +1,10 @@
 package de.tum.in.www1.artemis.service;
 
 import java.time.ZonedDateTime;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import javax.validation.constraints.NotNull;
@@ -14,6 +17,7 @@
 import de.tum.in.www1.artemis.domain.Course;
 import de.tum.in.www1.artemis.domain.Exercise;
 import de.tum.in.www1.artemis.domain.User;
+import de.tum.in.www1.artemis.domain.exam.Exam;
 import de.tum.in.www1.artemis.domain.exam.ExerciseGroup;
 import de.tum.in.www1.artemis.repository.CourseRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
@@ -183,6 +187,39 @@ public Course findOneWithExercises(long courseId) {
         return courseRepository.findWithEagerExercisesById(courseId);
     }
 
+    /**
+     * Get one course by id with all exercises for all exams
+     * @param courseId - The id of the entity
+     * @param examId - Id of the exam that contains the exercises
+     * @return the entity
+     */
+    public Course findOneWithExamExercises(long courseId, long examId) {
+        log.debug("Request to get Course : {}", courseId);
+        Optional<Course> optionalCourse = courseRepository.findById(courseId);
+
+        if (optionalCourse.isPresent()) {
+            Course course = optionalCourse.get();
+            Set<Exercise> exercises = new HashSet<>();
+
+            Exam exam = this.examService.findOneWithExerciseGroupsAndExercises(examId);
+
+            // check that exam is over
+            if (exam.getEndDate().isBefore(ZonedDateTime.now())) {
+                // extract all exercises for all the exam
+                List<ExerciseGroup> exerciseGroups = exam.getExerciseGroups();
+                for (ExerciseGroup exerciseGroup : exerciseGroups) {
+                    exercises.addAll(exerciseGroup.getExercises());
+                }
+            }
+
+            // set all exam exercises
+            course.setExercises(exercises);
+
+            return course;
+        }
+        return null;
+    }
+
     public Course findOneWithExercisesAndLectures(long courseId) {
         log.debug("Request to get Course : {}", courseId);
         return courseRepository.findWithEagerExercisesAndLecturesById(courseId);

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

@@ -558,6 +558,67 @@ public ResponseEntity<Course> getCourseForTutorDashboard(@PathVariable long cour
         return ResponseUtil.wrapOrNotFound(Optional.of(course));
     }
 
+    /**
+     * GET /courses/:courseId/for-exam-tutor-dashboard
+     *
+     * @param courseId the id of the course to retrieve
+     * @param examId the id of the exam that contains the exercises
+     * @return data about a course including all exercises, plus some data for the tutor as tutor status for assessment
+     */
+    @GetMapping("/courses/{courseId}/exam/{examId}/for-exam-tutor-dashboard")
+    @PreAuthorize("hasAnyRole('TA', 'INSTRUCTOR', 'ADMIN')")
+    public ResponseEntity<Course> getCourseForExamTutorDashboard(@PathVariable long courseId, @PathVariable long examId) {
+        log.debug("REST request /courses/{courseId}/exam/{examId}/for-exam-tutor-dashboard");
+        Course course = courseService.findOneWithExamExercises(courseId, examId);
+        if (course == null) {
+            return notFound();
+        }
+        User user = userService.getUserWithGroupsAndAuthorities();
+        if (!userHasPermission(course, user)) {
+            return forbidden();
+        }
+
+        Set<Exercise> interestingExercises = course.getInterestingExercisesForAssessmentDashboards();
+        course.setExercises(interestingExercises);
+
+        List<TutorParticipation> tutorParticipations = tutorParticipationService.findAllByCourseAndTutor(course, user);
+
+        for (Exercise exercise : course.getExercises()) {
+
+            DueDateStat numberOfSubmissions;
+            DueDateStat numberOfAssessments;
+
+            if (exercise instanceof ProgrammingExercise) {
+                numberOfSubmissions = new DueDateStat(programmingExerciseService.countSubmissionsByExerciseIdSubmitted(exercise.getId()), 0L);
+                numberOfAssessments = new DueDateStat(programmingExerciseService.countAssessmentsByExerciseIdSubmitted(exercise.getId()), 0L);
+            }
+            else {
+                numberOfSubmissions = submissionService.countSubmissionsForExercise(exercise.getId());
+                numberOfAssessments = resultService.countNumberOfFinishedAssessmentsForExercise(exercise.getId());
+            }
+
+            exercise.setNumberOfSubmissions(numberOfSubmissions);
+            exercise.setNumberOfAssessments(numberOfAssessments);
+
+            exerciseService.calculateNrOfOpenComplaints(exercise);
+
+            List<ExampleSubmission> exampleSubmissions = this.exampleSubmissionRepository.findAllByExerciseId(exercise.getId());
+            // Do not provide example submissions without any assessment
+            exampleSubmissions.removeIf(exampleSubmission -> exampleSubmission.getSubmission() == null || exampleSubmission.getSubmission().getResult() == null);
+            exercise.setExampleSubmissions(new HashSet<>(exampleSubmissions));
+
+            TutorParticipation tutorParticipation = tutorParticipations.stream().filter(participation -> participation.getAssessedExercise().getId().equals(exercise.getId()))
+                    .findFirst().orElseGet(() -> {
+                        TutorParticipation emptyTutorParticipation = new TutorParticipation();
+                        emptyTutorParticipation.setStatus(TutorParticipationStatus.NOT_PARTICIPATED);
+                        return emptyTutorParticipation;
+                    });
+            exercise.setTutorParticipations(Collections.singleton(tutorParticipation));
+        }
+
+        return ResponseUtil.wrapOrNotFound(Optional.of(course));
+    }
+
     /**
      * GET /courses/:courseId/stats-for-tutor-dashboard A collection of useful statistics for the tutor course dashboard, including: - number of submissions to the course - number of
      * assessments - number of assessments assessed by the tutor - number of complaints

src/main/webapp/app/course/dashboards/tutor-course-dashboard/tutor-course-dashboard.component.ts

@@ -53,6 +53,8 @@ export class TutorCourseDashboardComponent implements OnInit, AfterViewInit {
 
     exerciseForGuidedTour: Exercise | null;
 
+    isExamMode: boolean;
+
     constructor(
         private courseService: CourseManagementService,
         private jhiAlertService: AlertService,
@@ -84,7 +86,9 @@ export class TutorCourseDashboardComponent implements OnInit, AfterViewInit {
      * Percentages are calculated and rounded towards zero.
      */
     loadAll() {
-        this.courseService.getForTutors(this.courseId).subscribe(
+        const examId = Number(this.route.snapshot.paramMap.get('examId'));
+        this.isExamMode = !!examId;
+        this.courseService.getForTutors(this.courseId, examId).subscribe(
             (res: HttpResponse<Course>) => {
                 this.course = Course.from(res.body!);
                 this.course.isAtLeastTutor = this.accountService.isAtLeastTutorInCourse(this.course);
@@ -163,7 +167,11 @@ export class TutorCourseDashboardComponent implements OnInit, AfterViewInit {
      * Navigate back to the course management page.
      */
     back() {
-        this.router.navigate(['course-management']);
+        if (this.isExamMode) {
+            this.router.navigate(['course-management', this.course.id, 'exams']);
+        } else {
+            this.router.navigate(['course-management']);
+        }
     }
 
     sortRows() {

src/main/webapp/app/course/manage/course-management.service.ts

@@ -158,11 +158,18 @@ export class CourseManagementService {
     /**
      * returns the course with the provided unique identifier for the tutor dashboard
      * @param courseId - the id of the course
+     * @param examId - Id of the exam when it is in exam mode, otherwise undefined
      */
-    getForTutors(courseId: number): Observable<EntityResponseType> {
-        return this.http
-            .get<Course>(`${this.resourceUrl}/${courseId}/for-tutor-dashboard`, { observe: 'response' })
-            .pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)));
+    getForTutors(courseId: number, examId: number): Observable<EntityResponseType> {
+        if (examId) {
+            return this.http
+                .get<Course>(`${this.resourceUrl}/${courseId}/exam/${examId}/for-exam-tutor-dashboard`, { observe: 'response' })
+                .pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)));
+        } else {
+            return this.http
+                .get<Course>(`${this.resourceUrl}/${courseId}/for-tutor-dashboard`, { observe: 'response' })
+                .pipe(map((res: EntityResponseType) => this.convertDateFromServer(res)));
+        }
     }
 
     /**

src/main/webapp/app/exam/manage/exam-management.component.html

@@ -65,6 +65,19 @@ <h4 id="course-page-heading" jhiTranslate="artemisApp.examManagement.title">Exam
                     <td>{{ exam.startDate | durationTo: exam.endDate }}</td>
                     <td>{{ exam.numberOfRegisteredUsers }}</td>
                     <td class="text-right">
+                        <div class="btn-group-vertical mr-1 mb-1">
+                            <button
+                                *ngIf="isAtLeastInstructor"
+                                type="submit"
+                                [routerLink]="[exam.id, 'tutor-exam-dashboard']"
+                                class="btn btn-primary btn-sm mr-1 mb-1 exercise-button"
+                                id="exercises-button-{{ exam.id }}"
+                            >
+                                <fa-icon [icon]="'th-list'"></fa-icon>
+                                <span class="d-none d-md-inline">{{ 'artemisApp.examManagement.tutorDashboard' | translate }}</span>
+                            </button>
+                        </div>
+
                         <div class="btn-group flex-btn-group-container">
                             <div class="btn-group-vertical mr-1 mb-1">
                                 <button

src/main/webapp/app/exam/manage/exam-management.route.ts

@@ -26,6 +26,7 @@ import { FileUploadExerciseResolve } from 'app/exercises/file-upload/manage/file
 import { QuizExerciseDetailComponent } from 'app/exercises/quiz/manage/quiz-exercise-detail.component';
 import { ProgrammingExerciseUpdateComponent } from 'app/exercises/programming/manage/update/programming-exercise-update.component';
 import { ProgrammingExerciseResolve } from 'app/exercises/programming/manage/programming-exercise-management-routing.module';
+import { TutorCourseDashboardComponent } from 'app/course/dashboards/tutor-course-dashboard/tutor-course-dashboard.component';
 
 @Injectable({ providedIn: 'root' })
 export class ExamResolve implements Resolve<Exam> {
@@ -349,6 +350,15 @@ export const examManagementRoute: Routes = [
         },
         canActivate: [UserRouteAccessService],
     },
+    {
+        path: ':examId/tutor-exam-dashboard',
+        component: TutorCourseDashboardComponent,
+        data: {
+            authorities: ['ROLE_ADMIN', 'ROLE_INSTRUCTOR', 'ROLE_TA'],
+            pageTitle: 'artemisApp.examManagement.tutorDashboard',
+        },
+        canActivate: [UserRouteAccessService],
+    },
 ];
 
 const EXAM_MANAGEMENT_ROUTES = [...examManagementRoute];

src/main/webapp/app/exercises/shared/dashboards/tutor/tutor-exercise-dashboard.component.ts

@@ -1,6 +1,6 @@
 import { Component, OnInit, AfterViewInit } from '@angular/core';
 import { SafeHtml } from '@angular/platform-browser';
-import { ActivatedRoute, Router } from '@angular/router';
+import { ActivatedRoute, Router, ParamMap } from '@angular/router';
 import { CourseManagementService } from 'app/course/manage/course-management.service';
 import { AlertService } from 'app/core/alert/alert.service';
 import { User } from 'app/core/user/user.model';
@@ -452,6 +452,10 @@ export class TutorExerciseDashboardComponent implements OnInit, AfterViewInit {
      * Navigates back to the tutor dashboard
      */
     back() {
-        this.router.navigate([`/course-management/${this.courseId}/tutor-dashboard`]);
+        if (this.exercise?.course) {
+            this.router.navigate([`/course-management/${this.courseId}/tutor-dashboard`]);
+        } else {
+            this.router.navigate([`/course-management/${this.courseId}/exams/${this.exercise!.exerciseGroup!.exam!.id}/tutor-exam-dashboard`]);
+        }
     }
 }

src/main/webapp/app/exercises/text/assess-new/text-submission-assessment.component.ts

@@ -30,6 +30,7 @@ import { StructuredGradingCriterionService } from 'app/exercises/shared/structur
 export class TextSubmissionAssessmentComponent implements OnInit {
     private userId: number | null;
     exerciseId: number;
+    courseId: number;
     participation: StudentParticipation | null;
     submission: TextSubmission | null;
     exercise: TextExercise | null;
@@ -133,7 +134,14 @@ export class TextSubmissionAssessmentComponent implements OnInit {
         this.submission = this.participation?.submissions[0] as TextSubmission;
         this.exercise = this.participation?.exercise as TextExercise;
         this.result = this.submission?.result;
-        this.isAtLeastInstructor = this.accountService.isAtLeastInstructorInCourse(this.exercise!.course!);
+        this.courseId = this.exercise?.course ? this.exercise?.course?.id! : this.exercise?.exerciseGroup?.exam?.course?.id!;
+
+        // case distinction for exam mode
+        if (this.exercise!.course) {
+            this.isAtLeastInstructor = this.accountService.isAtLeastInstructorInCourse(this.exercise!.course);
+        } else {
+            this.isAtLeastInstructor = this.accountService.isAtLeastInstructorInCourse(this.exercise!.exerciseGroup!.exam!.course!);
+        }
         this.prepareTextBlocksAndFeedbacks();
         this.getComplaint();
         this.updateUrlIfNeeded();
@@ -147,7 +155,7 @@ export class TextSubmissionAssessmentComponent implements OnInit {
         if (this.isNewAssessmentRoute) {
             // Update the url with the new id, without reloading the page, to make the history consistent
             const newUrl = this.router
-                .createUrlTree(['course-management', this.exercise?.course?.id, 'text-exercises', this.exercise?.id, 'submissions', this.submission?.id, 'assessment'])
+                .createUrlTree(['course-management', this.courseId, 'text-exercises', this.exercise?.id, 'submissions', this.submission?.id, 'assessment'])
                 .toString();
             this.location.go(newUrl);
         }
@@ -215,7 +223,7 @@ export class TextSubmissionAssessmentComponent implements OnInit {
      */
     async nextSubmission(): Promise<void> {
         this.nextSubmissionBusy = true;
-        await this.router.navigate(['/course-management', this.exercise?.course?.id, 'text-exercises', this.exercise?.id, 'submissions', 'new', 'assessment']);
+        await this.router.navigate(['/course-management', this.courseId, 'text-exercises', this.exercise?.id, 'submissions', 'new', 'assessment']);
     }
 
     /**
@@ -242,11 +250,11 @@ export class TextSubmissionAssessmentComponent implements OnInit {
     }
 
     navigateBack() {
-        if (this.exercise && this.exercise.teamMode && this.exercise.course && this.submission) {
+        if (this.exercise && this.exercise.teamMode && this.courseId && this.submission) {
             const teamId = (this.submission.participation as StudentParticipation).team.id;
-            this.router.navigateByUrl(`/courses/${this.exercise.course.id}/exercises/${this.exercise.id}/teams/${teamId}`);
-        } else if (this.exercise && !this.exercise.teamMode && this.exercise.course) {
-            this.router.navigateByUrl(`/course-management/${this.exercise.course.id}/exercises/${this.exercise.id}/tutor-dashboard`);
+            this.router.navigateByUrl(`/courses/${this.courseId}/exercises/${this.exercise.id}/teams/${teamId}`);
+        } else if (this.exercise && !this.exercise.teamMode && this.courseId) {
+            this.router.navigateByUrl(`/course-management/${this.courseId}/exercises/${this.exercise.id}/tutor-dashboard`);
         } else {
             this.location.back();
         }

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

@@ -150,7 +150,8 @@
             "delete": {
                 "question": "Soll die Klausur <strong>{{ title }}</strong> wirklich dauerhaft gelöscht werden? Alle zugehörigen Elemente werden auch gelöscht. Diese Aktion kann NICHT rückgängig gemacht werden!",
                 "typeNameToConfirm": "Bitte gib den Namen der Klausur zur Bestätigung ein."
-            }
+            },
+            "tutorDashboard": "Tutor Klausur Dashboard"
         },
         "studentExamDetail": {
             "studentExam": "Klausur ({{ examTitle }})",

src/main/webapp/i18n/en/exam.json

@@ -150,7 +150,8 @@
             "delete": {
                 "question": "Are you sure you want to permanently delete the Exam <strong>{{ title }}</strong>? All associated elements will be deleted. This action can NOT be undone!",
                 "typeNameToConfirm": "Please type in the name of the Exam to confirm."
-            }
+            },
+            "tutorDashboard": "Tutor Exam Dashboard"
         },
         "studentExamDetail": {
             "studentExam": "Student exam ({{ examTitle }})",