Quiz exercises: Add unrated mode to quiz training

src/main/java/de/tum/cit/aet/artemis/quiz/domain/QuizQuestionProgress.java

@@ -16,6 +16,9 @@ public class QuizQuestionProgress extends DomainObject {
     @Column(name = "user_id")
     private long userId;
 
+    @Column(name = "course_id")
+    private long courseId;
+
     @Column(name = "quiz_question_id")
     private long quizQuestionId;
 
@@ -34,6 +37,14 @@ public void setUserId(long userId) {
         this.userId = userId;
     }
 
+    public long getCourseId() {
+        return courseId;
+    }
+
+    public void setCourseId(long courseId) {
+        this.courseId = courseId;
+    }
+
     public long getQuizQuestionId() {
         return quizQuestionId;
     }

src/main/java/de/tum/cit/aet/artemis/quiz/dto/QuizTrainingAnswerDTO.java

@@ -1,11 +1,11 @@
 package de.tum.cit.aet.artemis.quiz.dto;
 
-import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 import de.tum.cit.aet.artemis.quiz.domain.SubmittedAnswer;
 
 @JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record QuizTrainingAnswerDTO(@Nullable SubmittedAnswer submittedAnswer) {
+public record QuizTrainingAnswerDTO(@NotNull SubmittedAnswer submittedAnswer, boolean isRated) {
 }

src/main/java/de/tum/cit/aet/artemis/quiz/dto/question/QuizQuestionTrainingDTO.java

@@ -0,0 +1,16 @@
+package de.tum.cit.aet.artemis.quiz.dto.question;
+
+import java.util.Set;
+
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record QuizQuestionTrainingDTO(@NotNull QuizQuestionWithSolutionDTO quizQuestionWithSolutionDTO, boolean isRated, @Nullable Set<Long> questionIds) {
+
+    public long getId() {
+        return quizQuestionWithSolutionDTO().quizQuestionBaseDTO().id();
+    }
+}

src/main/java/de/tum/cit/aet/artemis/quiz/repository/QuizQuestionProgressRepository.java

@@ -19,6 +19,6 @@ public interface QuizQuestionProgressRepository extends ArtemisJpaRepository<Qui
 
     Optional<QuizQuestionProgress> findByUserIdAndQuizQuestionId(long userId, long quizQuestionId);
 
-    Set<QuizQuestionProgress> findAllByUserIdAndQuizQuestionIdIn(long userId, Set<Long> quizQuestionIds);
+    Set<QuizQuestionProgress> findAllByUserIdAndCourseId(long userId, long courseId);
 
 }

src/main/java/de/tum/cit/aet/artemis/quiz/repository/QuizQuestionRepository.java

@@ -7,6 +7,8 @@
 
 import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
@@ -43,14 +45,22 @@ public interface QuizQuestionRepository extends ArtemisJpaRepository<QuizQuestio
      * Finds all quiz question from a course that are open for practice.
      *
      * @param courseId of the course
+     * @param pageable pagination information
      * @return a set of quiz questions
      */
     @Query("""
             SELECT q
             FROM QuizQuestion q
             WHERE q.exercise.course.id = :courseId AND q.exercise.isOpenForPractice = TRUE
             """)
-    Set<QuizQuestion> findAllQuizQuestionsByCourseId(@Param("courseId") Long courseId);
+    Slice<QuizQuestion> findAllPracticeQuizQuestionsByCourseId(@Param("courseId") Long courseId, Pageable pageable);
+
+    @Query("""
+            SELECT q
+            FROM QuizQuestion q
+            WHERE q.exercise.course.id = :courseId AND q.exercise.isOpenForPractice = TRUE AND q.id NOT IN (:ids)
+            """)
+    Slice<QuizQuestion> findAllDueQuestions(@Param("ids") Set<Long> ids, @Param("courseId") long courseId, Pageable pageable);
 
     @Query("""
             SELECT COUNT(q) > 0
@@ -59,6 +69,13 @@ SELECT COUNT(q) > 0
             """)
     boolean areQuizQuestionsAvailableForPractice(@Param("courseId") Long courseId);
 
+    @Query("""
+            SELECT COUNT(q)
+            FROM QuizQuestion q
+            WHERE q.exercise.course.id = :courseId AND q.exercise.isOpenForPractice = TRUE
+            """)
+    long countAllPracticeQuizQuestionsByCourseId(@Param("courseId") long courseId);
+
     default DragAndDropQuestion findDnDQuestionByIdOrElseThrow(Long questionId) {
         return getValueElseThrow(findDnDQuestionById(questionId), questionId);
     }

src/main/java/de/tum/cit/aet/artemis/quiz/service/QuizQuestionProgressService.java

@@ -3,21 +3,23 @@
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 
 import java.time.ZonedDateTime;
-import java.util.Comparator;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
 import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
 import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
 import org.springframework.stereotype.Service;
 
 import de.tum.cit.aet.artemis.quiz.domain.QuizQuestion;
 import de.tum.cit.aet.artemis.quiz.domain.QuizQuestionProgress;
 import de.tum.cit.aet.artemis.quiz.domain.QuizQuestionProgressData;
 import de.tum.cit.aet.artemis.quiz.domain.SubmittedAnswer;
+import de.tum.cit.aet.artemis.quiz.dto.question.QuizQuestionTrainingDTO;
+import de.tum.cit.aet.artemis.quiz.dto.question.QuizQuestionWithSolutionDTO;
 import de.tum.cit.aet.artemis.quiz.repository.QuizQuestionProgressRepository;
 import de.tum.cit.aet.artemis.quiz.repository.QuizQuestionRepository;
 
@@ -85,30 +87,58 @@ public void updateProgressCalculations(QuizQuestionProgressData data, double sco
     }
 
     /**
-     * Get the sorted List of 10 quiz questions based on their due date
+     * Get the sorted List of quiz questions based on their due date
      *
-     * @param courseId ID of the course for which the quiz questions are to be fetched
-     * @param userId   ID of the user for whom the quiz questions are to be fetched
-     * @return A list of 10 quiz questions sorted by due date
+     * @param courseId    ID of the course for which the quiz questions are to be fetched
+     * @param userId      ID of the user for whom the quiz questions are to be fetched
+     * @param pageable    Pageable object with pagination information
+     * @param questionIds Optional set of question IDs to filter the questions
+     * @return A list of quiz questions sorted by due date
      */
-    public List<QuizQuestion> getQuestionsForSession(Long courseId, Long userId) {
-        Set<QuizQuestion> allQuestions = quizQuestionRepository.findAllQuizQuestionsByCourseId(courseId);
-        Set<Long> questionIds = allQuestions.stream().map(QuizQuestion::getId).collect(Collectors.toSet());
-        Set<QuizQuestionProgress> progressList = quizQuestionProgressRepository.findAllByUserIdAndQuizQuestionIdIn(userId, questionIds);
+    public Slice<QuizQuestionTrainingDTO> getQuestionsForSession(long courseId, long userId, Pageable pageable, Set<Long> questionIds) {
+        ZonedDateTime now = ZonedDateTime.now();
+        if (questionIds == null) {
+            Set<QuizQuestionProgress> allProgress = quizQuestionProgressRepository.findAllByUserIdAndCourseId(userId, courseId);
 
-        Map<Long, ZonedDateTime> dueDateMap = progressList.stream().collect(Collectors.toMap(QuizQuestionProgress::getQuizQuestionId, progress -> {
-            QuizQuestionProgressData data = progress.getProgressJson();
-            return (data != null && data.getDueDate() != null) ? data.getDueDate() : ZonedDateTime.now();
-        }));
+            questionIds = allProgress.stream().filter(progress -> {
+                QuizQuestionProgressData data = progress.getProgressJson();
+                return data != null && data.getDueDate() != null && data.getDueDate().isAfter(now);
+            }).map(QuizQuestionProgress::getQuizQuestionId).collect(Collectors.toSet());
+            if (questionIds.isEmpty()) {
+                questionIds.add(-1L);
+            }
+        }
 
-        ZonedDateTime now = ZonedDateTime.now();
+        if (areQuestionsDue(courseId, questionIds.size())) {
+            return loadDueQuestions(questionIds, courseId, pageable);
+        }
+        else {
+            return loadAllPracticeQuestions(courseId, pageable);
+        }
+    }
+
+    private boolean areQuestionsDue(Long courseId, int notDueCount) {
+        long totalQuestionsCount = quizQuestionRepository.countAllPracticeQuizQuestionsByCourseId(courseId);
+
+        return notDueCount < totalQuestionsCount;
+    }
+
+    private Slice<QuizQuestionTrainingDTO> loadDueQuestions(Set<Long> questionIds, Long courseId, Pageable pageable) {
+        Slice<QuizQuestion> questionPage = quizQuestionRepository.findAllDueQuestions(questionIds, courseId, pageable);
+
+        return questionPage.map(question -> {
+            QuizQuestionWithSolutionDTO dto = QuizQuestionWithSolutionDTO.of(question);
+            return new QuizQuestionTrainingDTO(dto, true, questionIds);
+        });
+    }
 
-        List<QuizQuestion> dueQuestions = allQuestions.stream().filter(q -> {
-            ZonedDateTime dueDate = dueDateMap.getOrDefault(q.getId(), now);
-            return !dueDate.toLocalDate().isAfter(now.toLocalDate());
-        }).sorted(Comparator.comparing(q -> dueDateMap.getOrDefault(q.getId(), now))).limit(10).toList();
+    private Slice<QuizQuestionTrainingDTO> loadAllPracticeQuestions(Long courseId, Pageable pageable) {
+        Slice<QuizQuestion> questionPage = quizQuestionRepository.findAllPracticeQuizQuestionsByCourseId(courseId, pageable);
 
-        return dueQuestions;
+        return questionPage.map(question -> {
+            QuizQuestionWithSolutionDTO dto = QuizQuestionWithSolutionDTO.of(question);
+            return new QuizQuestionTrainingDTO(dto, false, null);
+        });
     }
 
     /**
@@ -233,17 +263,19 @@ public boolean questionsAvailableForTraining(Long courseId) {
      *
      * @param question   The quiz question for which the progress is to be saved
      * @param userId     The id of the user
+     * @param courseId   The id of the course
      * @param answer     The submitted answer for the question
      * @param answeredAt The time when the question was answered
      */
-    public void saveProgressFromTraining(QuizQuestion question, Long userId, SubmittedAnswer answer, ZonedDateTime answeredAt) {
+    public void saveProgressFromTraining(QuizQuestion question, long userId, long courseId, SubmittedAnswer answer, ZonedDateTime answeredAt) {
         QuizQuestionProgress existingProgress = quizQuestionProgressRepository.findByUserIdAndQuizQuestionId(userId, question.getId()).orElse(new QuizQuestionProgress());
         QuizQuestionProgressData data = existingProgress.getProgressJson() != null ? existingProgress.getProgressJson() : new QuizQuestionProgressData();
 
         ZonedDateTime dueDate = data.getDueDate();
         if (dueDate == null || !dueDate.isAfter(answeredAt)) {
             existingProgress.setQuizQuestionId(question.getId());
             existingProgress.setUserId(userId);
+            existingProgress.setCourseId(courseId);
             double score = question.getPoints() > 0 ? answer.getScoreInPoints() / question.getPoints() : 0.0;
             updateProgressWithNewAttempt(data, score, answeredAt);
             updateProgressCalculations(data, score, existingProgress, answeredAt);

src/main/java/de/tum/cit/aet/artemis/quiz/service/QuizTrainingService.java

@@ -33,20 +33,25 @@ public QuizTrainingService(QuizQuestionProgressService quizQuestionProgressServi
      *
      * @param quizQuestionId         the id of the quiz question being submitted
      * @param userId                 the id of the user who is submitting the quiz
+     * @param courseId               the id of the course
      * @param studentSubmittedAnswer the answer submitted by the user
      * @param answeredAt             the time when the question was answered
      * @return a DTO containing the submitted answer after the evaluation
      */
-    public SubmittedAnswerAfterEvaluationDTO submitForTraining(long quizQuestionId, long userId, QuizTrainingAnswerDTO studentSubmittedAnswer, ZonedDateTime answeredAt) {
+    public SubmittedAnswerAfterEvaluationDTO submitForTraining(long quizQuestionId, long userId, long courseId, QuizTrainingAnswerDTO studentSubmittedAnswer,
+            ZonedDateTime answeredAt) {
         QuizQuestion quizQuestion = quizQuestionRepository.findByIdElseThrow(quizQuestionId);
         SubmittedAnswer answer = studentSubmittedAnswer.submittedAnswer();
+        boolean isRated = studentSubmittedAnswer.isRated();
 
         double score = quizQuestion.scoreForAnswer(answer);
 
         answer.setScoreInPoints(score);
         answer.setQuizQuestion(quizQuestion);
 
-        quizQuestionProgressService.saveProgressFromTraining(quizQuestion, userId, answer, answeredAt);
+        if (isRated) {
+            quizQuestionProgressService.saveProgressFromTraining(quizQuestion, userId, courseId, answer, answeredAt);
+        }
 
         return SubmittedAnswerAfterEvaluationDTO.of(answer);
     }

src/main/java/de/tum/cit/aet/artemis/quiz/web/QuizTrainingResource.java

@@ -4,15 +4,19 @@
 
 import java.time.ZonedDateTime;
 import java.util.List;
+import java.util.Set;
 
 import jakarta.validation.Valid;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -25,10 +29,10 @@
 import de.tum.cit.aet.artemis.core.repository.UserRepository;
 import de.tum.cit.aet.artemis.core.security.Role;
 import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastStudent;
+import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastStudentInCourse;
 import de.tum.cit.aet.artemis.core.service.AuthorizationCheckService;
-import de.tum.cit.aet.artemis.quiz.domain.QuizQuestion;
 import de.tum.cit.aet.artemis.quiz.dto.QuizTrainingAnswerDTO;
-import de.tum.cit.aet.artemis.quiz.dto.question.QuizQuestionWithSolutionDTO;
+import de.tum.cit.aet.artemis.quiz.dto.question.QuizQuestionTrainingDTO;
 import de.tum.cit.aet.artemis.quiz.dto.submittedanswer.SubmittedAnswerAfterEvaluationDTO;
 import de.tum.cit.aet.artemis.quiz.service.QuizQuestionProgressService;
 import de.tum.cit.aet.artemis.quiz.service.QuizTrainingService;
@@ -61,22 +65,28 @@ public QuizTrainingResource(UserRepository userRepository, CourseRepository cour
     }
 
     /**
-     * Retrieves 10 quiz questions for the training session for the given course. The questions are selected based on the spaced repetition algorithm.
+     * Retrieves the quiz questions for the training session for the given course. The questions are selected based on the spaced repetition algorithm.
      *
-     * @param courseId the id of the course whose quiz questions should be retrieved
+     * @param courseId    the id of the course whose quiz questions should be retrieved
+     * @param pageable    pagination information
+     * @param questionIds optional set of question IDs to filter the questions
      * @return a list of 10 quiz questions for the training session
      */
-    @GetMapping("courses/{courseId}/training-questions")
-    @EnforceAtLeastStudent
-    public ResponseEntity<List<QuizQuestionWithSolutionDTO>> getQuizQuestionsForPractice(@PathVariable long courseId) {
+    @PostMapping("courses/{courseId}/training-questions")
+    @EnforceAtLeastStudentInCourse
+    public ResponseEntity<List<QuizQuestionTrainingDTO>> getQuizQuestionsForPractice(@PathVariable long courseId, Pageable pageable,
+            @RequestBody(required = false) Set<Long> questionIds) {
         log.info("REST request to get quiz questions for course with id : {}", courseId);
         User user = userRepository.getUserWithGroupsAndAuthorities();
-        Course course = courseRepository.findByIdElseThrow(courseId);
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, user);
 
-        List<QuizQuestion> quizQuestions = quizQuestionProgressService.getQuestionsForSession(courseId, user.getId());
-        List<QuizQuestionWithSolutionDTO> quizQuestionsWithSolutions = quizQuestions.stream().map(QuizQuestionWithSolutionDTO::of).toList();
-        return ResponseEntity.ok(quizQuestionsWithSolutions);
+        if (questionIds != null && questionIds.isEmpty()) {
+            questionIds.add(-1L);
+        }
+
+        Slice<QuizQuestionTrainingDTO> quizQuestionsSlice = quizQuestionProgressService.getQuestionsForSession(courseId, user.getId(), pageable, questionIds);
+        HttpHeaders headers = new HttpHeaders();
+        headers.add("X-Has-Next", Boolean.toString(quizQuestionsSlice.hasNext()));
+        return new ResponseEntity<>(quizQuestionsSlice.getContent(), headers, HttpStatus.OK);
     }
 
     /**
@@ -98,7 +108,7 @@ public ResponseEntity<SubmittedAnswerAfterEvaluationDTO> submitForTraining(@Path
         authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, user);
         ZonedDateTime answeredAt = ZonedDateTime.now();
 
-        SubmittedAnswerAfterEvaluationDTO result = quizTrainingService.submitForTraining(quizQuestionId, user.getId(), submittedAnswer, answeredAt);
+        SubmittedAnswerAfterEvaluationDTO result = quizTrainingService.submitForTraining(quizQuestionId, user.getId(), courseId, submittedAnswer, answeredAt);
 
         return ResponseEntity.ok(result);
     }

src/main/resources/config/liquibase/changelog/20250920163252_changelog.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
+    <changeSet id="20250920163252-add-courseid-quiz-question-progress" author="MoritzSpengler">
+        <addColumn tableName="quiz_question_progress">
+            <column name="course_id" type="bigint"/>
+        </addColumn>
+    </changeSet>
+
+    <changeSet id="20250920163252-populate-courseid-quiz-question-progress" author="MoritzSpengler">
+        <comment>Populate course_id for existing entries</comment>
+        <sql>
+            UPDATE quiz_question_progress qqp
+            SET course_id = (
+                SELECT e.course_id
+                FROM quiz_question qq
+                         JOIN exercise e ON qq.exercise_id = e.id
+                WHERE qq.id = qqp.quiz_question_id
+            )
+            WHERE qqp.course_id IS NULL;
+        </sql>
+    </changeSet>
+
+    <changeSet id="20250920163252-set-not-null-courseid-quiz-question-progress-and-foreign-key" author="MoritzSpengler">
+        <addNotNullConstraint tableName="quiz_question_progress"
+                              columnName="course_id"
+                              columnDataType="bigint"/>
+
+        <addForeignKeyConstraint
+                baseTableName="quiz_question_progress"
+                baseColumnNames="course_id"
+                referencedTableName="course"
+                referencedColumnNames="id"
+                constraintName="fk_quiz_question_progress_course"
+                onDelete="CASCADE"/>
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/master.xml

@@ -44,6 +44,7 @@
     <include file="classpath:config/liquibase/changelog/20250731140151_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20250802175051_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20250911170100_changelog.xml" relativeToChangelogFile="false"/>
+    <include file="classpath:config/liquibase/changelog/20250920163252_changelog.xml" relativeToChangelogFile="false"/>
     <!-- NOTE: please use the format "YYYYMMDDhhmmss_changelog.xml", i.e. year month day hour minutes seconds and not something else! -->
     <!-- we should also stay in a chronological order! -->
     <!-- you can use the command 'date '+%Y%m%d%H%M%S' to get the current date and time in the correct format -->