Plagiarism checks: Add possibility for continuous daily plagiarism checks

src/main/java/de/tum/in/www1/artemis/domain/Exercise.java

@@ -25,6 +25,7 @@
 import de.tum.in.www1.artemis.domain.participation.StudentParticipation;
 import de.tum.in.www1.artemis.domain.participation.TutorParticipation;
 import de.tum.in.www1.artemis.domain.plagiarism.PlagiarismCase;
+import de.tum.in.www1.artemis.domain.plagiarism.PlagiarismChecksConfig;
 import de.tum.in.www1.artemis.domain.quiz.QuizExercise;
 import de.tum.in.www1.artemis.domain.view.QuizView;
 import de.tum.in.www1.artemis.service.ExerciseDateService;
@@ -143,6 +144,11 @@ public abstract class Exercise extends BaseExercise implements LearningObject {
     @JsonIncludeProperties({ "id" })
     private Set<PlagiarismCase> plagiarismCases = new HashSet<>();
 
+    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    @JsonIgnoreProperties("exercise")
+    private PlagiarismChecksConfig plagiarismChecksConfig;
+
     // NOTE: Helpers variable names must be different from Getter name, so that Jackson ignores the @Transient annotation, but Hibernate still respects it
     @Transient
     private DueDateStat numberOfSubmissionsTransient;
@@ -400,6 +406,14 @@ public void setPlagiarismCases(Set<PlagiarismCase> plagiarismCases) {
         this.plagiarismCases = plagiarismCases;
     }
 
+    public PlagiarismChecksConfig getPlagiarismChecksConfig() {
+        return plagiarismChecksConfig;
+    }
+
+    public void setPlagiarismChecksConfig(PlagiarismChecksConfig plagiarismChecksConfig) {
+        this.plagiarismChecksConfig = plagiarismChecksConfig;
+    }
+
     // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here, do not remove
 
     public Set<Competency> getCompetencies() {

src/main/java/de/tum/in/www1/artemis/domain/plagiarism/PlagiarismChecksConfig.java

@@ -0,0 +1,92 @@
+package de.tum.in.www1.artemis.domain.plagiarism;
+
+import javax.persistence.*;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.in.www1.artemis.domain.DomainObject;
+import de.tum.in.www1.artemis.domain.Exercise;
+
+/**
+ * Stores configuration for manual and continuous plagiarism control.
+ */
+@Entity
+@Table(name = "plagiarism_checks_config")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public class PlagiarismChecksConfig extends DomainObject {
+
+    @OneToOne(mappedBy = "plagiarismChecksConfig", fetch = FetchType.LAZY)
+    @JsonIgnoreProperties("plagiarismChecksConfig")
+    private Exercise exercise;
+
+    @Column(name = "continuous_plagiarism_control_enabled")
+    private boolean continuousPlagiarismControlEnabled = false;
+
+    @Column(name = "similarity_threshold")
+    private float similarityThreshold;
+
+    @Column(name = "minimum_score")
+    private int minimumScore;
+
+    @Column(name = "minimum_size")
+    private int minimumSize;
+
+    public Exercise getExercise() {
+        return exercise;
+    }
+
+    public void setExercise(Exercise exercise) {
+        this.exercise = exercise;
+    }
+
+    public boolean isContinuousPlagiarismControlEnabled() {
+        return continuousPlagiarismControlEnabled;
+    }
+
+    public void setContinuousPlagiarismControlEnabled(boolean continuousPlagiarismControlEnabled) {
+        this.continuousPlagiarismControlEnabled = continuousPlagiarismControlEnabled;
+    }
+
+    public float getSimilarityThreshold() {
+        return similarityThreshold;
+    }
+
+    public int getMinimumScore() {
+        return minimumScore;
+    }
+
+    public int getMinimumSize() {
+        return minimumSize;
+    }
+
+    public void setSimilarityThreshold(float similarityThreshold) {
+        this.similarityThreshold = similarityThreshold;
+    }
+
+    public void setMinimumScore(int minimumScore) {
+        this.minimumScore = minimumScore;
+    }
+
+    public void setMinimumSize(int minimumSize) {
+        this.minimumSize = minimumSize;
+    }
+
+    /**
+     * Creates PlagiarismChecksConfig with default data
+     *
+     * @return PlagiarismChecksConfig with default values
+     */
+    public static PlagiarismChecksConfig createDefault() {
+        var config = new PlagiarismChecksConfig();
+        config.setContinuousPlagiarismControlEnabled(false);
+        config.setSimilarityThreshold(0.5f);
+        config.setMinimumScore(0);
+        config.setMinimumSize(0);
+        return config;
+    }
+}

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

@@ -87,6 +87,19 @@ public interface ExerciseRepository extends JpaRepository<Exercise, Long> {
             """)
     Set<Exercise> findAllExercisesWithCurrentOrUpcomingDueDate(@Param("now") ZonedDateTime now);
 
+    @Query("""
+            SELECT e FROM Exercise e
+            LEFT JOIN FETCH e.plagiarismChecksConfig c
+            LEFT JOIN FETCH e.studentParticipations p
+            LEFT JOIN FETCH p.submissions s
+            LEFT JOIN FETCH s.results
+            WHERE e.course.testCourse = FALSE
+            	AND e.dueDate >= :now
+            	AND c.continuousPlagiarismControlEnabled = TRUE
+            ORDER BY e.dueDate ASC
+            """)
+    Set<Exercise> findAllExercisesWithCurrentOrUpcomingDueDateAndContinuousPlagiarismControlEnabledIsTrue(@Param("now") ZonedDateTime now);
+
     @Query("""
             SELECT e FROM Exercise e
             WHERE e.course.testCourse = FALSE
@@ -307,6 +320,16 @@ default Set<Exercise> findAllExercisesWithCurrentOrUpcomingDueDate() {
         return findAllExercisesWithCurrentOrUpcomingDueDate(ZonedDateTime.now().truncatedTo(ChronoUnit.DAYS));
     }
 
+    /**
+     * Finds all exercises where the due date is today or in the future and continuos plagiarism control is enabled
+     * (does not return exercises belonging to test courses).
+     *
+     * @return set of exercises
+     */
+    default Set<Exercise> findAllExercisesWithCurrentOrUpcomingDueDateAndContinuousPlagiarismControlEnabledIsTrue() {
+        return findAllExercisesWithCurrentOrUpcomingDueDateAndContinuousPlagiarismControlEnabledIsTrue(ZonedDateTime.now().truncatedTo(ChronoUnit.DAYS));
+    }
+
     /**
      * Find exercise by exerciseId and load participations in this exercise.
      *

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

@@ -31,8 +31,9 @@ public interface ModelingExerciseRepository extends JpaRepository<ModelingExerci
             """)
     List<ModelingExercise> findByCourseIdWithCategories(@Param("courseId") Long courseId);
 
-    @EntityGraph(type = LOAD, attributePaths = { "exampleSubmissions", "teamAssignmentConfig", "categories", "competencies", "exampleSubmissions.submission.results" })
-    Optional<ModelingExercise> findWithEagerExampleSubmissionsAndCompetenciesById(@Param("exerciseId") Long exerciseId);
+    @EntityGraph(type = LOAD, attributePaths = { "exampleSubmissions", "teamAssignmentConfig", "categories", "competencies", "exampleSubmissions.submission.results",
+            "plagiarismChecksConfig" })
+    Optional<ModelingExercise> findWithEagerExampleSubmissionsAndCompetenciesAndPlagiarismChecksConfigById(@Param("exerciseId") Long exerciseId);
 
     @Query("select modelingExercise from ModelingExercise modelingExercise left join fetch modelingExercise.exampleSubmissions exampleSubmissions left join fetch exampleSubmissions.submission submission left join fetch submission.results results left join fetch results.feedbacks left join fetch results.assessor left join fetch modelingExercise.teamAssignmentConfig where modelingExercise.id = :#{#exerciseId}")
     Optional<ModelingExercise> findByIdWithExampleSubmissionsAndResults(@Param("exerciseId") Long exerciseId);
@@ -65,14 +66,19 @@ public interface ModelingExerciseRepository extends JpaRepository<ModelingExerci
     @EntityGraph(type = LOAD, attributePaths = { "studentParticipations", "studentParticipations.submissions", "studentParticipations.submissions.results" })
     Optional<ModelingExercise> findWithStudentParticipationsSubmissionsResultsById(Long exerciseId);
 
+    @EntityGraph(type = LOAD, attributePaths = { "studentParticipations", "studentParticipations.submissions", "studentParticipations.submissions.results",
+            "plagiarismChecksConfig" })
+    Optional<ModelingExercise> findWithStudentParticipationsSubmissionsResultsAndPlagiarismChecksConfigById(Long exerciseId);
+
     @NotNull
     default ModelingExercise findByIdElseThrow(long exerciseId) {
         return findById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Modeling Exercise", exerciseId));
     }
 
     @NotNull
-    default ModelingExercise findWithEagerExampleSubmissionsAndCompetenciesByIdElseThrow(long exerciseId) {
-        return findWithEagerExampleSubmissionsAndCompetenciesById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Modeling Exercise", exerciseId));
+    default ModelingExercise findWithEagerExampleSubmissionsAndCompetenciesAndPlagiarismChecksConfigByIdElseThrow(long exerciseId) {
+        return findWithEagerExampleSubmissionsAndCompetenciesAndPlagiarismChecksConfigById(exerciseId)
+                .orElseThrow(() -> new EntityNotFoundException("Modeling Exercise", exerciseId));
     }
 
     @NotNull
@@ -84,4 +90,10 @@ default ModelingExercise findByIdWithExampleSubmissionsAndResultsElseThrow(long
     default ModelingExercise findByIdWithStudentParticipationsSubmissionsResultsElseThrow(long exerciseId) {
         return findWithStudentParticipationsSubmissionsResultsById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Modeling Exercise", exerciseId));
     }
+
+    @NotNull
+    default ModelingExercise findByIdWithStudentParticipationsSubmissionsResultsAndPlagiarismChecksConfigElseThrow(long exerciseId) {
+        return findWithStudentParticipationsSubmissionsResultsAndPlagiarismChecksConfigById(exerciseId)
+                .orElseThrow(() -> new EntityNotFoundException("Modeling Exercise", exerciseId));
+    }
 }

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

@@ -61,6 +61,10 @@
             "submissionPolicy" })
     Optional<ProgrammingExercise> findWithTemplateAndSolutionParticipationTeamAssignmentConfigCategoriesAndCompetenciesById(Long exerciseId);
 
+    @EntityGraph(type = LOAD, attributePaths = { "templateParticipation", "solutionParticipation", "teamAssignmentConfig", "categories", "competencies", "auxiliaryRepositories",
+            "submissionPolicy", "plagiarismChecksConfig" })
+    Optional<ProgrammingExercise> findWithTemplateAndSolutionParticipationTeamAssignmentConfigCategoriesAndCompetenciesAndPlagiarismChecksConfigById(Long exerciseId);
+
     @EntityGraph(type = LOAD, attributePaths = { "templateParticipation", "solutionParticipation", "auxiliaryRepositories" })
     Optional<ProgrammingExercise> findWithTemplateAndSolutionParticipationAndAuxiliaryRepositoriesById(Long exerciseId);
 
@@ -448,6 +452,9 @@
             """)
     List<ProgrammingExercise> findAllProgrammingExercisesInCourseOrInExamsOfCourse(@Param("course") Course course);
 
+    @EntityGraph(type = LOAD, attributePaths = { "plagiarismChecksConfig" })
+    Optional<ProgrammingExercise> findWithPlagiarismChecksConfigById(long id);
+
     long countByShortNameAndCourse(String shortName, Course course);
 
     long countByTitleAndCourse(String shortName, Course course);
@@ -476,6 +483,17 @@
         return findById(programmingExerciseId).orElseThrow(() -> new EntityNotFoundException("Programming Exercise", programmingExerciseId));
     }
 
+    /**
+     * Find a programming exercise with plagiarism checks config by its id and throw an EntityNotFoundException if it cannot be found
+     *
+     * @param programmingExerciseId of the programming exercise.
+     * @return The programming exercise related to the given id
+     */
+    @NotNull
+    default ProgrammingExercise findByIdWithPlagiarismChecksConfigElseThrow(Long programmingExerciseId) throws EntityNotFoundException {
+        return findWithPlagiarismChecksConfigById(programmingExerciseId).orElseThrow(() -> new EntityNotFoundException("Programming Exercise", programmingExerciseId));
+    }
+
     /**
      * Find a programming exercise with auxiliary repositories by its id and throw an EntityNotFoundException if it cannot be found
      *
@@ -591,6 +609,14 @@
         return programmingExercise.orElseThrow(() -> new EntityNotFoundException("Programming Exercise", programmingExerciseId));
     }
 
+    @NotNull
+    default ProgrammingExercise findByIdWithTemplateAndSolutionParticipationTeamAssignmentConfigCategoriesAndCompetenciesAndPlagiarismChecksConfigElseThrow(
+            long programmingExerciseId) throws EntityNotFoundException {
+        Optional<ProgrammingExercise> programmingExercise = findWithTemplateAndSolutionParticipationTeamAssignmentConfigCategoriesAndCompetenciesAndPlagiarismChecksConfigById(
+                programmingExerciseId);
+        return programmingExercise.orElseThrow(() -> new EntityNotFoundException("Programming Exercise", programmingExerciseId));
+    }
+
     /**
      * Find a programming exercise by its id, with eagerly loaded template and solution participation, submissions and results
      *

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

@@ -32,8 +32,8 @@ public interface TextExerciseRepository extends JpaRepository<TextExercise, Long
             """)
     List<TextExercise> findByCourseIdWithCategories(@Param("courseId") Long courseId);
 
-    @EntityGraph(type = LOAD, attributePaths = { "teamAssignmentConfig", "categories", "competencies" })
-    Optional<TextExercise> findWithEagerTeamAssignmentConfigAndCategoriesAndCompetenciesById(Long exerciseId);
+    @EntityGraph(type = LOAD, attributePaths = { "teamAssignmentConfig", "categories", "competencies", "plagiarismChecksConfig" })
+    Optional<TextExercise> findWithEagerTeamAssignmentConfigAndCategoriesAndCompetenciesAndPlagiarismChecksConfigById(Long exerciseId);
 
     List<TextExercise> findByAssessmentTypeAndDueDateIsAfter(AssessmentType assessmentType, ZonedDateTime dueDate);
 
@@ -43,6 +43,10 @@ public interface TextExerciseRepository extends JpaRepository<TextExercise, Long
     @EntityGraph(type = LOAD, attributePaths = { "studentParticipations", "studentParticipations.submissions", "studentParticipations.submissions.results" })
     Optional<TextExercise> findWithStudentParticipationsAndSubmissionsById(Long exerciseId);
 
+    @EntityGraph(type = LOAD, attributePaths = { "studentParticipations", "studentParticipations.submissions", "studentParticipations.submissions.results",
+            "plagiarismChecksConfig" })
+    Optional<TextExercise> findWithStudentParticipationsAndSubmissionsAndPlagiarismChecksConfigById(Long exerciseId);
+
     @NotNull
     default TextExercise findByIdElseThrow(long exerciseId) {
         return findById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
@@ -58,6 +62,11 @@ default TextExercise findByIdWithStudentParticipationsAndSubmissionsElseThrow(lo
         return findWithStudentParticipationsAndSubmissionsById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
     }
 
+    @NotNull
+    default TextExercise findByIdWithStudentParticipationsAndSubmissionsAndPlagiarismChecksConfigElseThrow(long exerciseId) {
+        return findWithStudentParticipationsAndSubmissionsAndPlagiarismChecksConfigById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
+    }
+
     /**
      * Find all exercises with *Due Date* in the future.
      *

src/main/java/de/tum/in/www1/artemis/service/ExerciseImportService.java

@@ -7,6 +7,7 @@
 
 import de.tum.in.www1.artemis.domain.*;
 import de.tum.in.www1.artemis.domain.enumeration.ExerciseMode;
+import de.tum.in.www1.artemis.domain.plagiarism.PlagiarismChecksConfig;
 import de.tum.in.www1.artemis.repository.*;
 
 public abstract class ExerciseImportService {
@@ -63,6 +64,22 @@ void copyExerciseBasis(final Exercise newExercise, final Exercise importedExerci
                 newExercise.setTeamAssignmentConfig(importedExercise.getTeamAssignmentConfig().copyTeamAssignmentConfig());
             }
         }
+
+        if (importedExercise.getPlagiarismChecksConfig() != null) {
+            var plagiarismChecksConfig = new PlagiarismChecksConfig();
+
+            var importedPlagiarismChecksConfig = importedExercise.getPlagiarismChecksConfig();
+            plagiarismChecksConfig.setContinuousPlagiarismControlEnabled(importedPlagiarismChecksConfig.isContinuousPlagiarismControlEnabled());
+            plagiarismChecksConfig.setSimilarityThreshold(importedPlagiarismChecksConfig.getSimilarityThreshold());
+            plagiarismChecksConfig.setMinimumSize(importedPlagiarismChecksConfig.getMinimumSize());
+            plagiarismChecksConfig.setMinimumScore(importedPlagiarismChecksConfig.getMinimumScore());
+
+            newExercise.setPlagiarismChecksConfig(plagiarismChecksConfig);
+        }
+        else {
+            newExercise.setPlagiarismChecksConfig(null);
+        }
+
     }
 
     /**