Adaptive learning: Improve user interface and fix several bugs related to learning paths

build.gradle

@@ -346,6 +346,7 @@ dependencies {
     implementation "org.commonmark:commonmark:0.21.0"
     implementation "commons-fileupload:commons-fileupload:1.5"
     implementation "net.lingala.zip4j:zip4j:2.11.5"
+    implementation "org.jgrapht:jgrapht-core:1.5.2"
 
 
     annotationProcessor "org.hibernate:hibernate-jpamodelgen:${hibernate_version}"

jest.config.js

@@ -3,7 +3,8 @@ const esModules = ['lodash-es', 'franc-min', 'trigram-utils', 'n-gram', 'collaps
     '@ngx-translate/core', '@ngx-translate/http-loader', '@fortawesome/angular-fontawesome', '@angular/cdk', '@angular/material', '@angular/cdk', 'dayjs/esm',
     'rxjs/operators', '@ng-bootstrap/ng-bootstrap', 'ngx-webstorage', '@ctrl/ngx-emoji-mart', 'ngx-device-detector', '@swimlane/ngx-charts',
     '@angular/service-worker', '@danielmoncada/angular-datetime-picker', '@flaviosantoro92/ngx-datatable', 'd3-color', 'd3-interpolate', 'd3-transition', 'd3-brush',
-    'd3-drag', 'd3-selection', 'd3-scale', 'd3-array', 'd3-format', 'd3-shape', 'd3-path', 'd3-ease', 'd3-time', 'd3-hierarchy', 'ngx-infinite-scroll', 'internmap'].join('|');
+    'd3-drag', 'd3-selection', 'd3-scale', 'd3-array', 'd3-format', 'd3-shape', 'd3-path', 'd3-ease', 'd3-time', 'd3-hierarchy', 'ngx-infinite-scroll', 'internmap',
+    '@swimlane/ngx-graph'].join('|');
 
 const {
     compilerOptions: { baseUrl = './' },

package.json

@@ -85,7 +85,9 @@
         "@swimlane/ngx-graph": {
             "d3-color": "^3.1.0",
             "d3-interpolate": "^3.0.1",
-            "d3-brush": "^3.0.0"
+            "d3-transition": "^3.0.0",
+            "d3-brush": "^3.0.0",
+            "d3-selection": "^3.0.0"
         },
         "critters": "0.0.20",
         "semver": "7.5.4",

src/main/java/de/tum/in/www1/artemis/domain/lecture/AttachmentUnit.java

@@ -81,4 +81,10 @@ public ZonedDateTime getReleaseDate() {
     public void setReleaseDate(ZonedDateTime releaseDate) {
         // Should be set in associated attachment
     }
+
+    // IMPORTANT NOTICE: The following string has to be consistent with the one defined in LectureUnit.java
+    @Override
+    public String getType() {
+        return "attachment";
+    }
 }

src/main/java/de/tum/in/www1/artemis/domain/lecture/ExerciseUnit.java

@@ -80,4 +80,10 @@ public void prePersistOrUpdate() {
         this.releaseDate = null;
         this.competencies = new HashSet<>();
     }
+
+    // IMPORTANT NOTICE: The following string has to be consistent with the one defined in LectureUnit.java
+    @Override
+    public String getType() {
+        return "exercise";
+    }
 }

src/main/java/de/tum/in/www1/artemis/domain/lecture/LectureUnit.java

@@ -121,4 +121,7 @@ public boolean isCompletedFor(User user) {
     public Optional<ZonedDateTime> getCompletionDate(User user) {
         return getCompletedUsers().stream().filter(completion -> completion.getUser().getId().equals(user.getId())).map(LectureUnitCompletion::getCompletedAt).findFirst();
     }
+
+    // Used to distinguish the type when used in a DTO, e.g., LectureUnitForLearningPathNodeDetailsDTO.
+    public abstract String getType();
 }

src/main/java/de/tum/in/www1/artemis/domain/lecture/OnlineUnit.java

@@ -32,4 +32,10 @@ public String getDescription() {
     public void setDescription(String description) {
         this.description = description;
     }
+
+    // IMPORTANT NOTICE: The following string has to be consistent with the one defined in LectureUnit.java
+    @Override
+    public String getType() {
+        return "online";
+    }
 }

