Merge branch 'develop' into feature/programming-exercises/add-groupin…

…g-feature-to-analysis-table

.github/PULL_REQUEST_TEMPLATE.md

@@ -111,10 +111,10 @@ Prerequisites:
 - [ ] Test 2
 
 ### Test Coverage
-<!-- Please add the test coverages for all changed files here. You can see this when executing the tests locally (see build.gradle and package.json) or when looking into the corresponding Bamboo build plan. -->
-<!-- The line coverage must be above 90% for changes files and you must use extensive and useful assertions for server tests and expect statements for client tests. -->
-<!-- Note: Use the table below and confirm in the last column that you have implemented extensive assertions for server tests and expect statements for client tests. -->
-<!--       You can use `supporting_script/generate_code_cov_table/generate_code_cov_table.py` to automatically generate one from the corresponding Bamboo build plan artefacts. -->
+<!-- Please add the test coverages for all changed files modified in this PR here. You can use `supporting_script/generate_code_cov_table/generate_code_cov_table.py` to automatically generate the coverage table from the corresponding artefacts of your branch (follow the ReadMe for setup details). -->
+<!-- Alternatively you can execute the tests locally (see build.gradle and package.json) or look into the corresponding artefacts. -->
+<!-- The line coverage must be above 90% for changes files, and you must use extensive and useful assertions for server tests and expect statements for client tests. -->
+<!-- Note: Confirm in the last column that you have implemented extensive assertions for server tests and expect statements for client tests. -->
 <!--       Remove rows with only trivial changes from the table. -->
 <!--
 | Class/File | Line Coverage | Confirmation (assert/expect) |

README.md

