Integrated code lifecycle: Add auxiliary repository view

src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingExerciseParticipationService.java

@@ -31,6 +31,7 @@
 import de.tum.cit.aet.artemis.exercise.domain.participation.Participation;
 import de.tum.cit.aet.artemis.exercise.repository.ParticipationRepository;
 import de.tum.cit.aet.artemis.exercise.repository.TeamRepository;
+import de.tum.cit.aet.artemis.programming.domain.AuxiliaryRepository;
 import de.tum.cit.aet.artemis.programming.domain.ProgrammingExercise;
 import de.tum.cit.aet.artemis.programming.domain.ProgrammingExerciseParticipation;
 import de.tum.cit.aet.artemis.programming.domain.ProgrammingExerciseStudentParticipation;
@@ -517,6 +518,22 @@ public List<CommitInfoDTO> getCommitInfos(ProgrammingExerciseParticipation parti
         }
     }
 
+    /**
+     * Get the commits information for the given auxiliary repository.
+     *
+     * @param auxiliaryRepository the auxiliary repository for which to get the commits.
+     * @return a list of CommitInfo DTOs containing author, timestamp, commit-hash and commit message.
+     */
+    public List<CommitInfoDTO> getAuxiliaryRepositoryCommitInfos(AuxiliaryRepository auxiliaryRepository) {
+        try {
+            return gitService.getCommitInfos(auxiliaryRepository.getVcsRepositoryUri());
+        }
+        catch (GitAPIException e) {
+            log.error("Could not get commit infos for auxiliaryRepository {} with repository uri {}", auxiliaryRepository.getId(), auxiliaryRepository.getVcsRepositoryUri());
+            return List.of();
+        }
+    }
+
     /**
      * Get the commits information for the test repository of the given participation's exercise.
      *

src/main/java/de/tum/cit/aet/artemis/programming/service/ProgrammingExerciseService.java

@@ -1009,4 +1009,15 @@ public ProgrammingExercise loadProgrammingExercise(long exerciseId, boolean with
         programmingExerciseTaskService.replaceTestIdsWithNames(programmingExercise);
         return programmingExercise;
     }
+
+    /**
+     * Load a programming exercise, only with eager auxiliary repositories
+     *
+     * @param exerciseId the ID of the programming exercise to load
+     * @return the loaded programming exercise entity
+     */
+    public ProgrammingExercise loadProgrammingExerciseWithAuxiliaryRepositories(long exerciseId) {
+        final Set<ProgrammingExerciseRepository.ProgrammingExerciseFetchOptions> fetchOptions = Set.of(AuxiliaryRepositories);
+        return programmingExerciseRepository.findByIdWithDynamicFetchElseThrow(exerciseId, fetchOptions);
+    }
 }

src/main/java/de/tum/cit/aet/artemis/programming/web/ProgrammingExerciseParticipationResource.java

@@ -44,6 +44,7 @@
 import de.tum.cit.aet.artemis.programming.domain.RepositoryType;
 import de.tum.cit.aet.artemis.programming.domain.VcsRepositoryUri;
 import de.tum.cit.aet.artemis.programming.dto.CommitInfoDTO;
+import de.tum.cit.aet.artemis.programming.repository.AuxiliaryRepositoryRepository;
 import de.tum.cit.aet.artemis.programming.repository.ProgrammingExerciseRepository;
 import de.tum.cit.aet.artemis.programming.repository.ProgrammingExerciseStudentParticipationRepository;
 import de.tum.cit.aet.artemis.programming.service.ProgrammingExerciseParticipationService;
