Programming exercises: Export and import build plan from file

src/main/java/de/tum/in/www1/artemis/repository/BuildPlanRepository.java

@@ -23,6 +23,14 @@ public interface BuildPlanRepository extends JpaRepository<BuildPlan, Long> {
             """)
     Optional<BuildPlan> findByProgrammingExercises_IdWithProgrammingExercises(@Param("exerciseId") long exerciseId);
 
+    @Query("""
+            SELECT buildPlan
+            FROM BuildPlan buildPlan
+                JOIN buildPlan.programmingExercises programmingExercises
+            WHERE programmingExercises.id = :exerciseId
+                """)
+    Optional<BuildPlan> findByProgrammingExercises_Id(long exerciseId);
+
     default BuildPlan findByProgrammingExercises_IdWithProgrammingExercisesElseThrow(final long exerciseId) {
         return findByProgrammingExercises_IdWithProgrammingExercises(exerciseId)
                 .orElseThrow(() -> new EntityNotFoundException("Could not find a build plan for exercise " + exerciseId));

src/main/java/de/tum/in/www1/artemis/service/ProfileService.java

@@ -29,6 +29,10 @@ public boolean isBamboo() {
         return isProfileActive("bamboo");
     }
 
+    public boolean isGitlabCiOrJenkins() {
+        return isProfileActive("gitlabci") || isProfileActive("jenkins");
+    }
+
     private boolean isProfileActive(String profile) {
         return Set.of(this.environment.getActiveProfiles()).contains(profile);
     }

src/main/java/de/tum/in/www1/artemis/service/export/ProgrammingExerciseExportService.java

@@ -6,16 +6,12 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.function.Predicate;
@@ -31,10 +27,7 @@
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;
-import javax.xml.xpath.XPath;
-import javax.xml.xpath.XPathConstants;
-import javax.xml.xpath.XPathException;
-import javax.xml.xpath.XPathFactory;
+import javax.xml.xpath.*;
 
 import org.apache.commons.io.FileUtils;
 import org.eclipse.jgit.api.errors.GitAPIException;
@@ -54,9 +47,7 @@
 import de.tum.in.www1.artemis.domain.participation.ProgrammingExerciseStudentParticipation;
 import de.tum.in.www1.artemis.domain.participation.StudentParticipation;
 import de.tum.in.www1.artemis.exception.GitException;
-import de.tum.in.www1.artemis.repository.AuxiliaryRepositoryRepository;
-import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
-import de.tum.in.www1.artemis.repository.StudentParticipationRepository;
+import de.tum.in.www1.artemis.repository.*;
 import de.tum.in.www1.artemis.service.ExerciseDateService;
 import de.tum.in.www1.artemis.service.FileService;
 import de.tum.in.www1.artemis.service.ZipFileService;
@@ -91,13 +82,17 @@ public class ProgrammingExerciseExportService extends ExerciseWithSubmissionsExp
 
     private final ZipFileService zipFileService;
 
+    private final BuildPlanRepository buildPlanRepository;
+
     public static final String EXPORTED_EXERCISE_DETAILS_FILE_PREFIX = "Exercise-Details";
 
     public static final String EXPORTED_EXERCISE_PROBLEM_STATEMENT_FILE_PREFIX = "Problem-Statement";
 
+    public static final String BUILD_PLAN_FILE_NAME = "buildPlan.txt";
+
     public ProgrammingExerciseExportService(ProgrammingExerciseRepository programmingExerciseRepository, ProgrammingExerciseTaskService programmingExerciseTaskService,
             StudentParticipationRepository studentParticipationRepository, FileService fileService, GitService gitService, ZipFileService zipFileService,
-            MappingJackson2HttpMessageConverter springMvcJacksonConverter, AuxiliaryRepositoryRepository auxiliaryRepositoryRepository) {
+            MappingJackson2HttpMessageConverter springMvcJacksonConverter, AuxiliaryRepositoryRepository auxiliaryRepositoryRepository, BuildPlanRepository buildPlanRepository) {
         // Programming exercises do not have a submission export service
         super(fileService, springMvcJacksonConverter, null);
         this.programmingExerciseRepository = programmingExerciseRepository;
@@ -107,6 +102,7 @@ public ProgrammingExerciseExportService(ProgrammingExerciseRepository programmin
         this.gitService = gitService;
         this.zipFileService = zipFileService;
         this.auxiliaryRepositoryRepository = auxiliaryRepositoryRepository;
+        this.buildPlanRepository = buildPlanRepository;
     }
 
     /**
@@ -132,8 +128,8 @@ private Path exportProgrammingExerciseMaterialWithStudentReposOptional(Programmi
             exportDir = Optional.of(fileService.getTemporaryUniquePathWithoutPathCreation(repoDownloadClonePath, 5));
         }
 
-        // Add the exported zip folder containing template, solution, and tests repositories
-        // wrap this in a try catch block to prevent the problem statement and exercise details not being exported if the repositories fail to export
+        // Add the exported zip folder containing template, solution, and tests repositories. Also export the build plan if one exists.
+        // Wrap this in a try catch block to prevent the problem statement and exercise details not being exported if the repositories fail to export
         try {
             var repoExportsPaths = exportProgrammingExerciseRepositories(exercise, includeStudentRepos, shouldZipZipFiles, repoDownloadClonePath, exportDir.orElseThrow(),
                     exportErrors, archivalReportEntries);
@@ -142,6 +138,15 @@ private Path exportProgrammingExerciseMaterialWithStudentReposOptional(Programmi
                     pathsToBeZipped.add(path);
                 }
             });
+
+            // Export the build plan of a programming exercise, if one exists. Only relevant for Gitlab/Jenkins or Gitlab/GitlabCI setups.
+            var buildPlan = buildPlanRepository.findByProgrammingExercises_Id(exercise.getId());
+            if (buildPlan.isPresent()) {
+                Path buildPlanPath = exportDir.orElseThrow().resolve(BUILD_PLAN_FILE_NAME);
+                FileUtils.writeStringToFile(buildPlanPath.toFile(), buildPlan.orElseThrow().getBuildPlan(), StandardCharsets.UTF_8);
+                pathsToBeZipped.add(buildPlanPath);
+            }
+
         }
         catch (Exception e) {
             exportErrors.add("Failed to export programming exercise repositories: " + e.getMessage());

src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseImportFromFileService.java

@@ -1,7 +1,10 @@
 package de.tum.in.www1.artemis.service.programming;
 
+import static de.tum.in.www1.artemis.service.export.ProgrammingExerciseExportService.BUILD_PLAN_FILE_NAME;
+
 import java.io.IOException;
 import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
@@ -13,6 +16,8 @@
 import org.apache.commons.io.filefilter.NameFileFilter;
 import org.apache.commons.io.filefilter.NotFileFilter;
 import org.eclipse.jgit.api.errors.GitAPIException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -21,13 +26,16 @@
 
 import de.tum.in.www1.artemis.domain.*;
 import de.tum.in.www1.artemis.domain.enumeration.RepositoryType;
+import de.tum.in.www1.artemis.repository.BuildPlanRepository;
 import de.tum.in.www1.artemis.service.*;
 import de.tum.in.www1.artemis.service.connectors.GitService;
 import de.tum.in.www1.artemis.web.rest.errors.BadRequestAlertException;
 
 @Service
 public class ProgrammingExerciseImportFromFileService {
 
+    private final Logger log = LoggerFactory.getLogger(ProgrammingExerciseImportFromFileService.class);
+
     private final ProgrammingExerciseService programmingExerciseService;
 
     private final ZipFileService zipFileService;
@@ -40,16 +48,23 @@ public class ProgrammingExerciseImportFromFileService {
 
     private final FileService fileService;
 
+    private final ProfileService profileService;
+
+    private final BuildPlanRepository buildPlanRepository;
+
     private static final List<String> SHORT_NAME_REPLACEMENT_EXCLUSIONS = List.of("gradle-wrapper.jar");
 
     public ProgrammingExerciseImportFromFileService(ProgrammingExerciseService programmingExerciseService, ZipFileService zipFileService,
-            StaticCodeAnalysisService staticCodeAnalysisService, RepositoryService repositoryService, GitService gitService, FileService fileService) {
+            StaticCodeAnalysisService staticCodeAnalysisService, RepositoryService repositoryService, GitService gitService, FileService fileService, ProfileService profileService,
+            BuildPlanRepository buildPlanRepository) {
         this.programmingExerciseService = programmingExerciseService;
         this.zipFileService = zipFileService;
         this.staticCodeAnalysisService = staticCodeAnalysisService;
         this.repositoryService = repositoryService;
         this.gitService = gitService;
         this.fileService = fileService;
+        this.profileService = profileService;
+        this.buildPlanRepository = buildPlanRepository;
     }
 
     /**
@@ -84,9 +99,14 @@ public ProgrammingExercise importProgrammingExerciseFromFile(ProgrammingExercise
             if (Boolean.TRUE.equals(programmingExerciseForImport.isStaticCodeAnalysisEnabled())) {
                 staticCodeAnalysisService.createDefaultCategories(importedProgrammingExercise);
             }
-            copyEmbeddedFiles(exerciseFilePath.toAbsolutePath().getParent().resolve(FileNameUtils.getBaseName(exerciseFilePath.toString())));
+            Path pathToDirectoryWithImportedContent = exerciseFilePath.toAbsolutePath().getParent().resolve(FileNameUtils.getBaseName(exerciseFilePath.toString()));
+            copyEmbeddedFiles(pathToDirectoryWithImportedContent);
             importRepositoriesFromFile(importedProgrammingExercise, importExerciseDir, oldShortName, user);
             importedProgrammingExercise.setCourse(course);
+            // It doesn't make sense to import a build plan on a bamboo or local CI setup.
+            if (profileService.isGitlabCiOrJenkins()) {
+                importBuildPlanIfExisting(importedProgrammingExercise, pathToDirectoryWithImportedContent);
+            }
         }
         finally {
             // want to make sure the directories are deleted, even if an exception is thrown
@@ -95,6 +115,25 @@ public ProgrammingExercise importProgrammingExerciseFromFile(ProgrammingExercise
         return importedProgrammingExercise;
     }
 
+    /**
+     * Imports a build plan if it exists in the extracted zip file
+     * If the file cannot be read, the build plan is skipped
+     *
+     * @param programmingExercise the programming exercise for which the build plan should be imported
+     * @param importExerciseDir   the directory where the extracted zip file is located
+     */
+    private void importBuildPlanIfExisting(ProgrammingExercise programmingExercise, Path importExerciseDir) {
+        Path buildPlanPath = importExerciseDir.resolve(BUILD_PLAN_FILE_NAME);
+        if (Files.exists(buildPlanPath)) {
+            try {
+                buildPlanRepository.setBuildPlanForExercise(FileUtils.readFileToString(buildPlanPath.toFile(), StandardCharsets.UTF_8), programmingExercise);
+            }
+            catch (IOException e) {
+                log.warn("Could not read build plan file. Continue importing the exercise but skipping the build plan.", e);
+            }
+        }
+    }
+
     /**
      * Copy embedded files from the extracted zip file to the markdown folder, so they can be used in the problem statement
      *

src/test/java/de/tum/in/www1/artemis/exercise/programmingexercise/ProgrammingExerciseBitbucketBambooIntegrationTest.java

@@ -349,7 +349,7 @@ void exportInstructorRepositories_forbidden() throws Exception {
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void exportProgrammingExerciseInstructorMaterial() throws Exception {
-        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFile(true);
+        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFileWithoutBuildplan(true);
         // we have a working directory and one directory for each repository
         verify(fileService, times(4)).scheduleDirectoryPathForRecursiveDeletion(any(Path.class), eq(5L));
         verify(fileService).schedulePathForDeletion(any(Path.class), eq(5L));
@@ -435,29 +435,29 @@ void testArchiveCourseWithProgrammingExercise() throws Exception {
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void testExportProgrammingExerciseInstructorMaterial_failToCreateZip() throws Exception {
         doThrow(IOException.class).when(zipFileService).createZipFile(any(Path.class), any());
-        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, true, true, true);
+        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, true, true, true, false);
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void testExportProgrammingExerciseInstructorMaterial_failToCreateTempDir() throws Exception {
         try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) {
             mockedFiles.when(() -> Files.createTempDirectory(any(Path.class), any(String.class))).thenThrow(IOException.class);
-            programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, true, false, false);
+            programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, true, false, false, false);
         }
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void testExportProgrammingExerciseInstructorMaterial_embeddedFilesDontExist() throws Exception {
-        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFile(false);
+        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFileWithoutBuildplan(false);
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void testExportProgrammingExerciseInstructorMaterial_failToExportRepository() throws Exception {
         doThrow(GitException.class).when(fileService).getTemporaryUniquePathWithoutPathCreation(any(Path.class), anyLong());
-        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, false, true, true);
+        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, false, true, true, false);
     }
 
     @Test

src/test/java/de/tum/in/www1/artemis/exercise/programmingexercise/ProgrammingExerciseGitlabJenkinsIntegrationTest.java

@@ -228,6 +228,12 @@ void importExerciseFromFile_embeddedFiles_filesCopied() throws Exception {
         programmingExerciseTestService.importFromFile_embeddedFiles_embeddedFilesCopied();
     }
 
+    @Test
+    @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
+    void importExerciseFromFile_buildPlanPresent_buildPlanSet() throws Exception {
+        programmingExerciseTestService.importFromFile_buildPlanPresent_buildPlanUsed();
+    }
+
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     @ParameterizedTest(name = "{displayName} [{index}] {argumentsWithNames}")
     @EnumSource(value = ProgrammingLanguage.class, names = { "HASKELL", "PYTHON" }, mode = EnumSource.Mode.INCLUDE)
@@ -404,7 +410,7 @@ void exportInstructorRepositories_forbidden() throws Exception {
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void exportProgrammingExerciseInstructorMaterial() throws Exception {
-        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFile(true);
+        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFileWithBuildplan();
         // we have a working directory and one directory for each repository
         verify(fileService, times(4)).scheduleDirectoryPathForRecursiveDeletion(any(Path.class), eq(5L));
         verify(fileService).schedulePathForDeletion(any(Path.class), eq(5L));
@@ -427,14 +433,14 @@ void exportProgrammingExerciseInstructorMaterial_problemStatementShouldContainTe
     void testExportProgrammingExerciseInstructorMaterial_failToCreateTempDir() throws Exception {
         try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) {
             mockedFiles.when(() -> Files.createTempDirectory(any(Path.class), any(String.class))).thenThrow(IOException.class);
-            programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, true, false, false);
+            programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial(HttpStatus.INTERNAL_SERVER_ERROR, true, false, false, false);
         }
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void testExportProgrammingExerciseInstructorMaterial_embeddedFilesDontExist() throws Exception {
-        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFile(false);
+        programmingExerciseTestService.exportProgrammingExerciseInstructorMaterial_shouldReturnFile(false, false);
     }
 
     @Test