@@ -193,7 +193,7 @@ Refer to [Using JHipster in production](http://www.jhipster.tech/production) for
 The following command can automate the deployment to a server. The example shows the deployment to the main Artemis test server (which runs a virtual machine):
 
 ```shell
-./artemis-server-cli deploy username@artemistest.ase.in.tum.de -w build/libs/Artemis-7.7.3.war
+./artemis-server-cli deploy username@artemistest.ase.in.tum.de -w build/libs/Artemis-7.7.4.war
 ```
 
 ## Architecture

build.gradle

@@ -25,7 +25,7 @@ plugins {
 }
 
 group = "de.tum.cit.aet.artemis"
-version = "7.7.3"
+version = "7.7.4"
 description = "Interactive Learning with Individual Feedback"
 
 java {

package.json

@@ -1,6 +1,6 @@
 {
     "name": "artemis",
-    "version": "7.7.3",
+    "version": "7.7.4",
     "description": "Interactive Learning with Individual Feedback",
     "private": true,
     "license": "MIT",
@@ -69,7 +69,6 @@
         "papaparse": "5.4.1",
         "pdf-lib": "1.17.1",
         "pdfjs-dist": "4.8.69",
-        "posthog-js": "1.187.2",
         "rxjs": "7.8.1",
         "simple-statistics": "7.8.7",
         "smoothscroll-polyfill": "0.4.4",

src/main/java/de/tum/cit/aet/artemis/assessment/service/AssessmentService.java

@@ -17,7 +17,6 @@
 import de.tum.cit.aet.artemis.assessment.dto.AssessmentUpdateBaseDTO;
 import de.tum.cit.aet.artemis.assessment.repository.ComplaintRepository;
 import de.tum.cit.aet.artemis.assessment.repository.FeedbackRepository;
-import de.tum.cit.aet.artemis.assessment.repository.LongFeedbackTextRepository;
 import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
 import de.tum.cit.aet.artemis.assessment.web.ResultWebsocketService;
 import de.tum.cit.aet.artemis.communication.service.notifications.SingleUserNotificationService;
@@ -68,12 +67,10 @@ public class AssessmentService {
 
     protected final ResultWebsocketService resultWebsocketService;
 
-    private final LongFeedbackTextRepository longFeedbackTextRepository;
-
     public AssessmentService(ComplaintResponseService complaintResponseService, ComplaintRepository complaintRepository, FeedbackRepository feedbackRepository,
             ResultRepository resultRepository, StudentParticipationRepository studentParticipationRepository, ResultService resultService, SubmissionService submissionService,
             SubmissionRepository submissionRepository, ExamDateService examDateService, UserRepository userRepository, Optional<LtiNewResultService> ltiNewResultService,
-            SingleUserNotificationService singleUserNotificationService, ResultWebsocketService resultWebsocketService, LongFeedbackTextRepository longFeedbackTextRepository) {
+            SingleUserNotificationService singleUserNotificationService, ResultWebsocketService resultWebsocketService) {
         this.complaintResponseService = complaintResponseService;
         this.complaintRepository = complaintRepository;
         this.feedbackRepository = feedbackRepository;
@@ -87,7 +84,6 @@ public AssessmentService(ComplaintResponseService complaintResponseService, Comp
         this.ltiNewResultService = ltiNewResultService;
         this.singleUserNotificationService = singleUserNotificationService;
         this.resultWebsocketService = resultWebsocketService;
-        this.longFeedbackTextRepository = longFeedbackTextRepository;
     }
 
     /**

src/main/java/de/tum/cit/aet/artemis/assessment/service/ParticipantScoreScheduleService.java

@@ -37,7 +37,7 @@
 import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
 import de.tum.cit.aet.artemis.assessment.repository.StudentScoreRepository;
 import de.tum.cit.aet.artemis.assessment.repository.TeamScoreRepository;
-import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyProgressService;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyProgressApi;
 import de.tum.cit.aet.artemis.core.domain.User;
 import de.tum.cit.aet.artemis.core.repository.UserRepository;
 import de.tum.cit.aet.artemis.core.security.SecurityUtils;
@@ -74,7 +74,7 @@ public class ParticipantScoreScheduleService {
 
     private Optional<Instant> lastScheduledRun = Optional.empty();
 
-    private final CompetencyProgressService competencyProgressService;
+    private final CompetencyProgressApi competencyProgressApi;
 
     private final ParticipantScoreRepository participantScoreRepository;
 
@@ -96,11 +96,11 @@ public class ParticipantScoreScheduleService {
      */
     private final AtomicBoolean isRunning = new AtomicBoolean(false);
 
-    public ParticipantScoreScheduleService(@Qualifier("taskScheduler") TaskScheduler scheduler, CompetencyProgressService competencyProgressService,
+    public ParticipantScoreScheduleService(@Qualifier("taskScheduler") TaskScheduler scheduler, CompetencyProgressApi competencyProgressApi,
             ParticipantScoreRepository participantScoreRepository, StudentScoreRepository studentScoreRepository, TeamScoreRepository teamScoreRepository,
             ExerciseRepository exerciseRepository, ResultRepository resultRepository, UserRepository userRepository, TeamRepository teamRepository) {
         this.scheduler = scheduler;
-        this.competencyProgressService = competencyProgressService;
+        this.competencyProgressApi = competencyProgressApi;
         this.participantScoreRepository = participantScoreRepository;
         this.studentScoreRepository = studentScoreRepository;
         this.teamScoreRepository = teamScoreRepository;
@@ -336,7 +336,7 @@ private void executeTask(Long exerciseId, Long participantId, Instant resultLast
             if (scoreParticipant instanceof Team team && !Hibernate.isInitialized(team.getStudents())) {
                 scoreParticipant = teamRepository.findWithStudentsByIdElseThrow(team.getId());
             }
-            competencyProgressService.updateProgressByLearningObjectSync(score.getExercise(), scoreParticipant.getParticipants());
+            competencyProgressApi.updateProgressByLearningObjectSync(score.getExercise(), scoreParticipant.getParticipants());
         }
         catch (Exception e) {
             log.error("Exception while processing participant score for exercise {} and participant {} for participant scores:", exerciseId, participantId, e);

src/main/java/de/tum/cit/aet/artemis/atlas/api/AbstractAtlasApi.java

@@ -0,0 +1,6 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import de.tum.cit.aet.artemis.core.api.AbstractApi;
+
+public abstract class AbstractAtlasApi implements AbstractApi {
+}

src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyApi.java

@@ -0,0 +1,24 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyService;
+import de.tum.cit.aet.artemis.lecture.domain.Lecture;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class CompetencyApi extends AbstractAtlasApi {
+
+    private final CompetencyService competencyService;
+
+    public CompetencyApi(CompetencyService competencyService) {
+        this.competencyService = competencyService;
+    }
+
+    public void addCompetencyLinksToExerciseUnits(Lecture lecture) {
+        competencyService.addCompetencyLinksToExerciseUnits(lecture);
+    }
+}

src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyProgressApi.java

@@ -0,0 +1,74 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.domain.LearningObject;
+import de.tum.cit.aet.artemis.atlas.domain.competency.Competency;
+import de.tum.cit.aet.artemis.atlas.domain.competency.CourseCompetency;
+import de.tum.cit.aet.artemis.atlas.repository.CompetencyRepository;
+import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyProgressService;
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.domain.User;
+import de.tum.cit.aet.artemis.exercise.domain.participation.Participant;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class CompetencyProgressApi extends AbstractAtlasApi {
+
+    private final CompetencyProgressService competencyProgressService;
+
+    private final CompetencyRepository competencyRepository;
+
+    public CompetencyProgressApi(CompetencyProgressService competencyProgressService, CompetencyRepository competencyRepository) {
+        this.competencyProgressService = competencyProgressService;
+        this.competencyRepository = competencyRepository;
+    }
+
+    public void updateProgressByLearningObjectForParticipantAsync(LearningObject learningObject, Participant participant) {
+        competencyProgressService.updateProgressByLearningObjectForParticipantAsync(learningObject, participant);
+    }
+
+    public void updateProgressByLearningObjectAsync(LearningObject learningObject) {
+        competencyProgressService.updateProgressByLearningObjectAsync(learningObject);
+    }
+
+    public void updateProgressByCompetencyAsync(CourseCompetency competency) {
+        competencyProgressService.updateProgressByCompetencyAsync(competency);
+    }
+
+    public void updateProgressForUpdatedLearningObjectAsync(LearningObject originalLearningObject, Optional<LearningObject> updatedLearningObject) {
+        competencyProgressService.updateProgressForUpdatedLearningObjectAsync(originalLearningObject, updatedLearningObject);
+    }
+
+    public void updateProgressByLearningObjectSync(LearningObject learningObject, Set<User> users) {
+        competencyProgressService.updateProgressByLearningObjectSync(learningObject, users);
+    }
+
+    public long countByCourse(Course course) {
+        return competencyRepository.countByCourse(course);
+    }
+
+    public void deleteAll(Set<Competency> competencies) {
+        competencyRepository.deleteAll(competencies);
+    }
+
+    /**
+     * Updates the progress for all competencies of the given courses.
+     *
+     * @param activeCourses the active courses
+     */
+    public void updateProgressForCoursesAsync(List<Course> activeCourses) {
+        activeCourses.forEach(course -> {
+            List<Competency> competencies = competencyRepository.findByCourseIdOrderById(course.getId());
+            // Asynchronously update the progress for each competency
+            competencies.forEach(competencyProgressService::updateProgressByCompetencyAsync);
+        });
+    }
+}

src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyRelationApi.java

@@ -0,0 +1,56 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.List;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyExerciseLink;
+import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyLectureUnitLink;
+import de.tum.cit.aet.artemis.atlas.repository.CompetencyExerciseLinkRepository;
+import de.tum.cit.aet.artemis.atlas.repository.CompetencyLectureUnitLinkRepository;
+import de.tum.cit.aet.artemis.atlas.repository.CompetencyRelationRepository;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class CompetencyRelationApi extends AbstractAtlasApi {
+
+    private final CompetencyRelationRepository competencyRelationRepository;
+
+    private final CompetencyExerciseLinkRepository competencyExerciseLinkRepository;
+
+    private final CompetencyLectureUnitLinkRepository lectureUnitLinkRepository;
+
+    public CompetencyRelationApi(CompetencyRelationRepository competencyRelationRepository, CompetencyExerciseLinkRepository competencyExerciseLinkRepository,
+            CompetencyLectureUnitLinkRepository lectureUnitLinkRepository) {
+        this.competencyRelationRepository = competencyRelationRepository;
+        this.competencyExerciseLinkRepository = competencyExerciseLinkRepository;
+        this.lectureUnitLinkRepository = lectureUnitLinkRepository;
+    }
+
+    public void deleteAllByCourseId(Long courseId) {
+        competencyRelationRepository.deleteAllByCourseId(courseId);
+    }
+
+    public void deleteAllExerciseLinks(Iterable<CompetencyExerciseLink> competencyExerciseLinks) {
+        competencyExerciseLinkRepository.deleteAll(competencyExerciseLinks);
+    }
+
+    public List<CompetencyExerciseLink> saveAllExerciseLinks(Iterable<CompetencyExerciseLink> competencyExerciseLinks) {
+        return competencyExerciseLinkRepository.saveAll(competencyExerciseLinks);
+    }
+
+    public List<CompetencyLectureUnitLink> saveAllLectureUnitLinks(Iterable<CompetencyLectureUnitLink> lectureUnitLinks) {
+        return lectureUnitLinkRepository.saveAll(lectureUnitLinks);
+    }
+
+    public void deleteAllLectureUnitLinks(Iterable<CompetencyLectureUnitLink> lectureUnitLinks) {
+        lectureUnitLinkRepository.deleteAll(lectureUnitLinks);
+    }
+
+    public void deleteAllLectureUnitLinksByLectureId(Long lectureId) {
+        lectureUnitLinkRepository.deleteAllByLectureId(lectureId);
+    }
+}