src/main/java/de/tum/in/www1/artemis/domain/lecture/TextUnit.java

@@ -19,4 +19,10 @@ public String getContent() {
     public void setContent(String content) {
         this.content = content;
     }
+
+    // IMPORTANT NOTICE: The following string has to be consistent with the one defined in LectureUnit.java
+    @Override
+    public String getType() {
+        return "text";
+    }
 }

src/main/java/de/tum/in/www1/artemis/domain/lecture/VideoUnit.java

@@ -30,4 +30,10 @@ public String getDescription() {
     public void setDescription(String description) {
         this.description = description;
     }
+
+    // IMPORTANT NOTICE: The following string has to be consistent with the one defined in LectureUnit.java
+    @Override
+    public String getType() {
+        return "video";
+    }
 }

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

@@ -19,18 +19,73 @@ public interface CompetencyRelationRepository extends JpaRepository<CompetencyRe
             SELECT relation
             FROM CompetencyRelation relation
             WHERE relation.headCompetency.id = :#{#competencyId}
-            OR relation.tailCompetency.id = :#{#competencyId}
+                OR relation.tailCompetency.id = :#{#competencyId}
             """)
     Set<CompetencyRelation> findAllByCompetencyId(@Param("competencyId") Long competencyId);
 
     @Query("""
             SELECT relation
             FROM CompetencyRelation relation
-            LEFT JOIN FETCH relation.headCompetency
-            LEFT JOIN FETCH relation.tailCompetency
+                LEFT JOIN FETCH relation.headCompetency
+                LEFT JOIN FETCH relation.tailCompetency
             WHERE relation.headCompetency.course.id = :#{#courseId}
-            AND relation.tailCompetency.course.id = :#{#courseId}
+                AND relation.tailCompetency.course.id = :#{#courseId}
             """)
     Set<CompetencyRelation> findAllByCourseId(@Param("courseId") Long courseId);
 
+    @Query("""
+            SELECT count(cr)
+            FROM CompetencyRelation cr
+            WHERE cr.headCompetency.course.id = :courseId
+                OR cr.tailCompetency.course.id = :courseId
+            """)
+    long countByCourseId(@Param("courseId") long courseId);
+
+    @Query("""
+            SELECT DISTINCT relation.headCompetency.id
+            FROM CompetencyRelation relation
+                LEFT JOIN relation.headCompetency
+                LEFT JOIN relation.tailCompetency
+            WHERE relation.tailCompetency.id IN :competencyIds
+                AND relation.type <> 'MATCHES'
+            """)
+    Set<Long> getPriorCompetenciesByCompetencyIds(@Param("competencyIds") Set<Long> competencyIds);
+
+    @Query("""
+            SELECT COUNT(relation)
+            FROM CompetencyRelation relation
+                LEFT JOIN relation.headCompetency
+                LEFT JOIN relation.tailCompetency
+            WHERE relation.tailCompetency.id IN :competencyTailIds
+                AND relation.headCompetency.id IN :competencyHeadIds
+                AND relation.type = :type
+            """)
+    long countRelationsOfTypeBetweenCompetencyGroups(@Param("competencyTailIds") Set<Long> competencyTailIds, @Param("type") CompetencyRelation.RelationType type,
+            @Param("competencyHeadIds") Set<Long> competencyHeadIds);
+
+    // Important: this query is native since JPARepositories don't support recursive queries of this form
+    @Query(value = """
+                    WITH RECURSIVE transitive_closure(id) AS
+                    (
+                        (SELECT competency.id FROM learning_goal as competency WHERE competency.id = :competencyId)
+                        UNION
+                        (
+                            (
+                                SELECT relation.head_learning_goal_id
+                                FROM learning_goal_relation as relation
+                                JOIN transitive_closure AS tc ON relation.tail_learning_goal_id = tc.id
+                                WHERE relation.type = 'M'
+                            )
+                            UNION
+                            (
+                                SELECT relation.tail_learning_goal_id
+                                FROM learning_goal_relation as relation
+                                JOIN transitive_closure AS tc ON relation.head_learning_goal_id = tc.id
+                                WHERE relation.type = 'M'
+                            )
+                        )
+                    )
+                    SELECT * FROM transitive_closure
+            """, nativeQuery = true)
+    Set<Long> getMatchingCompetenciesByCompetencyId(@Param("competencyId") long competencyId);
 }

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

@@ -11,6 +11,7 @@
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
+import de.tum.in.www1.artemis.domain.Course;
 import de.tum.in.www1.artemis.domain.competency.Competency;
 import de.tum.in.www1.artemis.web.rest.errors.EntityNotFoundException;
 
@@ -180,4 +181,6 @@ default Competency findByIdWithExercisesAndLectureUnitsElseThrow(Long competency
     default Competency findByIdWithExercisesElseThrow(Long competencyId) {
         return findByIdWithExercises(competencyId).orElseThrow(() -> new EntityNotFoundException("Competency", competencyId));
     }
+
+    long countByCourse(Course course);
 }

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

@@ -20,6 +20,17 @@ public interface LearningPathRepository extends JpaRepository<LearningPath, Long
 
     Optional<LearningPath> findByCourseIdAndUserId(long courseId, long userId);
 
+    default LearningPath findByCourseIdAndUserIdElseThrow(long courseId, long userId) {
+        return findByCourseIdAndUserId(courseId, userId).orElseThrow(() -> new EntityNotFoundException("LearningPath"));
+    }
+
+    @EntityGraph(type = LOAD, attributePaths = { "user" })
+    Optional<LearningPath> findWithEagerUserById(long learningPathId);
+
+    default LearningPath findWithEagerUserByIdElseThrow(long learningPathId) {
+        return findWithEagerUserById(learningPathId).orElseThrow(() -> new EntityNotFoundException("LearningPath"));
+    }
+
     @EntityGraph(type = LOAD, attributePaths = { "competencies" })
     Optional<LearningPath> findWithEagerCompetenciesByCourseIdAndUserId(long courseId, long userId);
 
@@ -40,4 +51,36 @@ SELECT COUNT (learningPath)
             WHERE learningPath.course.id = :courseId AND learningPath.user.isDeleted = false AND learningPath.course.studentGroupName MEMBER OF learningPath.user.groups
             """)
     long countLearningPathsOfEnrolledStudentsInCourse(@Param("courseId") long courseId);
