Programming exercises: Export and import build plan from file

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

@@ -29,6 +29,10 @@
         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

@@ -48,15 +48,15 @@
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 
+import com.google.common.base.Charsets;
+
 import de.tum.in.www1.artemis.domain.*;
 import de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage;
 import de.tum.in.www1.artemis.domain.enumeration.RepositoryType;
 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 +91,17 @@
 
     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 +111,7 @@
         this.gitService = gitService;
         this.zipFileService = zipFileService;
         this.auxiliaryRepositoryRepository = auxiliaryRepositoryRepository;
+        this.buildPlanRepository = buildPlanRepository;
     }
 
     /**
@@ -132,8 +137,8 @@
             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 +147,15 @@
                     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_IdWithProgrammingExercises(exercise.getId());
+            if (buildPlan.isPresent()) {
+                Path buildPlanPath = exportDir.orElseThrow().resolve(BUILD_PLAN_FILE_NAME);
+                FileUtils.writeStringToFile(buildPlanPath.toFile(), buildPlan.orElseThrow().getBuildPlan(), Charsets.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,5 +1,7 @@
 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.file.Files;
@@ -13,21 +15,28 @@
 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;
 
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Charsets;
 
 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.service.export.ProgrammingExerciseExportService;
 import de.tum.in.www1.artemis.web.rest.errors.BadRequestAlertException;
 
 @Service
 public class ProgrammingExerciseImportFromFileService {
 
+    private final Logger log = LoggerFactory.getLogger(ProgrammingExerciseExportService.class);
+
     private final ProgrammingExerciseService programmingExerciseService;
 
     private final ZipFileService zipFileService;
@@ -40,16 +49,23 @@
 
     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;
     }
 
     /**
@@ -87,6 +103,10 @@
             copyEmbeddedFiles(exerciseFilePath.toAbsolutePath().getParent().resolve(FileNameUtils.getBaseName(exerciseFilePath.toString())));
             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, importExerciseDir);
+            }
         }
         finally {
             // want to make sure the directories are deleted, even if an exception is thrown
@@ -95,6 +115,25 @@
         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(), Charsets.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/ProgrammingExerciseTestService.java

@@ -3,8 +3,7 @@
 import static de.tum.in.www1.artemis.domain.enumeration.ExerciseMode.INDIVIDUAL;
 import static de.tum.in.www1.artemis.domain.enumeration.ExerciseMode.TEAM;
 import static de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage.*;
-import static de.tum.in.www1.artemis.service.export.ProgrammingExerciseExportService.EXPORTED_EXERCISE_DETAILS_FILE_PREFIX;
-import static de.tum.in.www1.artemis.service.export.ProgrammingExerciseExportService.EXPORTED_EXERCISE_PROBLEM_STATEMENT_FILE_PREFIX;
+import static de.tum.in.www1.artemis.service.export.ProgrammingExerciseExportService.*;
 import static de.tum.in.www1.artemis.util.TestConstants.COMMIT_HASH_OBJECT_ID;
 import static de.tum.in.www1.artemis.web.rest.ProgrammingExerciseResourceEndpoints.*;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -206,6 +205,9 @@
     @Autowired
     private ParticipationUtilService participationUtilService;
 
+    @Autowired
+    private BuildPlanRepository buildPlanRepository;
+
     public Course course;
 
     public ProgrammingExercise exercise;
@@ -1392,39 +1394,43 @@
      * @throws Exception if the export fails
      */
     void exportProgrammingExerciseInstructorMaterial_shouldReturnFile(boolean saveEmbeddedFiles) throws Exception {
         var zipFile = exportProgrammingExerciseInstructorMaterial(HttpStatus.OK, false, true, saveEmbeddedFiles);
         // Assure, that the zip folder is already created and not 'in creation' which would lead to a failure when extracting it in the next step
         await().until(zipFile::exists);
         assertThat(zipFile).isNotNull();
         String embeddedFileName1 = "Markdown_2023-05-06T16-17-46-410_ad323711.jpg";
         String embeddedFileName2 = "Markdown_2023-05-06T16-17-46-822_b921f475.jpg";
         // delete the files to not only make a test pass because a previous test run succeeded
         Path embeddedFilePath1 = FilePathService.getMarkdownFilePath().resolve(embeddedFileName1);
         Path embeddedFilePath2 = FilePathService.getMarkdownFilePath().resolve(embeddedFileName2);
         if (Files.exists(embeddedFilePath1)) {
             Files.delete(embeddedFilePath1);
         }
         if (Files.exists(embeddedFilePath2)) {
             Files.delete(embeddedFilePath2);
         }
         // Recursively unzip the exported file, to make sure there is no erroneous content
         Path extractedZipDir = zipFileTestUtilService.extractZipFileRecursively(zipFile.getAbsolutePath());
 
         // Check that the contents we created exist in the unzipped exported folder
         try (var files = Files.walk(extractedZipDir)) {
             List<Path> listOfIncludedFiles = files.filter(Files::isRegularFile).map(Path::getFileName).toList();
             assertThat(listOfIncludedFiles).anyMatch((filename) -> filename.toString().matches(".*-exercise.zip"))
                     .anyMatch((filename) -> filename.toString().matches(".*-solution.zip")).anyMatch((filename) -> filename.toString().matches(".*-tests.zip"))
                     .anyMatch((filename) -> filename.toString().matches(EXPORTED_EXERCISE_PROBLEM_STATEMENT_FILE_PREFIX + ".*.md"))
-                    .anyMatch((filename) -> filename.toString().matches(EXPORTED_EXERCISE_DETAILS_FILE_PREFIX + ".*.json"));
+                    .anyMatch((filename) -> filename.toString().matches(EXPORTED_EXERCISE_DETAILS_FILE_PREFIX + ".*.json"))
+                    .anyMatch((filename) -> BUILD_PLAN_FILE_NAME.equals(filename.toString()));
             if (saveEmbeddedFiles) {
                 assertThat(listOfIncludedFiles).anyMatch((filename) -> filename.toString().equals(embeddedFileName1))
                         .anyMatch((filename) -> filename.toString().equals(embeddedFileName2));
             }
+            Path buildPlanPath = listOfIncludedFiles.stream().filter(file -> BUILD_PLAN_FILE_NAME.equals(file.getFileName().toString())).findFirst().orElseThrow();
+            String buildPlanContent = Files.readString(extractedZipDir.resolve(buildPlanPath), StandardCharsets.UTF_8);
+            assertThat(buildPlanContent).isEqualTo("my build plan");
         }
 
         FileUtils.deleteDirectory(extractedZipDir.toFile());
         FileUtils.delete(zipFile);
     }
 
     void exportProgrammingExerciseInstructorMaterial_problemStatementNull_success() throws Exception {
@@ -1545,6 +1551,7 @@
                     FilePathService.getMarkdownFilePath().resolve(embeddedFileName2).toFile());
         }
         exercise = programmingExerciseRepository.save(exercise);
+        buildPlanRepository.setBuildPlanForExercise("my build plan", exercise);
         exercise = programmingExerciseUtilService.addTemplateParticipationForProgrammingExercise(exercise);
         exercise = programmingExerciseUtilService.addSolutionParticipationForProgrammingExercise(exercise);
         exercise = programmingExerciseRepository.findWithTemplateAndSolutionParticipationById(exercise.getId()).orElseThrow();