@@ -79,11 +80,13 @@ public class ProgrammingExerciseParticipationResource {
 
     private final StudentExamRepository studentExamRepository;
 
+    private final AuxiliaryRepositoryRepository auxiliaryRepositoryRepository;
+
     public ProgrammingExerciseParticipationResource(ProgrammingExerciseParticipationService programmingExerciseParticipationService, ResultRepository resultRepository,
             ParticipationRepository participationRepository, ProgrammingExerciseStudentParticipationRepository programmingExerciseStudentParticipationRepository,
             ProgrammingSubmissionService submissionService, ProgrammingExerciseRepository programmingExerciseRepository, AuthorizationCheckService authCheckService,
             ResultService resultService, ParticipationAuthorizationCheckService participationAuthCheckService, RepositoryService repositoryService,
-            StudentExamRepository studentExamRepository) {
+            StudentExamRepository studentExamRepository, AuxiliaryRepositoryRepository auxiliaryRepositoryRepository) {
         this.programmingExerciseParticipationService = programmingExerciseParticipationService;
         this.participationRepository = participationRepository;
         this.programmingExerciseStudentParticipationRepository = programmingExerciseStudentParticipationRepository;
@@ -95,6 +98,7 @@ public ProgrammingExerciseParticipationResource(ProgrammingExerciseParticipation
         this.participationAuthCheckService = participationAuthCheckService;
         this.repositoryService = repositoryService;
         this.studentExamRepository = studentExamRepository;
+        this.auxiliaryRepositoryRepository = auxiliaryRepositoryRepository;
     }
 
     /**
@@ -312,17 +316,20 @@ public ResponseEntity<List<CommitInfoDTO>> getCommitHistoryForParticipationRepo(
      *
      * @param exerciseID     the id of the exercise for which to retrieve the commit history
      * @param repositoryType the type of the repository for which to retrieve the commit history
+     * @param repositoryId   the id of the repository
      * @return the ResponseEntity with status 200 (OK) and with body a list of commitInfo DTOs with the commits information of the repository
      */
     @GetMapping("programming-exercise/{exerciseID}/commit-history/{repositoryType}")
     @EnforceAtLeastTutor
-    public ResponseEntity<List<CommitInfoDTO>> getCommitHistoryForTemplateSolutionOrTestRepo(@PathVariable long exerciseID, @PathVariable RepositoryType repositoryType) {
+    public ResponseEntity<List<CommitInfoDTO>> getCommitHistoryForTemplateSolutionOrTestRepo(@PathVariable long exerciseID, @PathVariable RepositoryType repositoryType,
+            @RequestParam long repositoryId) {
         boolean isTemplateRepository = repositoryType.equals(RepositoryType.TEMPLATE);
         boolean isSolutionRepository = repositoryType.equals(RepositoryType.SOLUTION);
         boolean isTestRepository = repositoryType.equals(RepositoryType.TESTS);
+        boolean isAuxiliaryRepository = repositoryType.equals(RepositoryType.AUXILIARY);
         ProgrammingExerciseParticipation participation;
 
-        if (!isTemplateRepository && !isSolutionRepository && !isTestRepository) {
+        if (!isTemplateRepository && !isSolutionRepository && !isTestRepository && !isAuxiliaryRepository) {
             throw new BadRequestAlertException("Invalid repository type", ENTITY_NAME, "invalidRepositoryType");
         }
         else if (isTemplateRepository) {
@@ -332,6 +339,15 @@ else if (isTemplateRepository) {
             participation = programmingExerciseParticipationService.findSolutionParticipationByProgrammingExerciseId(exerciseID);
         }
         participationAuthCheckService.checkCanAccessParticipationElseThrow(participation);
+
+        if (isAuxiliaryRepository) {
+            var auxiliaryRepo = auxiliaryRepositoryRepository.findByIdElseThrow(repositoryId);
+            if (!auxiliaryRepo.getExercise().getId().equals(exerciseID)) {
+                throw new BadRequestAlertException("Invalid repository id", ENTITY_NAME, "invalidRepositoryId");
+            }
+            return ResponseEntity.ok(programmingExerciseParticipationService.getAuxiliaryRepositoryCommitInfos(auxiliaryRepo));
+        }
+
         if (isTestRepository) {
             return ResponseEntity.ok(programmingExerciseParticipationService.getCommitInfosTestRepo(participation));
         }

src/main/java/de/tum/cit/aet/artemis/programming/web/ProgrammingExerciseResource.java

@@ -531,6 +531,26 @@ public ResponseEntity<ProgrammingExercise> getProgrammingExerciseWithTemplateAnd
         return ResponseEntity.ok(programmingExercise);
     }
 
+    /**
+     * GET /programming-exercises/:exerciseId/with-auxiliary-repository/:auxiliaryRepositoryId
+     *
+     * @param exerciseId            the id of the programmingExercise to retrieve
+     * @param auxiliaryRepositoryId the id of the auxiliary repository of the exercise
+     * @return the ResponseEntity with status 200 (OK) and the programming exercise with template and solution participation, or with status 404 (Not Found)
+     */
+    @GetMapping("programming-exercises/{exerciseId}/with-auxiliary-repository/{auxiliaryRepositoryId}")
+    @EnforceAtLeastTutorInExercise
+    public ResponseEntity<ProgrammingExercise> getProgrammingExerciseWithTemplateAndSolutionParticipation(@PathVariable long exerciseId, @PathVariable long auxiliaryRepositoryId) {
+
+        log.debug("REST request to get programming exercise with template and solution participation : {}", exerciseId);
+        final var programmingExercise = programmingExerciseService.loadProgrammingExerciseWithAuxiliaryRepositories(exerciseId);
+        if (programmingExercise.getAuxiliaryRepositories().stream().noneMatch(id -> id.getId() == auxiliaryRepositoryId)) {
+            throw new BadRequestAlertException("The auxiliary repository Id does not belong to the exercise.", "Exercise",
+                    ProgrammingExerciseResourceErrorKeys.INVALID_AUXILIARY_REPOSITORY_ID);
+        }
+        return ResponseEntity.ok(programmingExercise);
+    }
+
     /**
      * DELETE /programming-exercises/:id : delete the "id" programmingExercise.
      *