Text Exercises: Replace feedback modal with inline feedback view

src/main/java/de/tum/cit/aet/artemis/exercise/domain/Submission.java

@@ -220,11 +220,11 @@ public List<Result> getManualResults() {
     /**
      * This method is necessary to ignore Athena results in the assessment view
      *
-     * @return non athena automatic results including null results
+     * @return non athena automatic results excluding null results
      */
     @JsonIgnore
     public List<Result> getNonAthenaResults() {
-        return results.stream().filter(result -> result == null || !result.isAthenaAutomatic()).collect(Collectors.toCollection(ArrayList::new));
+        return results.stream().filter(result -> result != null && !result.isAthenaAutomatic()).collect(Collectors.toCollection(ArrayList::new));
     }
 
     /**

src/main/java/de/tum/cit/aet/artemis/exercise/service/SubmissionService.java

@@ -787,6 +787,7 @@ private List<SubmissionWithComplaintDTO> getSubmissionsWithComplaintsFromComplai
             // add each submission with its complaint to the DTO
             submissions.stream().filter(submission -> submission.getResultWithComplaint() != null).forEach(submission -> {
                 // get the complaint which belongs to the submission
+                submission.setResults(submission.getNonAthenaResults());
                 Complaint complaintOfSubmission = complaintMap.get(submission.getResultWithComplaint().getId());
                 prepareComplaintAndSubmission(complaintOfSubmission, submission);
                 submissionWithComplaintDTOs.add(new SubmissionWithComplaintDTO(submission, complaintOfSubmission));

src/main/java/de/tum/cit/aet/artemis/exercise/web/AbstractSubmissionResource.java

@@ -82,7 +82,7 @@ protected ResponseEntity<List<Submission>> getAllSubmissions(Long exerciseId, bo
                 submission.getParticipation().setExercise(null);
             }
             // Important for exercises with Athena results
-            if (assessedByTutor) {
+            if (assessedByTutor && !examMode) {
                 submission.setResults(submission.getNonAthenaResults());
             }
         });

src/main/java/de/tum/cit/aet/artemis/exercise/web/ParticipationResource.java

@@ -414,7 +414,7 @@ else if (exercise instanceof ProgrammingExercise) {
         // Process feedback request
         StudentParticipation updatedParticipation;
         if (exercise instanceof TextExercise) {
-            updatedParticipation = textExerciseFeedbackService.handleNonGradedFeedbackRequest(exercise.getId(), participation, (TextExercise) exercise);
+            updatedParticipation = textExerciseFeedbackService.handleNonGradedFeedbackRequest(participation, (TextExercise) exercise);
         }
         else {
             updatedParticipation = programmingExerciseCodeReviewFeedbackService.handleNonGradedFeedbackRequest(exercise.getId(),

src/main/java/de/tum/cit/aet/artemis/text/service/TextExerciseFeedbackService.java

@@ -3,8 +3,11 @@
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 
 import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 
 import org.slf4j.Logger;
@@ -21,11 +24,10 @@
 import de.tum.cit.aet.artemis.assessment.web.ResultWebsocketService;
 import de.tum.cit.aet.artemis.athena.service.AthenaFeedbackSuggestionsService;
 import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
-import de.tum.cit.aet.artemis.core.exception.InternalServerErrorException;
-import de.tum.cit.aet.artemis.exercise.domain.participation.Participation;
 import de.tum.cit.aet.artemis.exercise.domain.participation.StudentParticipation;
 import de.tum.cit.aet.artemis.exercise.service.ParticipationService;
 import de.tum.cit.aet.artemis.exercise.service.SubmissionService;
+import de.tum.cit.aet.artemis.text.domain.TextBlock;
 import de.tum.cit.aet.artemis.text.domain.TextExercise;
 import de.tum.cit.aet.artemis.text.domain.TextSubmission;
 
@@ -49,14 +51,18 @@ public class TextExerciseFeedbackService {
 
     private final ResultRepository resultRepository;
 
+    private final TextBlockService textBlockService;
+
     public TextExerciseFeedbackService(Optional<AthenaFeedbackSuggestionsService> athenaFeedbackSuggestionsService, SubmissionService submissionService,
-            ResultService resultService, ResultRepository resultRepository, ResultWebsocketService resultWebsocketService, ParticipationService participationService) {
+            ResultService resultService, ResultRepository resultRepository, ResultWebsocketService resultWebsocketService, ParticipationService participationService,
+            TextBlockService textBlockService) {
         this.athenaFeedbackSuggestionsService = athenaFeedbackSuggestionsService;
         this.submissionService = submissionService;
         this.resultService = resultService;
         this.resultRepository = resultRepository;
         this.resultWebsocketService = resultWebsocketService;
         this.participationService = participationService;
+        this.textBlockService = textBlockService;
     }
 
     private void checkRateLimitOrThrow(StudentParticipation participation) {
@@ -74,12 +80,11 @@ private void checkRateLimitOrThrow(StudentParticipation participation) {
      * Handles the request for generating feedback for a text exercise.
      * Unlike programming exercises a tutor is not notified if Athena is not available.
      *
-     * @param exerciseId    the id of the text exercise.
      * @param participation the student participation associated with the exercise.
      * @param textExercise  the text exercise object.
      * @return StudentParticipation updated text exercise for an AI assessment
      */
-    public StudentParticipation handleNonGradedFeedbackRequest(Long exerciseId, StudentParticipation participation, TextExercise textExercise) {
+    public StudentParticipation handleNonGradedFeedbackRequest(StudentParticipation participation, TextExercise textExercise) {
         if (this.athenaFeedbackSuggestionsService.isPresent()) {
             this.checkRateLimitOrThrow(participation);
             CompletableFuture.runAsync(() -> this.generateAutomaticNonGradedFeedback(participation, textExercise));
@@ -103,50 +108,81 @@ public void generateAutomaticNonGradedFeedback(StudentParticipation participatio
         if (submissionOptional.isEmpty()) {
             throw new BadRequestAlertException("No legal submissions found", "submission", "noSubmission");
         }
-        var submission = submissionOptional.get();
+        TextSubmission textSubmission = (TextSubmission) submissionOptional.get();
 
         Result automaticResult = new Result();
         automaticResult.setAssessmentType(AssessmentType.AUTOMATIC_ATHENA);
         automaticResult.setRated(true);
         automaticResult.setScore(0.0);
         automaticResult.setSuccessful(null);
-        automaticResult.setSubmission(submission);
+        automaticResult.setSubmission(textSubmission);
         automaticResult.setParticipation(participation);
         try {
-            this.resultWebsocketService.broadcastNewResult((Participation) participation, automaticResult);
+            // This broadcast signals the client that feedback is being generated, does not save empty result
+            this.resultWebsocketService.broadcastNewResult(participation, automaticResult);
+
+            log.debug("Submission id: {}", textSubmission.getId());
 
-            log.debug("Submission id: {}", submission.getId());
+            var athenaResponse = this.athenaFeedbackSuggestionsService.orElseThrow().getTextFeedbackSuggestions(textExercise, textSubmission, true);
 
-            var athenaResponse = this.athenaFeedbackSuggestionsService.orElseThrow().getTextFeedbackSuggestions(textExercise, (TextSubmission) submission, false);
+            Set<TextBlock> textBlocks = new HashSet<>();
+            List<Feedback> feedbacks = new ArrayList<>();
 
-            List<Feedback> feedbacks = athenaResponse.stream().filter(individualFeedbackItem -> individualFeedbackItem.description() != null).map(individualFeedbackItem -> {
+            athenaResponse.stream().filter(individualFeedbackItem -> individualFeedbackItem.description() != null).forEach(individualFeedbackItem -> {
+                var textBlock = new TextBlock();
                 var feedback = new Feedback();
+
                 feedback.setText(individualFeedbackItem.title());
                 feedback.setDetailText(individualFeedbackItem.description());
                 feedback.setHasLongFeedbackText(false);
                 feedback.setType(FeedbackType.AUTOMATIC);
                 feedback.setCredits(individualFeedbackItem.credits());
-                return feedback;
-            }).toList();
+
+                if (textSubmission.getText() != null && individualFeedbackItem.indexStart() != null && individualFeedbackItem.indexEnd() != null) {
+                    textBlock.setStartIndex(individualFeedbackItem.indexStart());
+                    textBlock.setEndIndex(individualFeedbackItem.indexEnd());
+                    textBlock.setSubmission(textSubmission);
+                    textBlock.setTextFromSubmission();
+                    textBlock.automatic();
+                    textBlock.computeId();
+                    feedback.setReference(textBlock.getId());
+                    textBlock.setFeedback(feedback);
+                    log.debug(textBlock.toString());
+
+                    textBlocks.add(textBlock);
+                }
+                feedbacks.add(feedback);
+            });
 
             double totalFeedbacksScore = 0.0;
             for (Feedback feedback : feedbacks) {
                 totalFeedbacksScore += feedback.getCredits();
             }
             totalFeedbacksScore = totalFeedbacksScore / textExercise.getMaxPoints() * 100;
-            automaticResult.setSuccessful(true);
             automaticResult.setCompletionDate(ZonedDateTime.now());
-
             automaticResult.setScore(Math.clamp(totalFeedbacksScore, 0, 100));
 
+            // For Athena automatic results successful = true will mean that the generation was successful
+            // undefined in progress and false it failed
+            automaticResult.setSuccessful(true);
+
             automaticResult = this.resultRepository.save(automaticResult);
             resultService.storeFeedbackInResult(automaticResult, feedbacks, true);
-            submissionService.saveNewResult(submission, automaticResult);
-            this.resultWebsocketService.broadcastNewResult((Participation) participation, automaticResult);
+            textBlockService.saveAll(textBlocks);
+            textSubmission.setBlocks(textBlocks);
+            submissionService.saveNewResult(textSubmission, automaticResult);
+            // This broadcast signals the client that feedback generation succeeded, result is saved in this case only
+            this.resultWebsocketService.broadcastNewResult(participation, automaticResult);
         }
         catch (Exception e) {
             log.error("Could not generate feedback", e);
-            throw new InternalServerErrorException("Something went wrong... AI Feedback could not be generated");
+            // Broadcast the failed result but don't save, note that successful = false is normally used to indicate a score < 100
+            // but since we do not differentiate for athena feedback we use it to indicate a failed generation
+            automaticResult.setSuccessful(false);
+            automaticResult.setCompletionDate(null);
+            participation.addResult(automaticResult); // for proper change detection
+            // This broadcast signals the client that feedback generation failed, does not save empty result
+            this.resultWebsocketService.broadcastNewResult(participation, automaticResult);
         }
     }
 }

src/main/java/de/tum/cit/aet/artemis/text/web/TextExerciseResource.java

@@ -11,6 +11,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -413,55 +414,57 @@ public ResponseEntity<StudentParticipation> getDataForTextEditor(@PathVariable L
             participation.setResults(new HashSet<>(results));
         }
 
-        Optional<Submission> optionalSubmission = participation.findLatestSubmission();
+        if (!ExerciseDateService.isAfterAssessmentDueDate(textExercise)) {
+            // We want to have the preliminary feedback before the assessment due date too
+            Set<Result> athenaResults = participation.getResults().stream().filter(result -> result.getAssessmentType() == AssessmentType.AUTOMATIC_ATHENA)
+                    .collect(Collectors.toSet());
+            participation.setResults(athenaResults);
+        }
+
+        Set<Submission> submissions = participation.getSubmissions();
         participation.setSubmissions(new HashSet<>());
+        for (Submission submission : submissions) {
+            if (submission != null) {
+                TextSubmission textSubmission = (TextSubmission) submission;
 
-        if (optionalSubmission.isPresent()) {
-            TextSubmission textSubmission = (TextSubmission) optionalSubmission.get();
+                // set reference to participation to null, since we are already inside a participation
+                textSubmission.setParticipation(null);
 
-            // set reference to participation to null, since we are already inside a participation
-            textSubmission.setParticipation(null);
+                if (!ExerciseDateService.isAfterAssessmentDueDate(textExercise)) {
+                    // We want to have the preliminary feedback before the assessment due date too
+                    List<Result> athenaResults = submission.getResults().stream().filter(result -> result.getAssessmentType() == AssessmentType.AUTOMATIC_ATHENA).toList();
+                    textSubmission.setResults(athenaResults);
+                }
 
-            if (!ExerciseDateService.isAfterAssessmentDueDate(textExercise)) {
-                // We want to have the preliminary feedback before the assessment due date too
-                List<Result> athenaResults = participation.getResults().stream().filter(result -> result.getAssessmentType() == AssessmentType.AUTOMATIC_ATHENA).toList();
-                textSubmission.setResults(athenaResults);
-                Set<Result> athenaResultsSet = new HashSet<Result>(athenaResults);
-                participation.setResults(athenaResultsSet);
-            }
+                Result result = textSubmission.getLatestResult();
+                if (result != null) {
+                    // Load TextBlocks for the Submission. They are needed to display the Feedback in the client.
+                    final var textBlocks = textBlockRepository.findAllBySubmissionId(textSubmission.getId());
+                    textSubmission.setBlocks(textBlocks);
 
-            Result result = textSubmission.getLatestResult();
-            if (result != null) {
-                // Load TextBlocks for the Submission. They are needed to display the Feedback in the client.
-                final var textBlocks = textBlockRepository.findAllBySubmissionId(textSubmission.getId());
-                textSubmission.setBlocks(textBlocks);
+                    if (textSubmission.isSubmitted() && result.getCompletionDate() != null) {
+                        List<Feedback> assessments = feedbackRepository.findByResult(result);
+                        result.setFeedbacks(assessments);
+                    }
 
-                if (textSubmission.isSubmitted() && result.getCompletionDate() != null) {
-                    List<Feedback> assessments = feedbackRepository.findByResult(result);
-                    result.setFeedbacks(assessments);
-                }
+                    if (!authCheckService.isAtLeastTeachingAssistantForExercise(textExercise, user)) {
+                        result.filterSensitiveInformation();
+                    }
 
-                if (!authCheckService.isAtLeastTeachingAssistantForExercise(textExercise, user)) {
-                    result.filterSensitiveInformation();
+                    // only send the one latest result to the client per submission
+                    textSubmission.setResults(List.of(result));
                 }
-
-                // only send the one latest result to the client
-                textSubmission.setResults(List.of(result));
-                participation.setResults(Set.of(result));
+                participation.addSubmission(textSubmission);
+            }
+            if (!(authCheckService.isAtLeastInstructorForExercise(textExercise, user) || participation.isOwnedBy(user))) {
+                participation.filterSensitiveInformation();
             }
 
-            participation.addSubmission(textSubmission);
-        }
-
-        if (!(authCheckService.isAtLeastInstructorForExercise(textExercise, user) || participation.isOwnedBy(user))) {
-            participation.filterSensitiveInformation();
-        }
-
-        textExercise.filterSensitiveInformation();
-        if (textExercise.isExamExercise()) {
-            textExercise.getExam().setCourse(null);
+            textExercise.filterSensitiveInformation();
+            if (textExercise.isExamExercise()) {
+                textExercise.getExam().setCourse(null);
+            }
         }
-
         return ResponseEntity.ok(participation);
     }
 

src/main/webapp/app/exercises/shared/exercise-headers/header-participation-page.component.ts

@@ -56,10 +56,10 @@ export class HeaderParticipationPageComponent implements OnInit, OnChanges {
             this.exerciseStatusBadge = hasExerciseDueDatePassed(this.exercise, this.participation) ? 'bg-danger' : 'bg-success';
             this.exerciseCategories = this.exercise.categories || [];
             this.dueDate = getExerciseDueDate(this.exercise, this.participation);
-            if (this.participation?.results?.[0]?.rated) {
+            if (this.participation?.results?.last()?.rated) {
                 this.achievedPoints = roundValueSpecifiedByCourseSettings(
                     // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-                    (this.participation.results?.[0].score! * this.exercise.maxPoints!) / 100,
+                    (this.participation.results?.last()?.score! * this.exercise.maxPoints!) / 100,
                     getCourseFromExercise(this.exercise),
                 );
             }

src/main/webapp/app/exercises/shared/feedback-suggestion/exercise-feedback-suggestion-options.component.html

@@ -28,8 +28,8 @@
                     id="allowFeedbackRequests"
                     (change)="toggleFeedbackRequests($event)"
                 />
-                <label class="form-control-label" for="allowFeedbackRequests" jhiTranslate="artemisApp.programmingExercise.timeline.allowFeedbackRequests"></label>
-                <jhi-help-icon placement="right auto" [text]="'artemisApp.programmingExercise.timeline.allowFeedbackRequestsTooltip'" />
+                <label class="form-control-label" for="allowFeedbackRequests" jhiTranslate="artemisApp.textExercise.allowPreliminaryAthenaFeedbackRequests"></label>
+                <jhi-help-icon placement="right auto" [text]="'artemisApp.textExercise.allowPreliminaryAthenaFeedbackRequestsTooltip'" />
             </div>
         }
         @if (!!this.exercise.feedbackSuggestionModule) {

src/main/webapp/app/exercises/shared/feedback/feedback.component.ts

@@ -79,7 +79,6 @@ export class FeedbackComponent implements OnInit, OnChanges {
     faXmark = faXmark;
     faCircleNotch = faCircleNotch;
     faExclamationTriangle = faExclamationTriangle;
-
     private showTestDetails = false;
     isLoading = false;
     loadingFailed = false;