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/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, boolean isNewSession) {
+
+    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,57 @@ 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
+     * @param isNewSession Boolean indicating if it is a new training session or a continuation of an existing one
+     * @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, boolean isNewSession) {
+        ZonedDateTime now = ZonedDateTime.now();
+        if (isNewSession) {
+            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());
+            isNewSession = false;
+        }
 
-        ZonedDateTime now = ZonedDateTime.now();
+        if (areQuestionsDue(courseId, questionIds.size())) {
+            return loadDueQuestions(questionIds, courseId, pageable, isNewSession);
+        }
+        else {
+            return loadAllPracticeQuestions(courseId, pageable, isNewSession);
+        }
+    }
+
+    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, boolean isNewSession) {
+        Slice<QuizQuestion> questionPage = quizQuestionRepository.findAllDueQuestions(questionIds, courseId, pageable);
+
+        return questionPage.map(question -> {
+            QuizQuestionWithSolutionDTO dto = QuizQuestionWithSolutionDTO.of(question);
+            return new QuizQuestionTrainingDTO(dto, true, questionIds, isNewSession);
+        });
+    }
 
-        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, boolean isNewSession) {
+        Slice<QuizQuestion> questionPage = quizQuestionRepository.findAllPracticeQuizQuestionsByCourseId(courseId, pageable);
 
-        return dueQuestions;
+        return questionPage.map(question -> {
+            QuizQuestionWithSolutionDTO dto = QuizQuestionWithSolutionDTO.of(question);
+            return new QuizQuestionTrainingDTO(dto, false, null, isNewSession);
+        });
     }
 
     /**
@@ -233,17 +262,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

@@ -10,7 +10,6 @@
 
 import de.tum.cit.aet.artemis.quiz.domain.QuizQuestion;
 import de.tum.cit.aet.artemis.quiz.domain.SubmittedAnswer;
-import de.tum.cit.aet.artemis.quiz.dto.QuizTrainingAnswerDTO;
 import de.tum.cit.aet.artemis.quiz.dto.submittedanswer.SubmittedAnswerAfterEvaluationDTO;
 import de.tum.cit.aet.artemis.quiz.repository.QuizQuestionRepository;
 
@@ -31,23 +30,27 @@ public QuizTrainingService(QuizQuestionProgressService quizQuestionProgressServi
     /**
      * Submits a quiz question for training mode, calculates scores and creates a result.
      *
-     * @param quizQuestionId         the id of the quiz question being submitted
-     * @param userId                 the id of the user who is submitting the quiz
-     * @param studentSubmittedAnswer the answer submitted by the user
-     * @param answeredAt             the time when the question was answered
+     * @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 submittedAnswer the answer submitted by the user
+     * @param isRated         whether the answer is rated (i.e. updates progress)
+     * @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, SubmittedAnswer submittedAnswer, boolean isRated,
+            ZonedDateTime answeredAt) {
         QuizQuestion quizQuestion = quizQuestionRepository.findByIdElseThrow(quizQuestionId);
-        SubmittedAnswer answer = studentSubmittedAnswer.submittedAnswer();
 
-        double score = quizQuestion.scoreForAnswer(answer);
+        double score = quizQuestion.scoreForAnswer(submittedAnswer);
 
-        answer.setScoreInPoints(score);
-        answer.setQuizQuestion(quizQuestion);
+        submittedAnswer.setScoreInPoints(score);
+        submittedAnswer.setQuizQuestion(quizQuestion);
 
-        quizQuestionProgressService.saveProgressFromTraining(quizQuestion, userId, answer, answeredAt);
+        if (isRated) {
+            quizQuestionProgressService.saveProgressFromTraining(quizQuestion, userId, courseId, submittedAnswer, answeredAt);
+        }
 
-        return SubmittedAnswerAfterEvaluationDTO.of(answer);
+        return SubmittedAnswerAfterEvaluationDTO.of(submittedAnswer);
     }
 }

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

@@ -4,19 +4,24 @@
 
 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;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 import de.tum.cit.aet.artemis.core.domain.Course;
@@ -25,10 +30,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.domain.SubmittedAnswer;
+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,44 +66,48 @@ 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
-     * @return a list of 10 quiz questions for the training session
+     * @param courseId     the id of the course whose quiz questions should be retrieved
+     * @param pageable     pagination information
+     * @param isNewSession whether a new training session is being started
+     * @param questionIds  optional set of question IDs to filter the questions
+     * @return a list of quiz questions for the training session depending on the pagination information
      */
-    @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, @RequestParam boolean isNewSession,
+            @RequestBody 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);
+        Slice<QuizQuestionTrainingDTO> quizQuestionsSlice = quizQuestionProgressService.getQuestionsForSession(courseId, user.getId(), pageable, questionIds, isNewSession);
+        HttpHeaders headers = new HttpHeaders();
+        headers.add("X-Has-Next", Boolean.toString(quizQuestionsSlice.hasNext()));
+        return new ResponseEntity<>(quizQuestionsSlice.getContent(), headers, HttpStatus.OK);
     }
 
     /**
      * POST /courses/:courseId/training/:quizQuestionId/submit: Submit a new quizQuestion for training mode.
      *
      * @param courseId        the id of the course containing the quiz question
      * @param quizQuestionId  the id of the quiz question which is being answered
+     * @param isRated         whether the submitted answer should be rated (i.e. affect the user's progress= or not
      * @param submittedAnswer the submitted answer by the user for the quiz question
      * @return the ResponseEntity with status 200 (OK) and the result of the evaluated submitted answer as its body
      */
     @PostMapping("courses/{courseId}/training-questions/{quizQuestionId}/submit")
     @EnforceAtLeastStudent
-    public ResponseEntity<SubmittedAnswerAfterEvaluationDTO> submitForTraining(@PathVariable long courseId, @PathVariable long quizQuestionId,
-            @Valid @RequestBody QuizTrainingAnswerDTO submittedAnswer) {
+    public ResponseEntity<SubmittedAnswerAfterEvaluationDTO> submitForTraining(@PathVariable long courseId, @PathVariable long quizQuestionId, @RequestParam boolean isRated,
+            @Valid @RequestBody SubmittedAnswer submittedAnswer) {
         log.debug("REST request to submit QuizQuestion for training : {}", submittedAnswer);
 
         User user = userRepository.getUserWithGroupsAndAuthorities();
         Course course = courseRepository.findByIdElseThrow(courseId);
         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, isRated, answeredAt);
 
         return ResponseEntity.ok(result);
     }