Development: Introduce module-API for Atlas

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

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

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

@@ -0,0 +1,14 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_ATLAS;
+
+import org.springframework.core.env.Environment;
+
+import de.tum.cit.aet.artemis.core.api.AbstractApi;
+
+public abstract class AbstractAtlasApi extends AbstractApi {
+
+    protected AbstractAtlasApi(Environment environment) {
+        super(environment, PROFILE_ATLAS);
+    }
+}

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

@@ -0,0 +1,73 @@
+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 jakarta.validation.constraints.NotNull;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+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;
+
+@Profile(PROFILE_CORE)
+@Controller
+public class CompetencyProgressApi extends AbstractAtlasApi {
+
+    private final Optional<CompetencyProgressService> competencyProgressService;
+
+    private final Optional<CompetencyRepository> competencyRepository;
+
+    public CompetencyProgressApi(Environment environment, Optional<CompetencyProgressService> competencyProgressService, Optional<CompetencyRepository> competencyRepository) {
+        super(environment);
+        this.competencyProgressService = competencyProgressService;
+        this.competencyRepository = competencyRepository;
+    }
+
+    public void updateProgressByLearningObjectForParticipantAsync(LearningObject learningObject, @NotNull Participant participant) {
+        competencyProgressService.ifPresent(service -> service.updateProgressByLearningObjectForParticipantAsync(learningObject, participant));
+    }
+
+    public void updateProgressByLearningObjectAsync(LearningObject learningObject) {
+        competencyProgressService.ifPresent(service -> service.updateProgressByLearningObjectAsync(learningObject));
+    }
+
+    public void updateProgressByCompetencyAsync(CourseCompetency competency) {
+        competencyProgressService.ifPresent(service -> service.updateProgressByCompetencyAsync(competency));
+    }
+
+    public void updateProgressForUpdatedLearningObjectAsync(LearningObject originalLearningObject, Optional<LearningObject> updatedLearningObject) {
+        competencyProgressService.ifPresent(service -> service.updateProgressForUpdatedLearningObjectAsync(originalLearningObject, updatedLearningObject));
+    }
+
+    public void updateProgressByLearningObjectSync(LearningObject learningObject, Set<User> users) {
+        competencyProgressService.ifPresent(service -> service.updateProgressByLearningObjectSync(learningObject, users));
+    }
+
+    /**
+     * Updates the progress for all competencies of the given courses.
+     *
+     * @param activeCourses the active courses
+     */
+    public void updateProgressForCourses(List<Course> activeCourses) {
+        CompetencyProgressService competencyProgressService = getOrThrow(this.competencyProgressService);
+        CompetencyRepository competencyRepository = getOrThrow(this.competencyRepository);
+
+        activeCourses.forEach(course -> {
+            List<Competency> competencies = competencyRepository.findByCourseIdOrderById(course.getId());
+            // Asynchronously update the progress for each competency
+            competencies.forEach(competencyProgressService::updateProgressByCompetencyAsync);
+        });
+    }
+}

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

