ls1intum · krusche · Nov 25, 2023 · Aug 25, 2023 · Aug 25, 2023 · Aug 26, 2023
diff --git a/docs/dev/setup.rst b/docs/dev/setup.rst
@@ -221,6 +221,10 @@ You can override the following configuration options in this file.
        athena:
            url: http://localhost:5000
            secret: abcdef12345
+            modules:
+                # See https://github.com/ls1intum/Athena for a list of available modules
+                text: module_text_cofee
+                programming: module_programming_themisml
 
 Change all entries with ``<...>`` with proper values, e.g. your TUM
 Online account credentials to connect to the given instances of JIRA,

@@ -65,6 +65,8 @@ public final class Constants {
 
     public static final String APOLLON_CONVERSION_API_PATH = "/api/apollon/convert-to-pdf";
 
+    public static final String ATHENA_PROGRAMMING_EXERCISE_REPOSITORY_API_PATH = "/api/public/athena/programming-exercises/";
+
     // short names should have at least 3 characters and must start with a letter
     public static final String SHORT_NAME_REGEX = "^[a-zA-Z][a-zA-Z0-9]{2,}";
 

@@ -100,6 +100,9 @@ public abstract class Exercise extends BaseExercise implements LearningObject {
     @Column(name = "second_correction_enabled")
     private Boolean secondCorrectionEnabled = false;
 
+    @Column(name = "feedback_suggestions_enabled") // enables Athena
+    private boolean feedbackSuggestionsEnabled = false;
+
     @ManyToOne
     @JsonView(QuizView.Before.class)
     private Course course;
@@ -766,6 +769,14 @@ public void setSecondCorrectionEnabled(boolean secondCorrectionEnabled) {
         this.secondCorrectionEnabled = secondCorrectionEnabled;
     }
 
+    public boolean getFeedbackSuggestionsEnabled() {
+        return Boolean.TRUE.equals(feedbackSuggestionsEnabled);
+    }
+
+    public void setFeedbackSuggestionsEnabled(boolean feedbackSuggestionsEnabled) {
+        this.feedbackSuggestionsEnabled = feedbackSuggestionsEnabled;
+    }
+
     public List<GradingCriterion> getGradingCriteria() {
         return gradingCriteria;
     }

@@ -4,7 +4,6 @@
 
 import javax.persistence.*;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 import de.tum.in.www1.artemis.domain.enumeration.AssessmentType;
@@ -35,17 +34,12 @@ public void setExampleSolution(String exampleSolution) {
         this.exampleSolution = exampleSolution;
     }
 
-    @JsonIgnore
-    public boolean isFeedbackSuggestionsEnabled() {
-        return getAssessmentType() == AssessmentType.SEMI_AUTOMATIC;
-    }
-
     /**
      * Disable feedback suggestions for this exercise by setting the assessment type to MANUAL.
      * Only changes the assessment type if feedback suggestions are currently enabled.
      */
     public void disableFeedbackSuggestions() {
-        if (isFeedbackSuggestionsEnabled()) {
+        if (this.getFeedbackSuggestionsEnabled()) {
             setAssessmentType(AssessmentType.MANUAL);
         }
     }

@@ -505,6 +505,24 @@ default boolean toggleSecondCorrection(Exercise exercise) {
              """)
     Set<Exercise> getAllExercisesUserParticipatedInWithEagerParticipationsSubmissionsResultsFeedbacksByUserId(long userId);
 
+    /**
+     * Finds all exercises filtered by feedback suggestions and due date.
+     *
+     * @param feedbackSuggestionsEnabled - filter by feedback suggestions enabled
+     * @param dueDate                    - filter by due date
+     * @return List of Exercises
+     */
+    List<Exercise> findByFeedbackSuggestionsEnabledAndDueDateIsAfter(boolean feedbackSuggestionsEnabled, ZonedDateTime dueDate);
+
+    /**
+     * Find all exercises feedback suggestions (Athena) and with *Due Date* in the future.
+     *
+     * @return List of Exercises
+     */
+    default List<Exercise> findAllFeedbackSuggestionsEnabledExercisesWithFutureDueDate() {
+        return findByFeedbackSuggestionsEnabledAndDueDateIsAfter(true, ZonedDateTime.now());
+    }
+
     /**
      * For an explanation, see {@link de.tum.in.www1.artemis.web.rest.ExamResource#getAllExercisesWithPotentialPlagiarismForExam(long,long)}
      *

@@ -439,6 +439,24 @@
         return findById(programmingExerciseId).orElseThrow(() -> new EntityNotFoundException("Programming Exercise", programmingExerciseId));
     }
 
+    /**
+     * Find a programming exercise by its id, with grading criteria loaded, and throw an EntityNotFoundException if it cannot be found
+     *
+     * @param exerciseId of the programming exercise.
+     * @return The programming exercise related to the given id
+     */
+    @NotNull
+    @Query("""
+            SELECT DISTINCT e FROM ProgrammingExercise e
+            LEFT JOIN FETCH e.gradingCriteria
+            WHERE e.id = :#{#exerciseId}
+            """)
+    Optional<ProgrammingExercise> findByIdWithGradingCriteria(Long exerciseId);
+
+    default ProgrammingExercise findByIdWithGradingCriteriaElseThrow(long exerciseId) {
+        return findByIdWithGradingCriteria(exerciseId).orElseThrow(() -> new EntityNotFoundException("Programming Exercise", exerciseId));
+    }
+
     /**
      * Find a programming exercise with auxiliary repositories by its id and throw an EntityNotFoundException if it cannot be found
      *

@@ -23,6 +23,17 @@
 @Repository
 public interface ProgrammingSubmissionRepository extends JpaRepository<ProgrammingSubmission, Long> {
 
+    /**
+     * Load programming submission only
+     *
+     * @param submissionId the submissionId
+     * @return programming submission
+     */
+    @NotNull
+    default ProgrammingSubmission findByIdElseThrow(long submissionId) {
+        return findById(submissionId).orElseThrow(() -> new EntityNotFoundException("ProgrammingSubmission", submissionId));
+    }
+
     @EntityGraph(type = LOAD, attributePaths = { "results.feedbacks" })
     ProgrammingSubmission findFirstByParticipationIdAndCommitHashOrderByIdDesc(Long participationId, String commitHash);
 

@@ -6,6 +6,8 @@
 import java.util.Optional;
 import java.util.Set;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
@@ -441,6 +443,23 @@ default Submission findByIdWithResultsElseThrow(long submissionId) {
         return findWithEagerResultsAndAssessorById(submissionId).orElseThrow(() -> new EntityNotFoundException("Submission", +submissionId));
     }
 
+    /**
+     * Gets all Submissions which are submitted
+     *
+     * @param exerciseId the ID of the exercise
+     * @param pageable   the pagination information for the query
+     * @return Set of Submissions
+     */
+    Page<Submission> findByParticipation_ExerciseIdAndSubmittedIsTrue(long exerciseId, Pageable pageable);
+
+    /**
+     * Gets all submitted Submissions
+     *
+     * @param exerciseId the ID of the exercise
+     * @return Set of Submissions
+     */
+    Set<Submission> findByParticipation_ExerciseIdAndSubmittedIsTrue(long exerciseId);
+
     default Submission findByIdElseThrow(long submissionId) {
         return findById(submissionId).orElseThrow(() -> new EntityNotFoundException("Submission", submissionId));
     }

@@ -2,7 +2,6 @@
 
 import static org.springframework.data.jpa.repository.EntityGraph.EntityGraphType.LOAD;
 
-import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Optional;
 
@@ -16,7 +15,6 @@
 import org.springframework.stereotype.Repository;
 
 import de.tum.in.www1.artemis.domain.TextExercise;
-import de.tum.in.www1.artemis.domain.enumeration.AssessmentType;
 import de.tum.in.www1.artemis.web.rest.errors.EntityNotFoundException;
 
 /**
@@ -35,8 +33,6 @@
     @EntityGraph(type = LOAD, attributePaths = { "teamAssignmentConfig", "categories", "competencies" })
     Optional<TextExercise> findWithEagerTeamAssignmentConfigAndCategoriesAndCompetenciesById(Long exerciseId);
 
-    List<TextExercise> findByAssessmentTypeAndDueDateIsAfter(AssessmentType assessmentType, ZonedDateTime dueDate);
-
     @Query("select textExercise from TextExercise textExercise left join fetch textExercise.exampleSubmissions exampleSubmissions left join fetch exampleSubmissions.submission submission left join fetch submission.results result left join fetch result.feedbacks left join fetch submission.blocks left join fetch result.assessor left join fetch textExercise.teamAssignmentConfig where textExercise.id = :#{#exerciseId}")
     Optional<TextExercise> findByIdWithExampleSubmissionsAndResults(@Param("exerciseId") Long exerciseId);
 
@@ -48,6 +44,18 @@
         return findById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
     }
 
+    @Query("""
+            SELECT DISTINCT e FROM TextExercise e
+            LEFT JOIN FETCH e.gradingCriteria
+            WHERE e.id = :#{#exerciseId}
+            """)
+    Optional<TextExercise> findByIdWithGradingCriteria(long exerciseId);
+
+    @NotNull
+    default TextExercise findByIdWithGradingCriteriaElseThrow(long exerciseId) {
+        return findByIdWithGradingCriteria(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
+    }
+
     @NotNull
     default TextExercise findByIdWithExampleSubmissionsAndResultsElseThrow(long exerciseId) {
         return findByIdWithExampleSubmissionsAndResults(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
@@ -57,13 +65,4 @@
     default TextExercise findByIdWithStudentParticipationsAndSubmissionsElseThrow(long exerciseId) {
         return findWithStudentParticipationsAndSubmissionsById(exerciseId).orElseThrow(() -> new EntityNotFoundException("Text Exercise", exerciseId));
     }
-
-    /**
-     * Find all exercises with *Due Date* in the future.
-     *
-     * @return List of Text Exercises
-     */
-    default List<TextExercise> findAllAutomaticAssessmentTextExercisesWithFutureDueDate() {
-        return findByAssessmentTypeAndDueDateIsAfter(AssessmentType.SEMI_AUTOMATIC, ZonedDateTime.now());
-    }
 }
@@ -7,8 +7,6 @@
 
 import javax.validation.constraints.NotNull;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
@@ -67,16 +65,6 @@ default TextSubmission findByIdElseThrow(long submissionId) {
     @EntityGraph(type = LOAD, attributePaths = { "blocks" })
     Set<TextSubmission> findByParticipation_ExerciseIdAndSubmittedIsTrue(long exerciseId);
 
-    /**
-     * Gets all TextSubmissions which are submitted and loads all blocks
-     *
-     * @param exerciseId the ID of the exercise
-     * @param pageable   the pagination information for the query
-     * @return Set of Text Submissions
-     */
-    @EntityGraph(type = LOAD, attributePaths = { "blocks" })
-    Page<TextSubmission> findByParticipation_ExerciseIdAndSubmittedIsTrue(long exerciseId, Pageable pageable);
-
     @NotNull
     default TextSubmission getTextSubmissionWithResultAndTextBlocksAndFeedbackByResultIdElseThrow(long resultId) {
         return findWithEagerResultAndTextBlocksAndFeedbackByResults_Id(resultId) // TODO should be EntityNotFoundException

@@ -129,7 +129,7 @@ else if (textExercise.isExamExercise()) {
      */
     public Optional<TextSubmission> getRandomTextSubmissionEligibleForNewAssessment(TextExercise textExercise, boolean skipAssessmentQueue, boolean examMode, int correctionRound) {
         // If automatic assessment is enabled and available, try to learn the most possible amount during the first correction round
-        if (textExercise.isFeedbackSuggestionsEnabled() && athenaSubmissionSelectionService.isPresent() && !skipAssessmentQueue && correctionRound == 0) {
+        if (textExercise.getFeedbackSuggestionsEnabled() && athenaSubmissionSelectionService.isPresent() && !skipAssessmentQueue && correctionRound == 0) {
             var assessableSubmissions = getAssessableSubmissions(textExercise, examMode, correctionRound);
             var athenaSubmissionId = athenaSubmissionSelectionService.get().getProposedSubmissionId(textExercise, assessableSubmissions.stream().map(Submission::getId).toList());
             if (athenaSubmissionId.isPresent()) {

@@ -0,0 +1,95 @@
+package de.tum.in.www1.artemis.service.connectors.athena;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import de.tum.in.www1.artemis.domain.*;
+import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
+import de.tum.in.www1.artemis.repository.TextBlockRepository;
+import de.tum.in.www1.artemis.repository.TextExerciseRepository;
+import de.tum.in.www1.artemis.service.dto.athena.*;
+
+/**
+ * Service to convert exercises, submissions and feedback to DTOs for Athena.
+ */
+@Service
+public class AthenaDTOConverter {
+
+    @Value("${server.url}")
+    private String artemisServerUrl;
+
+    private final TextBlockRepository textBlockRepository;
+
+    private final TextExerciseRepository textExerciseRepository;
+
+    private final ProgrammingExerciseRepository programmingExerciseRepository;
+
+    public AthenaDTOConverter(TextBlockRepository textBlockRepository, TextExerciseRepository textExerciseRepository, ProgrammingExerciseRepository programmingExerciseRepository) {
+        this.textBlockRepository = textBlockRepository;
+        this.textExerciseRepository = textExerciseRepository;
+        this.programmingExerciseRepository = programmingExerciseRepository;
+    }
+
+    /**
+     * Convert an exercise to a DTO for Athena.
+     *
+     * @param exercise the exercise to convert
+     * @return *ExerciseDTO for Athena
+     */
+    public Object ofExercise(Exercise exercise) {
+        switch (exercise.getExerciseType()) {
+            case TEXT -> {
+                // Fetch text exercise with grade criteria
+                var textExercise = textExerciseRepository.findByIdWithGradingCriteriaElseThrow(exercise.getId());
+                return TextExerciseDTO.of(textExercise);
+            }
+            case PROGRAMMING -> {
+                // Fetch programming exercise with grading criteria
+                var programmingExercise = programmingExerciseRepository.findByIdWithGradingCriteriaElseThrow(exercise.getId());
+                return ProgrammingExerciseDTO.of(programmingExercise, artemisServerUrl);
+            }
+        }
+        throw new IllegalArgumentException("Exercise type not supported: " + exercise.getExerciseType());
+    }
+
+    /**
+     * Convert a submission to a DTO for Athena.
+     *
+     * @param exerciseId the id of the exercise the submission belongs to
+     * @param submission the submission to convert
+     * @return *SubmissionDTO for Athena
+     */
+    public Object ofSubmission(long exerciseId, Submission submission) {
+        if (submission instanceof TextSubmission) {
+            return TextSubmissionDTO.of(exerciseId, (TextSubmission) submission);
+        }
+        else if (submission instanceof ProgrammingSubmission) {
+            return ProgrammingSubmissionDTO.of(exerciseId, (ProgrammingSubmission) submission, artemisServerUrl);
+        }
+        throw new IllegalArgumentException("Submission type not supported: " + submission.getType());
+    }
+
+    /**
+     * Convert a feedback to a DTO for Athena.
+     *
+     * @param exercise     the exercise the feedback belongs to
+     * @param submissionId the id of the submission the feedback belongs to
+     * @param feedback     the feedback to convert
+     * @return *FeedbackDTO for Athena
+     */
+    public Object ofFeedback(Exercise exercise, long submissionId, Feedback feedback) {
+        switch (exercise.getExerciseType()) {
+            case TEXT -> {
+                TextBlock feedbackTextBlock = null;
+                if (feedback.getReference() != null) {
+                    feedbackTextBlock = textBlockRepository.findById(feedback.getReference()).orElse(null);
+                }
+                return TextFeedbackDTO.of(exercise.getId(), submissionId, feedback, feedbackTextBlock);
+            }
+            case PROGRAMMING -> {
+                return ProgrammingFeedbackDTO.of(exercise.getId(), submissionId, feedback);
+            }
+        }
+        throw new IllegalArgumentException("Feedback type not supported: " + exercise.getId());
+    }
+}