General: Add cleanup service for admins

src/main/java/de/tum/cit/aet/artemis/assessment/repository/FeedbackRepository.java

@@ -32,8 +32,8 @@ public interface FeedbackRepository extends ArtemisJpaRepository<Feedback, Long>
 
     @Query("""
             SELECT feedback
-            FROM Feedback feedback
-            WHERE feedback.gradingInstruction.id IN :gradingInstructionsIds
+                FROM Feedback feedback
+                WHERE feedback.gradingInstruction.id IN :gradingInstructionsIds
             """)
     List<Feedback> findFeedbackByGradingInstructionIds(@Param("gradingInstructionsIds") List<Long> gradingInstructionsIds);
 

src/main/java/de/tum/cit/aet/artemis/assessment/repository/StudentScoreRepository.java

@@ -69,4 +69,5 @@ public interface StudentScoreRepository extends ArtemisJpaRepository<StudentScor
     @Transactional // ok because of delete
     @Modifying
     void deleteByExerciseAndUser(Exercise exercise, User user);
+
 }

src/main/java/de/tum/cit/aet/artemis/assessment/repository/cleanup/FeedbackCleanupRepository.java

@@ -0,0 +1,116 @@
+package de.tum.cit.aet.artemis.assessment.repository.cleanup;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.time.ZonedDateTime;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import de.tum.cit.aet.artemis.assessment.domain.Feedback;
+import de.tum.cit.aet.artemis.assessment.domain.Result;
+import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
+import de.tum.cit.aet.artemis.exercise.domain.participation.Participation;
+
+/**
+ * Spring Data JPA repository for cleaning up old and orphaned feedback entries.
+ * THE FOLLOWING METHODS ARE USED FOR CLEANUP PURPOSES AND SHOULD NOT BE USED IN OTHER CASES
+ */
+@Profile(PROFILE_CORE)
+@Repository
+public interface FeedbackCleanupRepository extends ArtemisJpaRepository<Feedback, Long> {
+
+    /**
+     * Deletes {@link Feedback} entries where the associated {@link Result} has no submission and no participation.
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    // Subquery ok
+    @Query("""
+            DELETE FROM Feedback f
+            WHERE f.result IN (
+                SELECT r
+                FROM Result r
+                WHERE r.submission IS NULL
+                    AND r.participation IS NULL
+                )
+            """)
+    void deleteFeedbackForOrphanResults();
+
+    /**
+     * Deletes {@link Feedback} entries with a {@code null} result.
+     * Returns {@code void}
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM Feedback f
+            WHERE f.result IS NULL
+            """)
+    void deleteOrphanFeedback();
+
+    /**
+     * Deletes {@link Feedback} entries associated with rated {@link Result} that are not the latest rated result
+     * for a {@link Participation}, within courses conducted between the specified date range.
+     * This query removes old feedback entries that are not part of the latest rated results, for courses whose
+     * end date is before {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM Feedback f
+            WHERE f.result IN (
+                SELECT r
+                FROM Result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE r.id NOT IN (
+                    SELECT MAX(r2.id)
+                    FROM Result r2
+                    WHERE r2.participation.id = p.id
+                        AND r2.rated = TRUE
+                    )
+                    AND c.endDate < :deleteTo
+                    AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteOldFeedbackThatAreNotLatestRatedResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+
+    /**
+     * Deletes non-rated {@link Feedback} entries that are not the latest non-rated result, where the associated course's start and end dates
+     * are between the specified date range.
+     * This query removes old feedback entries that are not part of the latest non-rated result within courses whose end date is before
+     * {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM Feedback f
+            WHERE f.result IN (
+            SELECT r
+                FROM Result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE r.id NOT IN (
+                    SELECT MAX(r2.id)
+                    FROM Result r2
+                    WHERE r2.participation.id = p.id)
+                        AND r.rated = FALSE
+                        AND c.endDate < :deleteTo
+                        AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteOldNonRatedFeedbackWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+}

src/main/java/de/tum/cit/aet/artemis/assessment/repository/cleanup/LongFeedbackTextCleanupRepository.java

@@ -0,0 +1,124 @@
+package de.tum.cit.aet.artemis.assessment.repository.cleanup;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.time.ZonedDateTime;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import de.tum.cit.aet.artemis.assessment.domain.Feedback;
+import de.tum.cit.aet.artemis.assessment.domain.LongFeedbackText;
+import de.tum.cit.aet.artemis.assessment.domain.Result;
+import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
+import de.tum.cit.aet.artemis.exercise.domain.participation.Participation;
+
+/**
+ * Spring Data JPA repository for cleaning up old and orphaned long feedback text entries.
+ * THE FOLLOWING METHODS ARE USED FOR CLEANUP PURPOSES AND SHOULD NOT BE USED IN OTHER CASES
+ */
+@Profile(PROFILE_CORE)
+@Repository
+public interface LongFeedbackTextCleanupRepository extends ArtemisJpaRepository<LongFeedbackText, Long> {
+
+    /**
+     * Deletes {@link LongFeedbackText} entries linked to {@link Feedback} where the associated
+     * {@link Result} has no participation and no submission.
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM LongFeedbackText lft
+            WHERE lft.feedback.id IN (
+                SELECT f.id
+                FROM Feedback f
+                WHERE f.result.participation IS NULL
+                    AND f.result.submission IS NULL
+                )
+            """)
+    void deleteLongFeedbackTextForOrphanResult();
+
+    /**
+     * Deletes {@link LongFeedbackText} linked to {@link Feedback} with a {@code null} result.
+     * Returns {@code void}
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM LongFeedbackText lft
+            WHERE lft.feedback IN (
+                SELECT f
+                FROM Feedback f
+                WHERE f.result IS NULL
+                )
+            """)
+    void deleteLongFeedbackTextForOrphanedFeedback();
+
+    /**
+     * Deletes {@link LongFeedbackText} entries associated with rated {@link Result} that are not the latest rated result
+     * for a {@link Participation}, within courses conducted between the specified date range.
+     * This query removes old long feedback text that is not part of the latest rated results, for courses whose
+     * end date is before {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM LongFeedbackText lft
+            WHERE lft.feedback IN (
+                SELECT f
+                FROM Feedback f
+                    LEFT JOIN f.result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE f.result.id NOT IN (
+                    SELECT MAX(r2.id)
+                    FROM Result r2
+                    WHERE r2.participation.id = p.id
+                        AND r2.rated = TRUE
+                    )
+                    AND c.endDate < :deleteTo
+                    AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteLongFeedbackTextForRatedResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+
+    /**
+     * Deletes {@link LongFeedbackText} entries linked to non-rated {@link Feedback} that are not the latest rated result where the associated course's start
+     * and end dates are between the specified date range.
+     * This query deletes long feedback text for feedback associated with non-rated results, within courses whose
+     * end date is before {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM LongFeedbackText lft
+            WHERE lft.feedback IN (
+                SELECT f
+                FROM Feedback f
+                    LEFT JOIN f.result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE f.result.id NOT IN (
+                    SELECT MAX(r2.id)
+                    FROM Result r2
+                    WHERE r2.participation.id = p.id
+                        AND r2.rated = FALSE
+                    )
+                    AND c.endDate < :deleteTo
+                    AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteLongFeedbackTextForNonRatedResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+}

src/main/java/de/tum/cit/aet/artemis/assessment/repository/cleanup/ParticipantScoreCleanupRepository.java

@@ -0,0 +1,140 @@
+package de.tum.cit.aet.artemis.assessment.repository.cleanup;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.time.ZonedDateTime;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import de.tum.cit.aet.artemis.assessment.domain.ParticipantScore;
+import de.tum.cit.aet.artemis.assessment.domain.Result;
+import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
+import de.tum.cit.aet.artemis.exercise.domain.participation.Participation;
+
+/**
+ * Spring Data JPA repository for cleaning up old and orphaned participant scores.
+ * THE FOLLOWING METHODS ARE USED FOR CLEANUP PURPOSES AND SHOULD NOT BE USED IN OTHER CASES
+ */
+@Profile(PROFILE_CORE)
+@Repository
+public interface ParticipantScoreCleanupRepository extends ArtemisJpaRepository<ParticipantScore, Long> {
+
+    /**
+     * Deletes {@link ParticipantScore} entries where the associated {@link Result} is not the latest rated result
+     * for a {@link Participation}, within courses conducted between the specified date range.
+     * This query removes participant scores linked to results that are not the most recent rated results, for courses
+     * whose end date is before {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM ParticipantScore ps
+            WHERE ps.lastResult IN (
+                SELECT r
+                FROM Result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE r.id NOT IN (
+                    SELECT MAX(r2.id)
+                    FROM Result r2
+                    WHERE r2.participation.id = p.id
+                        AND r2.rated = TRUE
+                    )
+                    AND c.endDate < :deleteTo
+                    AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteParticipantScoresForNonLatestLastResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+
+    /**
+     * Deletes {@link ParticipantScore} entries where the associated last rated {@link Result} is not the latest rated result
+     * for a {@link Participation}, within courses conducted between the specified date range.
+     * This query removes participant scores linked to rated results that are not the most recent rated results, for courses
+     * whose end date is before {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM ParticipantScore ps
+            WHERE ps.lastRatedResult IN (
+                SELECT r
+                FROM Result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE r.id NOT IN (
+                    SELECT MAX(r2.id)
+                    FROM Result r2
+                    WHERE r2.participation.id = p.id
+                        AND r2.rated = TRUE
+                    )
+                AND c.endDate < :deleteTo
+                AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteParticipantScoresForNonLatestLastRatedResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+
+    /**
+     * Deletes {@link ParticipantScore} entries where the associated {@link Result} is the latest result and is non-rated,
+     * and the course's start and end dates are between the specified date range.
+     * This query deletes participant scores for non-rated results within courses whose end date is before
+     * {@code deleteTo} and start date is after {@code deleteFrom}.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM ParticipantScore ps
+            WHERE ps.lastResult IN (
+                SELECT r
+                FROM Result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE r.rated = FALSE
+                    AND c.endDate < :deleteTo
+                    AND c.startDate > :deleteFrom                                                                       )
+            """)
+    void deleteParticipantScoresForLatestNonRatedResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+
+    /**
+     * Deletes {@link ParticipantScore} entries where the associated {@link Result} is non-rated, even though
+     * it is marked as the last rated result, to prevent potential integrity violations.
+     * The deletion is based on courses whose start and end dates fall within the specified range.
+     * This scenario should not normally occur, as non-rated results cannot be marked as rated, but the
+     * method ensures cleanup in case of any potential integrity issues.
+     *
+     * @param deleteFrom the start date for selecting courses
+     * @param deleteTo   the end date for selecting courses
+     */
+    @Modifying
+    @Transactional // ok because of delete
+    @Query("""
+            DELETE FROM ParticipantScore ps
+            WHERE ps.lastRatedResult IN (
+                SELECT r
+                FROM Result r
+                    LEFT JOIN r.participation p
+                    LEFT JOIN p.exercise e
+                    LEFT JOIN e.course c
+                WHERE r.rated = FALSE
+                    AND c.endDate < :deleteTo
+                    AND c.startDate > :deleteFrom
+                )
+            """)
+    void deleteParticipantScoresForNonRatedResultsWhereCourseDateBetween(@Param("deleteFrom") ZonedDateTime deleteFrom, @Param("deleteTo") ZonedDateTime deleteTo);
+}