+
+    /**
+     * Gets a learning path with eagerly fetched competencies, linked lecture units and exercises, and the corresponding domain objects storing the progress.
+     * <p>
+     * The query only fetches data related to the owner of the learning path. participations and progress for other users are not included.
+     * IMPORTANT: JPA doesn't support JOIN-FETCH-ON statements. To fetch the relevant data we utilize the entity graph annotation.
+     * Moving the ON clauses to the WHERE clause would result in significantly different and faulty output.
+     *
+     * @param learningPathId the id of the learning path to fetch
+     * @return the learning path with fetched data
+     */
+    @Query("""
+            SELECT learningPath
+            FROM LearningPath learningPath
+                LEFT JOIN FETCH learningPath.competencies competencies
+                LEFT JOIN competencies.userProgress progress
+                    ON competencies.id = progress.learningGoal.id AND progress.user.id = learningPath.user.id
+                LEFT JOIN FETCH competencies.lectureUnits lectureUnits
+                LEFT JOIN lectureUnits.completedUsers completedUsers
+                    ON lectureUnits.id = completedUsers.lectureUnit.id AND completedUsers.user.id = learningPath.user.id
+                LEFT JOIN FETCH competencies.exercises exercises
+                LEFT JOIN exercises.studentParticipations studentParticipations
+                    ON exercises.id = studentParticipations.exercise.id AND studentParticipations.student.id = learningPath.user.id
+            WHERE learningPath.id = :learningPathId
+            """)
+    @EntityGraph(type = LOAD, attributePaths = { "competencies.userProgress", "competencies.lectureUnits.completedUsers", "competencies.exercises.studentParticipations" })
+    Optional<LearningPath> findWithEagerCompetenciesAndProgressAndLearningObjectsAndCompletedUsersById(@Param("learningPathId") long learningPathId);
+
+    default LearningPath findWithEagerCompetenciesAndProgressAndLearningObjectsAndCompletedUsersByIdElseThrow(long learningPathId) {
+        return findWithEagerCompetenciesAndProgressAndLearningObjectsAndCompletedUsersById(learningPathId)
+                .orElseThrow(() -> new EntityNotFoundException("LearningPath", learningPathId));
+    }
 }

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