Plagiarism checks: Add possibility for continuous daily plagiarism checks

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

@@ -23,6 +23,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.web.rest.dto.DueDateStat;
@@ -140,6 +141,13 @@ public abstract class Exercise extends BaseExercise implements LearningObject {
     @JsonIncludeProperties({ "id" })
     private Set<PlagiarismCase> plagiarismCases = new HashSet<>();
 
+    @Column(name = "continuous_plagiarism_control_enabled")
+    private boolean continuousPlagiarismControlEnabled = false;
+
+    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    private PlagiarismChecksConfig plagiarismChecksConfig = new 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;
@@ -391,6 +399,22 @@ public void setPlagiarismCases(Set<PlagiarismCase> plagiarismCases) {
         this.plagiarismCases = plagiarismCases;
     }
 
+    public boolean isContinuousPlagiarismControlEnabled() {
+        return continuousPlagiarismControlEnabled;
+    }
+
+    public void setContinuousPlagiarismControlEnabled(boolean continuousPlagiarismControlEnabled) {
+        this.continuousPlagiarismControlEnabled = continuousPlagiarismControlEnabled;
+    }
+
+    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,51 @@
+package de.tum.in.www1.artemis.domain.plagiarism;
+
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.in.www1.artemis.domain.DomainObject;
+
+/**
+ * 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 {
+
+    private float similarityThreshold;
+
+    private int minimumScore;
+
+    private int minimumSize;
+
+    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;
+    }
+}

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

@@ -88,6 +88,15 @@ public interface ExerciseRepository extends JpaRepository<Exercise, Long> {
             """)
     Set<Exercise> findAllExercisesWithCurrentOrUpcomingDueDate(@Param("now") ZonedDateTime now);
 
+    @Query("""
+            SELECT e FROM Exercise e
+            WHERE e.course.testCourse = FALSE
+            	AND e.dueDate >= :now
+            	AND e.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
@@ -474,6 +483,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/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 {
@@ -59,6 +60,11 @@ void copyExerciseBasis(final Exercise newExercise, final Exercise importedExerci
                 newExercise.setTeamAssignmentConfig(importedExercise.getTeamAssignmentConfig().copyTeamAssignmentConfig());
             }
         }
+        var plagiarismChecksConfig = new PlagiarismChecksConfig();
+        plagiarismChecksConfig.setSimilarityThreshold(importedExercise.getPlagiarismChecksConfig().getSimilarityThreshold());
+        plagiarismChecksConfig.setMinimumSize(importedExercise.getPlagiarismChecksConfig().getMinimumSize());
+        plagiarismChecksConfig.setMinimumScore(importedExercise.getPlagiarismChecksConfig().getMinimumScore());
+        newExercise.setPlagiarismChecksConfig(plagiarismChecksConfig);
     }
 
     /**

src/main/java/de/tum/in/www1/artemis/service/plagiarism/ContinuousPlagiarismControlService.java

@@ -0,0 +1,152 @@
+package de.tum.in.www1.artemis.service.plagiarism;
+
+import org.jvnet.hk2.annotations.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import de.jplag.exceptions.ExitException;
+import de.tum.in.www1.artemis.domain.Exercise;
+import de.tum.in.www1.artemis.domain.ProgrammingExercise;
+import de.tum.in.www1.artemis.domain.TextExercise;
+import de.tum.in.www1.artemis.domain.modeling.ModelingExercise;
+import de.tum.in.www1.artemis.repository.ExerciseRepository;
+import de.tum.in.www1.artemis.repository.ModelingExerciseRepository;
+import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
+import de.tum.in.www1.artemis.repository.TextExerciseRepository;
+import de.tum.in.www1.artemis.repository.plagiarism.PlagiarismResultRepository;
+import de.tum.in.www1.artemis.service.programming.ProgrammingLanguageFeatureService;
+import de.tum.in.www1.artemis.service.util.TimeLogUtil;
+
+/**
+ * Manages continuous plagiarism control.
+ */
+@Service
+@Component
+@Profile("scheduling")
+public class ContinuousPlagiarismControlService {
+
+    private static final Logger log = LoggerFactory.getLogger(ContinuousPlagiarismControlService.class);
+
+    private final ExerciseRepository exerciseRepository;
+
+    private final TextExerciseRepository textExerciseRepository;
+
+    private final TextPlagiarismDetectionService textPlagiarismDetectionService;
+
+    private final ProgrammingExerciseRepository programmingExerciseRepository;
+
+    private final ProgrammingLanguageFeatureService programmingLanguageFeatureService;
+
+    private final ProgrammingPlagiarismDetectionService programmingPlagiarismDetectionService;
+
+    private final ModelingExerciseRepository modelingExerciseRepository;
+
+    private final ModelingPlagiarismDetectionService modelingPlagiarismDetectionService;
+
+    private final PlagiarismResultRepository plagiarismResultRepository;
+
+    public ContinuousPlagiarismControlService(ExerciseRepository exerciseRepository, TextExerciseRepository textExerciseRepository,
+            TextPlagiarismDetectionService textPlagiarismDetectionService, ProgrammingExerciseRepository programmingExerciseRepository,
+            ProgrammingLanguageFeatureService programmingLanguageFeatureService, ProgrammingPlagiarismDetectionService programmingPlagiarismDetectionService,
+            ModelingExerciseRepository modelingExerciseRepository, ModelingPlagiarismDetectionService modelingPlagiarismDetectionService,
+            PlagiarismResultRepository plagiarismResultRepository) {
+        this.exerciseRepository = exerciseRepository;
+        this.textExerciseRepository = textExerciseRepository;
+        this.textPlagiarismDetectionService = textPlagiarismDetectionService;
+        this.programmingExerciseRepository = programmingExerciseRepository;
+        this.programmingLanguageFeatureService = programmingLanguageFeatureService;
+        this.programmingPlagiarismDetectionService = programmingPlagiarismDetectionService;
+        this.modelingExerciseRepository = modelingExerciseRepository;
+        this.modelingPlagiarismDetectionService = modelingPlagiarismDetectionService;
+        this.plagiarismResultRepository = plagiarismResultRepository;
+    }
+
+    /**
+     * Daily triggers plagiarism checks as a part of continuous plagiarism control.
+     */
+    @Scheduled(cron = "0 0 4 * * *") // execute this every night at 4:00:00 am
+    public void executeChecks() {
+        log.info("Starting continuous plagiarism control...");
+
+        var exercises = exerciseRepository.findAllExercisesWithCurrentOrUpcomingDueDateAndContinuousPlagiarismControlEnabledIsTrue();
+        exercises.forEach(exercise -> {
+            log.info("Started continuous plagiarism control for exercise: exerciseId={}, type={}.", exercise.getId(), exercise.getExerciseType());
+            final long startTime = System.nanoTime();
+
+            try {
+                executeChecksForExercise(exercise);
+            }
+            catch (ExitException e) {
+                log.error("Cannot check plagiarism due to Jplag error: exerciseId={}, type={}, error={}.", exercise.getId(), exercise.getExerciseType(), e.getMessage(), e);
+            }
+            catch (Exception e) {
+                log.error("Cannot check plagiarism due to unknown error: exerciseId={}, type={}, error={}.", exercise.getId(), exercise.getExerciseType(), e.getMessage(), e);
+            }
+
+            log.info("Finished continuous plagiarism control for exercise: exerciseId={}, elapsed={}.", exercise.getId(), TimeLogUtil.formatDurationFrom(startTime));
+        });
+
+        log.debug("Continuous plagiarism control done.");
+    }
+
+    private void executeChecksForExercise(Exercise exercise) throws Exception {
+        switch (exercise.getExerciseType()) {
+            case TEXT -> {
+                var textExercise = textExerciseRepository.findByIdWithStudentParticipationsAndSubmissionsElseThrow(exercise.getId());
+                executeChecksForTextExercise(textExercise);
+            }
+            case PROGRAMMING -> {
+                var programmingExercise = programmingExerciseRepository.findByIdWithStudentParticipationsAndLegalSubmissionsElseThrow(exercise.getId());
+                executeChecksForProgrammingExercise(programmingExercise);
+            }
+            case MODELING -> {
+                var modelingExercise = modelingExerciseRepository.findByIdWithStudentParticipationsSubmissionsResultsElseThrow(exercise.getId());
+                executeChecksForModelingExercise(modelingExercise);
+            }
+            case FILE_UPLOAD, QUIZ -> {
+                log.error("Cannot check plagiarism for exercise: type={}, id={}.", exercise.getExerciseType(), exercise.getId());
+            }
+        }
+    }
+
+    private void executeChecksForTextExercise(TextExercise exercise) throws Exception {
+        var plagiarismResult = textPlagiarismDetectionService.checkPlagiarism(exercise, exercise.getPlagiarismChecksConfig().getSimilarityThreshold(),
+                exercise.getPlagiarismChecksConfig().getMinimumScore(), exercise.getPlagiarismChecksConfig().getMinimumSize());
+        log.info("Finished textPlagiarismDetectionService.checkPlagiarism for exercise {} with {} comparisons,", exercise.getId(), plagiarismResult.getComparisons().size());
+
+        // TODO: limit the amount temporarily because of database issues
+        plagiarismResult.sortAndLimit(100);
+        plagiarismResultRepository.savePlagiarismResultAndRemovePrevious(plagiarismResult);
+
+        plagiarismResultRepository.prepareResultForClient(plagiarismResult);
+    }
+
+    private void executeChecksForProgrammingExercise(ProgrammingExercise exercise) throws Exception {
+        var language = exercise.getProgrammingLanguage();
+        var programmingLanguageFeature = programmingLanguageFeatureService.getProgrammingLanguageFeatures(language);
+        if (!programmingLanguageFeature.plagiarismCheckSupported()) {
+            log.error("Artemis does not support plagiarism checks for the programming language {}", language);
+        }
+
+        var plagiarismResult = programmingPlagiarismDetectionService.checkPlagiarism(exercise.getId(), exercise.getPlagiarismChecksConfig().getSimilarityThreshold(),
+                exercise.getPlagiarismChecksConfig().getMinimumScore());
+        log.info("Finished programmingExerciseExportService.checkPlagiarism call for {} comparisons", plagiarismResult.getComparisons().size());
+
+        plagiarismResultRepository.prepareResultForClient(plagiarismResult);
+    }
+
+    private void executeChecksForModelingExercise(ModelingExercise exercise) throws Exception {
+        var plagiarismResult = modelingPlagiarismDetectionService.checkPlagiarism(exercise, exercise.getPlagiarismChecksConfig().getSimilarityThreshold(),
+                exercise.getPlagiarismChecksConfig().getMinimumSize(), exercise.getPlagiarismChecksConfig().getMinimumScore());
+        log.info("Finished modelingPlagiarismDetectionService.checkPlagiarism call for {} comparisons", plagiarismResult.getComparisons().size());
+
+        // TODO: limit the amount temporarily because of database issues
+        plagiarismResult.sortAndLimit(100);
+        plagiarismResultRepository.savePlagiarismResultAndRemovePrevious(plagiarismResult);
+
+        plagiarismResultRepository.prepareResultForClient(plagiarismResult);
+    }
+}

src/main/java/de/tum/in/www1/artemis/web/rest/ModelingExerciseResource.java

@@ -353,22 +353,20 @@ public ResponseEntity<ModelingPlagiarismResult> getPlagiarismResult(@PathVariabl
      * <p>
      * Start the automated plagiarism detection for the given exercise and return its result.
      *
-     * @param exerciseId          for which all submission should be checked
-     * @param similarityThreshold ignore comparisons whose similarity is below this threshold (in % between 0 and 100)
-     * @param minimumScore        consider only submissions whose score is greater or equal to this value
-     * @param minimumSize         consider only submissions whose size is greater or equal to this value
+     * @param exerciseId for which all submission should be checked
      * @return the ResponseEntity with status 200 (OK) and the list of at most 500 pair-wise submissions with a similarity above the given threshold (e.g. 50%).
      */
     @GetMapping("modeling-exercises/{exerciseId}/check-plagiarism")
     @FeatureToggle(Feature.PlagiarismChecks)
     @PreAuthorize("hasRole('INSTRUCTOR')")
-    public ResponseEntity<ModelingPlagiarismResult> checkPlagiarism(@PathVariable long exerciseId, @RequestParam float similarityThreshold, @RequestParam int minimumScore,
-            @RequestParam int minimumSize) {
+    public ResponseEntity<ModelingPlagiarismResult> checkPlagiarism(@PathVariable long exerciseId) {
         var modelingExercise = modelingExerciseRepository.findByIdWithStudentParticipationsSubmissionsResultsElseThrow(exerciseId);
         authCheckService.checkHasAtLeastRoleForExerciseElseThrow(Role.INSTRUCTOR, modelingExercise, null);
         long start = System.nanoTime();
         log.info("Start modelingPlagiarismDetectionService.checkPlagiarism for exercise {}", exerciseId);
-        var plagiarismResult = modelingPlagiarismDetectionService.checkPlagiarism(modelingExercise, similarityThreshold / 100, minimumSize, minimumScore);
+        var plagiarismChecksConfig = modelingExerciseRepository.findByIdElseThrow(exerciseId).getPlagiarismChecksConfig();
+        var plagiarismResult = modelingPlagiarismDetectionService.checkPlagiarism(modelingExercise, plagiarismChecksConfig.getSimilarityThreshold(),
+                plagiarismChecksConfig.getMinimumSize(), plagiarismChecksConfig.getMinimumScore());
         log.info("Finished modelingPlagiarismDetectionService.checkPlagiarism call for {} comparisons in {}", plagiarismResult.getComparisons().size(),
                 TimeLogUtil.formatDurationFrom(start));
         // TODO: limit the amount temporarily because of database issues