Development: Extract plagiarism detection service

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

@@ -0,0 +1,7 @@
+package de.tum.in.www1.artemis.domain.plagiarism;
+
+/**
+ * Stores configuration for plagiarism detection.
+ */
+public record PlagiarismDetectionConfig(float similarityThreshold, int minimumScore, int minimumSize) {
+}

src/main/java/de/tum/in/www1/artemis/service/hestia/ProgrammingExerciseGitDiffReportService.java

@@ -2,6 +2,7 @@
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
@@ -19,6 +20,7 @@
 
 import de.tum.in.www1.artemis.domain.DomainObject;
 import de.tum.in.www1.artemis.domain.ProgrammingExercise;
+import de.tum.in.www1.artemis.domain.VcsRepositoryUrl;
 import de.tum.in.www1.artemis.domain.hestia.ProgrammingExerciseGitDiffEntry;
 import de.tum.in.www1.artemis.domain.hestia.ProgrammingExerciseGitDiffReport;
 import de.tum.in.www1.artemis.domain.participation.SolutionProgrammingExerciseParticipation;
@@ -158,6 +160,33 @@ public ProgrammingExerciseGitDiffReport getOrCreateReportOfExercise(ProgrammingE
         }
     }
 
+    /**
+     * Calculates git diff between two repositories and returns the cumulative number of diff lines.
+     *
+     * @param urlRepoA       url of the first repo to compare
+     * @param localPathRepoA local path to the checked out instance of the first repo to compare
+     * @param urlRepoB       url of the second repo to compare
+     * @param localPathRepoB local path to the checked out instance of the second repo to compare
+     * @return cumulative number of lines in the git diff of given repositories
+     */
+    public int calculateNumberOfDiffLinesBetweenRepos(VcsRepositoryUrl urlRepoA, Path localPathRepoA, VcsRepositoryUrl urlRepoB, Path localPathRepoB) {
+        var repoA = gitService.getExistingCheckedOutRepositoryByLocalPath(localPathRepoA, urlRepoA);
+        var repoB = gitService.getExistingCheckedOutRepositoryByLocalPath(localPathRepoB, urlRepoB);
+
+        var treeParserRepoA = new FileTreeIterator(repoA);
+        var treeParserRepoB = new FileTreeIterator(repoB);
+
+        try (var diffOutputStream = new ByteArrayOutputStream(); var git = Git.wrap(repoB)) {
+            git.diff().setOldTree(treeParserRepoB).setNewTree(treeParserRepoA).setOutputStream(diffOutputStream).call();
+            var diff = diffOutputStream.toString();
+            return extractDiffEntries(diff, true).stream().mapToInt(ProgrammingExerciseGitDiffEntry::getLineCount).sum();
+        }
+        catch (IOException | GitAPIException e) {
+            log.error("Error calculating number of diff lines between repositories: urlRepoA={}, urlRepoB={}.", urlRepoA, urlRepoB, e);
+            return Integer.MAX_VALUE;
+        }
+    }
+
     /**
      * Creates a new ProgrammingExerciseGitDiffReport for an exercise.
      * It will take the git-diff between the template and solution repositories and return all changes.
@@ -183,7 +212,7 @@ private ProgrammingExerciseGitDiffReport generateReport(TemplateProgrammingExerc
         try (ByteArrayOutputStream diffOutputStream = new ByteArrayOutputStream(); Git git = Git.wrap(templateRepo)) {
             git.diff().setOldTree(oldTreeParser).setNewTree(newTreeParser).setOutputStream(diffOutputStream).call();
             var diff = diffOutputStream.toString();
-            var programmingExerciseGitDiffEntries = extractDiffEntries(diff);
+            var programmingExerciseGitDiffEntries = extractDiffEntries(diff, false);
             var report = new ProgrammingExerciseGitDiffReport();
             for (ProgrammingExerciseGitDiffEntry gitDiffEntry : programmingExerciseGitDiffEntries) {
                 gitDiffEntry.setGitDiffReport(report);
@@ -199,7 +228,7 @@ private ProgrammingExerciseGitDiffReport generateReport(TemplateProgrammingExerc
      * @param diff The raw git-diff output
      * @return The extracted ProgrammingExerciseGitDiffEntries
      */
