Tutor exam dashboard for the assessment of exams

src/main/java/de/tum/in/www1/artemis/domain/Course.java

@@ -1,14 +1,12 @@
 package de.tum.in.www1.artemis.domain;
 
 import static de.tum.in.www1.artemis.config.Constants.ARTEMIS_GROUP_DEFAULT_PREFIX;
-import static de.tum.in.www1.artemis.domain.enumeration.AssessmentType.AUTOMATIC;
 
 import java.io.Serializable;
 import java.time.ZonedDateTime;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import javax.persistence.CascadeType;
 import javax.persistence.Column;
@@ -34,7 +32,6 @@
 
 import de.tum.in.www1.artemis.config.Constants;
 import de.tum.in.www1.artemis.domain.exam.Exam;
-import de.tum.in.www1.artemis.domain.modeling.ModelingExercise;
 import de.tum.in.www1.artemis.domain.view.QuizView;
 import de.tum.in.www1.artemis.service.FilePathService;
 import de.tum.in.www1.artemis.service.FileService;
@@ -580,12 +577,6 @@ public String toString() {
                 + ", presentationScore='" + getPresentationScore() + "}";
     }
 
-    @JsonIgnore
-    public Set<Exercise> getInterestingExercisesForAssessmentDashboards() {
-        return getExercises().stream().filter(exercise -> exercise instanceof TextExercise || exercise instanceof ModelingExercise || exercise instanceof FileUploadExercise
-                || (exercise instanceof ProgrammingExercise && exercise.getAssessmentType() != AUTOMATIC)).collect(Collectors.toSet());
-    }
-
     public void setNumberOfInstructors(Long numberOfInstructors) {
         this.numberOfInstructorsTransient = numberOfInstructors;
     }

src/main/java/de/tum/in/www1/artemis/domain/Exercise.java

