Development: Introduce exam module API

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

@@ -21,11 +21,12 @@
 import de.tum.cit.aet.artemis.assessment.web.ResultWebsocketService;
 import de.tum.cit.aet.artemis.communication.service.notifications.SingleUserNotificationService;
 import de.tum.cit.aet.artemis.core.domain.User;
+import de.tum.cit.aet.artemis.core.exception.ApiNotPresentException;
 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.repository.UserRepository;
+import de.tum.cit.aet.artemis.exam.api.ExamDateApi;
 import de.tum.cit.aet.artemis.exam.domain.Exam;
-import de.tum.cit.aet.artemis.exam.service.ExamDateService;
 import de.tum.cit.aet.artemis.exercise.domain.Exercise;
 import de.tum.cit.aet.artemis.exercise.domain.Submission;
 import de.tum.cit.aet.artemis.exercise.domain.participation.StudentParticipation;
@@ -53,7 +54,7 @@ public class AssessmentService {
 
     protected final ResultService resultService;
 
-    private final ExamDateService examDateService;
+    private final Optional<ExamDateApi> examDateApi;
 
     protected final SubmissionRepository submissionRepository;
 
@@ -69,7 +70,7 @@ public class AssessmentService {
 
     public AssessmentService(ComplaintResponseService complaintResponseService, ComplaintRepository complaintRepository, FeedbackRepository feedbackRepository,
             ResultRepository resultRepository, StudentParticipationRepository studentParticipationRepository, ResultService resultService, SubmissionService submissionService,
-            SubmissionRepository submissionRepository, ExamDateService examDateService, UserRepository userRepository, Optional<LtiNewResultService> ltiNewResultService,
+            SubmissionRepository submissionRepository, Optional<ExamDateApi> examDateApi, UserRepository userRepository, Optional<LtiNewResultService> ltiNewResultService,
             SingleUserNotificationService singleUserNotificationService, ResultWebsocketService resultWebsocketService) {
         this.complaintResponseService = complaintResponseService;
         this.complaintRepository = complaintRepository;
@@ -79,7 +80,7 @@ public AssessmentService(ComplaintResponseService complaintResponseService, Comp
         this.resultService = resultService;
         this.submissionService = submissionService;
         this.submissionRepository = submissionRepository;
-        this.examDateService = examDateService;
+        this.examDateApi = examDateApi;
         this.userRepository = userRepository;
         this.ltiNewResultService = ltiNewResultService;
         this.singleUserNotificationService = singleUserNotificationService;
@@ -155,7 +156,8 @@ public boolean isAllowedToCreateOrOverrideResult(Result existingResult, Exercise
             // Tutors can assess exam exercises only after the last student has finished the exam and before the publishing result date
             if (isExamMode && !isAtLeastInstructor) {
                 final Exam exam = exercise.getExerciseGroup().getExam();
-                ZonedDateTime latestExamDueDate = examDateService.getLatestIndividualExamEndDate(exam.getId());
+                var api = examDateApi.orElseThrow(() -> new ApiNotPresentException(ExamDateApi.class, PROFILE_CORE));
+                ZonedDateTime latestExamDueDate = api.getLatestIndividualExamEndDate(exam.getId());
                 if (latestExamDueDate.isAfter(ZonedDateTime.now()) || (exam.getPublishResultsDate() != null && exam.getPublishResultsDate().isBefore(ZonedDateTime.now()))) {
                     return false;
                 }

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

@@ -27,10 +27,11 @@
 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.domain.User;
+import de.tum.cit.aet.artemis.core.exception.ApiNotPresentException;
 import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
 import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.exam.api.ExamRepositoryApi;
 import de.tum.cit.aet.artemis.exam.domain.Exam;
-import de.tum.cit.aet.artemis.exam.repository.ExamRepository;
 import de.tum.cit.aet.artemis.exercise.domain.Exercise;
 import de.tum.cit.aet.artemis.exercise.domain.Team;
 import de.tum.cit.aet.artemis.exercise.domain.participation.Participant;
@@ -55,16 +56,16 @@ public class ComplaintService {
 
     private final UserRepository userRepository;
 
-    private final ExamRepository examRepository;
+    private final Optional<ExamRepositoryApi> examRepositoryApi;
 
     private final TeamRepository teamRepository;
 
     public ComplaintService(ComplaintRepository complaintRepository, ComplaintResponseRepository complaintResponseRepository, ResultRepository resultRepository,
-            ExamRepository examRepository, UserRepository userRepository, TeamRepository teamRepository) {
+            Optional<ExamRepositoryApi> examRepositoryApi, UserRepository userRepository, TeamRepository teamRepository) {
         this.complaintRepository = complaintRepository;
         this.complaintResponseRepository = complaintResponseRepository;
         this.resultRepository = resultRepository;
-        this.examRepository = examRepository;
+        this.examRepositoryApi = examRepositoryApi;
         this.userRepository = userRepository;
         this.teamRepository = teamRepository;
     }
@@ -99,7 +100,8 @@ public Complaint createComplaint(ComplaintRequestDTO complaintRequest, Optional<
 
         // checking if it is allowed to create a complaint
         if (examId.isPresent()) {
-            final Exam exam = examRepository.findByIdElseThrow(examId.get());
+            var api = examRepositoryApi.orElseThrow(() -> new ApiNotPresentException(ExamRepositoryApi.class, PROFILE_CORE));
+            final Exam exam = api.findByIdElseThrow(examId.get());
             final Set<User> instructors = userRepository.getInstructors(exam.getCourse());
             boolean examTestRun = instructors.stream().anyMatch(instructor -> instructor.getLogin().equals(principal.getName()));
             if (!examTestRun && !isTimeOfComplaintValid(exam)) {

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

@@ -49,13 +49,14 @@
 import de.tum.cit.aet.artemis.core.domain.User;
 import de.tum.cit.aet.artemis.core.dto.SearchResultPageDTO;
 import de.tum.cit.aet.artemis.core.dto.SortingOrder;
+import de.tum.cit.aet.artemis.core.exception.ApiNotPresentException;
 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.Role;
 import de.tum.cit.aet.artemis.core.service.AuthorizationCheckService;
 import de.tum.cit.aet.artemis.core.util.PageUtil;
+import de.tum.cit.aet.artemis.exam.api.StudentExamApi;
 import de.tum.cit.aet.artemis.exam.domain.Exam;
-import de.tum.cit.aet.artemis.exam.repository.StudentExamRepository;
 import de.tum.cit.aet.artemis.exercise.domain.Exercise;
 import de.tum.cit.aet.artemis.exercise.domain.Submission;
 import de.tum.cit.aet.artemis.exercise.domain.participation.Participation;
@@ -112,7 +113,7 @@ public class ResultService {
 
     private final ProgrammingExerciseStudentParticipationRepository programmingExerciseStudentParticipationRepository;
 
-    private final StudentExamRepository studentExamRepository;
+    private final Optional<StudentExamApi> studentExamApi;
 
     private final LongFeedbackTextRepository longFeedbackTextRepository;
 
@@ -136,7 +137,7 @@ public ResultService(UserRepository userRepository, ResultRepository resultRepos
             ParticipantScoreRepository participantScoreRepository, AuthorizationCheckService authCheckService, ExerciseDateService exerciseDateService,
             TemplateProgrammingExerciseParticipationRepository templateProgrammingExerciseParticipationRepository,
             SolutionProgrammingExerciseParticipationRepository solutionProgrammingExerciseParticipationRepository,
-            ProgrammingExerciseStudentParticipationRepository programmingExerciseStudentParticipationRepository, StudentExamRepository studentExamRepository,
+            ProgrammingExerciseStudentParticipationRepository programmingExerciseStudentParticipationRepository, Optional<StudentExamApi> studentExamApi,
             BuildJobRepository buildJobRepository, BuildLogEntryService buildLogEntryService, StudentParticipationRepository studentParticipationRepository,
             ProgrammingExerciseTaskService programmingExerciseTaskService, ProgrammingExerciseRepository programmingExerciseRepository) {
         this.userRepository = userRepository;
@@ -154,7 +155,7 @@ public ResultService(UserRepository userRepository, ResultRepository resultRepos
         this.templateProgrammingExerciseParticipationRepository = templateProgrammingExerciseParticipationRepository;
         this.solutionProgrammingExerciseParticipationRepository = solutionProgrammingExerciseParticipationRepository;
         this.programmingExerciseStudentParticipationRepository = programmingExerciseStudentParticipationRepository;
-        this.studentExamRepository = studentExamRepository;
+        this.studentExamApi = studentExamApi;
         this.buildJobRepository = buildJobRepository;
         this.buildLogEntryService = buildLogEntryService;
         this.studentParticipationRepository = studentParticipationRepository;
@@ -356,11 +357,12 @@ private void filterSensitiveFeedbackInCourseExercise(Participation participation
     }
 
     private void filterSensitiveFeedbacksInExamExercise(Participation participation, Collection<Result> results, Exercise exercise) {
+        var api = studentExamApi.orElseThrow(() -> new ApiNotPresentException(StudentExamApi.class, PROFILE_CORE));
         Exam exam = exercise.getExerciseGroup().getExam();
         boolean shouldResultsBePublished = exam.resultsPublished();
         if (!shouldResultsBePublished && exam.isTestExam() && participation instanceof StudentParticipation studentParticipation) {
             var participant = studentParticipation.getParticipant();
-            var studentExamOptional = studentExamRepository.findByExamIdAndUserId(exam.getId(), participant.getId());
+            var studentExamOptional = api.findByExamIdAndUserId(exam.getId(), participant.getId());
             if (studentExamOptional.isPresent()) {
                 shouldResultsBePublished = studentExamOptional.get().areResultsPublishedYet();
             }

src/main/java/de/tum/cit/aet/artemis/assessment/web/BonusResource.java

@@ -5,6 +5,7 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Objects;
+import java.util.Optional;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -30,6 +31,7 @@
 import de.tum.cit.aet.artemis.assessment.service.BonusService;
 import de.tum.cit.aet.artemis.assessment.service.CourseScoreCalculationService;
 import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.exception.ApiNotPresentException;
 import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
 import de.tum.cit.aet.artemis.core.exception.ConflictException;
 import de.tum.cit.aet.artemis.core.exception.EntityNotFoundException;
@@ -41,7 +43,7 @@
 import de.tum.cit.aet.artemis.core.security.annotations.ManualConfig;
 import de.tum.cit.aet.artemis.core.service.AuthorizationCheckService;
 import de.tum.cit.aet.artemis.core.util.HeaderUtil;
-import de.tum.cit.aet.artemis.exam.service.ExamAccessService;
+import de.tum.cit.aet.artemis.exam.api.ExamAccessApi;
 
 /**
  * REST controller for managing bonus
@@ -66,19 +68,19 @@ public class BonusResource {
 
     private final AuthorizationCheckService authCheckService;
 
-    private final ExamAccessService examAccessService;
+    private final Optional<ExamAccessApi> examAccessApi;
 
     private final CourseScoreCalculationService courseScoreCalculationService;
 
     private final CourseRepository courseRepository;
 
     public BonusResource(BonusService bonusService, BonusRepository bonusRepository, GradingScaleRepository gradingScaleRepository, AuthorizationCheckService authCheckService,
-            ExamAccessService examAccessService, CourseScoreCalculationService courseScoreCalculationService, CourseRepository courseRepository) {
+            Optional<ExamAccessApi> examAccessApi, CourseScoreCalculationService courseScoreCalculationService, CourseRepository courseRepository) {
         this.bonusService = bonusService;
         this.bonusRepository = bonusRepository;
         this.gradingScaleRepository = gradingScaleRepository;
         this.authCheckService = authCheckService;
-        this.examAccessService = examAccessService;
+        this.examAccessApi = examAccessApi;
         this.courseScoreCalculationService = courseScoreCalculationService;
         this.courseRepository = courseRepository;
     }
@@ -96,7 +98,8 @@ public BonusResource(BonusService bonusService, BonusRepository bonusRepository,
     @EnforceAtLeastStudent
     public ResponseEntity<Bonus> getBonusForExam(@PathVariable Long courseId, @PathVariable Long examId, @RequestParam(required = false) boolean includeSourceGradeSteps) {
         log.debug("REST request to get bonus for exam: {}", examId);
-        examAccessService.checkCourseAndExamAccessForStudentElseThrow(courseId, examId);
+        var api = examAccessApi.orElseThrow(() -> new ApiNotPresentException(ExamAccessApi.class, PROFILE_CORE));
+        api.checkCourseAndExamAccessForStudentElseThrow(courseId, examId);
 
         var bonus = bonusRepository.findAllByBonusToExamId(examId).stream().findAny().orElseThrow(() -> new EntityNotFoundException("BonusToGradingScale exam", examId));
         bonus.setBonusStrategy(bonus.getBonusToGradingScale().getBonusStrategy());
@@ -139,7 +142,8 @@ public ResponseEntity<BonusExampleDTO> calculateGradeWithBonus(@PathVariable Lon
             @RequestParam Double calculationSign, @RequestParam Double bonusToPoints, @RequestParam Long sourceGradingScaleId, @RequestParam Double sourcePoints) {
 
         // TODO: Add auth and validation and authorize to USER role. Currently enabled only to ADMINs for testing.
-        examAccessService.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
+        var api = examAccessApi.orElseThrow(() -> new ApiNotPresentException(ExamAccessApi.class, PROFILE_CORE));
+        api.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
 
         var bonusToGradingScale = gradingScaleRepository.findWithEagerBonusFromByExamId(examId).orElseThrow();
         var sourceGradingScale = gradingScaleRepository.findById(sourceGradingScaleId).orElseThrow();
@@ -168,7 +172,8 @@ public ResponseEntity<Bonus> createBonusForExam(@PathVariable Long courseId, @Pa
             throw new BadRequestAlertException("A new bonus cannot already have an ID", ENTITY_NAME, "idexists");
         }
 
-        examAccessService.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
+        var api = examAccessApi.orElseThrow(() -> new ApiNotPresentException(ExamAccessApi.class, PROFILE_CORE));
+        api.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
 
         GradingScale sourceGradingScaleFromDb = gradingScaleRepository.findById(bonus.getSourceGradingScale().getId()).orElseThrow();
         bonus.setSourceGradingScale(sourceGradingScaleFromDb);
@@ -234,7 +239,8 @@ public ResponseEntity<Bonus> updateBonus(@PathVariable Long courseId, @PathVaria
             throw new ConflictException("The updatedBonus id in the body and path do not match", ENTITY_NAME, "bonusIdMismatch");
         }
 
-        examAccessService.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
+        var api = examAccessApi.orElseThrow(() -> new ApiNotPresentException(ExamAccessApi.class, PROFILE_CORE));
+        api.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
 
         Bonus oldBonus = bonusRepository.findByIdElseThrow(updatedBonus.getId());
         checkBonusAppliesToExam(oldBonus, examId);
@@ -283,7 +289,8 @@ private void checkBonusAppliesToExam(Bonus bonus, Long examId) {
     @EnforceAtLeastInstructor
     public ResponseEntity<Void> deleteBonus(@PathVariable Long courseId, @PathVariable Long examId, @PathVariable Long bonusId) {
         log.debug("REST request to delete the bonus: {}", bonusId);
-        examAccessService.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
+        var api = examAccessApi.orElseThrow(() -> new ApiNotPresentException(ExamAccessApi.class, PROFILE_CORE));
+        api.checkCourseAndExamAccessForInstructorElseThrow(courseId, examId);
         Bonus bonus = bonusRepository.findByIdElseThrow(bonusId);
         checkBonusAppliesToExam(bonus, examId);