-    private List<ProgrammingExerciseGitDiffEntry> extractDiffEntries(String diff) {
+    private List<ProgrammingExerciseGitDiffEntry> extractDiffEntries(String diff, boolean useAbsoluteLineCount) {
         var lines = diff.split("\n");
         var parserState = new ParserState();
 
@@ -216,7 +245,7 @@ private List<ProgrammingExerciseGitDiffEntry> extractDiffEntries(String diff) {
             else if (!parserState.deactivateCodeReading) {
                 switch (line.charAt(0)) {
                     case '+' -> handleAddition(parserState);
-                    case '-' -> handleRemoval(parserState);
+                    case '-' -> handleRemoval(parserState, useAbsoluteLineCount);
                     case ' ' -> handleUnchanged(parserState);
                     default -> parserState.deactivateCodeReading = true;
                 }
@@ -262,7 +291,7 @@ private void handleUnchanged(ParserState parserState) {
         parserState.currentPreviousLineCount++;
     }
 
-    private void handleRemoval(ParserState parserState) {
+    private void handleRemoval(ParserState parserState, boolean useAbsoluteLineCount) {
         var entry = parserState.currentEntry;
         if (!parserState.lastLineRemoveOperation && !entry.isEmpty()) {
             parserState.entries.add(entry);
@@ -274,7 +303,16 @@ private void handleRemoval(ParserState parserState) {
             entry.setPreviousLineCount(0);
             entry.setPreviousStartLine(parserState.currentPreviousLineCount);
         }
-        entry.setPreviousLineCount(entry.getPreviousLineCount() + 1);
+        if (useAbsoluteLineCount) {
+            if (parserState.currentEntry.getLineCount() == null) {
+                parserState.currentEntry.setLineCount(0);
+                parserState.currentEntry.setStartLine(parserState.currentLineCount);
+            }
+            parserState.currentEntry.setLineCount(parserState.currentEntry.getLineCount() + 1);
+        }
+        else {
+            entry.setPreviousLineCount(entry.getPreviousLineCount() + 1);
+        }
 
         parserState.currentEntry = entry;
         parserState.lastLineRemoveOperation = true;

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

@@ -149,7 +149,7 @@ public ModelingPlagiarismResult checkPlagiarism(List<ModelingSubmission> modelin
                 final double similarity = model1.similarity(model2);
                 log.debug("Compare result {} with {}: {}", i, j, similarity);
 
-                if (similarity < minimumSimilarity) {
+                if (similarity * 100 < minimumSimilarity) {
                     // ignore comparison results with too small similarity
                     continue;
                 }

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

@@ -0,0 +1,131 @@
+package de.tum.in.www1.artemis.service.plagiarism;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Optional;
+
+import org.jvnet.hk2.annotations.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import de.jplag.exceptions.ExitException;
+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.domain.plagiarism.PlagiarismDetectionConfig;
+import de.tum.in.www1.artemis.domain.plagiarism.PlagiarismResult;
+import de.tum.in.www1.artemis.domain.plagiarism.modeling.ModelingPlagiarismResult;
+import de.tum.in.www1.artemis.domain.plagiarism.text.TextPlagiarismResult;
+import de.tum.in.www1.artemis.repository.plagiarism.PlagiarismResultRepository;
+import de.tum.in.www1.artemis.service.programming.ProgrammingLanguageFeatureService;
+
+/**
+ * Service for triggering plagiarism checks.
+ */
+@Service
+@Component
+public class PlagiarismDetectionService {
+
+    private static final Logger log = LoggerFactory.getLogger(PlagiarismDetectionService.class);
+
+    private final TextPlagiarismDetectionService textPlagiarismDetectionService;
+
+    private final Optional<ProgrammingLanguageFeatureService> programmingLanguageFeatureService;
+
+    private final ProgrammingPlagiarismDetectionService programmingPlagiarismDetectionService;
+
+    private final ModelingPlagiarismDetectionService modelingPlagiarismDetectionService;
+
+    private final PlagiarismResultRepository plagiarismResultRepository;
+
+    public PlagiarismDetectionService(TextPlagiarismDetectionService textPlagiarismDetectionService, Optional<ProgrammingLanguageFeatureService> programmingLanguageFeatureService,
+            ProgrammingPlagiarismDetectionService programmingPlagiarismDetectionService, ModelingPlagiarismDetectionService modelingPlagiarismDetectionService,
+            PlagiarismResultRepository plagiarismResultRepository) {
+        this.textPlagiarismDetectionService = textPlagiarismDetectionService;
+        this.programmingLanguageFeatureService = programmingLanguageFeatureService;
+        this.programmingPlagiarismDetectionService = programmingPlagiarismDetectionService;
+        this.modelingPlagiarismDetectionService = modelingPlagiarismDetectionService;
+        this.plagiarismResultRepository = plagiarismResultRepository;
+    }
+
+    /**
+     * Check plagiarism in given text exercise
+     *
+     * @param exercise exercise to check plagiarism
+     * @param config   configuration for plagiarism detection
+     * @return result of plagiarism checks
+     */
+    public TextPlagiarismResult checkTextExercise(TextExercise exercise, PlagiarismDetectionConfig config) throws ExitException {
+        var plagiarismResult = textPlagiarismDetectionService.checkPlagiarism(exercise, config.similarityThreshold(), config.minimumScore(), config.minimumSize());
+        log.info("Finished textPlagiarismDetectionService.checkPlagiarism for exercise {} with {} comparisons,", exercise.getId(), plagiarismResult.getComparisons().size());
+
+        trimAndSavePlagiarismResult(plagiarismResult);
+        return plagiarismResult;
+    }
+
+    /**
+     * Check plagiarism in given programing exercise
+     *
+     * @param exercise exercise to check plagiarism
+     * @param config   configuration for plagiarism detection
+     * @return result of plagiarism checks
+     */
+    public TextPlagiarismResult checkProgrammingExercise(ProgrammingExercise exercise, PlagiarismDetectionConfig config)
+            throws ExitException, IOException, ProgrammingLanguageNotSupportedForPlagiarismDetectionException {
+        checkProgrammingLanguageSupport(exercise);
+
+        var plagiarismResult = programmingPlagiarismDetectionService.checkPlagiarism(exercise.getId(), config.similarityThreshold(), config.minimumScore(), config.minimumSize());
+        log.info("Finished programmingExerciseExportService.checkPlagiarism call for {} comparisons", plagiarismResult.getComparisons().size());
+
+        plagiarismResultRepository.prepareResultForClient(plagiarismResult);
+
+        // make sure that participation is included in the exercise
+        plagiarismResult.setExercise(exercise);
+        return plagiarismResult;
+    }
+
+    /**
+     * Check plagiarism in given programing exercise and outputs a Jplag report
+     *
+     * @param exercise exercise to check plagiarism
+     * @param config   configuration for plagiarism detection
+     * @return Jplag report of plagiarism checks
+     */
+    public File checkProgrammingExerciseWithJplagReport(ProgrammingExercise exercise, PlagiarismDetectionConfig config)
+            throws ProgrammingLanguageNotSupportedForPlagiarismDetectionException {
+        checkProgrammingLanguageSupport(exercise);
+        return programmingPlagiarismDetectionService.checkPlagiarismWithJPlagReport(exercise.getId(), config.similarityThreshold(), config.minimumScore(), config.minimumSize());
+    }
+
+    /**
+     * Check plagiarism in given modeling exercise
+     *
+     * @param exercise exercise to check plagiarism
+     * @param config   configuration for plagiarism detection
+     * @return result of plagiarism checks
+     */
+    public ModelingPlagiarismResult checkModelingExercise(ModelingExercise exercise, PlagiarismDetectionConfig config) {
+        var plagiarismResult = modelingPlagiarismDetectionService.checkPlagiarism(exercise, config.similarityThreshold(), config.minimumSize(), config.minimumScore());
+        log.info("Finished modelingPlagiarismDetectionService.checkPlagiarism call for {} comparisons", plagiarismResult.getComparisons().size());
+
+        trimAndSavePlagiarismResult(plagiarismResult);
+        return plagiarismResult;
+    }
+
+    private void trimAndSavePlagiarismResult(PlagiarismResult<?> plagiarismResult) {
+        // Limit the amount temporarily because of database issues
+        plagiarismResult.sortAndLimit(100);
+        plagiarismResultRepository.savePlagiarismResultAndRemovePrevious(plagiarismResult);
+
+        plagiarismResultRepository.prepareResultForClient(plagiarismResult);
+    }
+
+    private void checkProgrammingLanguageSupport(ProgrammingExercise exercise) throws ProgrammingLanguageNotSupportedForPlagiarismDetectionException {
+        var language = exercise.getProgrammingLanguage();
+        var programmingLanguageFeature = programmingLanguageFeatureService.orElseThrow().getProgrammingLanguageFeatures(language);
+        if (!programmingLanguageFeature.plagiarismCheckSupported()) {
+            throw new ProgrammingLanguageNotSupportedForPlagiarismDetectionException(language);
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+package de.tum.in.www1.artemis.service.plagiarism;
+
+import de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage;
+
+public class ProgrammingLanguageNotSupportedForPlagiarismDetectionException extends Exception {
+
+    ProgrammingLanguageNotSupportedForPlagiarismDetectionException(ProgrammingLanguage language) {
+        super("Artemis does not support plagiarism checks for the programming language " + language);
+    }
+}