Adaptive learning: Extend learning path feature to recommend sequence of lecture units and exercises

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

@@ -56,7 +56,7 @@ SELECT u, SUM(sc.lastRatedPoints)
             WHERE s.user = :user
                 AND s.exercise IN :exercises
             """)
-    List<StudentScore> findAllByExercisesAndUser(@Param("exercises") List<Exercise> exercises, @Param("user") User user);
+    List<StudentScore> findAllByExercisesAndUser(@Param("exercises") Set<Exercise> exercises, @Param("user") User user);
 
     @Query("""
             SELECT s

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

@@ -65,7 +65,7 @@ SELECT t, SUM(s.lastRatedPoints)
             WHERE s.exercise IN :exercises
                 AND :user MEMBER OF s.team.students
             """)
-    List<TeamScore> findAllByExercisesAndUser(@Param("exercises") List<Exercise> exercises, @Param("user") User user);
+    List<TeamScore> findAllByExercisesAndUser(@Param("exercises") Set<Exercise> exercises, @Param("user") User user);
 
     @Transactional // ok because of delete
     @Modifying

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

@@ -2,7 +2,7 @@
 
 import java.time.Instant;
 import java.util.*;
-import java.util.stream.Stream;
+import java.util.stream.Collectors;
 
 import javax.validation.constraints.NotNull;
 
@@ -17,11 +17,10 @@
 import de.tum.in.www1.artemis.domain.competency.CompetencyProgress;
 import de.tum.in.www1.artemis.domain.lecture.ExerciseUnit;
 import de.tum.in.www1.artemis.domain.lecture.LectureUnit;
-import de.tum.in.www1.artemis.domain.lecture.LectureUnitCompletion;
 import de.tum.in.www1.artemis.domain.participation.Participant;
-import de.tum.in.www1.artemis.domain.scores.ParticipantScore;
 import de.tum.in.www1.artemis.repository.*;
 import de.tum.in.www1.artemis.security.SecurityUtils;
+import de.tum.in.www1.artemis.service.learningpath.LearningPathService;
 import de.tum.in.www1.artemis.service.util.RoundingUtil;
 
 /**
@@ -36,10 +35,6 @@ public class CompetencyProgressService {
 
     private final CompetencyProgressRepository competencyProgressRepository;
 
-    private final StudentScoreRepository studentScoreRepository;
-
-    private final TeamScoreRepository teamScoreRepository;
-
     private final ExerciseRepository exerciseRepository;
 
     private final LectureUnitRepository lectureUnitRepository;
@@ -48,17 +43,21 @@ public class CompetencyProgressService {
 
     private final LearningPathService learningPathService;
 
-    public CompetencyProgressService(CompetencyRepository competencyRepository, CompetencyProgressRepository competencyProgressRepository,
-            StudentScoreRepository studentScoreRepository, TeamScoreRepository teamScoreRepository, ExerciseRepository exerciseRepository,
-            LectureUnitRepository lectureUnitRepository, UserRepository userRepository, LearningPathService learningPathService) {
+    private final ParticipantScoreService participantScoreService;
+
+    private final LearningObjectService learningObjectService;
+
+    public CompetencyProgressService(CompetencyRepository competencyRepository, CompetencyProgressRepository competencyProgressRepository, ExerciseRepository exerciseRepository,
+            LectureUnitRepository lectureUnitRepository, UserRepository userRepository, LearningPathService learningPathService, ParticipantScoreService participantScoreService,
+            LearningObjectService learningObjectService) {
         this.competencyRepository = competencyRepository;
         this.competencyProgressRepository = competencyProgressRepository;
-        this.studentScoreRepository = studentScoreRepository;
-        this.teamScoreRepository = teamScoreRepository;
         this.exerciseRepository = exerciseRepository;
         this.lectureUnitRepository = lectureUnitRepository;
         this.userRepository = userRepository;
         this.learningPathService = learningPathService;
+        this.participantScoreService = participantScoreService;
+        this.learningObjectService = learningObjectService;
     }
 
     /**
@@ -188,12 +187,12 @@ public CompetencyProgress updateCompetencyProgress(Long competencyId, User user)
         }
 
         var studentProgress = competencyProgress.orElse(new CompetencyProgress());
-        List<LearningObject> learningObjects = new ArrayList<>();
+        Set<LearningObject> learningObjects = new HashSet<>();
 
-        List<LectureUnit> allLectureUnits = competency.getLectureUnits().stream().filter(LectureUnit::isVisibleToStudents).toList();
+        Set<LectureUnit> allLectureUnits = competency.getLectureUnits().stream().filter(LectureUnit::isVisibleToStudents).collect(Collectors.toSet());
 
-        List<LectureUnit> lectureUnits = allLectureUnits.stream().filter(lectureUnit -> !(lectureUnit instanceof ExerciseUnit)).toList();
-        List<Exercise> exercises = competency.getExercises().stream().filter(Exercise::isVisibleToStudents).toList();
+        Set<LectureUnit> lectureUnits = allLectureUnits.stream().filter(lectureUnit -> !(lectureUnit instanceof ExerciseUnit)).collect(Collectors.toSet());
+        Set<Exercise> exercises = competency.getExercises().stream().filter(Exercise::isVisibleToStudents).collect(Collectors.toSet());
 
         learningObjects.addAll(lectureUnits);
         learningObjects.addAll(exercises);
@@ -233,8 +232,9 @@ public CompetencyProgress updateCompetencyProgress(Long competencyId, User user)
      * @param user            The user for which the progress should be calculated
      * @return The percentage of completed learning objects by the user
      */
-    private double calculateProgress(@NotNull List<LearningObject> learningObjects, @NotNull User user) {
-        return learningObjects.stream().map(learningObject -> hasUserCompleted(user, learningObject)).mapToInt(completed -> completed ? 100 : 0).average().orElse(0.);
+    private double calculateProgress(@NotNull Set<LearningObject> learningObjects, @NotNull User user) {
+        return learningObjects.stream().map(learningObject -> learningObjectService.isCompletedByUser(learningObject, user)).mapToInt(completed -> completed ? 100 : 0).average()
+                .orElse(0.);
     }
 
     /**
@@ -244,29 +244,8 @@ private double calculateProgress(@NotNull List<LearningObject> learningObjects,
      * @param user      The user for which the confidence score should be calculated
      * @return The average score of the user in all exercises linked to the competency
      */
-    private double calculateConfidence(@NotNull List<Exercise> exercises, @NotNull User user) {
-        var studentScores = studentScoreRepository.findAllByExercisesAndUser(exercises, user);
-        var teamScores = teamScoreRepository.findAllByExercisesAndUser(exercises, user);
-        return Stream.concat(studentScores.stream(), teamScores.stream()).map(ParticipantScore::getLastScore).mapToDouble(score -> score).summaryStatistics().getAverage();
-    }
-
-    /**
-     * Checks if the user has completed the learning object.
-     *
-     * @param user           The user for which to check the completion status
-     * @param learningObject The lecture unit or exercise
-     * @return True if the user completed the lecture unit or has at least one result for the exercise, false otherwise
-     */
-    private boolean hasUserCompleted(@NotNull User user, LearningObject learningObject) {
-        if (learningObject instanceof LectureUnit lectureUnit) {
-            return lectureUnit.getCompletedUsers().stream().map(LectureUnitCompletion::getUser).anyMatch(user1 -> user1.getId().equals(user.getId()));
-        }
-        else if (learningObject instanceof Exercise exercise) {
-            var studentScores = studentScoreRepository.findAllByExercisesAndUser(List.of(exercise), user);
-            var teamScores = teamScoreRepository.findAllByExercisesAndUser(List.of(exercise), user);
-            return Stream.concat(studentScores.stream(), teamScores.stream()).findAny().isPresent();
-        }
-        throw new IllegalArgumentException("Learning object must be either LectureUnit or Exercise");
+    private double calculateConfidence(@NotNull Set<Exercise> exercises, @NotNull User user) {
+        return participantScoreService.getStudentAndTeamParticipationScoresAsDoubleStream(user, exercises).summaryStatistics().getAverage();
     }
 
     /**
@@ -303,4 +282,16 @@ public static boolean isMastered(@NotNull CompetencyProgress competencyProgress)
         return mastery >= competencyProgress.getCompetency().getMasteryThreshold();
     }
 
+    /**
+     * Checks if the competency can be mastered without completing any exercises.
+     *
+     * @param competency the competency to check
+     * @return true if the competency can be mastered without completing any exercises, false otherwise
+     */
+    public static boolean canBeMasteredWithoutExercises(@NotNull Competency competency) {
+        final var lectureUnits = competency.getLectureUnits().size();
+        final var numberOfLearningObjects = lectureUnits + competency.getExercises().size();
+        final var achievableMasteryScore = ((double) lectureUnits) / (3 * numberOfLearningObjects) * 100;
+        return achievableMasteryScore >= competency.getMasteryThreshold();
+    }
 }

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

@@ -56,6 +56,7 @@
 import de.tum.in.www1.artemis.service.dto.StudentDTO;
 import de.tum.in.www1.artemis.service.exam.ExamDeletionService;
 import de.tum.in.www1.artemis.service.export.CourseExamExportService;
+import de.tum.in.www1.artemis.service.learningpath.LearningPathService;
 import de.tum.in.www1.artemis.service.notifications.GroupNotificationService;
 import de.tum.in.www1.artemis.service.tutorialgroups.TutorialGroupService;
 import de.tum.in.www1.artemis.service.user.UserService;

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

@@ -6,6 +6,8 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
+import javax.validation.constraints.NotNull;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.actuate.audit.AuditEvent;
@@ -80,13 +82,15 @@ public class ExerciseService {
 
     private final QuizBatchService quizBatchService;
 
+    private final ParticipantScoreService participantScoreService;
+
     public ExerciseService(ExerciseRepository exerciseRepository, AuthorizationCheckService authCheckService, QuizScheduleService quizScheduleService,
             AuditEventRepository auditEventRepository, TeamRepository teamRepository, ProgrammingExerciseRepository programmingExerciseRepository,
             LtiOutcomeUrlRepository ltiOutcomeUrlRepository, StudentParticipationRepository studentParticipationRepository, ResultRepository resultRepository,
             SubmissionRepository submissionRepository, ParticipantScoreRepository participantScoreRepository, UserRepository userRepository,
             ComplaintRepository complaintRepository, TutorLeaderboardService tutorLeaderboardService, ComplaintResponseRepository complaintResponseRepository,
             GradingCriterionRepository gradingCriterionRepository, FeedbackRepository feedbackRepository, RatingService ratingService, ExerciseDateService exerciseDateService,
-            ExampleSubmissionRepository exampleSubmissionRepository, QuizBatchService quizBatchService) {
+            ExampleSubmissionRepository exampleSubmissionRepository, QuizBatchService quizBatchService, ParticipantScoreService participantScoreService) {
         this.exerciseRepository = exerciseRepository;
         this.resultRepository = resultRepository;
         this.authCheckService = authCheckService;
@@ -108,6 +112,7 @@ public ExerciseService(ExerciseRepository exerciseRepository, AuthorizationCheck
         this.ratingService = ratingService;
         this.exampleSubmissionRepository = exampleSubmissionRepository;
         this.quizBatchService = quizBatchService;
+        this.participantScoreService = participantScoreService;
     }
 
     /**
@@ -732,4 +737,20 @@ public List<Feedback> getFeedbackToBeDeletedAfterGradingInstructionUpdate(boolea
         }
         return feedbackToBeDeleted;
     }
+
+    /**
+     * Checks if the user has achieved the minimum score.
+     *
+     * @param exercise the exercise that should be checked
+     * @param user     the user for which to check the score
+     * @param minScore the minimum score that should be achieved
+     * @return true if the user achieved the minimum score, false otherwise
+     */
+    public boolean hasScoredAtLeast(@NotNull Exercise exercise, @NotNull User user, double minScore) {
+        final var score = participantScoreService.getStudentAndTeamParticipationScoresAsDoubleStream(user, Set.of(exercise)).max();
+        if (score.isEmpty()) {
+            return false;
+        }
+        return score.getAsDouble() >= minScore;
+    }
 }

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

@@ -0,0 +1,49 @@
+package de.tum.in.www1.artemis.service;
+
+import java.util.Set;
+
+import javax.validation.constraints.NotNull;
+
+import org.springframework.stereotype.Service;
+
+import de.tum.in.www1.artemis.domain.Exercise;
+import de.tum.in.www1.artemis.domain.LearningObject;
+import de.tum.in.www1.artemis.domain.User;
+import de.tum.in.www1.artemis.domain.lecture.LectureUnit;
+import de.tum.in.www1.artemis.domain.lecture.LectureUnitCompletion;
+
+/**
+ * Service implementation for interactions with learning objects.
+ * <p>
+ * The interface {@code LearningObject} is implemented by all {@code LectureUnit}s and {@code Exercise}s.
+ *
+ * @see LearningObject
+ * @see LectureUnit
+ * @see Exercise
+ */
+@Service
+public class LearningObjectService {
+
+    private final ParticipantScoreService participantScoreService;
+
+    public LearningObjectService(ParticipantScoreService participantScoreService) {
+        this.participantScoreService = participantScoreService;
+    }
+
+    /**
+     * Checks if the user has completed the learning object.
+     *
+     * @param learningObject the lecture unit or exercise
+     * @param user           the user for which to check the completion status
+     * @return true if the user completed the lecture unit or has at least one result for the exercise, false otherwise
+     */
+    public boolean isCompletedByUser(@NotNull LearningObject learningObject, @NotNull User user) {
+        if (learningObject instanceof LectureUnit lectureUnit) {
+            return lectureUnit.getCompletedUsers().stream().map(LectureUnitCompletion::getUser).anyMatch(user1 -> user1.getId().equals(user.getId()));
+        }
+        else if (learningObject instanceof Exercise exercise) {
+            return participantScoreService.getStudentAndTeamParticipations(user, Set.of(exercise)).findAny().isPresent();
+        }
+        throw new IllegalArgumentException("Learning object must be either LectureUnit or Exercise");
+    }
+}