Adaptive learning: Add option to import exercises and lecture units when importing competencies

src/main/java/de/tum/in/www1/artemis/domain/quiz/DragAndDropSubmittedAnswer.java

@@ -76,7 +76,6 @@ public DragItem getSelectedDragItemForDropLocation(DropLocation dropLocation) {
      * @param question the changed question with the changed DragItems and DropLocations
      */
     private void checkAndDeleteMappings(DragAndDropQuestion question) {
-
         if (question != null) {
             // Check if a dragItem or dropLocation was deleted and delete reference to it in mappings
             Set<DragAndDropMapping> selectedMappingsToDelete = new HashSet<>();
@@ -98,7 +97,6 @@ private void checkAndDeleteMappings(DragAndDropQuestion question) {
      */
     @Override
     public void checkAndDeleteReferences(QuizExercise quizExercise) {
-
         // Delete all references to question, dropLocations and dragItem if the question was deleted
         if (!quizExercise.getQuizQuestions().contains(getQuizQuestion())) {
             setQuizQuestion(null);

src/main/java/de/tum/in/www1/artemis/domain/quiz/DragItem.java

@@ -110,6 +110,10 @@ public void setInvalid(Boolean invalid) {
         this.invalid = invalid;
     }
 
+    public void setMappings(Set<DragAndDropMapping> mappings) {
+        this.mappings = mappings;
+    }
+
     /**
      * This method is called after the entity is saved for the first time. We replace the placeholder in the pictureFilePath with the id of the entity because we don't know it
      * before creation.

src/main/java/de/tum/in/www1/artemis/domain/quiz/DropLocation.java

@@ -129,6 +129,10 @@ public void setInvalid(Boolean invalid) {
         this.invalid = invalid;
     }
 
+    public void setMappings(Set<DragAndDropMapping> mappings) {
+        this.mappings = mappings;
+    }
+
     /**
      * check if the DropLocation is solved correctly
      *

src/main/java/de/tum/in/www1/artemis/domain/quiz/ShortAnswerSolution.java

@@ -78,6 +78,10 @@ public void setQuestion(ShortAnswerQuestion shortAnswerQuestion) {
         this.question = shortAnswerQuestion;
     }
 
+    public void setMappings(Set<ShortAnswerMapping> mappings) {
+        this.mappings = mappings;
+    }
+
     @Override
     public String toString() {
         return "ShortAnswerSolution{" + "id=" + getId() + ", text='" + getText() + "'" + ", invalid='" + isInvalid() + "'" + "}";

src/main/java/de/tum/in/www1/artemis/domain/quiz/ShortAnswerSpot.java

@@ -95,6 +95,10 @@ public void setQuestion(ShortAnswerQuestion shortAnswerQuestion) {
         this.question = shortAnswerQuestion;
     }
 
+    public void setMappings(Set<ShortAnswerMapping> shortAnswerMappings) {
+        this.mappings = shortAnswerMappings;
+    }
+
     @Override
     public String toString() {
         return "ShortAnswerSpot{" + "id=" + getId() + ", width=" + getWidth() + ", spotNr=" + getSpotNr() + ", invalid='" + isInvalid() + "'" + "}";

src/main/java/de/tum/in/www1/artemis/exception/NoUniqueQueryException.java

@@ -0,0 +1,11 @@
+package de.tum.in.www1.artemis.exception;
+
+/**
+ * Checked exception in case a query does not return a unique result, so calling methods must handle this case.
+ */
+public class NoUniqueQueryException extends Exception {
+
+    public NoUniqueQueryException(String message) {
+        super(message);
+    }
+}

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

@@ -26,9 +26,13 @@ public interface CompetencyRepository extends ArtemisJpaRepository<Competency, L
     @Query("""
             SELECT c
             FROM Competency c
+                LEFT JOIN FETCH c.exercises
+                LEFT JOIN FETCH c.lectureUnits lu
+                LEFT JOIN FETCH lu.lecture l
+                LEFT JOIN FETCH l.attachments
             WHERE c.course.id = :courseId
             """)
-    Set<Competency> findAllForCourse(@Param("courseId") long courseId);
+    Set<Competency> findAllForCourseWithExercisesAndLectureUnitsAndLecturesAndAttachments(@Param("courseId") long courseId);
 
     @Query("""
             SELECT c

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

@@ -45,6 +45,44 @@ public interface CourseCompetencyRepository extends ArtemisJpaRepository<CourseC
             """)
     Set<CourseCompetency> findAllForCourse(@Param("courseId") long courseId);
 
+    @Query("""
+            SELECT c
+            FROM CourseCompetency c
+                LEFT JOIN FETCH c.exercises ex
+                LEFT JOIN FETCH c.lectureUnits lu
+                LEFT JOIN FETCH lu.lecture l
+                LEFT JOIN FETCH l.attachments
+            WHERE c.course.id = :courseId
+            """)
+    Set<CourseCompetency> findAllForCourseWithExercisesAndLectureUnitsAndLecturesAndAttachments(@Param("courseId") long courseId);
+
+    @Query("""
+            SELECT c
+            FROM CourseCompetency c
+                LEFT JOIN FETCH c.exercises ex
+                LEFT JOIN FETCH c.lectureUnits lu
+                LEFT JOIN FETCH lu.lecture l
+                LEFT JOIN FETCH l.lectureUnits
+                LEFT JOIN FETCH l.attachments
+            WHERE c.id = :id
+            """)
+    Optional<CourseCompetency> findByIdWithExercisesAndLectureUnitsAndLectures(@Param("id") long id);
+
+    default CourseCompetency findByIdWithExercisesAndLectureUnitsAndLecturesElseThrow(long id) {
+        return getValueElseThrow(findByIdWithExercisesAndLectureUnitsAndLectures(id), id);
+    }
+
+    @Query("""
+            SELECT c
+            FROM CourseCompetency c
+                LEFT JOIN FETCH c.exercises ex
+                LEFT JOIN FETCH c.lectureUnits lu
+                LEFT JOIN FETCH lu.lecture l
+                LEFT JOIN FETCH l.attachments
+            WHERE c.id IN :ids
+            """)
+    Set<CourseCompetency> findAllByIdWithExercisesAndLectureUnitsAndLecturesAndAttachments(@Param("ids") Set<Long> ids);
+
     /**
      * Fetches all information related to the calculation of the mastery for exercises in a competency.
      * The complex grouping by is necessary for postgres

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

@@ -5,9 +5,11 @@
 
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import jakarta.validation.constraints.NotNull;
 
+import org.hibernate.NonUniqueResultException;
 import org.springframework.context.annotation.Profile;
 import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
@@ -16,6 +18,7 @@
 import org.springframework.stereotype.Repository;
 
 import de.tum.in.www1.artemis.domain.FileUploadExercise;
+import de.tum.in.www1.artemis.exception.NoUniqueQueryException;
 import de.tum.in.www1.artemis.repository.base.ArtemisJpaRepository;
 
 /**
@@ -38,8 +41,41 @@ public interface FileUploadExerciseRepository extends ArtemisJpaRepository<FileU
     @EntityGraph(type = LOAD, attributePaths = { "teamAssignmentConfig", "categories", "competencies" })
     Optional<FileUploadExercise> findWithEagerTeamAssignmentConfigAndCategoriesAndCompetenciesById(Long exerciseId);
 
+    @Query("""
+            SELECT f
+            FROM FileUploadExercise f
+                LEFT JOIN FETCH f.competencies
+            WHERE f.title = :title
+                AND f.course.id = :courseId
+            """)
+    Set<FileUploadExercise> findAllWithCompetenciesByTitleAndCourseId(@Param("title") String title, @Param("courseId") long courseId) throws NonUniqueResultException;
+
+    /**
+     * Finds a file upload exercise by its title and course id and throws a NoUniqueQueryException if multiple exercises are found.
+     *
+     * @param title    the title of the exercise
+     * @param courseId the id of the course
+     * @return the exercise with the given title and course id
+     * @throws NoUniqueQueryException if multiple exercises are found with the same title
+     */
+    default Optional<FileUploadExercise> findUniqueWithCompetenciesByTitleAndCourseId(String title, long courseId) throws NoUniqueQueryException {
+        Set<FileUploadExercise> allExercises = findAllWithCompetenciesByTitleAndCourseId(title, courseId);
+        if (allExercises.size() > 1) {
+            throw new NoUniqueQueryException("Found multiple exercises with title " + title + " in course with id " + courseId);
+        }
+        return allExercises.stream().findFirst();
+    }
+
     @NotNull
     default FileUploadExercise findWithEagerCompetenciesByIdElseThrow(Long exerciseId) {
         return getValueElseThrow(findWithEagerCompetenciesById(exerciseId), exerciseId);
     }
+
+    @EntityGraph(type = LOAD, attributePaths = { "gradingCriteria" })
+    Optional<FileUploadExercise> findWithGradingCriteriaById(Long exerciseId);
+
+    @NotNull
+    default FileUploadExercise findWithGradingCriteriaByIdElseThrow(Long exerciseId) {
+        return getValueElseThrow(findWithGradingCriteriaById(exerciseId), exerciseId);
+    }
 }

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

@@ -17,6 +17,7 @@
 import org.springframework.stereotype.Repository;
 
 import de.tum.in.www1.artemis.domain.Lecture;
+import de.tum.in.www1.artemis.exception.NoUniqueQueryException;
 import de.tum.in.www1.artemis.repository.base.ArtemisJpaRepository;
 import de.tum.in.www1.artemis.web.rest.dto.CourseContentCount;
 
@@ -100,6 +101,30 @@ public interface LectureRepository extends ArtemisJpaRepository<Lecture, Long> {
             """)
     Optional<Lecture> findByIdWithLectureUnitsAndSlidesAndAttachments(@Param("lectureId") long lectureId);
 
+    @Query("""
+            SELECT lecture
+            FROM Lecture lecture
+                LEFT JOIN FETCH lecture.lectureUnits
+            WHERE lecture.title = :title AND lecture.course.id = :courseId
+            """)
+    Set<Lecture> findAllByTitleAndCourseIdWithLectureUnits(@Param("title") String title, @Param("courseId") long courseId);
+
+    /**
+     * Finds a lecture by its title and course id and throws a NoUniqueQueryException if multiple lectures are found.
+     *
+     * @param title    the title of the lecture
+     * @param courseId the id of the course
+     * @return the lecture with the given title and course id
+     * @throws NoUniqueQueryException if multiple lectures are found with the same title
+     */
+    default Optional<Lecture> findUniqueByTitleAndCourseIdWithLectureUnitsElseThrow(String title, long courseId) throws NoUniqueQueryException {
+        Set<Lecture> allLectures = findAllByTitleAndCourseIdWithLectureUnits(title, courseId);
+        if (allLectures.size() > 1) {
+            throw new NoUniqueQueryException("Found multiple lectures with title " + title + " in course with id " + courseId);
+        }
+        return allLectures.stream().findFirst();
+    }
+
     @SuppressWarnings("PMD.MethodNamingConventions")
     Page<Lecture> findByTitleIgnoreCaseContainingOrCourse_TitleIgnoreCaseContaining(String partialTitle, String partialCourseTitle, Pageable pageable);
 

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

@@ -5,6 +5,7 @@
 import java.util.Optional;
 import java.util.Set;
 
+import org.hibernate.NonUniqueResultException;
 import org.springframework.context.annotation.Profile;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
@@ -61,6 +62,27 @@ public interface LectureUnitRepository extends ArtemisJpaRepository<LectureUnit,
             """)
     Optional<LectureUnit> findByIdWithCompletedUsers(@Param("lectureUnitId") long lectureUnitId);
 
+    /**
+     * Finds a lecture unit by name, lecture title and course id. Currently, name duplicates are allowed but this method throws an exception if multiple lecture units with the
+     * same name are found.
+     *
+     * @param name         the name of the lecture unit
+     * @param lectureTitle the title of the lecture containing the lecture unit
+     * @param courseId     the id of the course containing the lecture
+     * @return the lecture unit with the given name, lecture title and course id
+     * @throws NonUniqueResultException if multiple lecture units with the same name in the same lecture are found
+     */
+    @Query("""
+            SELECT lu
+            FROM LectureUnit lu
+                LEFT JOIN FETCH lu.competencies
+            WHERE lu.name = :name
+                AND lu.lecture.title = :lectureTitle
+                AND lu.lecture.course.id = :courseId
+            """)
+    Optional<LectureUnit> findByNameAndLectureTitleAndCourseIdWithCompetencies(@Param("name") String name, @Param("lectureTitle") String lectureTitle,
+            @Param("courseId") long courseId) throws NonUniqueResultException;
+
     default LectureUnit findByIdWithCompletedUsersElseThrow(long lectureUnitId) {
         return getValueElseThrow(findByIdWithCompletedUsers(lectureUnitId), lectureUnitId);
     }

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

@@ -6,6 +6,7 @@
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import jakarta.validation.constraints.NotNull;
 
@@ -17,6 +18,7 @@
 import org.springframework.stereotype.Repository;
 
 import de.tum.in.www1.artemis.domain.modeling.ModelingExercise;
+import de.tum.in.www1.artemis.exception.NoUniqueQueryException;
 import de.tum.in.www1.artemis.repository.base.ArtemisJpaRepository;
 
 /**
@@ -54,9 +56,10 @@ public interface ModelingExerciseRepository extends ArtemisJpaRepository<Modelin
                 LEFT JOIN FETCH results.assessor
                 LEFT JOIN FETCH modelingExercise.teamAssignmentConfig
                 LEFT JOIN FETCH modelingExercise.plagiarismDetectionConfig
+                LEFT JOIN FETCH modelingExercise.gradingCriteria
             WHERE modelingExercise.id = :exerciseId
             """)
-    Optional<ModelingExercise> findByIdWithExampleSubmissionsAndResultsAndPlagiarismDetectionConfig(@Param("exerciseId") Long exerciseId);
+    Optional<ModelingExercise> findByIdWithExampleSubmissionsAndResultsAndPlagiarismDetectionConfigAndGradingCriteria(@Param("exerciseId") Long exerciseId);
 
     /**
      * Get all modeling exercises that need to be scheduled: Those must satisfy one of the following requirements:
@@ -94,6 +97,31 @@ public interface ModelingExerciseRepository extends ArtemisJpaRepository<Modelin
     @EntityGraph(type = LOAD, attributePaths = { "studentParticipations", "studentParticipations.submissions", "studentParticipations.submissions.results" })
     Optional<ModelingExercise> findWithStudentParticipationsSubmissionsResultsById(Long exerciseId);
 
+    @Query("""
+            SELECT m
+            FROM ModelingExercise m
+                LEFT JOIN FETCH m.competencies
+            WHERE m.title = :title
+                AND m.course.id = :courseId
+            """)
+    Set<ModelingExercise> findAllWithCompetenciesByTitleAndCourseId(@Param("title") String title, @Param("courseId") long courseId);
+
+    /**
+     * Finds a modeling exercise by its title and course id and throws a NoUniqueQueryException if multiple exercises are found.
+     *
+     * @param title    the title of the exercise
+     * @param courseId the id of the course
+     * @return the exercise with the given title and course id
+     * @throws NoUniqueQueryException if multiple exercises are found with the same title
+     */
+    default Optional<ModelingExercise> findUniqueWithCompetenciesByTitleAndCourseId(String title, long courseId) throws NoUniqueQueryException {
+        Set<ModelingExercise> allExercises = findAllWithCompetenciesByTitleAndCourseId(title, courseId);
+        if (allExercises.size() > 1) {
+            throw new NoUniqueQueryException("Found multiple exercises with title " + title + " in course with id " + courseId);
+        }
+        return allExercises.stream().findFirst();
+    }
+
     @NotNull
     default ModelingExercise findWithEagerExampleSubmissionsAndCompetenciesByIdElseThrow(long exerciseId) {
         return getValueElseThrow(findWithEagerExampleSubmissionsAndCompetenciesById(exerciseId), exerciseId);
@@ -106,7 +134,7 @@ default ModelingExercise findWithEagerExampleSubmissionsAndCompetenciesAndPlagia
 
     @NotNull
     default ModelingExercise findByIdWithExampleSubmissionsAndResultsAndPlagiarismDetectionConfigElseThrow(long exerciseId) {
-        return getValueElseThrow(findByIdWithExampleSubmissionsAndResultsAndPlagiarismDetectionConfig(exerciseId), exerciseId);
+        return getValueElseThrow(findByIdWithExampleSubmissionsAndResultsAndPlagiarismDetectionConfigAndGradingCriteria(exerciseId), exerciseId);
     }
 
     @NotNull

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

@@ -19,26 +19,30 @@ public interface PrerequisiteRepository extends ArtemisJpaRepository<Prerequisit
     List<Prerequisite> findAllByCourseIdOrderById(long courseId);
 
     @Query("""
-            SELECT c
-            FROM Prerequisite c
-            WHERE c.course.id = :courseId
+            SELECT p
+            FROM Prerequisite p
+                LEFT JOIN FETCH p.exercises
+                LEFT JOIN FETCH p.lectureUnits lu
+                LEFT JOIN FETCH lu.lecture l
+                LEFT JOIN FETCH l.attachments
+            WHERE p.course.id = :courseId
             """)
-    Set<Prerequisite> findAllForCourse(@Param("courseId") long courseId);
+    Set<Prerequisite> findAllForCourseWithExercisesAndLectureUnitsAndLecturesAndAttachments(@Param("courseId") long courseId);
 
     @Query("""
-            SELECT c
-            FROM Prerequisite c
-                LEFT JOIN FETCH c.lectureUnits lu
-                LEFT JOIN FETCH c.exercises
-            WHERE c.id = :competencyId
+            SELECT p
+            FROM Prerequisite p
+                LEFT JOIN FETCH p.lectureUnits lu
+                LEFT JOIN FETCH p.exercises
+            WHERE p.id = :competencyId
             """)
     Optional<Prerequisite> findByIdWithLectureUnitsAndExercises(@Param("competencyId") long competencyId);
 
     @Query("""
-            SELECT c
-            FROM Prerequisite c
-                LEFT JOIN FETCH c.lectureUnits lu
-            WHERE c.id = :competencyId
+            SELECT p
+            FROM Prerequisite p
+                LEFT JOIN FETCH p.lectureUnits lu
+            WHERE p.id = :competencyId
             """)
     Optional<Prerequisite> findByIdWithLectureUnits(@Param("competencyId") long competencyId);