diff --git a/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml b/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml
index 217477ace79d..2eae7040817e 100644
--- a/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml
+++ b/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml
@@ -9,4 +9,4 @@
-
\ No newline at end of file
+
diff --git a/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml b/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml
index 2323d3d5ca3b..9135ec4a2fd2 100644
--- a/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml
+++ b/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml
@@ -1,7 +1,7 @@
-
-
+
+
diff --git a/src/main/java/de/tum/cit/aet/artemis/assessment/service/AssessmentService.java b/src/main/java/de/tum/cit/aet/artemis/assessment/service/AssessmentService.java
index 6b7b45c8c65b..35596c4a4c15 100644
--- a/src/main/java/de/tum/cit/aet/artemis/assessment/service/AssessmentService.java
+++ b/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,
- 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;
}
/**
diff --git a/src/main/java/de/tum/cit/aet/artemis/assessment/service/ParticipantScoreScheduleService.java b/src/main/java/de/tum/cit/aet/artemis/assessment/service/ParticipantScoreScheduleService.java
index fffd4957b5b2..a3b7521668f4 100644
--- a/src/main/java/de/tum/cit/aet/artemis/assessment/service/ParticipantScoreScheduleService.java
+++ b/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 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);
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/AbstractAtlasApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/AbstractAtlasApi.java
new file mode 100644
index 000000000000..41481096ac68
--- /dev/null
+++ b/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 {
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyApi.java
new file mode 100644
index 000000000000..7c4f349d9215
--- /dev/null
+++ b/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);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyProgressApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyProgressApi.java
new file mode 100644
index 000000000000..eddc384ad8c7
--- /dev/null
+++ b/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 updatedLearningObject) {
+ competencyProgressService.updateProgressForUpdatedLearningObjectAsync(originalLearningObject, updatedLearningObject);
+ }
+
+ public void updateProgressByLearningObjectSync(LearningObject learningObject, Set users) {
+ competencyProgressService.updateProgressByLearningObjectSync(learningObject, users);
+ }
+
+ public long countByCourse(Course course) {
+ return competencyRepository.countByCourse(course);
+ }
+
+ public void deleteAll(Set competencies) {
+ competencyRepository.deleteAll(competencies);
+ }
+
+ /**
+ * Updates the progress for all competencies of the given courses.
+ *
+ * @param activeCourses the active courses
+ */
+ public void updateProgressForCoursesAsync(List activeCourses) {
+ activeCourses.forEach(course -> {
+ List competencies = competencyRepository.findByCourseIdOrderById(course.getId());
+ // Asynchronously update the progress for each competency
+ competencies.forEach(competencyProgressService::updateProgressByCompetencyAsync);
+ });
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyRelationApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/CompetencyRelationApi.java
new file mode 100644
index 000000000000..d7857bdcf509
--- /dev/null
+++ b/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 competencyExerciseLinks) {
+ competencyExerciseLinkRepository.deleteAll(competencyExerciseLinks);
+ }
+
+ public List saveAllExerciseLinks(Iterable competencyExerciseLinks) {
+ return competencyExerciseLinkRepository.saveAll(competencyExerciseLinks);
+ }
+
+ public List saveAllLectureUnitLinks(Iterable lectureUnitLinks) {
+ return lectureUnitLinkRepository.saveAll(lectureUnitLinks);
+ }
+
+ public void deleteAllLectureUnitLinks(Iterable lectureUnitLinks) {
+ lectureUnitLinkRepository.deleteAll(lectureUnitLinks);
+ }
+
+ public void deleteAllLectureUnitLinksByLectureId(Long lectureId) {
+ lectureUnitLinkRepository.deleteAllByLectureId(lectureId);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/CourseCompetencyApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/CourseCompetencyApi.java
new file mode 100644
index 000000000000..c970d2f137ff
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/api/CourseCompetencyApi.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.domain.competency.CourseCompetency;
+import de.tum.cit.aet.artemis.atlas.repository.CourseCompetencyRepository;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class CourseCompetencyApi extends AbstractAtlasApi {
+
+ private final CourseCompetencyRepository courseCompetencyRepository;
+
+ public CourseCompetencyApi(CourseCompetencyRepository courseCompetencyRepository) {
+ this.courseCompetencyRepository = courseCompetencyRepository;
+ }
+
+ public void save(CourseCompetency courseCompetency) {
+ courseCompetencyRepository.save(courseCompetency);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/LearningMetricsApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/LearningMetricsApi.java
new file mode 100644
index 000000000000..cf2a5271cab0
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/api/LearningMetricsApi.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.dto.metrics.StudentMetricsDTO;
+import de.tum.cit.aet.artemis.atlas.service.LearningMetricsService;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class LearningMetricsApi extends AbstractAtlasApi {
+
+ private final LearningMetricsService metricsService;
+
+ public LearningMetricsApi(LearningMetricsService metricsService) {
+ this.metricsService = metricsService;
+ }
+
+ public StudentMetricsDTO getStudentCourseMetrics(long userId, long courseId) {
+ return metricsService.getStudentCourseMetrics(userId, courseId);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/LearningPathApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/LearningPathApi.java
new file mode 100644
index 000000000000..834297c04288
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/api/LearningPathApi.java
@@ -0,0 +1,31 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import jakarta.validation.constraints.NotNull;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.service.learningpath.LearningPathService;
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.domain.User;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class LearningPathApi extends AbstractAtlasApi {
+
+ private final LearningPathService learningPathService;
+
+ public LearningPathApi(LearningPathService learningPathService) {
+ this.learningPathService = learningPathService;
+ }
+
+ public void generateLearningPathForUser(@NotNull Course course, @NotNull User user) {
+ learningPathService.generateLearningPathForUser(course, user);
+ }
+
+ public void generateLearningPaths(@NotNull Course course) {
+ learningPathService.generateLearningPaths(course);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/PrerequisitesApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/PrerequisitesApi.java
new file mode 100644
index 000000000000..ddcc8fa3c56a
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/api/PrerequisitesApi.java
@@ -0,0 +1,29 @@
+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.domain.competency.Prerequisite;
+import de.tum.cit.aet.artemis.atlas.repository.PrerequisiteRepository;
+import de.tum.cit.aet.artemis.core.domain.Course;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class PrerequisitesApi extends AbstractAtlasApi {
+
+ private final PrerequisiteRepository prerequisiteRepository;
+
+ public PrerequisitesApi(PrerequisiteRepository prerequisiteRepository) {
+ this.prerequisiteRepository = prerequisiteRepository;
+ }
+
+ public long countByCourse(Course course) {
+ return prerequisiteRepository.countByCourse(course);
+ }
+
+ public void deleteAll(Iterable prerequisites) {
+ prerequisiteRepository.deleteAll(prerequisites);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/api/ScienceEventApi.java b/src/main/java/de/tum/cit/aet/artemis/atlas/api/ScienceEventApi.java
new file mode 100644
index 000000000000..0da5e4beb0ca
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/api/ScienceEventApi.java
@@ -0,0 +1,30 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Set;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.domain.science.ScienceEvent;
+import de.tum.cit.aet.artemis.atlas.repository.ScienceEventRepository;
+
+@Controller
+@Profile(PROFILE_CORE)
+public class ScienceEventApi extends AbstractAtlasApi {
+
+ private final ScienceEventRepository scienceEventRepository;
+
+ public ScienceEventApi(ScienceEventRepository scienceEventRepository) {
+ this.scienceEventRepository = scienceEventRepository;
+ }
+
+ public Set findAllByIdentity(String login) {
+ return scienceEventRepository.findAllByIdentity(login);
+ }
+
+ public void renameIdentity(String oldIdentity, String newIdentity) {
+ scienceEventRepository.renameIdentity(oldIdentity, newIdentity);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/exercise/service/LearningMetricsService.java b/src/main/java/de/tum/cit/aet/artemis/atlas/service/LearningMetricsService.java
similarity index 99%
rename from src/main/java/de/tum/cit/aet/artemis/exercise/service/LearningMetricsService.java
rename to src/main/java/de/tum/cit/aet/artemis/atlas/service/LearningMetricsService.java
index c939f59367b5..38b4552c19c3 100644
--- a/src/main/java/de/tum/cit/aet/artemis/exercise/service/LearningMetricsService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/service/LearningMetricsService.java
@@ -1,4 +1,4 @@
-package de.tum.cit.aet.artemis.exercise.service;
+package de.tum.cit.aet.artemis.atlas.service;
import static de.tum.cit.aet.artemis.core.config.Constants.MIN_SCORE_GREEN;
import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
diff --git a/src/main/java/de/tum/cit/aet/artemis/atlas/web/MetricsResource.java b/src/main/java/de/tum/cit/aet/artemis/atlas/web/MetricsResource.java
index ca2fa2f30251..db24d9569c88 100644
--- a/src/main/java/de/tum/cit/aet/artemis/atlas/web/MetricsResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/atlas/web/MetricsResource.java
@@ -12,9 +12,9 @@
import org.springframework.web.bind.annotation.RestController;
import de.tum.cit.aet.artemis.atlas.dto.metrics.StudentMetricsDTO;
+import de.tum.cit.aet.artemis.atlas.service.LearningMetricsService;
import de.tum.cit.aet.artemis.core.repository.UserRepository;
import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastStudentInCourse;
-import de.tum.cit.aet.artemis.exercise.service.LearningMetricsService;
@Profile(PROFILE_CORE)
@RestController
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/api/AbstractApi.java b/src/main/java/de/tum/cit/aet/artemis/core/api/AbstractApi.java
new file mode 100644
index 000000000000..8ca26f995aa0
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/core/api/AbstractApi.java
@@ -0,0 +1,4 @@
+package de.tum.cit.aet.artemis.core.api;
+
+public interface AbstractApi {
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/config/migration/entries/MigrationEntry20240614_140000.java b/src/main/java/de/tum/cit/aet/artemis/core/config/migration/entries/MigrationEntry20240614_140000.java
index 7371408c2df6..b385c3f01053 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/config/migration/entries/MigrationEntry20240614_140000.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/config/migration/entries/MigrationEntry20240614_140000.java
@@ -6,9 +6,7 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import de.tum.cit.aet.artemis.atlas.domain.competency.Competency;
-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.atlas.api.CompetencyProgressApi;
import de.tum.cit.aet.artemis.core.config.migration.MigrationEntry;
import de.tum.cit.aet.artemis.core.domain.Course;
import de.tum.cit.aet.artemis.core.repository.CourseRepository;
@@ -19,14 +17,11 @@ public class MigrationEntry20240614_140000 extends MigrationEntry {
private final CourseRepository courseRepository;
- private final CompetencyRepository competencyRepository;
+ private final CompetencyProgressApi competencyProgressApi;
- private final CompetencyProgressService competencyProgressService;
-
- public MigrationEntry20240614_140000(CourseRepository courseRepository, CompetencyRepository competencyRepository, CompetencyProgressService competencyProgressService) {
+ public MigrationEntry20240614_140000(CourseRepository courseRepository, CompetencyProgressApi competencyProgressApi) {
this.courseRepository = courseRepository;
- this.competencyRepository = competencyRepository;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
@Override
@@ -34,12 +29,7 @@ public void execute() {
List activeCourses = courseRepository.findAllActiveWithoutTestCourses(ZonedDateTime.now());
log.info("Updating competency progress for {} active courses", activeCourses.size());
-
- activeCourses.forEach(course -> {
- List competencies = competencyRepository.findByCourseIdOrderById(course.getId());
- // Asynchronously update the progress for each competency
- competencies.forEach(competencyProgressService::updateProgressByCompetencyAsync);
- });
+ competencyProgressApi.updateProgressForCoursesAsync(activeCourses);
}
@Override
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/domain/User.java b/src/main/java/de/tum/cit/aet/artemis/core/domain/User.java
index 2ef2478cf295..c435194cdf40 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/domain/User.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/domain/User.java
@@ -156,23 +156,6 @@ public class User extends AbstractAuditingEntity implements Participant {
@Column(name = "vcs_access_token_expiry_date")
private ZonedDateTime vcsAccessTokenExpiryDate = null;
- /**
- * The actual full public ssh key of a user used to authenticate git clone and git push operations if available
- */
- @Nullable
- @JsonIgnore
- @Column(name = "ssh_public_key")
- private final String sshPublicKey = null;
-
- /**
- * A hash of the public ssh key for fast comparison in the database (with an index)
- */
- @Nullable
- @Size(max = 100)
- @JsonIgnore
- @Column(name = "ssh_public_key_hash")
- private final String sshPublicKeyHash = null;
-
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(name = "user_groups", joinColumns = @JoinColumn(name = "user_id"))
@Column(name = "user_groups")
@@ -560,14 +543,4 @@ public void hasAcceptedIrisElseThrow() {
throw new AccessForbiddenException("The user has not accepted the Iris privacy policy yet.");
}
}
-
- @Nullable
- public String getSshPublicKey() {
- return sshPublicKey;
- }
-
- @Nullable
- public @Size(max = 100) String getSshPublicKeyHash() {
- return sshPublicKeyHash;
- }
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/dto/UserDTO.java b/src/main/java/de/tum/cit/aet/artemis/core/dto/UserDTO.java
index 3d627425a8f7..1f5ea1e653b8 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/dto/UserDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/dto/UserDTO.java
@@ -76,10 +76,6 @@ public class UserDTO extends AuditingEntityDTO {
private ZonedDateTime vcsAccessTokenExpiryDate;
- private String sshPublicKey;
-
- private String sshKeyHash;
-
private ZonedDateTime irisAccepted;
public UserDTO() {
@@ -262,14 +258,6 @@ public ZonedDateTime getVcsAccessTokenExpiryDate() {
return vcsAccessTokenExpiryDate;
}
- public String getSshPublicKey() {
- return sshPublicKey;
- }
-
- public void setSshPublicKey(String sshPublicKey) {
- this.sshPublicKey = sshPublicKey;
- }
-
@Override
public String toString() {
return "UserDTO{" + "login='" + login + '\'' + ", firstName='" + firstName + '\'' + ", lastName='" + lastName + '\'' + ", email='" + email + '\'' + ", imageUrl='"
@@ -293,12 +281,4 @@ public ZonedDateTime getIrisAccepted() {
public void setIrisAccepted(ZonedDateTime irisAccepted) {
this.irisAccepted = irisAccepted;
}
-
- public String getSshKeyHash() {
- return sshKeyHash;
- }
-
- public void setSshKeyHash(String sshKeyHash) {
- this.sshKeyHash = sshKeyHash;
- }
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/repository/UserRepository.java b/src/main/java/de/tum/cit/aet/artemis/core/repository/UserRepository.java
index 5b66b31aee98..0d3280cf5d96 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/repository/UserRepository.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/repository/UserRepository.java
@@ -724,16 +724,6 @@ default Page searchAllWithGroupsByLoginOrNameInCourseAndReturnPage(Pageabl
""")
void updateUserLanguageKey(@Param("userId") long userId, @Param("languageKey") String languageKey);
- @Modifying
- @Transactional // ok because of modifying query
- @Query("""
- UPDATE User user
- SET user.sshPublicKeyHash = :sshPublicKeyHash,
- user.sshPublicKey = :sshPublicKey
- WHERE user.id = :userId
- """)
- void updateUserSshPublicKeyHash(@Param("userId") long userId, @Param("sshPublicKeyHash") String sshPublicKeyHash, @Param("sshPublicKey") String sshPublicKey);
-
@Modifying
@Transactional // ok because of modifying query
@Query("""
@@ -1120,8 +1110,6 @@ default boolean isCurrentUser(String login) {
return SecurityUtils.getCurrentUserLogin().map(currentLogin -> currentLogin.equals(login)).orElse(false);
}
- Optional findBySshPublicKeyHash(String keyString);
-
/**
* Finds all users which a non-null VCS access token that expires before some given date.
*
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/service/CourseService.java b/src/main/java/de/tum/cit/aet/artemis/core/service/CourseService.java
index 81aa6a27f6b0..1b037532e453 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/service/CourseService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/service/CourseService.java
@@ -53,10 +53,11 @@
import de.tum.cit.aet.artemis.assessment.service.ComplaintService;
import de.tum.cit.aet.artemis.assessment.service.PresentationPointsCalculationService;
import de.tum.cit.aet.artemis.assessment.service.TutorLeaderboardService;
-import de.tum.cit.aet.artemis.atlas.repository.CompetencyRelationRepository;
-import de.tum.cit.aet.artemis.atlas.repository.CompetencyRepository;
-import de.tum.cit.aet.artemis.atlas.repository.PrerequisiteRepository;
-import de.tum.cit.aet.artemis.atlas.service.learningpath.LearningPathService;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyProgressApi;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyRelationApi;
+import de.tum.cit.aet.artemis.atlas.api.LearningPathApi;
+import de.tum.cit.aet.artemis.atlas.api.PrerequisitesApi;
+import de.tum.cit.aet.artemis.communication.domain.FaqState;
import de.tum.cit.aet.artemis.communication.domain.NotificationType;
import de.tum.cit.aet.artemis.communication.domain.Post;
import de.tum.cit.aet.artemis.communication.domain.notification.GroupNotification;
@@ -131,7 +132,7 @@ public class CourseService {
private final TutorialGroupChannelManagementService tutorialGroupChannelManagementService;
- private final CompetencyRelationRepository competencyRelationRepository;
+ private final CompetencyRelationApi competencyRelationApi;
private final ExerciseService exerciseService;
@@ -161,9 +162,9 @@ public class CourseService {
private final AuditEventRepository auditEventRepository;
- private final CompetencyRepository competencyRepository;
+ private final CompetencyProgressApi competencyProgressApi;
- private final PrerequisiteRepository prerequisiteRepository;
+ private final PrerequisitesApi prerequisitesApi;
private final GradingScaleRepository gradingScaleRepository;
@@ -199,7 +200,7 @@ public class CourseService {
private final ConversationRepository conversationRepository;
- private final LearningPathService learningPathService;
+ private final LearningPathApi learningPathApi;
private final Optional irisSettingsService;
@@ -216,17 +217,17 @@ public class CourseService {
public CourseService(CourseRepository courseRepository, ExerciseService exerciseService, ExerciseDeletionService exerciseDeletionService,
AuthorizationCheckService authCheckService, UserRepository userRepository, LectureService lectureService, GroupNotificationRepository groupNotificationRepository,
ExerciseGroupRepository exerciseGroupRepository, AuditEventRepository auditEventRepository, UserService userService, ExamDeletionService examDeletionService,
- CompetencyRepository competencyRepository, GroupNotificationService groupNotificationService, ExamRepository examRepository,
+ CompetencyProgressApi competencyProgressApi, GroupNotificationService groupNotificationService, ExamRepository examRepository,
CourseExamExportService courseExamExportService, GradingScaleRepository gradingScaleRepository, StatisticsRepository statisticsRepository,
StudentParticipationRepository studentParticipationRepository, TutorLeaderboardService tutorLeaderboardService, RatingRepository ratingRepository,
ComplaintService complaintService, ComplaintRepository complaintRepository, ResultRepository resultRepository, ComplaintResponseRepository complaintResponseRepository,
SubmissionRepository submissionRepository, ProgrammingExerciseRepository programmingExerciseRepository, ExerciseRepository exerciseRepository,
ParticipantScoreRepository participantScoreRepository, PresentationPointsCalculationService presentationPointsCalculationService,
TutorialGroupRepository tutorialGroupRepository, PlagiarismCaseRepository plagiarismCaseRepository, ConversationRepository conversationRepository,
- LearningPathService learningPathService, Optional irisSettingsService, LectureRepository lectureRepository,
+ LearningPathApi learningPathApi, Optional irisSettingsService, LectureRepository lectureRepository,
TutorialGroupNotificationRepository tutorialGroupNotificationRepository, TutorialGroupChannelManagementService tutorialGroupChannelManagementService,
- PrerequisiteRepository prerequisiteRepository, CompetencyRelationRepository competencyRelationRepository, PostRepository postRepository,
- AnswerPostRepository answerPostRepository, BuildJobRepository buildJobRepository, FaqRepository faqRepository) {
+ PrerequisitesApi prerequisitesApi, CompetencyRelationApi competencyRelationApi, PostRepository postRepository, AnswerPostRepository answerPostRepository,
+ BuildJobRepository buildJobRepository, FaqRepository faqRepository) {
this.courseRepository = courseRepository;
this.exerciseService = exerciseService;
this.exerciseDeletionService = exerciseDeletionService;
@@ -238,7 +239,7 @@ public CourseService(CourseRepository courseRepository, ExerciseService exercise
this.auditEventRepository = auditEventRepository;
this.userService = userService;
this.examDeletionService = examDeletionService;
- this.competencyRepository = competencyRepository;
+ this.competencyProgressApi = competencyProgressApi;
this.groupNotificationService = groupNotificationService;
this.examRepository = examRepository;
this.courseExamExportService = courseExamExportService;
@@ -259,13 +260,13 @@ public CourseService(CourseRepository courseRepository, ExerciseService exercise
this.tutorialGroupRepository = tutorialGroupRepository;
this.plagiarismCaseRepository = plagiarismCaseRepository;
this.conversationRepository = conversationRepository;
- this.learningPathService = learningPathService;
+ this.learningPathApi = learningPathApi;
this.irisSettingsService = irisSettingsService;
this.lectureRepository = lectureRepository;
this.tutorialGroupNotificationRepository = tutorialGroupNotificationRepository;
this.tutorialGroupChannelManagementService = tutorialGroupChannelManagementService;
- this.prerequisiteRepository = prerequisiteRepository;
- this.competencyRelationRepository = competencyRelationRepository;
+ this.prerequisitesApi = prerequisitesApi;
+ this.competencyRelationApi = competencyRelationApi;
this.buildJobRepository = buildJobRepository;
this.postRepository = postRepository;
this.answerPostRepository = answerPostRepository;
@@ -343,7 +344,7 @@ public void fetchPlagiarismCasesForCourseExercises(Set exercises, Long
* @param user the user entity
* @return the course including exercises, lectures, exams, competencies and tutorial groups (filtered for given user)
*/
- public Course findOneWithExercisesAndLecturesAndExamsAndCompetenciesAndTutorialGroupsForUser(Long courseId, User user) {
+ public Course findOneWithExercisesAndLecturesAndExamsAndCompetenciesAndTutorialGroupsAndFaqForUser(Long courseId, User user) {
Course course = courseRepository.findByIdWithLecturesElseThrow(courseId);
// Load exercises with categories separately because this is faster than loading them with lectures and exam above (the query would become too complex)
course.setExercises(exerciseRepository.findByCourseIdWithCategories(course.getId()));
@@ -353,11 +354,14 @@ public Course findOneWithExercisesAndLecturesAndExamsAndCompetenciesAndTutorialG
// TODO: in the future, we only want to know if lectures exist, the actual lectures will be loaded when the user navigates into the lecture
course.setLectures(lectureService.filterVisibleLecturesWithActiveAttachments(course, course.getLectures(), user));
// NOTE: in this call we only want to know if competencies exist in the course, we will load them when the user navigates into them
- course.setNumberOfCompetencies(competencyRepository.countByCourse(course));
+ course.setNumberOfCompetencies(competencyProgressApi.countByCourse(course));
// NOTE: in this call we only want to know if prerequisites exist in the course, we will load them when the user navigates into them
- course.setNumberOfPrerequisites(prerequisiteRepository.countByCourse(course));
+ course.setNumberOfPrerequisites(prerequisitesApi.countByCourse(course));
// NOTE: in this call we only want to know if tutorial groups exist in the course, we will load them when the user navigates into them
course.setNumberOfTutorialGroups(tutorialGroupRepository.countByCourse(course));
+ if (course.isFaqEnabled()) {
+ course.setFaqs(faqRepository.findAllByCourseIdAndFaqState(courseId, FaqState.ACCEPTED));
+ }
if (authCheckService.isOnlyStudentInCourse(course, user)) {
course.setExams(examRepository.filterVisibleExams(course.getExams()));
}
@@ -574,9 +578,9 @@ private void deleteExercisesOfCourse(Course course) {
}
private void deleteCompetenciesOfCourse(Course course) {
- competencyRelationRepository.deleteAllByCourseId(course.getId());
- prerequisiteRepository.deleteAll(course.getPrerequisites());
- competencyRepository.deleteAll(course.getCompetencies());
+ competencyRelationApi.deleteAllByCourseId(course.getId());
+ prerequisitesApi.deleteAll(course.getPrerequisites());
+ competencyProgressApi.deleteAll(course.getCompetencies());
}
private void deleteFaqsOfCourse(Course course) {
@@ -614,7 +618,7 @@ public void enrollUserForCourseOrThrow(User user, Course course) {
authCheckService.checkUserAllowedToEnrollInCourseElseThrow(user, course);
userService.addUserToGroup(user, course.getStudentGroupName());
if (course.getLearningPathsEnabled()) {
- learningPathService.generateLearningPathForUser(course, user);
+ learningPathApi.generateLearningPathForUser(course, user);
}
final var auditEvent = new AuditEvent(user.getLogin(), Constants.ENROLL_IN_COURSE, "course=" + course.getTitle());
auditEventRepository.add(auditEvent);
@@ -647,7 +651,7 @@ public List registerUsersForCourseGroup(Long courseId, List ldapUserService, GuidedTourSettingsRepository guidedTourSettingsRepository, PasswordService passwordService,
Optional optionalVcsUserManagementService, Optional optionalCIUserManagementService,
- InstanceMessageSendService instanceMessageSendService, FileService fileService, ScienceEventRepository scienceEventRepository,
+ InstanceMessageSendService instanceMessageSendService, FileService fileService, ScienceEventApi scienceEventApi,
ParticipationVcsAccessTokenService participationVCSAccessTokenService, SavedPostRepository savedPostRepository) {
this.userCreationService = userCreationService;
this.userRepository = userRepository;
@@ -134,7 +134,7 @@ public UserService(UserCreationService userCreationService, UserRepository userR
this.optionalCIUserManagementService = optionalCIUserManagementService;
this.instanceMessageSendService = instanceMessageSendService;
this.fileService = fileService;
- this.scienceEventRepository = scienceEventRepository;
+ this.scienceEventApi = scienceEventApi;
this.participationVCSAccessTokenService = participationVCSAccessTokenService;
this.savedPostRepository = savedPostRepository;
}
@@ -508,7 +508,7 @@ protected void anonymizeUser(User user) {
clearUserCaches(user);
userRepository.flush();
- scienceEventRepository.renameIdentity(originalLogin, anonymizedLogin);
+ scienceEventApi.renameIdentity(originalLogin, anonymizedLogin);
if (userImageString != null) {
fileService.schedulePathForDeletion(FilePathService.actualPathForPublicPath(URI.create(userImageString)), 0);
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/web/AccountResource.java b/src/main/java/de/tum/cit/aet/artemis/core/web/AccountResource.java
index 997574c76da7..16c94629047c 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/web/AccountResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/web/AccountResource.java
@@ -2,19 +2,15 @@
import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
-import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.Path;
-import java.security.GeneralSecurityException;
-import java.security.PublicKey;
import java.time.ZonedDateTime;
import java.util.Optional;
import jakarta.validation.Valid;
import jakarta.ws.rs.BadRequestException;
-import org.apache.sshd.common.config.keys.AuthorizedKeyEntry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
@@ -45,7 +41,6 @@
import de.tum.cit.aet.artemis.core.service.user.UserCreationService;
import de.tum.cit.aet.artemis.core.service.user.UserService;
import de.tum.cit.aet.artemis.programming.service.localvc.LocalVCPersonalAccessTokenManagementService;
-import de.tum.cit.aet.artemis.programming.service.localvc.ssh.HashUtils;
/**
* REST controller for managing the current user's account.
@@ -128,50 +123,6 @@ public ResponseEntity changePassword(@RequestBody PasswordChangeDTO passwo
return ResponseEntity.ok().build();
}
- /**
- * PUT account/ssh-public-key : sets the ssh public key
- *
- * @param sshPublicKey the ssh public key to set
- *
- * @return the ResponseEntity with status 200 (OK), with status 404 (Not Found), or with status 400 (Bad Request)
- */
- @PutMapping("account/ssh-public-key")
- @EnforceAtLeastStudent
- public ResponseEntity addSshPublicKey(@RequestBody String sshPublicKey) throws GeneralSecurityException, IOException {
-
- User user = userRepository.getUser();
- log.debug("REST request to add SSH key to user {}", user.getLogin());
- // Parse the public key string
- AuthorizedKeyEntry keyEntry;
- try {
- keyEntry = AuthorizedKeyEntry.parseAuthorizedKeyEntry(sshPublicKey);
- }
- catch (IllegalArgumentException e) {
- throw new BadRequestAlertException("Invalid SSH key format", "SSH key", "invalidKeyFormat", true);
- }
- // Extract the PublicKey object
- PublicKey publicKey = keyEntry.resolvePublicKey(null, null, null);
- String keyHash = HashUtils.getSha512Fingerprint(publicKey);
- userRepository.updateUserSshPublicKeyHash(user.getId(), keyHash, sshPublicKey);
- return ResponseEntity.ok().build();
- }
-
- /**
- * PUT account/ssh-public-key : sets the ssh public key
- *
- * @return the ResponseEntity with status 200 (OK), with status 404 (Not Found), or with status 400 (Bad Request)
- */
- @DeleteMapping("account/ssh-public-key")
- @EnforceAtLeastStudent
- public ResponseEntity deleteSshPublicKey() {
- User user = userRepository.getUser();
- log.debug("REST request to remove SSH key of user {}", user.getLogin());
- userRepository.updateUserSshPublicKeyHash(user.getId(), null, null);
-
- log.debug("Successfully deleted SSH key of user {}", user.getLogin());
- return ResponseEntity.ok().build();
- }
-
/**
* PUT account/user-vcs-access-token : creates a vcsAccessToken for a user
*
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/web/CourseResource.java b/src/main/java/de/tum/cit/aet/artemis/core/web/CourseResource.java
index ba364d0c4fb5..2545a6ffb192 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/web/CourseResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/web/CourseResource.java
@@ -66,7 +66,7 @@
import de.tum.cit.aet.artemis.assessment.service.CourseScoreCalculationService;
import de.tum.cit.aet.artemis.assessment.service.GradingScaleService;
import de.tum.cit.aet.artemis.athena.service.AthenaModuleService;
-import de.tum.cit.aet.artemis.atlas.service.learningpath.LearningPathService;
+import de.tum.cit.aet.artemis.atlas.api.LearningPathApi;
import de.tum.cit.aet.artemis.communication.service.ConductAgreementService;
import de.tum.cit.aet.artemis.core.config.Constants;
import de.tum.cit.aet.artemis.core.domain.Course;
@@ -180,7 +180,7 @@ public class CourseResource {
@Value("${artemis.course-archives-path}")
private String courseArchivesDirPath;
- private final LearningPathService learningPathService;
+ private final LearningPathApi learningPathApi;
private final ExamRepository examRepository;
@@ -193,7 +193,7 @@ public CourseResource(UserRepository userRepository, CourseService courseService
TutorParticipationRepository tutorParticipationRepository, SubmissionService submissionService, Optional optionalVcsUserManagementService,
AssessmentDashboardService assessmentDashboardService, ExerciseRepository exerciseRepository, Optional optionalCiUserManagementService,
FileService fileService, TutorialGroupsConfigurationService tutorialGroupsConfigurationService, GradingScaleService gradingScaleService,
- CourseScoreCalculationService courseScoreCalculationService, GradingScaleRepository gradingScaleRepository, LearningPathService learningPathService,
+ CourseScoreCalculationService courseScoreCalculationService, GradingScaleRepository gradingScaleRepository, LearningPathApi learningPathApi,
ConductAgreementService conductAgreementService, Optional athenaModuleService, ExamRepository examRepository, ComplaintService complaintService,
TeamRepository teamRepository) {
this.courseService = courseService;
@@ -213,7 +213,7 @@ public CourseResource(UserRepository userRepository, CourseService courseService
this.gradingScaleService = gradingScaleService;
this.courseScoreCalculationService = courseScoreCalculationService;
this.gradingScaleRepository = gradingScaleRepository;
- this.learningPathService = learningPathService;
+ this.learningPathApi = learningPathApi;
this.conductAgreementService = conductAgreementService;
this.athenaModuleService = athenaModuleService;
this.examRepository = examRepository;
@@ -335,7 +335,7 @@ else if (courseUpdate.getCourseIcon() == null && existingCourse.getCourseIcon()
// if learning paths got enabled, generate learning paths for students
if (existingCourse.getLearningPathsEnabled() != courseUpdate.getLearningPathsEnabled() && courseUpdate.getLearningPathsEnabled()) {
Course courseWithCompetencies = courseRepository.findWithEagerCompetenciesAndPrerequisitesByIdElseThrow(result.getId());
- learningPathService.generateLearningPaths(courseWithCompetencies);
+ learningPathApi.generateLearningPaths(courseWithCompetencies);
}
// if access to restricted athena modules got disabled for the course, we need to set all exercises that use restricted modules to null
@@ -589,7 +589,7 @@ public ResponseEntity getCourseForDashboard(@PathVariable
log.debug("REST request to get one course {} with exams, lectures, exercises, participations, submissions and results, etc.", courseId);
User user = userRepository.getUserWithGroupsAndAuthorities();
- Course course = courseService.findOneWithExercisesAndLecturesAndExamsAndCompetenciesAndTutorialGroupsForUser(courseId, user);
+ Course course = courseService.findOneWithExercisesAndLecturesAndExamsAndCompetenciesAndTutorialGroupsAndFaqForUser(courseId, user);
log.debug("courseService.findOneWithExercisesAndLecturesAndExamsAndCompetenciesAndTutorialGroupsForUser done");
if (!authCheckService.isAtLeastStudentInCourse(course, user)) {
// user might be allowed to enroll in the course
@@ -1244,7 +1244,7 @@ public ResponseEntity addUserToCourseGroup(String userLogin, User instruct
courseService.addUserToGroup(userToAddToGroup.get(), group);
if (role == Role.STUDENT && course.getLearningPathsEnabled()) {
Course courseWithCompetencies = courseRepository.findWithEagerCompetenciesAndPrerequisitesByIdElseThrow(course.getId());
- learningPathService.generateLearningPathForUser(courseWithCompetencies, userToAddToGroup.get());
+ learningPathApi.generateLearningPathForUser(courseWithCompetencies, userToAddToGroup.get());
}
return ResponseEntity.ok().body(null);
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/core/web/open/PublicAccountResource.java b/src/main/java/de/tum/cit/aet/artemis/core/web/open/PublicAccountResource.java
index bd673ece51d4..543ad85964da 100644
--- a/src/main/java/de/tum/cit/aet/artemis/core/web/open/PublicAccountResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/core/web/open/PublicAccountResource.java
@@ -166,8 +166,6 @@ public ResponseEntity getAccount() {
// we set this value on purpose here: the user can only fetch their own information, make the token available for constructing the token-based clone-URL
userDTO.setVcsAccessToken(user.getVcsAccessToken());
userDTO.setVcsAccessTokenExpiryDate(user.getVcsAccessTokenExpiryDate());
- userDTO.setSshPublicKey(user.getSshPublicKey());
- userDTO.setSshKeyHash(user.getSshPublicKeyHash());
log.info("GET /account {} took {}ms", user.getLogin(), System.currentTimeMillis() - start);
return ResponseEntity.ok(userDTO);
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseDeletionService.java b/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseDeletionService.java
index 36b7e99fedd0..fd80e0a00fb5 100644
--- a/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseDeletionService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseDeletionService.java
@@ -16,8 +16,8 @@
import de.tum.cit.aet.artemis.assessment.repository.TutorParticipationRepository;
import de.tum.cit.aet.artemis.assessment.service.ExampleSubmissionService;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyProgressApi;
import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyExerciseLink;
-import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyProgressService;
import de.tum.cit.aet.artemis.communication.domain.conversation.Channel;
import de.tum.cit.aet.artemis.communication.repository.conversation.ChannelRepository;
import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
@@ -78,7 +78,7 @@ public class ExerciseDeletionService {
private final ChannelService channelService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final Optional irisSettingsService;
@@ -86,8 +86,7 @@ public ExerciseDeletionService(ExerciseRepository exerciseRepository, ExerciseUn
ProgrammingExerciseService programmingExerciseService, ModelingExerciseService modelingExerciseService, QuizExerciseService quizExerciseService,
TutorParticipationRepository tutorParticipationRepository, ExampleSubmissionService exampleSubmissionService, StudentExamRepository studentExamRepository,
LectureUnitService lectureUnitService, PlagiarismResultRepository plagiarismResultRepository, TextExerciseService textExerciseService,
- ChannelRepository channelRepository, ChannelService channelService, CompetencyProgressService competencyProgressService,
- Optional irisSettingsService) {
+ ChannelRepository channelRepository, ChannelService channelService, CompetencyProgressApi competencyProgressApi, Optional irisSettingsService) {
this.exerciseRepository = exerciseRepository;
this.participationService = participationService;
this.programmingExerciseService = programmingExerciseService;
@@ -102,7 +101,7 @@ public ExerciseDeletionService(ExerciseRepository exerciseRepository, ExerciseUn
this.textExerciseService = textExerciseService;
this.channelRepository = channelRepository;
this.channelService = channelService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.irisSettingsService = irisSettingsService;
}
@@ -215,7 +214,7 @@ public void delete(long exerciseId, boolean deleteStudentReposBuildPlans, boolea
exerciseRepository.delete(exercise);
}
- competencyLinks.stream().map(CompetencyExerciseLink::getCompetency).forEach(competencyProgressService::updateProgressByCompetencyAsync);
+ competencyLinks.stream().map(CompetencyExerciseLink::getCompetency).forEach(competencyProgressApi::updateProgressByCompetencyAsync);
}
/**
diff --git a/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseService.java b/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseService.java
index 0a355a870620..73fce3b0f9f1 100644
--- a/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseService.java
@@ -45,9 +45,9 @@
import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
import de.tum.cit.aet.artemis.assessment.service.RatingService;
import de.tum.cit.aet.artemis.assessment.service.TutorLeaderboardService;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyRelationApi;
import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyExerciseLink;
import de.tum.cit.aet.artemis.atlas.domain.competency.CourseCompetency;
-import de.tum.cit.aet.artemis.atlas.repository.CompetencyExerciseLinkRepository;
import de.tum.cit.aet.artemis.communication.service.notifications.GroupNotificationScheduleService;
import de.tum.cit.aet.artemis.core.config.Constants;
import de.tum.cit.aet.artemis.core.domain.Course;
@@ -130,7 +130,7 @@ public class ExerciseService {
private final GroupNotificationScheduleService groupNotificationScheduleService;
- private final CompetencyExerciseLinkRepository competencyExerciseLinkRepository;
+ private final CompetencyRelationApi competencyRelationApi;
public ExerciseService(ExerciseRepository exerciseRepository, AuthorizationCheckService authCheckService, AuditEventRepository auditEventRepository,
TeamRepository teamRepository, ProgrammingExerciseRepository programmingExerciseRepository, Optional lti13ResourceLaunchRepository,
@@ -139,7 +139,7 @@ public ExerciseService(ExerciseRepository exerciseRepository, AuthorizationCheck
TutorLeaderboardService tutorLeaderboardService, ComplaintResponseRepository complaintResponseRepository, GradingCriterionRepository gradingCriterionRepository,
FeedbackRepository feedbackRepository, RatingService ratingService, ExerciseDateService exerciseDateService, ExampleSubmissionRepository exampleSubmissionRepository,
QuizBatchService quizBatchService, ExamLiveEventsService examLiveEventsService, GroupNotificationScheduleService groupNotificationScheduleService,
- CompetencyExerciseLinkRepository competencyExerciseLinkRepository) {
+ CompetencyRelationApi competencyRelationApi) {
this.exerciseRepository = exerciseRepository;
this.resultRepository = resultRepository;
this.authCheckService = authCheckService;
@@ -162,7 +162,7 @@ public ExerciseService(ExerciseRepository exerciseRepository, AuthorizationCheck
this.quizBatchService = quizBatchService;
this.examLiveEventsService = examLiveEventsService;
this.groupNotificationScheduleService = groupNotificationScheduleService;
- this.competencyExerciseLinkRepository = competencyExerciseLinkRepository;
+ this.competencyRelationApi = competencyRelationApi;
}
/**
@@ -773,7 +773,7 @@ public List getFeedbackToBeDeletedAfterGradingInstructionUpdate(boolea
* @param competency competency to remove
*/
public void removeCompetency(@NotNull Set exerciseLinks, @NotNull CourseCompetency competency) {
- competencyExerciseLinkRepository.deleteAll(exerciseLinks);
+ competencyRelationApi.deleteAllExerciseLinks(exerciseLinks);
competency.getExerciseLinks().removeAll(exerciseLinks);
}
@@ -815,7 +815,7 @@ public T saveWithCompetencyLinks(T exercise, Function
if (Hibernate.isInitialized(links) && !links.isEmpty()) {
savedExercise.setCompetencyLinks(links);
reconnectCompetencyExerciseLinks(savedExercise);
- savedExercise.setCompetencyLinks(new HashSet<>(competencyExerciseLinkRepository.saveAll(links)));
+ savedExercise.setCompetencyLinks(new HashSet<>(competencyRelationApi.saveAllExerciseLinks(links)));
}
return savedExercise;
diff --git a/src/main/java/de/tum/cit/aet/artemis/exercise/service/ParticipationService.java b/src/main/java/de/tum/cit/aet/artemis/exercise/service/ParticipationService.java
index 9074ad8ec1f8..a8c4d3507813 100644
--- a/src/main/java/de/tum/cit/aet/artemis/exercise/service/ParticipationService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/exercise/service/ParticipationService.java
@@ -24,7 +24,7 @@
import de.tum.cit.aet.artemis.assessment.repository.StudentScoreRepository;
import de.tum.cit.aet.artemis.assessment.repository.TeamScoreRepository;
import de.tum.cit.aet.artemis.assessment.service.ResultService;
-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.exception.ContinuousIntegrationException;
import de.tum.cit.aet.artemis.core.exception.EntityNotFoundException;
@@ -109,7 +109,7 @@ public class ParticipationService {
private final ParticipationVcsAccessTokenService participationVCSAccessTokenService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
public ParticipationService(GitService gitService, Optional continuousIntegrationService, Optional versionControlService,
BuildLogEntryService buildLogEntryService, ParticipationRepository participationRepository, StudentParticipationRepository studentParticipationRepository,
@@ -118,7 +118,7 @@ public ParticipationService(GitService gitService, Optional localCISharedBuildJobQueueService, ProfileService profileService,
- ParticipationVcsAccessTokenService participationVCSAccessTokenService, CompetencyProgressService competencyProgressService) {
+ ParticipationVcsAccessTokenService participationVCSAccessTokenService, CompetencyProgressApi competencyProgressApi) {
this.gitService = gitService;
this.continuousIntegrationService = continuousIntegrationService;
this.versionControlService = versionControlService;
@@ -139,7 +139,7 @@ public ParticipationService(GitService gitService, Optional createFileUploadExercise(@RequestBody
channelService.createExerciseChannel(result, Optional.ofNullable(fileUploadExercise.getChannelName()));
groupNotificationScheduleService.checkNotificationsForNewExerciseAsync(fileUploadExercise);
- competencyProgressService.updateProgressByLearningObjectAsync(result);
+ competencyProgressApi.updateProgressByLearningObjectAsync(result);
return ResponseEntity.created(new URI("/api/file-upload-exercises/" + result.getId())).body(result);
}
@@ -287,7 +287,7 @@ public ResponseEntity updateFileUploadExercise(@RequestBody
participationRepository.removeIndividualDueDatesIfBeforeDueDate(updatedExercise, fileUploadExerciseBeforeUpdate.getDueDate());
exerciseService.notifyAboutExerciseChanges(fileUploadExerciseBeforeUpdate, updatedExercise, notificationText);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(fileUploadExerciseBeforeUpdate, Optional.of(fileUploadExercise));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(fileUploadExerciseBeforeUpdate, Optional.of(fileUploadExercise));
return ResponseEntity.ok(updatedExercise);
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java
new file mode 100644
index 000000000000..6ed226ce4400
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java
@@ -0,0 +1,5 @@
+package de.tum.cit.aet.artemis.iris.dto;
+
+public enum IngestionState {
+ NOT_STARTED, IN_PROGRESS, PARTIALLY_INGESTED, DONE, ERROR
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java
new file mode 100644
index 000000000000..54d5a04bd3cf
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java
@@ -0,0 +1,4 @@
+package de.tum.cit.aet.artemis.iris.dto;
+
+public record IngestionStateResponseDTO(IngestionState state) {
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java
index f41de6b6c97d..911428b5b176 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java
@@ -2,6 +2,8 @@
import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;
@@ -20,11 +22,15 @@
import com.fasterxml.jackson.databind.ObjectMapper;
import de.tum.cit.aet.artemis.iris.domain.settings.IrisSubSettingsType;
+import de.tum.cit.aet.artemis.iris.dto.IngestionState;
+import de.tum.cit.aet.artemis.iris.dto.IngestionStateResponseDTO;
import de.tum.cit.aet.artemis.iris.exception.IrisException;
import de.tum.cit.aet.artemis.iris.exception.IrisForbiddenException;
import de.tum.cit.aet.artemis.iris.exception.IrisInternalPyrisErrorException;
import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisVariantDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureDeletionExecutionDTO;
import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureIngestionExecutionDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.job.IngestionWebhookJob;
import de.tum.cit.aet.artemis.iris.web.open.PublicPyrisStatusUpdateResource;
/**
@@ -42,12 +48,19 @@ public class PyrisConnectorService {
private final ObjectMapper objectMapper;
+ private final PyrisJobService pyrisJobService;
+
+ @Value("${server.url}")
+ private String artemisBaseUrl;
+
@Value("${artemis.iris.url}")
private String pyrisUrl;
- public PyrisConnectorService(@Qualifier("pyrisRestTemplate") RestTemplate restTemplate, MappingJackson2HttpMessageConverter springMvcJacksonConverter) {
+ public PyrisConnectorService(@Qualifier("pyrisRestTemplate") RestTemplate restTemplate, MappingJackson2HttpMessageConverter springMvcJacksonConverter,
+ PyrisJobService pyrisJobService) {
this.restTemplate = restTemplate;
this.objectMapper = springMvcJacksonConverter.getObjectMapper();
+ this.pyrisJobService = pyrisJobService;
}
/**
@@ -97,15 +110,63 @@ public void executePipeline(String feature, String variant, Object executionDTO)
* @param variant The variant of the feature to execute
* @param executionDTO The DTO sent as a body for the execution
*/
- public void executeLectureWebhook(String variant, PyrisWebhookLectureIngestionExecutionDTO executionDTO) {
+ public void executeLectureAddtionWebhook(String variant, PyrisWebhookLectureIngestionExecutionDTO executionDTO) {
var endpoint = "/api/v1/webhooks/lectures/" + variant;
try {
restTemplate.postForEntity(pyrisUrl + endpoint, objectMapper.valueToTree(executionDTO), Void.class);
}
+ catch (HttpStatusCodeException e) {
+ log.error("Failed to send lecture unit {} to Pyris: {}", executionDTO.pyrisLectureUnit().lectureUnitId(), e.getMessage());
+ throw toIrisException(e);
+ }
+ catch (RestClientException | IllegalArgumentException e) {
+ log.error("Failed to send lecture unit {} to Pyris: {}", executionDTO.pyrisLectureUnit().lectureUnitId(), e.getMessage());
+ throw new PyrisConnectorException("Could not fetch response from Pyris");
+ }
+ }
+
+ /**
+ * Retrieves the ingestion state of the lecture unit specified by retrieving the ingestion state from the vector database in Pyris.
+ *
+ * @param courseId id of the course
+ * @param lectureId id of the lecture
+ * @param lectureUnitId id of the lectureUnit to check in the Pyris vector database
+ * @return The ingestion state of the lecture Unit
+ *
+ */
+ IngestionState getLectureUnitIngestionState(long courseId, long lectureId, long lectureUnitId) {
+ try {
+ String encodedBaseUrl = URLEncoder.encode(artemisBaseUrl, StandardCharsets.UTF_8);
+ String url = pyrisUrl + "/api/v1/courses/" + courseId + "/lectures/" + lectureId + "/lectureUnits/" + lectureUnitId + "/ingestion-state?base_url=" + encodedBaseUrl;
+ IngestionStateResponseDTO response = restTemplate.getForObject(url, IngestionStateResponseDTO.class);
+ IngestionState state = response.state();
+ if (state != IngestionState.DONE) {
+ if (pyrisJobService.currentJobs().stream().filter(job -> job instanceof IngestionWebhookJob).map(job -> (IngestionWebhookJob) job)
+ .anyMatch(ingestionJob -> ingestionJob.courseId() == courseId && ingestionJob.lectureId() == lectureId && ingestionJob.lectureUnitId() == lectureUnitId)) {
+ return IngestionState.IN_PROGRESS;
+ }
+ }
+ return state;
+ }
+ catch (RestClientException | IllegalArgumentException e) {
+ log.error("Error fetching ingestion state for lecture {}, lecture unit {}", lectureId, lectureUnitId, e);
+ throw new PyrisConnectorException("Error fetching ingestion state for lecture unit" + lectureUnitId);
+ }
+ }
+
+ /**
+ * Executes a webhook and send lectures to the webhook with the given variant
+ *
+ * @param executionDTO The DTO sent as a body for the execution
+ */
+ public void executeLectureDeletionWebhook(PyrisWebhookLectureDeletionExecutionDTO executionDTO) {
+ var endpoint = "/api/v1/webhooks/lectures/delete";
+ try {
+ restTemplate.postForEntity(pyrisUrl + endpoint, objectMapper.valueToTree(executionDTO), Void.class);
+ }
catch (HttpStatusCodeException e) {
log.error("Failed to send lectures to Pyris", e);
throw toIrisException(e);
- // TODO : add error ingestion UI.
}
catch (RestClientException | IllegalArgumentException e) {
log.error("Failed to send lectures to Pyris", e);
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java
index 16e8969bc463..46c0dd7547cd 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java
@@ -3,6 +3,7 @@
import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
import java.security.SecureRandom;
+import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
@@ -93,11 +94,14 @@ public String addCourseChatJob(Long courseId, Long sessionId) {
/**
* Adds a new ingestion webhook job to the job map with a timeout.
*
+ * @param courseId the ID of the course associated with the webhook job
+ * @param lectureId the ID of the lecture associated with the webhook job
+ * @param lectureUnitId the ID of the lecture unit associated with the webhook job
* @return a unique token identifying the created webhook job
*/
- public String addIngestionWebhookJob() {
+ public String addIngestionWebhookJob(long courseId, long lectureId, long lectureUnitId) {
var token = generateJobIdToken();
- var job = new IngestionWebhookJob(token);
+ var job = new IngestionWebhookJob(token, courseId, lectureId, lectureUnitId);
long timeoutWebhookJob = 60;
TimeUnit unitWebhookJob = TimeUnit.MINUTES;
jobMap.put(token, job, timeoutWebhookJob, unitWebhookJob);
@@ -122,6 +126,15 @@ public void updateJob(PyrisJob job) {
jobMap.put(job.jobId(), job);
}
+ /**
+ * Get all current jobs.
+ *
+ * @return the all current jobs
+ */
+ public Collection currentJobs() {
+ return jobMap.values();
+ }
+
/**
* Get the job of a token.
*
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisPipelineService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisPipelineService.java
index 08861c06a773..c8851341e29e 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisPipelineService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisPipelineService.java
@@ -17,13 +17,13 @@
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
+import de.tum.cit.aet.artemis.atlas.api.LearningMetricsApi;
import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyJol;
import de.tum.cit.aet.artemis.atlas.dto.CompetencyJolDTO;
import de.tum.cit.aet.artemis.core.domain.Course;
import de.tum.cit.aet.artemis.core.repository.CourseRepository;
import de.tum.cit.aet.artemis.exercise.domain.participation.StudentParticipation;
import de.tum.cit.aet.artemis.exercise.repository.StudentParticipationRepository;
-import de.tum.cit.aet.artemis.exercise.service.LearningMetricsService;
import de.tum.cit.aet.artemis.iris.domain.session.IrisCourseChatSession;
import de.tum.cit.aet.artemis.iris.domain.session.IrisExerciseChatSession;
import de.tum.cit.aet.artemis.iris.exception.IrisException;
@@ -61,20 +61,20 @@ public class PyrisPipelineService {
private final StudentParticipationRepository studentParticipationRepository;
- private final LearningMetricsService learningMetricsService;
+ private final LearningMetricsApi learningMetricsApi;
@Value("${server.url}")
private String artemisBaseUrl;
public PyrisPipelineService(PyrisConnectorService pyrisConnectorService, PyrisJobService pyrisJobService, PyrisDTOService pyrisDTOService,
- IrisChatWebsocketService irisChatWebsocketService, CourseRepository courseRepository, LearningMetricsService learningMetricsService,
+ IrisChatWebsocketService irisChatWebsocketService, CourseRepository courseRepository, LearningMetricsApi learningMetricsApi,
StudentParticipationRepository studentParticipationRepository) {
this.pyrisConnectorService = pyrisConnectorService;
this.pyrisJobService = pyrisJobService;
this.pyrisDTOService = pyrisDTOService;
this.irisChatWebsocketService = irisChatWebsocketService;
this.courseRepository = courseRepository;
- this.learningMetricsService = learningMetricsService;
+ this.learningMetricsApi = learningMetricsApi;
this.studentParticipationRepository = studentParticipationRepository;
}
@@ -186,7 +186,7 @@ public void executeCourseChatPipeline(String variant, IrisCourseChatSession sess
var fullCourse = loadCourseWithParticipationOfStudent(courseId, studentId);
return new PyrisCourseChatPipelineExecutionDTO(
PyrisExtendedCourseDTO.of(fullCourse),
- learningMetricsService.getStudentCourseMetrics(session.getUser().getId(), courseId),
+ learningMetricsApi.getStudentCourseMetrics(session.getUser().getId(), courseId),
competencyJol == null ? null : CompetencyJolDTO.of(competencyJol),
pyrisDTOService.toPyrisMessageDTOList(session.getMessages()),
new PyrisUserDTO(session.getUser()),
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java
index cdd398e5c683..ad1a63e60c58 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java
@@ -126,14 +126,12 @@ private void removeJobIfTerminatedElseUpdate(List stages, PyrisJo
}
/**
- * Handles the status update of a lecture ingestion job and logs the results for now => will change later
- * TODO: Update this method to handle changes beyond logging
+ * Handles the status update of a lecture ingestion job.
*
* @param job the job that is updated
* @param statusUpdate the status update
*/
public void handleStatusUpdate(IngestionWebhookJob job, PyrisLectureIngestionStatusUpdateDTO statusUpdate) {
- statusUpdate.stages().forEach(stage -> log.info(stage.name() + ":" + stage.message()));
removeJobIfTerminatedElseUpdate(statusUpdate.stages(), job);
}
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java
index 03f58ad5ba14..2138b8789b0b 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java
@@ -9,6 +9,9 @@
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -17,16 +20,23 @@
import org.springframework.stereotype.Service;
import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.domain.DomainObject;
import de.tum.cit.aet.artemis.core.service.FilePathService;
import de.tum.cit.aet.artemis.iris.domain.settings.IrisCourseSettings;
+import de.tum.cit.aet.artemis.iris.dto.IngestionState;
import de.tum.cit.aet.artemis.iris.exception.IrisInternalPyrisErrorException;
import de.tum.cit.aet.artemis.iris.repository.IrisSettingsRepository;
import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisPipelineExecutionSettingsDTO;
import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisLectureUnitWebhookDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureDeletionExecutionDTO;
import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureIngestionExecutionDTO;
import de.tum.cit.aet.artemis.iris.service.settings.IrisSettingsService;
import de.tum.cit.aet.artemis.lecture.domain.AttachmentType;
import de.tum.cit.aet.artemis.lecture.domain.AttachmentUnit;
+import de.tum.cit.aet.artemis.lecture.domain.Lecture;
+import de.tum.cit.aet.artemis.lecture.domain.LectureUnit;
+import de.tum.cit.aet.artemis.lecture.repository.LectureRepository;
+import de.tum.cit.aet.artemis.lecture.repository.LectureUnitRepository;
@Service
@Profile(PROFILE_IRIS)
@@ -42,15 +52,21 @@ public class PyrisWebhookService {
private final IrisSettingsRepository irisSettingsRepository;
+ private final LectureUnitRepository lectureUnitRepository;
+
+ private final LectureRepository lectureRepository;
+
@Value("${server.url}")
private String artemisBaseUrl;
public PyrisWebhookService(PyrisConnectorService pyrisConnectorService, PyrisJobService pyrisJobService, IrisSettingsService irisSettingsService,
- IrisSettingsRepository irisSettingsRepository) {
+ IrisSettingsRepository irisSettingsRepository, LectureUnitRepository lectureUnitRepository, LectureRepository lectureRepository) {
this.pyrisConnectorService = pyrisConnectorService;
this.pyrisJobService = pyrisJobService;
this.irisSettingsService = irisSettingsService;
this.irisSettingsRepository = irisSettingsRepository;
+ this.lectureUnitRepository = lectureUnitRepository;
+ this.lectureRepository = lectureRepository;
}
private boolean lectureIngestionEnabled(Course course) {
@@ -78,15 +94,15 @@ private PyrisLectureUnitWebhookDTO processAttachmentForUpdate(AttachmentUnit att
String courseTitle = attachmentUnit.getLecture().getCourse().getTitle();
String courseDescription = attachmentUnit.getLecture().getCourse().getDescription() == null ? "" : attachmentUnit.getLecture().getCourse().getDescription();
String base64EncodedPdf = attachmentToBase64(attachmentUnit);
- return new PyrisLectureUnitWebhookDTO(true, artemisBaseUrl, base64EncodedPdf, lectureUnitId, lectureUnitName, lectureId, lectureTitle, courseId, courseTitle,
- courseDescription);
+ lectureUnitRepository.save(attachmentUnit);
+ return new PyrisLectureUnitWebhookDTO(base64EncodedPdf, lectureUnitId, lectureUnitName, lectureId, lectureTitle, courseId, courseTitle, courseDescription);
}
private PyrisLectureUnitWebhookDTO processAttachmentForDeletion(AttachmentUnit attachmentUnit) {
Long lectureUnitId = attachmentUnit.getId();
Long lectureId = attachmentUnit.getLecture().getId();
Long courseId = attachmentUnit.getLecture().getCourse().getId();
- return new PyrisLectureUnitWebhookDTO(false, artemisBaseUrl, "", lectureUnitId, "", lectureId, "", courseId, "", "");
+ return new PyrisLectureUnitWebhookDTO("", lectureUnitId, "", lectureId, "", courseId, "", "");
}
/**
@@ -94,15 +110,15 @@ private PyrisLectureUnitWebhookDTO processAttachmentForDeletion(AttachmentUnit a
*
* @param courseId Id of the course where the attachment is added
* @param newAttachmentUnits the new attachment Units to be sent to pyris for ingestion
- * @return true if the units were sent to pyris
*/
- public boolean autoUpdateAttachmentUnitsInPyris(Long courseId, List newAttachmentUnits) {
+ public void autoUpdateAttachmentUnitsInPyris(Long courseId, List newAttachmentUnits) {
IrisCourseSettings courseSettings = irisSettingsRepository.findCourseSettings(courseId).isPresent() ? irisSettingsRepository.findCourseSettings(courseId).get() : null;
if (courseSettings != null && courseSettings.getIrisLectureIngestionSettings() != null && courseSettings.getIrisLectureIngestionSettings().isEnabled()
&& courseSettings.getIrisLectureIngestionSettings().getAutoIngestOnLectureAttachmentUpload()) {
- return addLectureUnitsToPyrisDB(newAttachmentUnits) != null;
+ for (AttachmentUnit attachmentUnit : newAttachmentUnits) {
+ addLectureUnitToPyrisDB(attachmentUnit);
+ }
}
- return false;
}
/**
@@ -112,44 +128,29 @@ public boolean autoUpdateAttachmentUnitsInPyris(Long courseId, List attachmentUnits) {
- try {
- List toUpdateAttachmentUnits = new ArrayList<>();
- attachmentUnits.stream().filter(unit -> unit.getAttachment().getAttachmentType() == AttachmentType.FILE && unit.getAttachment().getLink().endsWith(".pdf"))
- .forEach(unit -> {
- toUpdateAttachmentUnits.add(processAttachmentForDeletion(unit));
- });
- if (!toUpdateAttachmentUnits.isEmpty()) {
- return executeLectureWebhook(toUpdateAttachmentUnits);
- }
- }
- catch (Exception e) {
- log.error(e.getMessage());
+ List toUpdateAttachmentUnits = new ArrayList<>();
+ attachmentUnits.stream().filter(unit -> unit.getAttachment().getAttachmentType() == AttachmentType.FILE && unit.getAttachment().getLink().endsWith(".pdf"))
+ .forEach(unit -> {
+ toUpdateAttachmentUnits.add(processAttachmentForDeletion(unit));
+ });
+ if (!toUpdateAttachmentUnits.isEmpty()) {
+ return executeLectureDeletionWebhook(toUpdateAttachmentUnits);
}
return null;
}
/**
- * adds the lectures to the vector database on pyris
+ * adds the lectures to the vector database in Pyris
*
- * @param attachmentUnits The attachmentUnit that got Updated / erased
- * @return jobToken if the job was created
+ * @param attachmentUnit The attachmentUnit that got Updated
+ * @return jobToken if the job was created else null
*/
- public String addLectureUnitsToPyrisDB(List attachmentUnits) {
- if (!lectureIngestionEnabled(attachmentUnits.getFirst().getLecture().getCourse())) {
- return null;
- }
- try {
- List toUpdateAttachmentUnits = new ArrayList<>();
- attachmentUnits.stream().filter(unit -> unit.getAttachment().getAttachmentType() == AttachmentType.FILE && unit.getAttachment().getLink().endsWith(".pdf"))
- .forEach(unit -> {
- toUpdateAttachmentUnits.add(processAttachmentForUpdate(unit));
- });
- if (!toUpdateAttachmentUnits.isEmpty()) {
- return executeLectureWebhook(toUpdateAttachmentUnits);
+ public String addLectureUnitToPyrisDB(AttachmentUnit attachmentUnit) {
+ if (lectureIngestionEnabled(attachmentUnit.getLecture().getCourse())) {
+ if (attachmentUnit.getAttachment().getAttachmentType() == AttachmentType.FILE && attachmentUnit.getAttachment().getLink().endsWith(".pdf")) {
+ return executeLectureAdditionWebhook(processAttachmentForUpdate(attachmentUnit));
}
- }
- catch (Exception e) {
- log.error(e.getMessage());
+ log.error("Attachment {} is not a file or is not of type pdf thus it will not be sent to Pyris", attachmentUnit.getId());
}
return null;
}
@@ -157,15 +158,85 @@ public String addLectureUnitsToPyrisDB(List attachmentUnits) {
/**
* executes executeLectureWebhook add or delete lectures from to the vector database on pyris
*
- * @param toUpdateAttachmentUnits The attachmentUnit that are goin to be Updated / deleted
+ * @param toUpdateAttachmentUnits The attachmentUnit that are goin to be deleted
* @return jobToken if the job was created
*/
- private String executeLectureWebhook(List toUpdateAttachmentUnits) {
- String jobToken = pyrisJobService.addIngestionWebhookJob();
+ private String executeLectureDeletionWebhook(List toUpdateAttachmentUnits) {
+ String jobToken = pyrisJobService.addIngestionWebhookJob(0, 0, 0);
PyrisPipelineExecutionSettingsDTO settingsDTO = new PyrisPipelineExecutionSettingsDTO(jobToken, List.of(), artemisBaseUrl);
- PyrisWebhookLectureIngestionExecutionDTO executionDTO = new PyrisWebhookLectureIngestionExecutionDTO(toUpdateAttachmentUnits, settingsDTO, List.of());
- pyrisConnectorService.executeLectureWebhook("fullIngestion", executionDTO);
+ PyrisWebhookLectureDeletionExecutionDTO executionDTO = new PyrisWebhookLectureDeletionExecutionDTO(toUpdateAttachmentUnits, settingsDTO, List.of());
+ pyrisConnectorService.executeLectureDeletionWebhook(executionDTO);
return jobToken;
}
+ /**
+ * executes executeLectureAdditionWebhook add lecture from to the vector database on pyris
+ *
+ * @param toUpdateAttachmentUnit The attachmentUnit that are going to be Updated
+ * @return jobToken if the job was created
+ */
+ private String executeLectureAdditionWebhook(PyrisLectureUnitWebhookDTO toUpdateAttachmentUnit) {
+ String jobToken = pyrisJobService.addIngestionWebhookJob(toUpdateAttachmentUnit.courseId(), toUpdateAttachmentUnit.lectureId(), toUpdateAttachmentUnit.lectureUnitId());
+ PyrisPipelineExecutionSettingsDTO settingsDTO = new PyrisPipelineExecutionSettingsDTO(jobToken, List.of(), artemisBaseUrl);
+ PyrisWebhookLectureIngestionExecutionDTO executionDTO = new PyrisWebhookLectureIngestionExecutionDTO(toUpdateAttachmentUnit, settingsDTO, List.of());
+ pyrisConnectorService.executeLectureAddtionWebhook("fullIngestion", executionDTO);
+ return jobToken;
+ }
+
+ /**
+ * uses getLectureUnitIngestionState for all lecture units and then determines the IngestionState of the lecture
+ *
+ * @param courseId id of the course
+ * @return The ingestion state of the lecture
+ *
+ */
+ public Map getLecturesIngestionState(long courseId) {
+ Set lectures = lectureRepository.findAllByCourseId(courseId);
+ return lectures.stream().collect(Collectors.toMap(DomainObject::getId, lecture -> getLectureIngestionState(courseId, lecture.getId())));
+
+ }
+
+ /**
+ * uses getLectureUnitIngestionState for all lecture units and then determines the IngestionState of the lecture
+ *
+ * @param courseId id of the course
+ * @param lectureId id of the lecture
+ * @return The ingestion state of the lecture
+ *
+ */
+ private IngestionState getLectureIngestionState(long courseId, long lectureId) {
+ Map states = getLectureUnitsIngestionState(courseId, lectureId);
+
+ if (states.values().stream().allMatch(state -> state == IngestionState.DONE)) {
+ return IngestionState.DONE;
+ }
+
+ if (states.values().stream().allMatch(state -> state == IngestionState.NOT_STARTED)) {
+ return IngestionState.NOT_STARTED;
+ }
+
+ if (states.values().stream().allMatch(state -> state == IngestionState.ERROR)) {
+ return IngestionState.ERROR;
+ }
+
+ if (states.containsValue(IngestionState.DONE) || states.containsValue(IngestionState.IN_PROGRESS)) {
+ return IngestionState.PARTIALLY_INGESTED;
+ }
+
+ return IngestionState.NOT_STARTED;
+ }
+
+ /**
+ * uses send an api call to get all the ingestion states of the lecture units of one lecture in Pyris
+ *
+ * @param courseId id of the course
+ * @param lectureId id of the lecture
+ * @return The ingestion state of the lecture Unit
+ */
+ public Map getLectureUnitsIngestionState(long courseId, long lectureId) {
+ List lectureunits = lectureRepository.findByIdWithLectureUnitsElseThrow(lectureId).getLectureUnits();
+ return lectureunits.stream().filter(lectureUnit -> lectureUnit instanceof AttachmentUnit)
+ .collect(Collectors.toMap(DomainObject::getId, unit -> pyrisConnectorService.getLectureUnitIngestionState(courseId, lectureId, unit.getId())));
+ }
+
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java
index b49aafefac79..56582b2e1ac2 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java
@@ -7,5 +7,5 @@
import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
@JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record PyrisLectureIngestionStatusUpdateDTO(String result, List stages) {
+public record PyrisLectureIngestionStatusUpdateDTO(String result, List stages, long jobId) {
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java
index 1bef48d26c2e..b2f2cde1019d 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java
@@ -8,6 +8,6 @@
* providing necessary details such as lecture and course identifiers, names, and descriptions.
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record PyrisLectureUnitWebhookDTO(Boolean toUpdate, String artemisBaseUrl, String pdfFile, Long lectureUnitId, String lectureUnitName, Long lectureId, String lectureName,
- Long courseId, String courseName, String courseDescription) {
+public record PyrisLectureUnitWebhookDTO(String pdfFile, long lectureUnitId, String lectureUnitName, long lectureId, String lectureName, long courseId, String courseName,
+ String courseDescription) {
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java
new file mode 100644
index 000000000000..45f3bb809f01
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java
@@ -0,0 +1,13 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook;
+
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisPipelineExecutionSettingsDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
+
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record PyrisWebhookLectureDeletionExecutionDTO(List pyrisLectureUnits, PyrisPipelineExecutionSettingsDTO settings,
+ List initialStages) {
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java
index 4ef052e91de3..d1eb256e27b0 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java
@@ -8,6 +8,5 @@
import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
@JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record PyrisWebhookLectureIngestionExecutionDTO(List pyrisLectureUnitWebhookDTOS, PyrisPipelineExecutionSettingsDTO settings,
- List initialStages) {
+public record PyrisWebhookLectureIngestionExecutionDTO(PyrisLectureUnitWebhookDTO pyrisLectureUnit, PyrisPipelineExecutionSettingsDTO settings, List initialStages) {
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java
index e29bb966520f..5dbfe0955520 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java
@@ -7,7 +7,7 @@
* An implementation of a PyrisJob for Lecture Ingestion in Pyris.
* This job is used to reference the details of then Ingestion when Pyris sends a status update.
*/
-public record IngestionWebhookJob(String jobId) implements PyrisJob {
+public record IngestionWebhookJob(String jobId, long courseId, long lectureId, long lectureUnitId) implements PyrisJob {
@Override
public boolean canAccess(Course course) {
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java b/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java
index 58f40981a861..37e2983e39e0 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java
@@ -2,34 +2,60 @@
import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.boot.actuate.health.Status;
import org.springframework.context.annotation.Profile;
+import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.repository.CourseRepository;
import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.core.security.Role;
import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastStudent;
+import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastInstructorInCourse;
+import de.tum.cit.aet.artemis.core.service.AuthorizationCheckService;
+import de.tum.cit.aet.artemis.iris.dto.IngestionState;
import de.tum.cit.aet.artemis.iris.dto.IrisStatusDTO;
import de.tum.cit.aet.artemis.iris.service.IrisRateLimitService;
+import de.tum.cit.aet.artemis.iris.service.pyris.PyrisConnectorException;
import de.tum.cit.aet.artemis.iris.service.pyris.PyrisHealthIndicator;
+import de.tum.cit.aet.artemis.iris.service.pyris.PyrisWebhookService;
@Profile(PROFILE_IRIS)
@RestController
@RequestMapping("api/iris/")
public class IrisResource {
+ private static final Logger log = LoggerFactory.getLogger(IrisResource.class);
+
protected final UserRepository userRepository;
protected final IrisRateLimitService irisRateLimitService;
protected final PyrisHealthIndicator pyrisHealthIndicator;
- public IrisResource(UserRepository userRepository, PyrisHealthIndicator pyrisHealthIndicator, IrisRateLimitService irisRateLimitService) {
+ private final AuthorizationCheckService authorizationCheckService;
+
+ private final CourseRepository courseRepository;
+
+ private final PyrisWebhookService pyrisWebhookService;
+
+ public IrisResource(UserRepository userRepository, PyrisHealthIndicator pyrisHealthIndicator, IrisRateLimitService irisRateLimitService,
+ AuthorizationCheckService authorizationCheckService, CourseRepository courseRepository, PyrisWebhookService pyrisWebhookService) {
this.userRepository = userRepository;
this.pyrisHealthIndicator = pyrisHealthIndicator;
this.irisRateLimitService = irisRateLimitService;
+ this.authorizationCheckService = authorizationCheckService;
+ this.courseRepository = courseRepository;
+ this.pyrisWebhookService = pyrisWebhookService;
}
/**
@@ -47,4 +73,58 @@ public ResponseEntity getStatus() {
return ResponseEntity.ok(new IrisStatusDTO(health.getStatus() == Status.UP, rateLimitInfo));
}
+ /**
+ * Retrieves the overall ingestion state of a lecture by communicating with Pyris.
+ *
+ *
+ * This method sends a GET request to the external Pyris service to fetch the current ingestion
+ * state of all lectures in a course, identified by its `lectureId`. The ingestion state can be aggregated from
+ * multiple lecture units or can reflect the overall status of the lecture ingestion process.
+ *
+ *
+ * @param courseId the ID of the lecture for which the ingestion state is being requested
+ * @return a {@link ResponseEntity} containing the {@link IngestionState} of the lecture,
+ */
+ @GetMapping("courses/{courseId}/lectures/ingestion-state")
+ @EnforceAtLeastInstructorInCourse
+ public ResponseEntity> getStatusOfLectureIngestion(@PathVariable long courseId) {
+ try {
+ Course course = courseRepository.findByIdElseThrow(courseId);
+ authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
+ return ResponseEntity.ok(pyrisWebhookService.getLecturesIngestionState(courseId));
+ }
+ catch (PyrisConnectorException e) {
+ log.error("Error fetching ingestion state for course {}", courseId, e);
+ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+ }
+ }
+
+ /**
+ * Retrieves the ingestion state of all lecture unit in a lecture by communicating with Pyris.
+ *
+ *
+ * This method sends a GET request to the external Pyris service to fetch the current ingestion
+ * state of a lecture unit, identified by its ID. It constructs a request using the provided
+ * `lectureId` and `lectureUnitId` and returns the state of the ingestion process (e.g., NOT_STARTED,
+ * IN_PROGRESS, DONE, ERROR).
+ *
+ *
+ * @param courseId the ID of the lecture the unit belongs to
+ * @param lectureId the ID of the lecture the unit belongs to
+ * @return a {@link ResponseEntity} containing the {@link IngestionState} of the lecture unit,
+ */
+ @GetMapping("courses/{courseId}/lectures/{lectureId}/lecture-units/ingestion-state")
+ @EnforceAtLeastInstructorInCourse
+ public ResponseEntity> getStatusOfLectureUnitsIngestion(@PathVariable long courseId, @PathVariable long lectureId) {
+ try {
+ Course course = courseRepository.findByIdElseThrow(courseId);
+ authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
+ return ResponseEntity.ok(pyrisWebhookService.getLectureUnitsIngestionState(courseId, lectureId));
+ }
+ catch (PyrisConnectorException e) {
+ log.error("Error fetching ingestion state for lecture {}", lectureId, e);
+ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+ }
+ }
+
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java b/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java
index 025a6ce4e897..73e4520c32a6 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java
@@ -171,7 +171,6 @@ public ResponseEntity setStatusOfIngestionJob(@PathVariable String runId,
}
pyrisStatusUpdateService.handleStatusUpdate(ingestionWebhookJob, statusUpdateDTO);
-
return ResponseEntity.ok().build();
}
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java
index d0fd1afbf8a6..33ce07e7b6fb 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java
@@ -28,6 +28,13 @@
@Repository
public interface LectureRepository extends ArtemisJpaRepository {
+ @Query("""
+ SELECT lecture
+ FROM Lecture lecture
+ WHERE lecture.course.id = :courseId
+ """)
+ Set findAllByCourseId(@Param("courseId") Long courseId);
+
@Query("""
SELECT lecture
FROM Lecture lecture
@@ -85,6 +92,14 @@ public interface LectureRepository extends ArtemisJpaRepository {
""")
Optional findByIdWithLectureUnitsAndCompetencies(@Param("lectureId") Long lectureId);
+ @Query("""
+ SELECT lecture
+ FROM Lecture lecture
+ LEFT JOIN FETCH lecture.lectureUnits
+ WHERE lecture.id = :lectureId
+ """)
+ Optional findByIdWithLectureUnits(@Param("lectureId") Long lectureId);
+
@Query("""
SELECT lecture
FROM Lecture lecture
@@ -165,6 +180,11 @@ Page findByTitleInLectureOrCourseAndUserHasAccessToCourse(@Param("parti
@Cacheable(cacheNames = "lectureTitle", key = "#lectureId", unless = "#result == null")
String getLectureTitle(@Param("lectureId") Long lectureId);
+ @NotNull
+ default Lecture findByIdWithLectureUnitsElseThrow(Long lectureId) {
+ return getValueElseThrow(findByIdWithLectureUnits(lectureId), lectureId);
+ }
+
@NotNull
default Lecture findByIdWithLectureUnitsAndCompetenciesElseThrow(Long lectureId) {
return getValueElseThrow(findByIdWithLectureUnitsAndCompetencies(lectureId), lectureId);
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java
index 031fdc300e9d..42807551d308 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java
@@ -21,6 +21,13 @@
@Repository
public interface LectureUnitRepository extends ArtemisJpaRepository {
+ @Query("""
+ SELECT lu
+ FROM LectureUnit lu
+ WHERE lu.id = :lectureUnitId
+ """)
+ Optional findById(@Param("lectureUnitId") long lectureUnitId);
+
@Query("""
SELECT lu
FROM LectureUnit lu
@@ -104,4 +111,7 @@ default LectureUnit findByIdWithCompetenciesAndSlidesElseThrow(long lectureUnitI
return getValueElseThrow(findWithCompetenciesAndSlidesById(lectureUnitId), lectureUnitId);
}
+ default LectureUnit findByIdElseThrow(long lectureUnitId) {
+ return getValueElseThrow(findById(lectureUnitId), lectureUnitId);
+ }
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/service/AttachmentUnitService.java b/src/main/java/de/tum/cit/aet/artemis/lecture/service/AttachmentUnitService.java
index 83d3ffdf6751..342e463b5650 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/service/AttachmentUnitService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/service/AttachmentUnitService.java
@@ -16,8 +16,8 @@
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyProgressApi;
import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyLectureUnitLink;
-import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyProgressService;
import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
import de.tum.cit.aet.artemis.core.service.FilePathService;
import de.tum.cit.aet.artemis.core.service.FileService;
@@ -49,13 +49,13 @@ public class AttachmentUnitService {
private final Optional irisSettingsRepository;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressService;
private final LectureUnitService lectureUnitService;
public AttachmentUnitService(SlideRepository slideRepository, SlideSplitterService slideSplitterService, AttachmentUnitRepository attachmentUnitRepository,
AttachmentRepository attachmentRepository, FileService fileService, Optional pyrisWebhookService,
- Optional irisSettingsRepository, CompetencyProgressService competencyProgressService, LectureUnitService lectureUnitService) {
+ Optional irisSettingsRepository, CompetencyProgressApi competencyProgressService, LectureUnitService lectureUnitService) {
this.attachmentUnitRepository = attachmentUnitRepository;
this.attachmentRepository = attachmentRepository;
this.fileService = fileService;
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java
index 3095605139a1..9bf8edba5bea 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java
@@ -13,8 +13,8 @@
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;
-import de.tum.cit.aet.artemis.atlas.repository.CompetencyLectureUnitLinkRepository;
-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.atlas.api.CompetencyRelationApi;
import de.tum.cit.aet.artemis.communication.domain.conversation.Channel;
import de.tum.cit.aet.artemis.communication.repository.conversation.ChannelRepository;
import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
@@ -46,20 +46,19 @@ public class LectureService {
private final Optional pyrisWebhookService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
- private final CompetencyLectureUnitLinkRepository competencyLectureUnitLinkRepository;
+ private final CompetencyRelationApi competencyRelationApi;
public LectureService(LectureRepository lectureRepository, AuthorizationCheckService authCheckService, ChannelRepository channelRepository, ChannelService channelService,
- Optional pyrisWebhookService, CompetencyProgressService competencyProgressService,
- CompetencyLectureUnitLinkRepository competencyLectureUnitLinkRepository) {
+ Optional pyrisWebhookService, CompetencyProgressApi competencyProgressApi, CompetencyRelationApi competencyRelationApi) {
this.lectureRepository = lectureRepository;
this.authCheckService = authCheckService;
this.channelRepository = channelRepository;
this.channelService = channelService;
this.pyrisWebhookService = pyrisWebhookService;
- this.competencyProgressService = competencyProgressService;
- this.competencyLectureUnitLinkRepository = competencyLectureUnitLinkRepository;
+ this.competencyProgressApi = competencyProgressApi;
+ this.competencyRelationApi = competencyRelationApi;
}
/**
@@ -162,13 +161,13 @@ public void delete(Lecture lecture, boolean updateCompetencyProgress) {
if (updateCompetencyProgress) {
lecture.getLectureUnits().stream().filter(lectureUnit -> !(lectureUnit instanceof ExerciseUnit))
- .forEach(lectureUnit -> competencyProgressService.updateProgressForUpdatedLearningObjectAsync(lectureUnit, Optional.empty()));
+ .forEach(lectureUnit -> competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(lectureUnit, Optional.empty()));
}
Channel lectureChannel = channelRepository.findChannelByLectureId(lecture.getId());
channelService.deleteChannel(lectureChannel);
- competencyLectureUnitLinkRepository.deleteAllByLectureId(lecture.getId());
+ competencyRelationApi.deleteAllLectureUnitLinksByLectureId(lecture.getId());
lectureRepository.deleteById(lecture.getId());
}
@@ -177,16 +176,14 @@ public void delete(Lecture lecture, boolean updateCompetencyProgress) {
* Ingest the lectures when triggered by the ingest lectures button
*
* @param lectures set of lectures to be ingested
- * @return returns the job token if the operation is successful else it returns null
*/
- public boolean ingestLecturesInPyris(Set lectures) {
+ public void ingestLecturesInPyris(Set lectures) {
if (pyrisWebhookService.isPresent()) {
List attachmentUnitList = lectures.stream().flatMap(lec -> lec.getLectureUnits().stream()).filter(unit -> unit instanceof AttachmentUnit)
.map(unit -> (AttachmentUnit) unit).toList();
- if (!attachmentUnitList.isEmpty()) {
- return pyrisWebhookService.get().addLectureUnitsToPyrisDB(attachmentUnitList) != null;
+ for (AttachmentUnit attachmentUnit : attachmentUnitList) {
+ pyrisWebhookService.get().addLectureUnitToPyrisDB(attachmentUnit);
}
}
- return false;
}
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java
index bda282499738..b3fba2a6c829 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java
@@ -19,15 +19,19 @@
import jakarta.ws.rs.BadRequestException;
import org.hibernate.Hibernate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyProgressApi;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyRelationApi;
+import de.tum.cit.aet.artemis.atlas.api.CourseCompetencyApi;
import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyLectureUnitLink;
import de.tum.cit.aet.artemis.atlas.domain.competency.CourseCompetency;
-import de.tum.cit.aet.artemis.atlas.repository.CompetencyLectureUnitLinkRepository;
-import de.tum.cit.aet.artemis.atlas.repository.CourseCompetencyRepository;
-import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyProgressService;
import de.tum.cit.aet.artemis.core.domain.User;
import de.tum.cit.aet.artemis.core.service.FilePathService;
import de.tum.cit.aet.artemis.core.service.FileService;
@@ -47,6 +51,8 @@
@Service
public class LectureUnitService {
+ private static final Logger log = LoggerFactory.getLogger(LectureUnitService.class);
+
private final LectureUnitRepository lectureUnitRepository;
private final LectureRepository lectureRepository;
@@ -59,24 +65,24 @@ public class LectureUnitService {
private final Optional pyrisWebhookService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
- private final CourseCompetencyRepository courseCompetencyRepository;
+ private final CourseCompetencyApi courseCompetencyApi;
- private final CompetencyLectureUnitLinkRepository competencyLectureUnitLinkRepository;
+ private final CompetencyRelationApi competencyRelationApi;
public LectureUnitService(LectureUnitRepository lectureUnitRepository, LectureRepository lectureRepository, LectureUnitCompletionRepository lectureUnitCompletionRepository,
- FileService fileService, SlideRepository slideRepository, Optional pyrisWebhookService, CompetencyProgressService competencyProgressService,
- CourseCompetencyRepository courseCompetencyRepository, CompetencyLectureUnitLinkRepository competencyLectureUnitLinkRepository) {
+ FileService fileService, SlideRepository slideRepository, Optional pyrisWebhookService, CompetencyProgressApi competencyProgressApi,
+ CourseCompetencyApi courseCompetencyApi, CompetencyRelationApi competencyRelationApi) {
this.lectureUnitRepository = lectureUnitRepository;
this.lectureRepository = lectureRepository;
this.lectureUnitCompletionRepository = lectureUnitCompletionRepository;
this.fileService = fileService;
this.slideRepository = slideRepository;
this.pyrisWebhookService = pyrisWebhookService;
- this.courseCompetencyRepository = courseCompetencyRepository;
- this.competencyProgressService = competencyProgressService;
- this.competencyLectureUnitLinkRepository = competencyLectureUnitLinkRepository;
+ this.courseCompetencyApi = courseCompetencyApi;
+ this.competencyProgressApi = competencyProgressApi;
+ this.competencyRelationApi = competencyRelationApi;
}
/**
@@ -177,7 +183,7 @@ public void removeLectureUnit(@NotNull LectureUnit lectureUnit) {
if (!(lectureUnitToDelete instanceof ExerciseUnit)) {
// update associated competency progress objects
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(lectureUnitToDelete, Optional.empty());
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(lectureUnitToDelete, Optional.empty());
}
}
@@ -190,7 +196,7 @@ public void removeLectureUnit(@NotNull LectureUnit lectureUnit) {
public void linkLectureUnitsToCompetency(CourseCompetency competency, Set lectureUnitLinks) {
lectureUnitLinks.forEach(link -> link.setCompetency(competency));
competency.setLectureUnitLinks(lectureUnitLinks);
- courseCompetencyRepository.save(competency);
+ courseCompetencyApi.save(competency);
}
/**
@@ -200,7 +206,7 @@ public void linkLectureUnitsToCompetency(CourseCompetency competency, Set lectureUnitLinks, CourseCompetency competency) {
- competencyLectureUnitLinkRepository.deleteAll(lectureUnitLinks);
+ competencyRelationApi.deleteAllLectureUnitLinks(lectureUnitLinks);
competency.getLectureUnitLinks().removeAll(lectureUnitLinks);
}
@@ -220,6 +226,30 @@ public URL validateUrlStringAndReturnUrl(String urlString) {
}
}
+ /**
+ * This method is responsible for ingesting a specific `LectureUnit` into Pyris, but only if it is an instance of
+ * `AttachmentUnit`. If the Pyris webhook service is available, it attempts to add the `LectureUnit` to the Pyris
+ * database.
+ * The method responds with different HTTP status codes based on the result:
+ * Returns {OK} if the ingestion is successful.
+ * Returns {SERVICE_UNAVAILABLE} if the Pyris webhook service is unavailable or if the ingestion fails.
+ * Returns {400 BAD_REQUEST} if the provided lecture unit is not of type {AttachmentUnit}.
+ *
+ * @param lectureUnit the lecture unit to be ingested, which must be an instance of AttachmentUnit.
+ * @return ResponseEntity representing the outcome of the operation with the appropriate HTTP status.
+ */
+ public ResponseEntity ingestLectureUnitInPyris(LectureUnit lectureUnit) {
+ if (!(lectureUnit instanceof AttachmentUnit)) {
+ return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+ }
+ if (pyrisWebhookService.isEmpty()) {
+ log.error("Could not send Lecture Unit to Pyris: Pyris webhook service is not available, check if IRIS is enabled.");
+ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+ }
+ boolean isIngested = pyrisWebhookService.get().addLectureUnitToPyrisDB((AttachmentUnit) lectureUnit) != null;
+ return ResponseEntity.status(isIngested ? HttpStatus.OK : HttpStatus.BAD_REQUEST).build();
+ }
+
/**
* Disconnects the competency exercise links from the exercise before the cycle is broken by the deserialization.
*
@@ -256,7 +286,7 @@ public T saveWithCompetencyLinks(T lectureUnit, Function
if (Hibernate.isInitialized(links) && links != null && !links.isEmpty()) {
savedLectureUnit.setCompetencyLinks(links);
reconnectCompetencyLectureUnitLinks(savedLectureUnit);
- savedLectureUnit.setCompetencyLinks(new HashSet<>(competencyLectureUnitLinkRepository.saveAll(links)));
+ savedLectureUnit.setCompetencyLinks(new HashSet<>(competencyRelationApi.saveAllLectureUnitLinks(links)));
}
return savedLectureUnit;
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/AttachmentUnitResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/AttachmentUnitResource.java
index 83aa9f8ebefb..ec1514ca668b 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/AttachmentUnitResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/AttachmentUnitResource.java
@@ -29,7 +29,7 @@
import com.fasterxml.jackson.databind.ObjectMapper;
-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.communication.service.notifications.GroupNotificationService;
import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
import de.tum.cit.aet.artemis.core.exception.EntityNotFoundException;
@@ -69,7 +69,7 @@ public class AttachmentUnitResource {
private final LectureUnitProcessingService lectureUnitProcessingService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final SlideSplitterService slideSplitterService;
@@ -77,14 +77,14 @@ public class AttachmentUnitResource {
public AttachmentUnitResource(AttachmentUnitRepository attachmentUnitRepository, LectureRepository lectureRepository, LectureUnitProcessingService lectureUnitProcessingService,
AuthorizationCheckService authorizationCheckService, GroupNotificationService groupNotificationService, AttachmentUnitService attachmentUnitService,
- CompetencyProgressService competencyProgressService, SlideSplitterService slideSplitterService, FileService fileService) {
+ CompetencyProgressApi competencyProgressApi, SlideSplitterService slideSplitterService, FileService fileService) {
this.attachmentUnitRepository = attachmentUnitRepository;
this.lectureUnitProcessingService = lectureUnitProcessingService;
this.lectureRepository = lectureRepository;
this.authorizationCheckService = authorizationCheckService;
this.groupNotificationService = groupNotificationService;
this.attachmentUnitService = attachmentUnitService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.slideSplitterService = slideSplitterService;
this.fileService = fileService;
}
@@ -173,7 +173,7 @@ public ResponseEntity createAttachmentUnit(@PathVariable Long le
slideSplitterService.splitAttachmentUnitIntoSingleSlides(savedAttachmentUnit);
}
attachmentUnitService.prepareAttachmentUnitForClient(savedAttachmentUnit);
- competencyProgressService.updateProgressByLearningObjectAsync(savedAttachmentUnit);
+ competencyProgressApi.updateProgressByLearningObjectAsync(savedAttachmentUnit);
return ResponseEntity.created(new URI("/api/attachment-units/" + savedAttachmentUnit.getId())).body(savedAttachmentUnit);
}
@@ -228,7 +228,7 @@ public ResponseEntity> createAttachmentUnits(@PathVariable
List savedAttachmentUnits = lectureUnitProcessingService.splitAndSaveUnits(lectureUnitSplitInformationDTO, fileBytes,
lectureRepository.findByIdWithLectureUnitsAndAttachmentsElseThrow(lectureId));
savedAttachmentUnits.forEach(attachmentUnitService::prepareAttachmentUnitForClient);
- savedAttachmentUnits.forEach(competencyProgressService::updateProgressByLearningObjectAsync);
+ savedAttachmentUnits.forEach(competencyProgressApi::updateProgressByLearningObjectAsync);
return ResponseEntity.ok().body(savedAttachmentUnits);
}
catch (IOException e) {
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java
index baecd6cd7c57..deeb3ec3861c 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java
@@ -27,7 +27,7 @@
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
-import de.tum.cit.aet.artemis.atlas.service.competency.CompetencyService;
+import de.tum.cit.aet.artemis.atlas.api.CompetencyApi;
import de.tum.cit.aet.artemis.communication.domain.conversation.Channel;
import de.tum.cit.aet.artemis.communication.repository.conversation.ChannelRepository;
import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
@@ -67,7 +67,7 @@ public class LectureResource {
private static final String ENTITY_NAME = "lecture";
- private final CompetencyService competencyService;
+ private final CompetencyApi competencyApi;
@Value("${jhipster.clientApp.name}")
private String applicationName;
@@ -92,7 +92,7 @@ public class LectureResource {
public LectureResource(LectureRepository lectureRepository, LectureService lectureService, LectureImportService lectureImportService, CourseRepository courseRepository,
UserRepository userRepository, AuthorizationCheckService authCheckService, ExerciseService exerciseService, ChannelService channelService,
- ChannelRepository channelRepository, CompetencyService competencyService) {
+ ChannelRepository channelRepository, CompetencyApi competencyApi) {
this.lectureRepository = lectureRepository;
this.lectureService = lectureService;
this.lectureImportService = lectureImportService;
@@ -102,7 +102,7 @@ public LectureResource(LectureRepository lectureRepository, LectureService lectu
this.exerciseService = exerciseService;
this.channelService = channelService;
this.channelRepository = channelRepository;
- this.competencyService = competencyService;
+ this.competencyApi = competencyApi;
}
/**
@@ -276,21 +276,21 @@ public ResponseEntity importLecture(@PathVariable long sourceLectureId,
@Profile(PROFILE_IRIS)
@PostMapping("courses/{courseId}/ingest")
@EnforceAtLeastInstructorInCourse
- public ResponseEntity ingestLectures(@PathVariable Long courseId, @RequestParam(required = false) Optional lectureId) {
- log.debug("REST request to ingest lectures of course : {}", courseId);
+ public ResponseEntity ingestLectures(@PathVariable Long courseId, @RequestParam(required = false) Optional lectureId) {
Course course = courseRepository.findByIdWithLecturesAndLectureUnitsElseThrow(courseId);
+ authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
if (lectureId.isPresent()) {
Optional lectureToIngest = course.getLectures().stream().filter(lecture -> lecture.getId().equals(lectureId.get())).findFirst();
if (lectureToIngest.isPresent()) {
Set lecturesToIngest = new HashSet<>();
lecturesToIngest.add(lectureToIngest.get());
- return ResponseEntity.ok().body(lectureService.ingestLecturesInPyris(lecturesToIngest));
+ lectureService.ingestLecturesInPyris(lecturesToIngest);
+ return ResponseEntity.ok().build();
}
- return ResponseEntity.badRequest()
- .headers(HeaderUtil.createAlert(applicationName, "Could not send lecture to Iris, no lecture found with the provided id.", "idExists")).body(null);
-
+ return ResponseEntity.badRequest().headers(HeaderUtil.createAlert(applicationName, "artemisApp.iris.ingestionAlert.allLecturesError", "idExists")).body(null);
}
- return ResponseEntity.ok().body(lectureService.ingestLecturesInPyris(course.getLectures()));
+ lectureService.ingestLecturesInPyris(course.getLectures());
+ return ResponseEntity.ok().build();
}
/**
@@ -304,7 +304,7 @@ public ResponseEntity ingestLectures(@PathVariable Long courseId, @Requ
public ResponseEntity getLectureWithDetails(@PathVariable Long lectureId) {
log.debug("REST request to get lecture {} with details", lectureId);
Lecture lecture = lectureRepository.findByIdWithAttachmentsAndPostsAndLectureUnitsAndCompetenciesAndCompletionsElseThrow(lectureId);
- competencyService.addCompetencyLinksToExerciseUnits(lecture);
+ competencyApi.addCompetencyLinksToExerciseUnits(lecture);
Course course = lecture.getCourse();
if (course == null) {
return ResponseEntity.badRequest().build();
@@ -334,7 +334,7 @@ public ResponseEntity getLectureWithDetailsAndSlides(@PathVariable long
User user = userRepository.getUserWithGroupsAndAuthorities();
authCheckService.checkIsAllowedToSeeLectureElseThrow(lecture, user);
- competencyService.addCompetencyLinksToExerciseUnits(lecture);
+ competencyApi.addCompetencyLinksToExerciseUnits(lecture);
lectureService.filterActiveAttachmentUnits(lecture);
lectureService.filterActiveAttachments(lecture, user);
return ResponseEntity.ok(lecture);
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java
index b14667346674..2faca61e3854 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java
@@ -4,6 +4,7 @@
import java.util.Comparator;
import java.util.List;
+import java.util.Optional;
import jakarta.validation.Valid;
@@ -11,6 +12,7 @@
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Profile;
+import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
@@ -22,7 +24,7 @@
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
-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.exception.BadRequestAlertException;
import de.tum.cit.aet.artemis.core.exception.EntityNotFoundException;
@@ -63,16 +65,16 @@ public class LectureUnitResource {
private final LectureUnitService lectureUnitService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
public LectureUnitResource(AuthorizationCheckService authorizationCheckService, UserRepository userRepository, LectureRepository lectureRepository,
- LectureUnitRepository lectureUnitRepository, LectureUnitService lectureUnitService, CompetencyProgressService competencyProgressService, UserService userService) {
+ LectureUnitRepository lectureUnitRepository, LectureUnitService lectureUnitService, CompetencyProgressApi competencyProgressApi, UserService userService) {
this.authorizationCheckService = authorizationCheckService;
this.userRepository = userRepository;
this.lectureUnitRepository = lectureUnitRepository;
this.lectureRepository = lectureRepository;
this.lectureUnitService = lectureUnitService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
/**
@@ -142,7 +144,7 @@ public ResponseEntity completeLectureUnit(@PathVariable Long lectureUnitId
authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, lectureUnit.getLecture().getCourse(), user);
lectureUnitService.setLectureUnitCompletion(lectureUnit, user, completed);
- competencyProgressService.updateProgressByLearningObjectForParticipantAsync(lectureUnit, user);
+ competencyProgressApi.updateProgressByLearningObjectForParticipantAsync(lectureUnit, user);
return ResponseEntity.ok().build();
}
@@ -156,7 +158,7 @@ public ResponseEntity completeLectureUnit(@PathVariable Long lectureUnitId
*/
@DeleteMapping("lectures/{lectureId}/lecture-units/{lectureUnitId}")
@EnforceAtLeastInstructor
- public ResponseEntity deleteLectureUnit(@PathVariable Long lectureUnitId, @PathVariable Long lectureId) {
+ public ResponseEntity deleteLectureUnit(@PathVariable long lectureUnitId, @PathVariable Long lectureId) {
log.info("REST request to delete lecture unit: {}", lectureUnitId);
LectureUnit lectureUnit = lectureUnitRepository.findByIdWithCompetenciesBidirectionalElseThrow(lectureUnitId);
if (lectureUnit.getLecture() == null || lectureUnit.getLecture().getCourse() == null) {
@@ -200,11 +202,35 @@ public ResponseEntity getLectureUnitFo
*/
@GetMapping("lecture-units/{lectureUnitId}")
@EnforceAtLeastStudent
- public ResponseEntity getLectureUnitById(@PathVariable @Valid Long lectureUnitId) {
+ public ResponseEntity getLectureUnitById(@PathVariable @Valid long lectureUnitId) {
log.debug("REST request to get lecture unit with id: {}", lectureUnitId);
var lectureUnit = lectureUnitRepository.findByIdWithCompletedUsersElseThrow(lectureUnitId);
authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, lectureUnit.getLecture().getCourse(), null);
lectureUnit.setCompleted(lectureUnit.isCompletedFor(userRepository.getUser()));
return ResponseEntity.ok(lectureUnit);
}
+
+ /**
+ * This endpoint triggers the ingestion process for a specified lecture unit into Pyris.
+ *
+ * @param lectureId the ID of the lecture to which the lecture unit belongs
+ * @param lectureUnitId the ID of the lecture unit to be ingested
+ * @return ResponseEntity with the status of the ingestion operation.
+ * Returns 200 OK if the ingestion is successfully started.
+ * Returns 400 BAD_REQUEST if the lecture unit cannot be ingested.
+ * Returns SERVICE_UNAVAILABLE if the Pyris service is unavailable or
+ * ingestion fails for another reason.
+ */
+ @PostMapping("lectures/{lectureId}/lecture-units/{lectureUnitId}/ingest")
+ @EnforceAtLeastInstructor
+ public ResponseEntity ingestLectureUnit(@PathVariable long lectureId, @PathVariable long lectureUnitId) {
+ Lecture lecture = this.lectureRepository.findByIdWithLectureUnitsElseThrow(lectureId);
+ Optional lectureUnitOptional = lecture.getLectureUnits().stream().filter(lu -> lu.getId() == lectureUnitId).findFirst();
+ if (lectureUnitOptional.isEmpty()) {
+ return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+ }
+ LectureUnit lectureUnit = lectureUnitOptional.get();
+ authorizationCheckService.checkHasAtLeastRoleForLectureElseThrow(Role.INSTRUCTOR, lectureUnit.getLecture(), null);
+ return lectureUnitService.ingestLectureUnitInPyris(lectureUnit);
+ }
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/OnlineUnitResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/OnlineUnitResource.java
index c5e8bfa600d1..891701b00afc 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/OnlineUnitResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/OnlineUnitResource.java
@@ -28,7 +28,7 @@
import com.google.common.net.InternetDomainName;
-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.dto.OnlineResourceDTO;
import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
import de.tum.cit.aet.artemis.core.exception.InternalServerErrorException;
@@ -56,16 +56,16 @@ public class OnlineUnitResource {
private final AuthorizationCheckService authorizationCheckService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final LectureUnitService lectureUnitService;
public OnlineUnitResource(LectureRepository lectureRepository, AuthorizationCheckService authorizationCheckService, OnlineUnitRepository onlineUnitRepository,
- CompetencyProgressService competencyProgressService, LectureUnitService lectureUnitService) {
+ CompetencyProgressApi competencyProgressApi, LectureUnitService lectureUnitService) {
this.lectureRepository = lectureRepository;
this.authorizationCheckService = authorizationCheckService;
this.onlineUnitRepository = onlineUnitRepository;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.lectureUnitService = lectureUnitService;
}
@@ -110,7 +110,7 @@ public ResponseEntity updateOnlineUnit(@PathVariable Long lectureId,
OnlineUnit result = lectureUnitService.saveWithCompetencyLinks(onlineUnit, onlineUnitRepository::save);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(existingOnlineUnit, Optional.of(onlineUnit));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(existingOnlineUnit, Optional.of(onlineUnit));
return ResponseEntity.ok(result);
}
@@ -148,7 +148,7 @@ public ResponseEntity createOnlineUnit(@PathVariable Long lectureId,
lecture.addLectureUnit(persistedOnlineUnit);
lectureRepository.save(lecture);
- competencyProgressService.updateProgressByLearningObjectAsync(persistedOnlineUnit);
+ competencyProgressApi.updateProgressByLearningObjectAsync(persistedOnlineUnit);
return ResponseEntity.created(new URI("/api/online-units/" + persistedOnlineUnit.getId())).body(persistedOnlineUnit);
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/TextUnitResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/TextUnitResource.java
index b48d11ca87d4..e7c15d7e786f 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/TextUnitResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/TextUnitResource.java
@@ -18,7 +18,7 @@
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
-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.exception.BadRequestAlertException;
import de.tum.cit.aet.artemis.core.exception.EntityNotFoundException;
import de.tum.cit.aet.artemis.core.security.Role;
@@ -45,16 +45,16 @@ public class TextUnitResource {
private final AuthorizationCheckService authorizationCheckService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final LectureUnitService lectureUnitService;
public TextUnitResource(LectureRepository lectureRepository, TextUnitRepository textUnitRepository, AuthorizationCheckService authorizationCheckService,
- CompetencyProgressService competencyProgressService, LectureUnitService lectureUnitService) {
+ CompetencyProgressApi competencyProgressApi, LectureUnitService lectureUnitService) {
this.lectureRepository = lectureRepository;
this.textUnitRepository = textUnitRepository;
this.authorizationCheckService = authorizationCheckService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.lectureUnitService = lectureUnitService;
}
@@ -108,7 +108,7 @@ public ResponseEntity updateTextUnit(@PathVariable Long lectureId, @Re
TextUnit result = lectureUnitService.saveWithCompetencyLinks(textUnitForm, textUnitRepository::save);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(existingTextUnit, Optional.of(textUnitForm));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(existingTextUnit, Optional.of(textUnitForm));
return ResponseEntity.ok(result);
}
@@ -146,7 +146,7 @@ public ResponseEntity createTextUnit(@PathVariable Long lectureId, @Re
Lecture updatedLecture = lectureRepository.save(lecture);
TextUnit persistedTextUnit = (TextUnit) updatedLecture.getLectureUnits().getLast();
- competencyProgressService.updateProgressByLearningObjectAsync(persistedTextUnit);
+ competencyProgressApi.updateProgressByLearningObjectAsync(persistedTextUnit);
lectureUnitService.disconnectCompetencyLectureUnitLinks(persistedTextUnit);
return ResponseEntity.created(new URI("/api/text-units/" + persistedTextUnit.getId())).body(persistedTextUnit);
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/VideoUnitResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/VideoUnitResource.java
index e38d2580f83e..ad4e2d75b163 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/VideoUnitResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/VideoUnitResource.java
@@ -20,7 +20,7 @@
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
-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.exception.BadRequestAlertException;
import de.tum.cit.aet.artemis.core.security.Role;
import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastEditor;
@@ -46,16 +46,16 @@ public class VideoUnitResource {
private final AuthorizationCheckService authorizationCheckService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final LectureUnitService lectureUnitService;
public VideoUnitResource(LectureRepository lectureRepository, AuthorizationCheckService authorizationCheckService, VideoUnitRepository videoUnitRepository,
- CompetencyProgressService competencyProgressService, LectureUnitService lectureUnitService) {
+ CompetencyProgressApi competencyProgressApi, LectureUnitService lectureUnitService) {
this.lectureRepository = lectureRepository;
this.authorizationCheckService = authorizationCheckService;
this.videoUnitRepository = videoUnitRepository;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.lectureUnitService = lectureUnitService;
}
@@ -99,7 +99,7 @@ public ResponseEntity updateVideoUnit(@PathVariable Long lectureId, @
VideoUnit result = lectureUnitService.saveWithCompetencyLinks(videoUnit, videoUnitRepository::save);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(existingVideoUnit, Optional.of(videoUnit));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(existingVideoUnit, Optional.of(videoUnit));
return ResponseEntity.ok(result);
}
@@ -139,7 +139,7 @@ public ResponseEntity createVideoUnit(@PathVariable Long lectureId, @
Lecture updatedLecture = lectureRepository.save(lecture);
VideoUnit persistedVideoUnit = (VideoUnit) updatedLecture.getLectureUnits().getLast();
- competencyProgressService.updateProgressByLearningObjectAsync(persistedVideoUnit);
+ competencyProgressApi.updateProgressByLearningObjectAsync(persistedVideoUnit);
lectureUnitService.disconnectCompetencyLectureUnitLinks(persistedVideoUnit);
return ResponseEntity.created(new URI("/api/video-units/" + persistedVideoUnit.getId())).body(persistedVideoUnit);
diff --git a/src/main/java/de/tum/cit/aet/artemis/modeling/service/ModelingExerciseImportService.java b/src/main/java/de/tum/cit/aet/artemis/modeling/service/ModelingExerciseImportService.java
index 3c877ce69465..c418596c3a49 100644
--- a/src/main/java/de/tum/cit/aet/artemis/modeling/service/ModelingExerciseImportService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/modeling/service/ModelingExerciseImportService.java
@@ -21,7 +21,7 @@
import de.tum.cit.aet.artemis.assessment.repository.ExampleSubmissionRepository;
import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
import de.tum.cit.aet.artemis.assessment.service.FeedbackService;
-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.communication.service.conversation.ChannelService;
import de.tum.cit.aet.artemis.exercise.domain.Exercise;
import de.tum.cit.aet.artemis.exercise.domain.Submission;
@@ -42,17 +42,17 @@ public class ModelingExerciseImportService extends ExerciseImportService {
private final ChannelService channelService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final ExerciseService exerciseService;
public ModelingExerciseImportService(ModelingExerciseRepository modelingExerciseRepository, ExampleSubmissionRepository exampleSubmissionRepository,
SubmissionRepository submissionRepository, ResultRepository resultRepository, ChannelService channelService, FeedbackService feedbackService,
- CompetencyProgressService competencyProgressService, ExerciseService exerciseService) {
+ CompetencyProgressApi competencyProgressApi, ExerciseService exerciseService) {
super(exampleSubmissionRepository, submissionRepository, resultRepository, feedbackService);
this.modelingExerciseRepository = modelingExerciseRepository;
this.channelService = channelService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.exerciseService = exerciseService;
}
@@ -77,7 +77,7 @@ public ModelingExercise importModelingExercise(ModelingExercise templateExercise
channelService.createExerciseChannel(newModelingExercise, Optional.ofNullable(importedExercise.getChannelName()));
newModelingExercise.setExampleSubmissions(copyExampleSubmission(templateExercise, newExercise, gradingInstructionCopyTracker));
- competencyProgressService.updateProgressByLearningObjectAsync(newModelingExercise);
+ competencyProgressApi.updateProgressByLearningObjectAsync(newModelingExercise);
return newModelingExercise;
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/modeling/web/ModelingExerciseResource.java b/src/main/java/de/tum/cit/aet/artemis/modeling/web/ModelingExerciseResource.java
index a2739ed28c76..899e16a32127 100644
--- a/src/main/java/de/tum/cit/aet/artemis/modeling/web/ModelingExerciseResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/modeling/web/ModelingExerciseResource.java
@@ -29,7 +29,7 @@
import de.tum.cit.aet.artemis.assessment.domain.GradingCriterion;
import de.tum.cit.aet.artemis.assessment.repository.GradingCriterionRepository;
-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.communication.domain.conversation.Channel;
import de.tum.cit.aet.artemis.communication.repository.conversation.ChannelRepository;
import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
@@ -81,7 +81,7 @@ public class ModelingExerciseResource {
private static final String ENTITY_NAME = "modelingExercise";
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
@Value("${jhipster.clientApp.name}")
private String applicationName;
@@ -126,7 +126,7 @@ public ModelingExerciseResource(ModelingExerciseRepository modelingExerciseRepos
ModelingExerciseImportService modelingExerciseImportService, SubmissionExportService modelingSubmissionExportService, ExerciseService exerciseService,
GroupNotificationScheduleService groupNotificationScheduleService, GradingCriterionRepository gradingCriterionRepository,
PlagiarismDetectionService plagiarismDetectionService, ChannelService channelService, ChannelRepository channelRepository,
- CompetencyProgressService competencyProgressService) {
+ CompetencyProgressApi competencyProgressApi) {
this.modelingExerciseRepository = modelingExerciseRepository;
this.courseService = courseService;
this.modelingExerciseService = modelingExerciseService;
@@ -144,7 +144,7 @@ public ModelingExerciseResource(ModelingExerciseRepository modelingExerciseRepos
this.plagiarismDetectionService = plagiarismDetectionService;
this.channelService = channelService;
this.channelRepository = channelRepository;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
// TODO: most of these calls should be done in the context of a course
@@ -182,7 +182,7 @@ public ResponseEntity createModelingExercise(@RequestBody Mode
channelService.createExerciseChannel(result, Optional.ofNullable(modelingExercise.getChannelName()));
modelingExerciseService.scheduleOperations(result.getId());
groupNotificationScheduleService.checkNotificationsForNewExerciseAsync(modelingExercise);
- competencyProgressService.updateProgressByLearningObjectAsync(result);
+ competencyProgressApi.updateProgressByLearningObjectAsync(result);
return ResponseEntity.created(new URI("/api/modeling-exercises/" + result.getId())).body(result);
}
@@ -253,7 +253,7 @@ public ResponseEntity updateModelingExercise(@RequestBody Mode
exerciseService.notifyAboutExerciseChanges(modelingExerciseBeforeUpdate, updatedModelingExercise, notificationText);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(modelingExerciseBeforeUpdate, Optional.of(modelingExercise));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(modelingExerciseBeforeUpdate, Optional.of(modelingExercise));
return ResponseEntity.ok(updatedModelingExercise);
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/domain/UserSshPublicKey.java b/src/main/java/de/tum/cit/aet/artemis/programming/domain/UserSshPublicKey.java
new file mode 100644
index 000000000000..8348c7eb656c
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/domain/UserSshPublicKey.java
@@ -0,0 +1,131 @@
+package de.tum.cit.aet.artemis.programming.domain;
+
+import java.time.ZonedDateTime;
+
+import jakarta.annotation.Nullable;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import de.tum.cit.aet.artemis.core.domain.DomainObject;
+
+/**
+ * A public SSH key of a user.
+ */
+@Entity
+@Table(name = "user_public_ssh_key")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class UserSshPublicKey extends DomainObject {
+
+ /**
+ * The user who is owner of the public key
+ */
+ @NotNull
+ @Column(name = "user_id")
+ private long userId;
+
+ /**
+ * The label of the SSH key shwon in the UI
+ */
+ @Size(max = 50)
+ @Column(name = "label", length = 50)
+ private String label;
+
+ /**
+ * The actual full public ssh key of a user used to authenticate git clone and git push operations if available
+ */
+ @NotNull
+ @Column(name = "public_key")
+ private String publicKey;
+
+ /**
+ * A hash of the public ssh key for fast comparison in the database (with an index)
+ */
+ @Size(max = 100)
+ @Column(name = "key_hash")
+ private String keyHash;
+
+ /**
+ * The creation date of the public SSH key
+ */
+ @Column(name = "creation_date")
+ private ZonedDateTime creationDate = null;
+
+ /**
+ * The last used date of the public SSH key
+ */
+ @Nullable
+ @Column(name = "last_used_date")
+ private ZonedDateTime lastUsedDate = null;
+
+ /**
+ * The expiry date of the public SSH key
+ */
+ @Nullable
+ @Column(name = "expiry_date")
+ private ZonedDateTime expiryDate = null;
+
+ public @NotNull long getUserId() {
+ return userId;
+ }
+
+ public void setUserId(@NotNull long userId) {
+ this.userId = userId;
+ }
+
+ public @Size(max = 50) String getLabel() {
+ return label;
+ }
+
+ public void setLabel(@Size(max = 50) String label) {
+ this.label = label;
+ }
+
+ public String getPublicKey() {
+ return publicKey;
+ }
+
+ public void setPublicKey(String publicKey) {
+ this.publicKey = publicKey;
+ }
+
+ @Nullable
+ public @Size(max = 100) String getKeyHash() {
+ return keyHash;
+ }
+
+ public void setKeyHash(@Nullable @Size(max = 100) String keyHash) {
+ this.keyHash = keyHash;
+ }
+
+ public ZonedDateTime getCreationDate() {
+ return creationDate;
+ }
+
+ public void setCreationDate(ZonedDateTime creationDate) {
+ this.creationDate = creationDate;
+ }
+
+ @Nullable
+ public ZonedDateTime getLastUsedDate() {
+ return lastUsedDate;
+ }
+
+ public void setLastUsedDate(@Nullable ZonedDateTime lastUsedDate) {
+ this.lastUsedDate = lastUsedDate;
+ }
+
+ @Nullable
+ public ZonedDateTime getExpiryDate() {
+ return expiryDate;
+ }
+
+ public void setExpiryDate(@Nullable ZonedDateTime expiryDate) {
+ this.expiryDate = expiryDate;
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/dto/UserSshPublicKeyDTO.java b/src/main/java/de/tum/cit/aet/artemis/programming/dto/UserSshPublicKeyDTO.java
new file mode 100644
index 000000000000..ecfeedab8126
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/dto/UserSshPublicKeyDTO.java
@@ -0,0 +1,16 @@
+package de.tum.cit.aet.artemis.programming.dto;
+
+import java.time.ZonedDateTime;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.programming.domain.UserSshPublicKey;
+
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record UserSshPublicKeyDTO(Long id, String label, String publicKey, String keyHash, ZonedDateTime creationDate, ZonedDateTime lastUsedDate, ZonedDateTime expiryDate) {
+
+ public static UserSshPublicKeyDTO of(UserSshPublicKey userSshPublicKey) {
+ return new UserSshPublicKeyDTO(userSshPublicKey.getId(), userSshPublicKey.getLabel(), userSshPublicKey.getPublicKey(), userSshPublicKey.getKeyHash(),
+ userSshPublicKey.getCreationDate(), userSshPublicKey.getLastUsedDate(), userSshPublicKey.getExpiryDate());
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/repository/UserSshPublicKeyRepository.java b/src/main/java/de/tum/cit/aet/artemis/programming/repository/UserSshPublicKeyRepository.java
new file mode 100644
index 000000000000..b177b7b72089
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/repository/UserSshPublicKeyRepository.java
@@ -0,0 +1,27 @@
+package de.tum.cit.aet.artemis.programming.repository;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Repository;
+
+import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
+import de.tum.cit.aet.artemis.programming.domain.UserSshPublicKey;
+
+@Profile(PROFILE_CORE)
+@Repository
+public interface UserSshPublicKeyRepository extends ArtemisJpaRepository {
+
+ List findAllByUserId(Long userId);
+
+ Optional findByKeyHash(String keyHash);
+
+ Optional findByIdAndUserId(Long keyId, Long userId);
+
+ boolean existsByIdAndUserId(Long id, Long userId);
+
+ boolean existsByUserId(Long userId);
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingAssessmentService.java b/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingAssessmentService.java
index 03ec7f527429..f62bde6cc957 100644
--- a/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingAssessmentService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingAssessmentService.java
@@ -52,7 +52,7 @@ public ProgrammingAssessmentService(ComplaintResponseService complaintResponseSe
ProgrammingExerciseParticipationService programmingExerciseParticipationService, Optional athenaFeedbackSendingService,
LongFeedbackTextRepository longFeedbackTextRepository) {
super(complaintResponseService, complaintRepository, feedbackRepository, resultRepository, studentParticipationRepository, resultService, submissionService,
- submissionRepository, examDateService, userRepository, ltiNewResultService, singleUserNotificationService, resultWebsocketService, longFeedbackTextRepository);
+ submissionRepository, examDateService, userRepository, ltiNewResultService, singleUserNotificationService, resultWebsocketService);
this.programmingExerciseParticipationService = programmingExerciseParticipationService;
this.athenaFeedbackSendingService = athenaFeedbackSendingService;
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingExerciseService.java b/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingExerciseService.java
index 65a12b87be77..20b546ad4a48 100644
--- a/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingExerciseService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingExerciseService.java
@@ -45,7 +45,7 @@
import com.fasterxml.jackson.databind.ObjectMapper;
import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
-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.communication.service.conversation.ChannelService;
import de.tum.cit.aet.artemis.communication.service.notifications.GroupNotificationScheduleService;
import de.tum.cit.aet.artemis.core.domain.Course;
@@ -183,7 +183,7 @@ public class ProgrammingExerciseService {
private final ExerciseService exerciseService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
public ProgrammingExerciseService(ProgrammingExerciseRepository programmingExerciseRepository, GitService gitService, Optional versionControlService,
Optional continuousIntegrationService, Optional continuousIntegrationTriggerService,
@@ -199,7 +199,7 @@ public ProgrammingExerciseService(ProgrammingExerciseRepository programmingExerc
ProgrammingSubmissionService programmingSubmissionService, Optional irisSettingsService, Optional aeolusTemplateService,
Optional buildScriptGenerationService,
ProgrammingExerciseStudentParticipationRepository programmingExerciseStudentParticipationRepository, ProfileService profileService, ExerciseService exerciseService,
- ProgrammingExerciseBuildConfigRepository programmingExerciseBuildConfigRepository, CompetencyProgressService competencyProgressService) {
+ ProgrammingExerciseBuildConfigRepository programmingExerciseBuildConfigRepository, CompetencyProgressApi competencyProgressApi) {
this.programmingExerciseRepository = programmingExerciseRepository;
this.gitService = gitService;
this.versionControlService = versionControlService;
@@ -232,7 +232,7 @@ public ProgrammingExerciseService(ProgrammingExerciseRepository programmingExerc
this.profileService = profileService;
this.exerciseService = exerciseService;
this.programmingExerciseBuildConfigRepository = programmingExerciseBuildConfigRepository;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
/**
@@ -339,7 +339,7 @@ public ProgrammingExercise createProgrammingExercise(ProgrammingExercise program
// Step 12c: Check notifications for new exercise
groupNotificationScheduleService.checkNotificationsForNewExerciseAsync(savedProgrammingExercise);
// Step 12d: Update student competency progress
- competencyProgressService.updateProgressByLearningObjectAsync(savedProgrammingExercise);
+ competencyProgressApi.updateProgressByLearningObjectAsync(savedProgrammingExercise);
// Step 13: Set Iris settings
if (irisSettingsService.isPresent()) {
@@ -627,7 +627,7 @@ public ProgrammingExercise updateProgrammingExercise(ProgrammingExercise program
exerciseService.notifyAboutExerciseChanges(programmingExerciseBeforeUpdate, updatedProgrammingExercise, notificationText);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(programmingExerciseBeforeUpdate, Optional.of(updatedProgrammingExercise));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(programmingExerciseBeforeUpdate, Optional.of(updatedProgrammingExercise));
irisSettingsService
.ifPresent(settingsService -> settingsService.setEnabledForExerciseByCategories(savedProgrammingExercise, programmingExerciseBeforeUpdate.getCategories()));
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/service/UserSshPublicKeyService.java b/src/main/java/de/tum/cit/aet/artemis/programming/service/UserSshPublicKeyService.java
new file mode 100644
index 000000000000..232afd327663
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/service/UserSshPublicKeyService.java
@@ -0,0 +1,139 @@
+package de.tum.cit.aet.artemis.programming.service;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.PublicKey;
+import java.time.ZonedDateTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.sshd.common.config.keys.AuthorizedKeyEntry;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Service;
+
+import de.tum.cit.aet.artemis.core.domain.User;
+import de.tum.cit.aet.artemis.core.exception.AccessForbiddenException;
+import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
+import de.tum.cit.aet.artemis.programming.domain.UserSshPublicKey;
+import de.tum.cit.aet.artemis.programming.dto.UserSshPublicKeyDTO;
+import de.tum.cit.aet.artemis.programming.repository.UserSshPublicKeyRepository;
+import de.tum.cit.aet.artemis.programming.service.localvc.ssh.HashUtils;
+
+@Profile(PROFILE_CORE)
+@Service
+public class UserSshPublicKeyService {
+
+ private final UserSshPublicKeyRepository userSshPublicKeyRepository;
+
+ public UserSshPublicKeyService(UserSshPublicKeyRepository userSshPublicKeyRepository) {
+ this.userSshPublicKeyRepository = userSshPublicKeyRepository;
+ }
+
+ /**
+ * Creates a new SSH public key for the specified user, ensuring that the key is unique
+ * based on its SHA-512 hash fingerprint. If the key already exists, an exception is thrown.
+ *
+ * @param user the {@link User} for whom the SSH key is being created.
+ * @param keyEntry the {@link AuthorizedKeyEntry} containing the SSH public key details, used to resolve the {@link PublicKey}.
+ * @param sshPublicKey the {@link UserSshPublicKey} object containing metadata about the SSH key such as the key itself, label, and expiry date.
+ */
+ public void createSshKeyForUser(User user, AuthorizedKeyEntry keyEntry, UserSshPublicKeyDTO sshPublicKey) throws GeneralSecurityException, IOException {
+ PublicKey publicKey = keyEntry.resolvePublicKey(null, null, null);
+ String keyHash = HashUtils.getSha512Fingerprint(publicKey);
+
+ if (userSshPublicKeyRepository.findByKeyHash(keyHash).isPresent()) {
+ throw new BadRequestAlertException("Key already exists", "SSH key", "keyAlreadyExists", true);
+ }
+
+ UserSshPublicKey newUserSshPublicKey = new UserSshPublicKey();
+ newUserSshPublicKey.setUserId(user.getId());
+ newUserSshPublicKey.setPublicKey(sshPublicKey.publicKey());
+ newUserSshPublicKey.setKeyHash(keyHash);
+ setLabelForKey(newUserSshPublicKey, sshPublicKey.label());
+ newUserSshPublicKey.setCreationDate(ZonedDateTime.now());
+ newUserSshPublicKey.setExpiryDate(sshPublicKey.expiryDate());
+ userSshPublicKeyRepository.save(newUserSshPublicKey);
+ }
+
+ /**
+ * Sets the label for the provided SSH public key. If the given label is null or empty,
+ * the label is extracted from the public key or defaults to a predefined value.
+ *
+ * @param newSshPublicKey the {@link UserSshPublicKey} for which the label is being set.
+ * @param label the label to assign to the SSH key, or null/empty to use the default logic.
+ * @throws BadRequestAlertException if the key label is longer than 50 characters
+ */
+ private void setLabelForKey(UserSshPublicKey newSshPublicKey, String label) {
+ if (StringUtils.isBlank(label)) {
+ String[] parts = newSshPublicKey.getPublicKey().split("\\s+");
+
+ // we are only interested in the comment of the key. A typical key looks like this, the key prefix, the actual key and then the comment:
+ // ssh-rsa AAAAB3NzaC1yc2EAAAADAYVTLQ== comment
+ if (parts.length >= 3) {
+ label = String.join(" ", Arrays.copyOfRange(parts, 2, parts.length));
+ }
+ else {
+ label = "Key " + (userSshPublicKeyRepository.findAllByUserId(newSshPublicKey.getUserId()).size() + 1);
+ }
+ }
+ if (label.length() <= 50) {
+ newSshPublicKey.setLabel(label);
+ }
+ else {
+ throw new BadRequestAlertException("Key label is too long", "SSH key", "keyLabelTooLong", true);
+ }
+ }
+
+ /**
+ * Retrieves the SSH public key for the specified user by key ID.
+ *
+ * @param user the {@link User} to whom the SSH key belongs.
+ * @param keyId the ID of the SSH key.
+ * @return the {@link UserSshPublicKey} if found and belongs to the user.
+ * @throws AccessForbiddenException if the key does not belong to the user, or does not exist
+ */
+ public UserSshPublicKey getSshKeyForUser(User user, Long keyId) {
+ Optional userSshPublicKey = userSshPublicKeyRepository.findByIdAndUserId(keyId, user.getId());
+ return userSshPublicKey.orElseThrow(() -> new AccessForbiddenException("SSH key", keyId));
+ }
+
+ /**
+ * Retrieves all SSH public keys associated with the specified user.
+ *
+ * @param user the {@link User} whose SSH keys are to be retrieved.
+ * @return a list of {@link UserSshPublicKey} objects for the user.
+ */
+ public List getAllSshKeysForUser(User user) {
+ return userSshPublicKeyRepository.findAllByUserId(user.getId()).stream().map(UserSshPublicKeyDTO::of).toList();
+ }
+
+ /**
+ * Deletes the specified SSH public key for the given user ID.
+ *
+ * @param userId the ID of the user.
+ * @param keyId the ID of the SSH key to delete.
+ * @throws AccessForbiddenException if the key does not belong to the user.
+ */
+ public void deleteUserSshPublicKey(Long userId, Long keyId) {
+ if (userSshPublicKeyRepository.existsByIdAndUserId(keyId, userId)) {
+ userSshPublicKeyRepository.deleteById(keyId);
+ }
+ else {
+ throw new AccessForbiddenException("SSH key", keyId);
+ }
+ }
+
+ /**
+ * Returns whether the user of the specified id has stored SSH keys
+ *
+ * @param userId the ID of the user.
+ * @return true if the user has SSH keys, false if not
+ */
+ public boolean hasUserSSHkeys(Long userId) {
+ return userSshPublicKeyRepository.existsByUserId(userId);
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java b/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java
index 49d17e49649a..5b280e65e9c0 100644
--- a/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java
@@ -89,7 +89,7 @@ public enum Kind {
private final String value;
- private final static Map CONSTANTS = new HashMap<>();
+ private static final Map CONSTANTS = new HashMap<>();
static {
for (Kind c : values()) {
@@ -111,6 +111,14 @@ public String value() {
return this.value;
}
+ /**
+ * Creates a {@link Kind} instance from a given string value.
+ *
+ *
+ * @param value the string representation of the {@link Kind}
+ * @return the matching {@link Kind} instance
+ * @throws IllegalArgumentException if the provided value does not correspond to any defined {@link Kind}
+ */
@JsonCreator
public static Kind fromValue(String value) {
Kind constant = CONSTANTS.get(value);
@@ -121,7 +129,6 @@ public static Kind fromValue(String value) {
return constant;
}
}
-
}
/**
@@ -133,7 +140,7 @@ public enum Level {
private final String value;
- private final static Map CONSTANTS = new HashMap<>();
+ private static final Map CONSTANTS = new HashMap<>();
static {
for (Level c : values()) {
@@ -155,6 +162,13 @@ public String value() {
return this.value;
}
+ /**
+ * Creates a {@link Level} instance from a given string value.
+ *
+ * @param value the string representation of the {@link Level}
+ * @return the matching {@link Level} instance
+ * @throws IllegalArgumentException if the provided value does not correspond to any defined {@link Level}
+ */
@JsonCreator
public static Level fromValue(String value) {
Level constant = CONSTANTS.get(value);
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/service/localvc/GitPublickeyAuthenticatorService.java b/src/main/java/de/tum/cit/aet/artemis/programming/service/localvc/GitPublickeyAuthenticatorService.java
index 4f0cad0aa4e9..3c9bc85f83a4 100644
--- a/src/main/java/de/tum/cit/aet/artemis/programming/service/localvc/GitPublickeyAuthenticatorService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/service/localvc/GitPublickeyAuthenticatorService.java
@@ -5,6 +5,7 @@
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.PublicKey;
+import java.time.ZonedDateTime;
import java.util.Objects;
import java.util.Optional;
@@ -13,11 +14,14 @@
import org.apache.sshd.server.session.ServerSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
import de.tum.cit.aet.artemis.buildagent.dto.BuildAgentInformation;
import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.programming.domain.UserSshPublicKey;
+import de.tum.cit.aet.artemis.programming.repository.UserSshPublicKeyRepository;
import de.tum.cit.aet.artemis.programming.service.localci.SharedQueueManagementService;
import de.tum.cit.aet.artemis.programming.service.localvc.ssh.HashUtils;
import de.tum.cit.aet.artemis.programming.service.localvc.ssh.SshConstants;
@@ -32,41 +36,85 @@ public class GitPublickeyAuthenticatorService implements PublickeyAuthenticator
private final Optional localCIBuildJobQueueService;
- public GitPublickeyAuthenticatorService(UserRepository userRepository, Optional localCIBuildJobQueueService) {
+ private final UserSshPublicKeyRepository userSshPublicKeyRepository;
+
+ private final int AUTHENTICATION_FAILED_CODE = 10;
+
+ @Value("${server.url}")
+ private String artemisServerUrl;
+
+ public GitPublickeyAuthenticatorService(UserRepository userRepository, Optional localCIBuildJobQueueService,
+ UserSshPublicKeyRepository userSshPublicKeyRepository) {
this.userRepository = userRepository;
this.localCIBuildJobQueueService = localCIBuildJobQueueService;
+ this.userSshPublicKeyRepository = userSshPublicKeyRepository;
}
@Override
public boolean authenticate(String username, PublicKey publicKey, ServerSession session) {
String keyHash = HashUtils.getSha512Fingerprint(publicKey);
- var user = userRepository.findBySshPublicKeyHash(keyHash);
- if (user.isPresent()) {
- try {
- // Retrieve the stored public key string
- String storedPublicKeyString = user.get().getSshPublicKey();
-
- // Parse the stored public key string
- AuthorizedKeyEntry keyEntry = AuthorizedKeyEntry.parseAuthorizedKeyEntry(storedPublicKeyString);
- PublicKey storedPublicKey = keyEntry.resolvePublicKey(null, null, null);
-
- // Compare the stored public key with the provided public key
- if (Objects.equals(storedPublicKey, publicKey)) {
- log.debug("Found user {} for public key authentication", user.get().getLogin());
- session.setAttribute(SshConstants.USER_KEY, user.get());
- session.setAttribute(SshConstants.IS_BUILD_AGENT_KEY, false);
- return true;
- }
- else {
- log.warn("Public key mismatch for user {}", user.get().getLogin());
- }
+ var userSshPublicKey = userSshPublicKeyRepository.findByKeyHash(keyHash);
+ return userSshPublicKey.map(sshPublicKey -> {
+ ZonedDateTime expiryDate = sshPublicKey.getExpiryDate();
+ if (expiryDate == null || expiryDate.isAfter(ZonedDateTime.now())) {
+ return authenticateUser(sshPublicKey, publicKey, session);
+ }
+ else {
+ disconnectBecauseKeyHasExpired(session);
+ }
+
+ return false;
+ }).orElseGet(() -> authenticateBuildAgent(publicKey, session));
+ }
+
+ /**
+ * Tries to authenticate a user by the provided key
+ *
+ * @param storedKey The key stored in the Artemis database
+ * @param providedKey The key provided by the user for authentication
+ * @param session The SSH server session
+ *
+ * @return true if the authentication succeeds, and false if it doesn't
+ */
+ private boolean authenticateUser(UserSshPublicKey storedKey, PublicKey providedKey, ServerSession session) {
+ try {
+ var user = userRepository.findById(storedKey.getUserId());
+ if (user.isEmpty()) {
+ return false;
+ }
+ // Retrieve and parse the stored public key string
+ AuthorizedKeyEntry keyEntry = AuthorizedKeyEntry.parseAuthorizedKeyEntry(storedKey.getPublicKey());
+ PublicKey storedPublicKey = keyEntry.resolvePublicKey(null, null, null);
+
+ // Compare the stored public key with the provided public key
+ if (Objects.equals(storedPublicKey, providedKey)) {
+ log.debug("Found user {} for public key authentication", user.get().getLogin());
+ session.setAttribute(SshConstants.USER_KEY, user.get());
+ session.setAttribute(SshConstants.IS_BUILD_AGENT_KEY, false);
+ return true;
}
- catch (Exception e) {
- log.error("Failed to convert stored public key string to PublicKey object", e);
+ else {
+ log.warn("Public key mismatch for user {}", user.get().getLogin());
}
}
- else if (localCIBuildJobQueueService.isPresent()
- && localCIBuildJobQueueService.get().getBuildAgentInformation().stream().anyMatch(agent -> checkPublicKeyMatchesBuildAgentPublicKey(agent, publicKey))) {
+ catch (Exception e) {
+ log.error("Failed to convert stored public key string to PublicKey object", e);
+ }
+ return false;
+ }
+
+ /**
+ * Tries to authenticate a build agent by the provided key
+ *
+ * @param providedKey The key provided by the user for authentication
+ * @param session The SSH server session
+ *
+ * @return true if the authentication succeeds, and false if it doesn't
+ */
+ private boolean authenticateBuildAgent(PublicKey providedKey, ServerSession session) {
+ if (localCIBuildJobQueueService.isPresent()
+ && localCIBuildJobQueueService.get().getBuildAgentInformation().stream().anyMatch(agent -> checkPublicKeyMatchesBuildAgentPublicKey(agent, providedKey))) {
+
log.info("Authenticating as build agent");
session.setAttribute(SshConstants.IS_BUILD_AGENT_KEY, true);
return true;
@@ -74,6 +122,14 @@ else if (localCIBuildJobQueueService.isPresent()
return false;
}
+ /**
+ * Checks whether a provided key matches the build agents public key
+ *
+ * @param agent The build agent which tires to be authenticated by Artemis
+ * @param publicKey The provided public key
+ *
+ * @return true if the build agents has this public key, and false if it doesn't
+ */
private boolean checkPublicKeyMatchesBuildAgentPublicKey(BuildAgentInformation agent, PublicKey publicKey) {
if (agent.publicSshKey() == null) {
return false;
@@ -90,4 +146,25 @@ private boolean checkPublicKeyMatchesBuildAgentPublicKey(BuildAgentInformation a
return agentPublicKey.equals(publicKey);
}
+
+ /**
+ * Disconnects the client from the session and informs that the key used to authenticate with has expired
+ *
+ * @param session the session with the client
+ */
+ private void disconnectBecauseKeyHasExpired(ServerSession session) {
+ try {
+ var keyExpiredErrorMessage = String.format("""
+ Keys expired.
+
+ One of your SSH keys has expired. Renew it in the Artemis settings:
+ %s/user-settings/ssh
+ """, artemisServerUrl);
+
+ session.disconnect(AUTHENTICATION_FAILED_CODE, keyExpiredErrorMessage);
+ }
+ catch (IOException e) {
+ log.info("Failed to disconnect SSH client session {}", e.getMessage());
+ }
+ }
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/web/ProgrammingExerciseExportImportResource.java b/src/main/java/de/tum/cit/aet/artemis/programming/web/ProgrammingExerciseExportImportResource.java
index 1659956ac1f8..748645568dc6 100644
--- a/src/main/java/de/tum/cit/aet/artemis/programming/web/ProgrammingExerciseExportImportResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/web/ProgrammingExerciseExportImportResource.java
@@ -42,7 +42,7 @@
import de.tum.cit.aet.artemis.assessment.domain.Visibility;
import de.tum.cit.aet.artemis.athena.service.AthenaModuleService;
-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.Course;
import de.tum.cit.aet.artemis.core.domain.User;
import de.tum.cit.aet.artemis.core.dto.RepositoryExportOptionsDTO;
@@ -95,7 +95,7 @@ public class ProgrammingExerciseExportImportResource {
private static final String ENTITY_NAME = "programmingExercise";
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
@Value("${jhipster.clientApp.name}")
private String applicationName;
@@ -136,7 +136,7 @@ public ProgrammingExerciseExportImportResource(ProgrammingExerciseRepository pro
AuxiliaryRepositoryRepository auxiliaryRepositoryRepository, SubmissionPolicyService submissionPolicyService,
ProgrammingExerciseTaskRepository programmingExerciseTaskRepository, ExamAccessService examAccessService, CourseRepository courseRepository,
ProgrammingExerciseImportFromFileService programmingExerciseImportFromFileService, ConsistencyCheckService consistencyCheckService,
- Optional athenaModuleService, CompetencyProgressService competencyProgressService) {
+ Optional athenaModuleService, CompetencyProgressApi competencyProgressApi) {
this.programmingExerciseRepository = programmingExerciseRepository;
this.userRepository = userRepository;
this.courseService = courseService;
@@ -152,7 +152,7 @@ public ProgrammingExerciseExportImportResource(ProgrammingExerciseRepository pro
this.programmingExerciseImportFromFileService = programmingExerciseImportFromFileService;
this.consistencyCheckService = consistencyCheckService;
this.athenaModuleService = athenaModuleService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
/**
@@ -259,7 +259,7 @@ public ResponseEntity importProgrammingExercise(@PathVariab
importedProgrammingExercise.setExerciseHints(null);
importedProgrammingExercise.setTasks(null);
- competencyProgressService.updateProgressByLearningObjectAsync(importedProgrammingExercise);
+ competencyProgressApi.updateProgressByLearningObjectAsync(importedProgrammingExercise);
return ResponseEntity.ok().headers(HeaderUtil.createEntityCreationAlert(applicationName, true, ENTITY_NAME, importedProgrammingExercise.getTitle()))
.body(importedProgrammingExercise);
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/web/localvc/ssh/SshPublicKeysResource.java b/src/main/java/de/tum/cit/aet/artemis/programming/web/localvc/ssh/SshPublicKeysResource.java
new file mode 100644
index 000000000000..8eb38fdfd263
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/web/localvc/ssh/SshPublicKeysResource.java
@@ -0,0 +1,117 @@
+package de.tum.cit.aet.artemis.programming.web.localvc.ssh;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_LOCALVC;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.util.List;
+
+import org.apache.sshd.common.config.keys.AuthorizedKeyEntry;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import de.tum.cit.aet.artemis.core.domain.User;
+import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
+import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastStudent;
+import de.tum.cit.aet.artemis.programming.domain.UserSshPublicKey;
+import de.tum.cit.aet.artemis.programming.dto.UserSshPublicKeyDTO;
+import de.tum.cit.aet.artemis.programming.service.UserSshPublicKeyService;
+
+@Profile(PROFILE_LOCALVC)
+@RestController
+@RequestMapping("api/ssh-settings/")
+public class SshPublicKeysResource {
+
+ private static final Logger log = LoggerFactory.getLogger(SshPublicKeysResource.class);
+
+ private final UserSshPublicKeyService userSshPublicKeyService;
+
+ private final UserRepository userRepository;
+
+ public SshPublicKeysResource(UserSshPublicKeyService userSshPublicKeyService, UserRepository userRepository) {
+ this.userSshPublicKeyService = userSshPublicKeyService;
+ this.userRepository = userRepository;
+ }
+
+ /**
+ * GET public-keys : retrieves all SSH keys of a user
+ *
+ * @return the ResponseEntity containing all public SSH keys of a user with status 200 (OK)
+ */
+ @GetMapping("public-keys")
+ @EnforceAtLeastStudent
+ public ResponseEntity> getSshPublicKeys() {
+ User user = userRepository.getUser();
+ List keys = userSshPublicKeyService.getAllSshKeysForUser(user);
+ return ResponseEntity.ok(keys);
+ }
+
+ /**
+ * GET public-key : gets the ssh public key
+ *
+ * @param keyId The id of the key that should be fetched
+ *
+ * @return the ResponseEntity containing the requested public SSH key of a user with status 200 (OK), or with status 403 (Access Forbidden) if the key does not exist or is not
+ * owned by the requesting user
+ */
+ @GetMapping("public-key/{keyId}")
+ @EnforceAtLeastStudent
+ public ResponseEntity getSshPublicKey(@PathVariable Long keyId) {
+ User user = userRepository.getUser();
+ UserSshPublicKey key = userSshPublicKeyService.getSshKeyForUser(user, keyId);
+ return ResponseEntity.ok(UserSshPublicKeyDTO.of(key));
+ }
+
+ /**
+ * POST public-key : creates a new ssh public key for a user
+ *
+ * @param sshPublicKey the ssh public key to create
+ *
+ * @return the ResponseEntity with status 200 (OK), or with status 400 (Bad Request) when the SSH key is malformed, the label is too long, or when a key with the same hash
+ * already exists
+ */
+ @PostMapping("public-key")
+ @EnforceAtLeastStudent
+ public ResponseEntity addSshPublicKey(@RequestBody UserSshPublicKeyDTO sshPublicKey) throws GeneralSecurityException, IOException {
+ User user = userRepository.getUser();
+ log.debug("REST request to add SSH key to user {}", user.getLogin());
+ AuthorizedKeyEntry keyEntry;
+ try {
+ keyEntry = AuthorizedKeyEntry.parseAuthorizedKeyEntry(sshPublicKey.publicKey());
+ }
+ catch (IllegalArgumentException e) {
+ throw new BadRequestAlertException("Invalid SSH key format", "SSH key", "invalidKeyFormat", true);
+ }
+
+ userSshPublicKeyService.createSshKeyForUser(user, keyEntry, sshPublicKey);
+ return ResponseEntity.ok().build();
+ }
+
+ /**
+ * Delete - public-key : deletes the ssh public key by its keyId
+ *
+ * @param keyId The id of the key that should be deleted
+ *
+ * @return the ResponseEntity with status 200 (OK) when the deletion succeeded, or with status 403 (Access Forbidden) if the key does not belong to the user, or does not exist
+ */
+ @DeleteMapping("public-key/{keyId}")
+ @EnforceAtLeastStudent
+ public ResponseEntity deleteSshPublicKey(@PathVariable Long keyId) {
+ User user = userRepository.getUser();
+ log.debug("REST request to remove SSH key of user {}", user.getLogin());
+ userSshPublicKeyService.deleteUserSshPublicKey(user.getId(), keyId);
+
+ log.debug("Successfully deleted SSH key with id {} of user {}", keyId, user.getLogin());
+ return ResponseEntity.ok().build();
+ }
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/quiz/service/QuizExerciseImportService.java b/src/main/java/de/tum/cit/aet/artemis/quiz/service/QuizExerciseImportService.java
index 1b26865c641b..b76d15598f91 100644
--- a/src/main/java/de/tum/cit/aet/artemis/quiz/service/QuizExerciseImportService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/quiz/service/QuizExerciseImportService.java
@@ -24,7 +24,7 @@
import de.tum.cit.aet.artemis.assessment.repository.ExampleSubmissionRepository;
import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
import de.tum.cit.aet.artemis.assessment.service.FeedbackService;
-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.communication.service.conversation.ChannelService;
import de.tum.cit.aet.artemis.core.service.FilePathService;
import de.tum.cit.aet.artemis.core.service.FileService;
@@ -56,16 +56,16 @@ public class QuizExerciseImportService extends ExerciseImportService {
private final ChannelService channelService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
public QuizExerciseImportService(QuizExerciseService quizExerciseService, FileService fileService, ExampleSubmissionRepository exampleSubmissionRepository,
SubmissionRepository submissionRepository, ResultRepository resultRepository, ChannelService channelService, FeedbackService feedbackService,
- CompetencyProgressService competencyProgressService) {
+ CompetencyProgressApi competencyProgressApi) {
super(exampleSubmissionRepository, submissionRepository, resultRepository, feedbackService);
this.quizExerciseService = quizExerciseService;
this.fileService = fileService;
this.channelService = channelService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
/**
@@ -90,7 +90,7 @@ public QuizExercise importQuizExercise(final QuizExercise templateExercise, Quiz
channelService.createExerciseChannel(newQuizExercise, Optional.ofNullable(importedExercise.getChannelName()));
- competencyProgressService.updateProgressByLearningObjectAsync(newQuizExercise);
+ competencyProgressApi.updateProgressByLearningObjectAsync(newQuizExercise);
if (files != null) {
newQuizExercise = quizExerciseService.save(quizExerciseService.uploadNewFilesToNewImportedQuiz(newQuizExercise, files));
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/quiz/web/QuizExerciseResource.java b/src/main/java/de/tum/cit/aet/artemis/quiz/web/QuizExerciseResource.java
index d9d276bb3bd4..ecb693e49250 100644
--- a/src/main/java/de/tum/cit/aet/artemis/quiz/web/QuizExerciseResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/quiz/web/QuizExerciseResource.java
@@ -38,7 +38,7 @@
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
-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.communication.domain.conversation.Channel;
import de.tum.cit.aet.artemis.communication.repository.conversation.ChannelRepository;
import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
@@ -148,7 +148,7 @@ public class QuizExerciseResource {
private final ChannelRepository channelRepository;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
public QuizExerciseResource(QuizExerciseService quizExerciseService, QuizMessagingService quizMessagingService, QuizExerciseRepository quizExerciseRepository,
UserRepository userRepository, CourseService courseService, ExerciseService exerciseService, ExerciseDeletionService exerciseDeletionService,
@@ -156,7 +156,7 @@ public QuizExerciseResource(QuizExerciseService quizExerciseService, QuizMessagi
QuizExerciseImportService quizExerciseImportService, AuthorizationCheckService authCheckService, GroupNotificationService groupNotificationService,
GroupNotificationScheduleService groupNotificationScheduleService, StudentParticipationRepository studentParticipationRepository, QuizBatchService quizBatchService,
QuizBatchRepository quizBatchRepository, FileService fileService, ChannelService channelService, ChannelRepository channelRepository,
- QuizSubmissionService quizSubmissionService, QuizResultService quizResultService, CompetencyProgressService competencyProgressService) {
+ QuizSubmissionService quizSubmissionService, QuizResultService quizResultService, CompetencyProgressApi competencyProgressApi) {
this.quizExerciseService = quizExerciseService;
this.quizMessagingService = quizMessagingService;
this.quizExerciseRepository = quizExerciseRepository;
@@ -179,7 +179,7 @@ public QuizExerciseResource(QuizExerciseService quizExerciseService, QuizMessagi
this.channelRepository = channelRepository;
this.quizSubmissionService = quizSubmissionService;
this.quizResultService = quizResultService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
}
/**
@@ -241,7 +241,7 @@ public ResponseEntity createQuizExercise(@RequestPart("exercise")
channelService.createExerciseChannel(result, Optional.ofNullable(quizExercise.getChannelName()));
- competencyProgressService.updateProgressByLearningObjectAsync(result);
+ competencyProgressApi.updateProgressByLearningObjectAsync(result);
return ResponseEntity.created(new URI("/api/quiz-exercises/" + result.getId()))
.headers(HeaderUtil.createEntityCreationAlert(applicationName, true, ENTITY_NAME, result.getId().toString())).body(result);
@@ -308,7 +308,7 @@ public ResponseEntity updateQuizExercise(@PathVariable Long exerci
if (updatedChannel != null) {
quizExercise.setChannelName(updatedChannel.getName());
}
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(originalQuiz, Optional.of(quizExercise));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(originalQuiz, Optional.of(quizExercise));
return ResponseEntity.ok(quizExercise);
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/text/service/TextAssessmentService.java b/src/main/java/de/tum/cit/aet/artemis/text/service/TextAssessmentService.java
index ad1e367c2735..774e3655e752 100644
--- a/src/main/java/de/tum/cit/aet/artemis/text/service/TextAssessmentService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/text/service/TextAssessmentService.java
@@ -44,7 +44,7 @@ public TextAssessmentService(UserRepository userRepository, ComplaintResponseSer
SubmissionService submissionService, Optional ltiNewResultService, SingleUserNotificationService singleUserNotificationService,
ResultWebsocketService resultWebsocketService, LongFeedbackTextRepository longFeedbackTextRepository) {
super(complaintResponseService, complaintRepository, feedbackRepository, resultRepository, studentParticipationRepository, resultService, submissionService,
- submissionRepository, examDateService, userRepository, ltiNewResultService, singleUserNotificationService, resultWebsocketService, longFeedbackTextRepository);
+ submissionRepository, examDateService, userRepository, ltiNewResultService, singleUserNotificationService, resultWebsocketService);
this.textBlockService = textBlockService;
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/text/service/TextExerciseImportService.java b/src/main/java/de/tum/cit/aet/artemis/text/service/TextExerciseImportService.java
index 161c6426589b..f45cadcd7ddd 100644
--- a/src/main/java/de/tum/cit/aet/artemis/text/service/TextExerciseImportService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/text/service/TextExerciseImportService.java
@@ -27,7 +27,7 @@
import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
import de.tum.cit.aet.artemis.assessment.repository.TextBlockRepository;
import de.tum.cit.aet.artemis.assessment.service.FeedbackService;
-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.communication.service.conversation.ChannelService;
import de.tum.cit.aet.artemis.exercise.domain.Exercise;
import de.tum.cit.aet.artemis.exercise.domain.Submission;
@@ -57,13 +57,13 @@ public class TextExerciseImportService extends ExerciseImportService {
private final ChannelService channelService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final ExerciseService exerciseService;
public TextExerciseImportService(TextExerciseRepository textExerciseRepository, ExampleSubmissionRepository exampleSubmissionRepository,
SubmissionRepository submissionRepository, ResultRepository resultRepository, TextBlockRepository textBlockRepository, FeedbackRepository feedbackRepository,
- TextSubmissionRepository textSubmissionRepository, ChannelService channelService, FeedbackService feedbackService, CompetencyProgressService competencyProgressService,
+ TextSubmissionRepository textSubmissionRepository, ChannelService channelService, FeedbackService feedbackService, CompetencyProgressApi competencyProgressApi,
ExerciseService exerciseService) {
super(exampleSubmissionRepository, submissionRepository, resultRepository, feedbackService);
this.textBlockRepository = textBlockRepository;
@@ -71,7 +71,7 @@ public TextExerciseImportService(TextExerciseRepository textExerciseRepository,
this.feedbackRepository = feedbackRepository;
this.textSubmissionRepository = textSubmissionRepository;
this.channelService = channelService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.exerciseService = exerciseService;
}
@@ -100,7 +100,7 @@ public TextExercise importTextExercise(final TextExercise templateExercise, Text
channelService.createExerciseChannel(newTextExercise, Optional.ofNullable(importedExercise.getChannelName()));
newExercise.setExampleSubmissions(copyExampleSubmission(templateExercise, newExercise, gradingInstructionCopyTracker));
- competencyProgressService.updateProgressByLearningObjectAsync(newTextExercise);
+ competencyProgressApi.updateProgressByLearningObjectAsync(newTextExercise);
return newExercise;
}
diff --git a/src/main/java/de/tum/cit/aet/artemis/text/web/TextExerciseResource.java b/src/main/java/de/tum/cit/aet/artemis/text/web/TextExerciseResource.java
index 0040e183e1e8..0b72f23ba0db 100644
--- a/src/main/java/de/tum/cit/aet/artemis/text/web/TextExerciseResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/text/web/TextExerciseResource.java
@@ -41,7 +41,7 @@
import de.tum.cit.aet.artemis.assessment.repository.ResultRepository;
import de.tum.cit.aet.artemis.assessment.repository.TextBlockRepository;
import de.tum.cit.aet.artemis.athena.service.AthenaModuleService;
-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.communication.domain.conversation.Channel;
import de.tum.cit.aet.artemis.communication.repository.conversation.ChannelRepository;
import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
@@ -154,7 +154,7 @@ public class TextExerciseResource {
private final Optional athenaModuleService;
- private final CompetencyProgressService competencyProgressService;
+ private final CompetencyProgressApi competencyProgressApi;
private final Optional irisSettingsService;
@@ -165,8 +165,8 @@ public TextExerciseResource(TextExerciseRepository textExerciseRepository, TextE
TextSubmissionExportService textSubmissionExportService, ExampleSubmissionRepository exampleSubmissionRepository, ExerciseService exerciseService,
GradingCriterionRepository gradingCriterionRepository, TextBlockRepository textBlockRepository, GroupNotificationScheduleService groupNotificationScheduleService,
InstanceMessageSendService instanceMessageSendService, PlagiarismDetectionService plagiarismDetectionService, CourseRepository courseRepository,
- ChannelService channelService, ChannelRepository channelRepository, Optional athenaModuleService,
- CompetencyProgressService competencyProgressService, Optional irisSettingsService) {
+ ChannelService channelService, ChannelRepository channelRepository, Optional athenaModuleService, CompetencyProgressApi competencyProgressApi,
+ Optional irisSettingsService) {
this.feedbackRepository = feedbackRepository;
this.exerciseDeletionService = exerciseDeletionService;
this.plagiarismResultRepository = plagiarismResultRepository;
@@ -191,7 +191,7 @@ public TextExerciseResource(TextExerciseRepository textExerciseRepository, TextE
this.channelService = channelService;
this.channelRepository = channelRepository;
this.athenaModuleService = athenaModuleService;
- this.competencyProgressService = competencyProgressService;
+ this.competencyProgressApi = competencyProgressApi;
this.irisSettingsService = irisSettingsService;
}
@@ -232,7 +232,7 @@ public ResponseEntity createTextExercise(@RequestBody TextExercise
channelService.createExerciseChannel(result, Optional.ofNullable(textExercise.getChannelName()));
instanceMessageSendService.sendTextExerciseSchedule(result.getId());
groupNotificationScheduleService.checkNotificationsForNewExerciseAsync(textExercise);
- competencyProgressService.updateProgressByLearningObjectAsync(result);
+ competencyProgressApi.updateProgressByLearningObjectAsync(result);
irisSettingsService.ifPresent(iss -> iss.setEnabledForExerciseByCategories(result, new HashSet<>()));
@@ -294,7 +294,7 @@ public ResponseEntity updateTextExercise(@RequestBody TextExercise
exerciseService.checkExampleSubmissions(updatedTextExercise);
exerciseService.notifyAboutExerciseChanges(textExerciseBeforeUpdate, updatedTextExercise, notificationText);
- competencyProgressService.updateProgressForUpdatedLearningObjectAsync(textExerciseBeforeUpdate, Optional.of(textExercise));
+ competencyProgressApi.updateProgressForUpdatedLearningObjectAsync(textExerciseBeforeUpdate, Optional.of(textExercise));
irisSettingsService.ifPresent(iss -> iss.setEnabledForExerciseByCategories(textExercise, textExerciseBeforeUpdate.getCategories()));
diff --git a/src/main/resources/config/liquibase/changelog/20241105150000_changelog.xml b/src/main/resources/config/liquibase/changelog/20241105150000_changelog.xml
new file mode 100644
index 000000000000..0e7e5e68aac6
--- /dev/null
+++ b/src/main/resources/config/liquibase/changelog/20241105150000_changelog.xml
@@ -0,0 +1,59 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ INSERT INTO user_public_ssh_key (user_id, label, public_key, key_hash, creation_date, last_used_date, expiry_date)
+ SELECT id, 'Key 1', ssh_public_key, ssh_public_key_hash, CURRENT_TIMESTAMP, NULL, NULL
+ FROM jhi_user
+ WHERE ssh_public_key IS NOT NULL;
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/config/liquibase/master.xml b/src/main/resources/config/liquibase/master.xml
index e29f09657055..d331337ceef4 100644
--- a/src/main/resources/config/liquibase/master.xml
+++ b/src/main/resources/config/liquibase/master.xml
@@ -29,11 +29,12 @@
-
+
+
diff --git a/src/main/webapp/app/core/auth/account.service.ts b/src/main/webapp/app/core/auth/account.service.ts
index a89944954c05..8745ae5357b9 100644
--- a/src/main/webapp/app/core/auth/account.service.ts
+++ b/src/main/webapp/app/core/auth/account.service.ts
@@ -30,7 +30,6 @@ export interface IAccountService {
isAuthenticated: () => boolean;
getAuthenticationState: () => Observable;
getImageUrl: () => string | undefined;
- addSshPublicKey: (sshPublicKey: string) => Observable;
}
@Injectable({ providedIn: 'root' })
@@ -325,28 +324,6 @@ export class AccountService implements IAccountService {
this.prefilledUsernameValue = prefilledUsername;
}
- /**
- * Sends the added SSH key to the server
- *
- * @param sshPublicKey
- */
- addSshPublicKey(sshPublicKey: string): Observable {
- if (this.userIdentity) {
- this.userIdentity.sshPublicKey = sshPublicKey;
- }
- return this.http.put('api/account/ssh-public-key', sshPublicKey);
- }
-
- /**
- * Sends a request to the server to delete the user's current SSH key
- */
- deleteSshPublicKey(): Observable {
- if (this.userIdentity) {
- this.userIdentity.sshPublicKey = undefined;
- }
- return this.http.delete('api/account/ssh-public-key');
- }
-
/**
* Sends a request to the server to delete the user's current vcsAccessToken
*/
diff --git a/src/main/webapp/app/core/user/user.model.ts b/src/main/webapp/app/core/user/user.model.ts
index f793581b21a3..52fa28f56ab9 100644
--- a/src/main/webapp/app/core/user/user.model.ts
+++ b/src/main/webapp/app/core/user/user.model.ts
@@ -15,8 +15,6 @@ export class User extends Account {
public password?: string;
public vcsAccessToken?: string;
public vcsAccessTokenExpiryDate?: string;
- public sshPublicKey?: string;
- public sshKeyHash?: string;
public irisAccepted?: dayjs.Dayjs;
constructor(
@@ -38,7 +36,6 @@ export class User extends Account {
imageUrl?: string,
vcsAccessToken?: string,
vcsAccessTokenExpiryDate?: string,
- sshPublicKey?: string,
irisAccepted?: dayjs.Dayjs,
) {
super(activated, authorities, email, firstName, langKey, lastName, login, imageUrl);
@@ -52,7 +49,6 @@ export class User extends Account {
this.password = password;
this.vcsAccessToken = vcsAccessToken;
this.vcsAccessTokenExpiryDate = vcsAccessTokenExpiryDate;
- this.sshPublicKey = sshPublicKey;
this.irisAccepted = irisAccepted;
}
}
diff --git a/src/main/webapp/app/course/manage/course-update.component.ts b/src/main/webapp/app/course/manage/course-update.component.ts
index 08f48b72632a..fd7c49954ea4 100644
--- a/src/main/webapp/app/course/manage/course-update.component.ts
+++ b/src/main/webapp/app/course/manage/course-update.component.ts
@@ -1,5 +1,5 @@
import { ActivatedRoute, Router } from '@angular/router';
-import { Component, ElementRef, OnInit, ViewChild } from '@angular/core';
+import { Component, ElementRef, OnInit, ViewChild, inject } from '@angular/core';
import { FormControl, FormGroup, ValidatorFn, Validators } from '@angular/forms';
import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
import { AlertService, AlertType } from 'app/core/util/alert.service';
@@ -31,6 +31,7 @@ import { onError } from 'app/shared/util/global.utils';
import { getSemesters } from 'app/utils/semester-utils';
import { ImageCropperModalComponent } from 'app/course/manage/image-cropper-modal.component';
import { scrollToTopOfPage } from 'app/shared/util/utils';
+import { CourseStorageService } from 'app/course/manage/course-storage.service';
const DEFAULT_CUSTOM_GROUP_NAME = 'artemis-dev';
@@ -78,6 +79,8 @@ export class CourseUpdateComponent implements OnInit {
isAthenaEnabled = false;
tutorialGroupsFeatureActivated = false;
+ private courseStorageServivce = inject(CourseStorageService);
+
readonly semesters = getSemesters();
// NOTE: These constants are used to define the maximum length of complaints and complaint responses.
@@ -344,6 +347,7 @@ export class CourseUpdateComponent implements OnInit {
name: 'courseModification',
content: 'Changed a course',
});
+ this.courseStorageServivce.updateCourse(updatedCourse!);
}
this.router.navigate(['course-management', updatedCourse?.id?.toString()]);
diff --git a/src/main/webapp/app/entities/course.model.ts b/src/main/webapp/app/entities/course.model.ts
index 6cddcfe61040..f3084853431a 100644
--- a/src/main/webapp/app/entities/course.model.ts
+++ b/src/main/webapp/app/entities/course.model.ts
@@ -13,6 +13,7 @@ import { TutorialGroup } from 'app/entities/tutorial-group/tutorial-group.model'
import { TutorialGroupsConfiguration } from 'app/entities/tutorial-group/tutorial-groups-configuration.model';
import { LearningPath } from 'app/entities/competency/learning-path.model';
import { Prerequisite } from 'app/entities/prerequisite.model';
+import { Faq } from 'app/entities/faq.model';
export enum CourseInformationSharingConfiguration {
COMMUNICATION_AND_MESSAGING = 'COMMUNICATION_AND_MESSAGING',
@@ -28,6 +29,10 @@ export function isCommunicationEnabled(course: Course | undefined) {
return config === CourseInformationSharingConfiguration.COMMUNICATION_AND_MESSAGING || config === CourseInformationSharingConfiguration.COMMUNICATION_ONLY;
}
+export function isFaqEnabled(course: Course | undefined) {
+ return course?.faqEnabled;
+}
+
/**
* Note: Keep in sync with method in CourseRepository.java
*/
@@ -98,6 +103,7 @@ export class Course implements BaseEntity {
public exercises?: Exercise[];
public lectures?: Lecture[];
+ public faqs?: Faq[];
public competencies?: Competency[];
public prerequisites?: Prerequisite[];
public learningPathsEnabled?: boolean;
diff --git a/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts b/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts
index 9d1e9986329e..d83c834fe83a 100644
--- a/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts
+++ b/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts
@@ -6,8 +6,17 @@ export class AttachmentUnit extends LectureUnit {
public description?: string;
public attachment?: Attachment;
public slides?: Slide[];
+ public pyrisIngestionState?: IngestionState;
constructor() {
super(LectureUnitType.ATTACHMENT);
}
}
+
+export enum IngestionState {
+ NOT_STARTED = 'NOT_STARTED',
+ IN_PROGRESS = 'IN_PROGRESS',
+ DONE = 'DONE',
+ ERROR = 'ERROR',
+ PARTIALLY_INGESTED = 'PARTIALLY_INGESTED',
+}
diff --git a/src/main/webapp/app/entities/lecture.model.ts b/src/main/webapp/app/entities/lecture.model.ts
index 3f039edafe40..d213ed53de1d 100644
--- a/src/main/webapp/app/entities/lecture.model.ts
+++ b/src/main/webapp/app/entities/lecture.model.ts
@@ -4,6 +4,7 @@ import { Attachment } from 'app/entities/attachment.model';
import { Post } from 'app/entities/metis/post.model';
import { Course } from 'app/entities/course.model';
import { LectureUnit } from 'app/entities/lecture-unit/lectureUnit.model';
+import { IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
export class Lecture implements BaseEntity {
id?: number;
@@ -21,6 +22,7 @@ export class Lecture implements BaseEntity {
channelName?: string;
isAtLeastEditor?: boolean;
isAtLeastInstructor?: boolean;
+ ingested?: IngestionState;
constructor() {}
}
diff --git a/src/main/webapp/app/entities/programming/user-ssh-public-key.model.ts b/src/main/webapp/app/entities/programming/user-ssh-public-key.model.ts
new file mode 100644
index 000000000000..4d53e9d2cef5
--- /dev/null
+++ b/src/main/webapp/app/entities/programming/user-ssh-public-key.model.ts
@@ -0,0 +1,13 @@
+import { BaseEntity } from 'app/shared/model/base-entity';
+import dayjs from 'dayjs/esm';
+
+export class UserSshPublicKey implements BaseEntity {
+ id: number;
+ label: string;
+ publicKey: string;
+ keyHash: string;
+ expiryDate?: dayjs.Dayjs;
+ lastUsedDate?: dayjs.Dayjs;
+ creationDate: dayjs.Dayjs;
+ hasExpired?: boolean;
+}
diff --git a/src/main/webapp/app/lecture/lecture-attachments.component.html b/src/main/webapp/app/lecture/lecture-attachments.component.html
index 6192f270d64e..82050a7c3efe 100644
--- a/src/main/webapp/app/lecture/lecture-attachments.component.html
+++ b/src/main/webapp/app/lecture/lecture-attachments.component.html
@@ -44,7 +44,6 @@