@@ -0,0 +1,78 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Optional;
+import java.util.Set;
+
+import jakarta.validation.constraints.NotNull;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.domain.competency.CourseCompetency;
+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.CourseCompetencyRepository;
+import de.tum.cit.aet.artemis.atlas.repository.PrerequisiteRepository;
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.lecture.domain.ExerciseUnit;
+import de.tum.cit.aet.artemis.lecture.domain.LectureUnit;
+
+@Profile(PROFILE_CORE)
+@Controller
+public class CourseCompetencyApi extends AbstractAtlasApi {
+
+    private final Optional<CourseCompetencyRepository> optionalCourseCompetencyRepository;
+
+    private final Optional<CompetencyRelationRepository> optionalCompetencyRelationRepository;
+
+    private final Optional<PrerequisiteRepository> optionalPrerequisitesRepository;
+
+    private final Optional<CompetencyRepository> optionalCompetencyRepository;
+
+    public CourseCompetencyApi(Environment environment, Optional<CourseCompetencyRepository> optionalCourseCompetencyRepository,
+            Optional<CompetencyRelationRepository> optionalCompetencyRelationRepository, Optional<PrerequisiteRepository> optionalPrerequisitesRepository,
+            Optional<CompetencyRepository> optionalCompetencyRepository) {
+        super(environment);
+        this.optionalCourseCompetencyRepository = optionalCourseCompetencyRepository;
+        this.optionalCompetencyRelationRepository = optionalCompetencyRelationRepository;
+        this.optionalPrerequisitesRepository = optionalPrerequisitesRepository;
+        this.optionalCompetencyRepository = optionalCompetencyRepository;
+    }
+
+    public void findAndSetCompetenciesForCourse(Course course) {
+        optionalCompetencyRepository.ifPresent(service -> course.setNumberOfCompetencies(service.countByCourse(course)));
+        optionalPrerequisitesRepository.ifPresent(service -> course.setNumberOfPrerequisites(service.countByCourse(course)));
+    }
+
+    public void deleteCompetenciesOfCourse(Course course) {
+        optionalCompetencyRelationRepository.ifPresent(service -> service.deleteAllByCourseId(course.getId()));
+        optionalPrerequisitesRepository.ifPresent(service -> service.deleteAll(course.getPrerequisites()));
+        optionalCompetencyRepository.ifPresent(service -> service.deleteAll(course.getCompetencies()));
+    }
+
+    /**
+     * ToDo: Consider moving to service
+     * Deletes the competencies associated with the given lecture unit.
+     *
+     * @param lectureUnit the lecture unit
+     */
+    public void deleteCompetencyOfLectureUnit(@NotNull LectureUnit lectureUnit) {
+        if (optionalCourseCompetencyRepository.isEmpty()) {
+            return;
+        }
+
+        CourseCompetencyRepository repository = optionalCourseCompetencyRepository.get();
+        if (!(lectureUnit instanceof ExerciseUnit)) {
+            // update associated competencies
+            Set<CourseCompetency> competencies = lectureUnit.getCompetencies();
+            repository.saveAll(competencies.stream().map(competency -> {
+                CourseCompetency updatedCompetency = repository.findByIdWithLectureUnitsElseThrow(competency.getId());
+                updatedCompetency.getLectureUnits().remove(lectureUnit);
+                return updatedCompetency;
+            }).toList());
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Optional;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.dto.metrics.StudentMetricsDTO;
+import de.tum.cit.aet.artemis.atlas.service.LearningMetricsService;
+
+@Profile(PROFILE_CORE)
+@Controller
+public class LearningMetricsApi extends AbstractAtlasApi {
+
+    private final Optional<LearningMetricsService> learningMetricsService;
+
+    public LearningMetricsApi(Environment environment, Optional<LearningMetricsService> learningMetricsService) {
+        super(environment);
+        this.learningMetricsService = learningMetricsService;
+    }
+
+    public StudentMetricsDTO getStudentCourseMetrics(long userId, long courseId) {
+        return getOrThrow(learningMetricsService).getStudentCourseMetrics(userId, courseId);
+    }
+}

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

@@ -0,0 +1,35 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Optional;
+
+import jakarta.validation.constraints.NotNull;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+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;
+
+@Profile(PROFILE_CORE)
+@Controller
+public class LearningPathApi extends AbstractAtlasApi {
+
+    private final Optional<LearningPathService> optionalLearningPathService;
+
+    public LearningPathApi(Environment environment, Optional<LearningPathService> optionalLearningPathService) {
+        super(environment);
+        this.optionalLearningPathService = optionalLearningPathService;
+    }
+
+    public void generateLearningPathForUser(@NotNull Course course, @NotNull User user) {
+        optionalLearningPathService.ifPresent(service -> service.generateLearningPathForUser(course, user));
+    }
+
+    public void generateLearningPaths(@NotNull Course course) {
+        optionalLearningPathService.ifPresent(service -> service.generateLearningPaths(course));
+    }
+}

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

@@ -0,0 +1,33 @@
+package de.tum.cit.aet.artemis.atlas.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Optional;
+import java.util.Set;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.atlas.domain.science.ScienceEvent;
+import de.tum.cit.aet.artemis.atlas.repository.ScienceEventRepository;
+
+@Profile(PROFILE_CORE)
+@Controller
+public class ScienceEventApi extends AbstractAtlasApi {
+
+    private final Optional<ScienceEventRepository> scienceEventRepository;
+
+    public ScienceEventApi(Environment environment, Optional<ScienceEventRepository> scienceEventRepository) {
+        super(environment);
+        this.scienceEventRepository = scienceEventRepository;
+    }
+
+    public Set<ScienceEvent> findAllByIdentity(String login) {
+        return getOrThrow(scienceEventRepository).findAllByIdentity(login);
+    }
+
+    public void renameIdentity(String oldIdentity, String newIdentity) {
+        scienceEventRepository.ifPresent(repository -> repository.renameIdentity(oldIdentity, newIdentity));
+    }
+}

src/main/java/de/tum/cit/aet/artemis/atlas/config/AtlasConfig.java

@@ -0,0 +1,35 @@
+package de.tum.cit.aet.artemis.atlas.config;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Set;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+import de.tum.cit.aet.artemis.core.config.AbstractModuleConfig;
+import de.tum.cit.aet.artemis.core.config.DatabaseConfiguration;
+import de.tum.cit.aet.artemis.core.repository.base.RepositoryImpl;
+
+@Profile(PROFILE_CORE) // in the future, we will switch to PROFILE_ATLAS
+@Configuration
+public class AtlasConfig extends AbstractModuleConfig {
+
+    /**
+     * Crucially required profiles for which - if not enabled - renders Atlas useless.
+     */
+    private static final Set<Profiles> requiredProfiles = Set.of(Profiles.of(PROFILE_CORE));
+
+    public AtlasConfig(Environment environment) {
+        super(environment, requiredProfiles);
+    }
+
+    @Profile(PROFILE_CORE)
+    @Configuration
+    @EnableJpaRepositories(basePackages = { "de.tum.cit.aet.artemis.atlas.repository" }, repositoryBaseClass = RepositoryImpl.class)
+    static class AtlasDatabaseConfig extends DatabaseConfiguration {
+    }
+}

src/main/java/de/tum/cit/aet/artemis/exercise/service/LearningMetricsService.java → 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;

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

src/main/java/de/tum/cit/aet/artemis/core/api/AbstractApi.java

@@ -0,0 +1,36 @@
+package de.tum.cit.aet.artemis.core.api;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Optional;
+
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+
+import de.tum.cit.aet.artemis.core.exception.ModuleNotPresentException;
+
+public abstract class AbstractApi {
+
+    private final Environment environment;
+
+    private final String profileName;
+
+    public AbstractApi(Environment environment, String profileName) {
+        this.environment = environment;
+        this.profileName = profileName;
+    }
+
+    public boolean isActive(String profileName) {
+        return environment.acceptsProfiles(Profiles.of(profileName));
+    }
+
+    /** @noinspection OptionalUsedAsFieldOrParameterType */
+    protected <T> T getOrThrow(Optional<T> instance) {
+        // noinspection UnnecessaryLocalVariable
+        String moduleProfileName = PROFILE_CORE; // in the future, we will switch to profileName
+        if (!isActive(moduleProfileName) || instance.isEmpty()) {
+            throw new ModuleNotPresentException(profileName);
+        }
+        return instance.get();
+    }
+}