@@ -156,7 +156,6 @@ public abstract class Exercise implements Serializable {
 
     @ManyToOne
     @JsonView(QuizView.Before.class)
-    @JsonIgnoreProperties(value = "exercises")
     private ExerciseGroup exerciseGroup;
 
     @OneToMany(mappedBy = "exercise", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)

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

@@ -83,7 +83,7 @@ public class Exam implements Serializable {
     @OneToMany(mappedBy = "exam", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)
     @OrderColumn(name = "exercise_group_order")
     @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
-    @JsonIgnoreProperties("exam")
+    @JsonIgnoreProperties(value = "exam", allowSetters = true)
     private List<ExerciseGroup> exerciseGroups = new ArrayList<>();
 
     // TODO: add a big fat warning in case instructor delete exams where student exams already exist
@@ -253,12 +253,12 @@ public void setRegisteredUsers(Set<User> registeredUsers) {
         this.registeredUsers = registeredUsers;
     }
 
-    public Exam addUser(User user) {
+    public Exam addRegisteredUser(User user) {
         this.registeredUsers.add(user);
         return this;
     }
 
-    public Exam removeUser(User user) {
+    public Exam removeRegisteredUser(User user) {
         this.registeredUsers.remove(user);
         return this;
     }

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

@@ -49,7 +49,7 @@ public class ExerciseGroup implements Serializable {
 
     @OneToMany(mappedBy = "exerciseGroup", fetch = FetchType.LAZY)
     @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
-    @JsonIgnoreProperties("exerciseGroup")
+    @JsonIgnoreProperties(value = "exerciseGroup", allowSetters = true)
     private Set<Exercise> exercises = new HashSet<>();
 
     public Long getId() {

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 static de.tum.in.www1.artemis.domain.enumeration.AssessmentType.AUTOMATIC;
+
 import java.time.ZonedDateTime;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import javax.validation.constraints.NotNull;
@@ -11,10 +14,9 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-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.*;
 import de.tum.in.www1.artemis.domain.exam.ExerciseGroup;
+import de.tum.in.www1.artemis.domain.modeling.ModelingExercise;
 import de.tum.in.www1.artemis.repository.CourseRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
 import de.tum.in.www1.artemis.web.rest.errors.EntityNotFoundException;
@@ -225,4 +227,14 @@ public Course retrieveCourseOverExerciseGroupOrCourseId(Exercise exercise) {
             return findOne(exercise.getCourseViaExerciseGroupOrCourseMember().getId());
         }
     }
+
+    /**
+     * filters the passed exercises for the relevant ones that need to be manually assessed. This excludes quizzes and automatic programming exercises
+     * @param exercises all exercises (e.g. of a course or exercise group) that should be filtered
+     * @return the filtered and relevant exercises for manual assessment
+     */
+    public Set<Exercise> getInterestingExercisesForAssessmentDashboards(Set<Exercise> exercises) {
+        return exercises.stream().filter(exercise -> exercise instanceof TextExercise || exercise instanceof ModelingExercise || exercise instanceof FileUploadExercise
+                || (exercise instanceof ProgrammingExercise && exercise.getAssessmentType() != AUTOMATIC)).collect(Collectors.toSet());
+    }
 }

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

@@ -358,7 +358,7 @@ public List<StudentDTO> registerStudentsForExam(@PathVariable Long courseId, @Pa
                     if (!student.getGroups().contains(course.getStudentGroupName())) {
                         userService.addUserToGroup(student, course.getStudentGroupName());
                     }
-                    exam.addUser(student);
+                    exam.addRegisteredUser(student);
                     continue;
                 }
                 // 2) if we cannot find the student, we use the registration number and try to find the student in the (TUM) LDAP, create it in the Artemis DB and in a potential
@@ -368,7 +368,7 @@ public List<StudentDTO> registerStudentsForExam(@PathVariable Long courseId, @Pa
                     var student = optionalStudent.get();
                     // the newly created student needs to get the rights to access the course, otherwise the student cannot access the exam (within the course)
                     userService.addUserToGroup(student, course.getStudentGroupName());
-                    exam.addUser(student);
+                    exam.addRegisteredUser(student);
                     continue;
                 }
                 // 3) if we cannot find the user in the (TUM) LDAP, we report this to the client

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

@@ -0,0 +1,87 @@
+package de.tum.in.www1.artemis.service;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import de.tum.in.www1.artemis.domain.ExampleSubmission;
+import de.tum.in.www1.artemis.domain.Exercise;
+import de.tum.in.www1.artemis.domain.ProgrammingExercise;
+import de.tum.in.www1.artemis.domain.enumeration.TutorParticipationStatus;
+import de.tum.in.www1.artemis.domain.participation.TutorParticipation;
+import de.tum.in.www1.artemis.repository.ExampleSubmissionRepository;
+import de.tum.in.www1.artemis.web.rest.dto.DueDateStat;
+
+/**
+ * Service Implementation for managing Tutor-Assessment-Dashboard.
+ */
+@Service
+public class TutorDashboardService {
+
+    private final Logger log = LoggerFactory.getLogger(ExamService.class);
+
+    private final ExerciseService exerciseService;
+
+    private final ProgrammingExerciseService programmingExerciseService;
+
+    private final SubmissionService submissionService;
+
+    private final ResultService resultService;
+
+    private final ExampleSubmissionRepository exampleSubmissionRepository;
+
+    public TutorDashboardService(ExerciseService exerciseService, ProgrammingExerciseService programmingExerciseService, SubmissionService submissionService,
+            ResultService resultService, ExampleSubmissionRepository exampleSubmissionRepository) {
+        this.exerciseService = exerciseService;
+        this.programmingExerciseService = programmingExerciseService;
+        this.submissionService = submissionService;
+        this.resultService = resultService;
+        this.exampleSubmissionRepository = exampleSubmissionRepository;
+    }
+
+    /**
+     * Prepares the exercises for the tutor dashboard by setting the tutor participations and statistics
+     *
+     * @param exercises exercises to be prepared for the tutor dashboard
+     * @param tutorParticipations participations of the tutors
+     */
+    public void prepareExercisesForTutorDashboard(Set<Exercise> exercises, List<TutorParticipation> tutorParticipations) {
+        for (Exercise exercise : exercises) {
+
+            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));
+        }
+    }
+}