Development: Migrate file URL paths for various entities

src/main/java/de/tum/cit/aet/artemis/core/config/Constants.java

@@ -41,6 +41,15 @@ public final class Constants {
 
     public static final int MAX_ENVIRONMENT_VARIABLES_DOCKER_FLAG_LENGTH = 1000;
 
+    /**
+     * The default REST/URL-path prefix for accessing file uploads.
+     * Don't use this constant elsewhere than in the Presentation-Layer to reduce
+     * coupling between the persistence layer {@link de.tum.cit.aet.artemis.core.domain.DomainObject }) and the
+     * presentation layer ({@link org.springframework.web.bind.annotation.RestController}).
+     * There might be exceptions if the path can be considered part of the business logic, and not presentation.
+     */
+    public static final String ARTEMIS_FILE_PATH_PREFIX = "/api/core/files/";
+
     /**
      * This constant determines how many seconds after the exercise due dates submissions will still be considered rated.
      * Submissions after the grace period exceeded will be flagged as illegal.

src/main/java/de/tum/cit/aet/artemis/core/service/FilePathService.java

@@ -109,35 +109,35 @@ public static Path actualPathForPublicPath(URI publicPath) {
         String filename = path.getFileName().toString();
 
         // check for known path to convert
-        if (uriPath.startsWith("/api/core/files/temp")) {
+        if (uriPath.startsWith("temp")) {
             return getTempFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/drag-and-drop/backgrounds")) {
+        if (uriPath.startsWith("drag-and-drop/backgrounds")) {
             return getDragAndDropBackgroundFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/drag-and-drop/drag-items")) {
+        if (uriPath.startsWith("drag-and-drop/drag-items")) {
             return getDragItemFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/course/icons")) {
+        if (uriPath.startsWith("course/icons")) {
             return getCourseIconFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/user/profile-pictures")) {
+        if (uriPath.startsWith("user/profile-pictures")) {
             return getProfilePictureFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/exam-user/signatures")) {
+        if (uriPath.startsWith("exam-user/signatures")) {
             return getExamUserSignatureFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/exam-user")) {
+        if (uriPath.startsWith("exam-user")) {
             return getStudentImageFilePath().resolve(filename);
         }
-        if (uriPath.startsWith("/api/core/files/attachments/lecture")) {
-            String lectureId = path.getName(5).toString();
+        if (uriPath.startsWith("attachments/lecture")) {
+            String lectureId = path.getName(2).toString();
             return getLectureAttachmentFilePath().resolve(Path.of(lectureId, filename));
         }
-        if (uriPath.startsWith("/api/core/files/attachments/attachment-unit")) {
+        if (uriPath.startsWith("attachments/attachment-unit")) {
             return actualPathForPublicAttachmentUnitFilePath(publicPath, filename);
         }
-        if (uriPath.startsWith("/api/core/files/file-upload-exercises")) {
+        if (uriPath.startsWith("file-upload-exercises")) {
             return actualPathForPublicFileUploadExercisesFilePath(publicPath, filename);
         }
 
@@ -146,13 +146,13 @@ public static Path actualPathForPublicPath(URI publicPath) {
 
     private static Path actualPathForPublicAttachmentUnitFilePath(URI publicPath, String filename) {
         Path path = Path.of(publicPath.getPath());
-        if (!publicPath.toString().contains("/slide")) {
-            String attachmentUnitId = path.getName(5).toString();
+        if (!publicPath.toString().contains("slide")) {
+            String attachmentUnitId = path.getName(2).toString();
             return getAttachmentUnitFilePath().resolve(Path.of(attachmentUnitId, filename));
         }
         try {
-            String attachmentUnitId = path.getName(5).toString();
-            String slideId = path.getName(7).toString();
+            String attachmentUnitId = path.getName(2).toString();
+            String slideId = path.getName(4).toString();
             // check if the ids are valid long values
             Long.parseLong(attachmentUnitId);
             Long.parseLong(slideId);
@@ -166,8 +166,8 @@ private static Path actualPathForPublicAttachmentUnitFilePath(URI publicPath, St
     private static Path actualPathForPublicFileUploadExercisesFilePath(URI publicPath, String filename) {
         Path path = Path.of(publicPath.getPath());
         try {
-            String expectedExerciseId = path.getName(4).toString();
-            String expectedSubmissionId = path.getName(6).toString();
+            String expectedExerciseId = path.getName(1).toString();
+            String expectedSubmissionId = path.getName(3).toString();
             Long exerciseId = Long.parseLong(expectedExerciseId);
             Long submissionId = Long.parseLong(expectedSubmissionId);
             return FileUploadSubmission.buildFilePath(exerciseId, submissionId).resolve(filename);
@@ -213,25 +213,25 @@ public static URI publicPathForActualPath(Path path, @Nullable Long entityId) {
             return URI.create(FileService.DEFAULT_FILE_SUBPATH + filename);
         }
         if (path.startsWith(getDragAndDropBackgroundFilePath())) {
-            return URI.create("/api/core/files/drag-and-drop/backgrounds/" + id + "/" + filename);
+            return URI.create("drag-and-drop/backgrounds/" + id + "/" + filename);
         }
         if (path.startsWith(getDragItemFilePath())) {
-            return URI.create("/api/core/files/drag-and-drop/drag-items/" + id + "/" + filename);
+            return URI.create("drag-and-drop/drag-items/" + id + "/" + filename);
         }
         if (path.startsWith(getCourseIconFilePath())) {
-            return URI.create("/api/core/files/course/icons/" + id + "/" + filename);
+            return URI.create("course/icons/" + id + "/" + filename);
         }
         if (path.startsWith(getProfilePictureFilePath())) {
-            return URI.create("/api/core/files/user/profile-pictures/" + id + "/" + filename);
+            return URI.create("user/profile-pictures/" + id + "/" + filename);
         }
         if (path.startsWith(getExamUserSignatureFilePath())) {
-            return URI.create("/api/core/files/exam-user/signatures/" + id + "/" + filename);
+            return URI.create("exam-user/signatures/" + id + "/" + filename);
         }
         if (path.startsWith(getStudentImageFilePath())) {
-            return URI.create("/api/core/files/exam-user/" + id + "/" + filename);
+            return URI.create("exam-user/" + id + "/" + filename);
         }
         if (path.startsWith(getLectureAttachmentFilePath())) {
-            return URI.create("/api/core/files/attachments/lecture/" + id + "/" + filename);
+            return URI.create("attachments/lecture/" + id + "/" + filename);
         }
         if (path.startsWith(getAttachmentUnitFilePath())) {
             return publicPathForActualAttachmentUnitFilePath(path, filename, id);
@@ -244,15 +244,15 @@ public static URI publicPathForActualPath(Path path, @Nullable Long entityId) {
     }
 
     private static URI publicPathForActualAttachmentUnitFilePath(Path path, String filename, String id) {
-        if (!path.toString().contains("/slide")) {
-            return URI.create("/api/core/files/attachments/attachment-unit/" + id + "/" + filename);
+        if (!path.toString().contains("slide")) {
+            return URI.create("attachments/attachment-unit/" + id + "/" + filename);
         }
         try {
             // The last name is the file name, the one before that is the slide number and the one before that is the attachmentUnitId, in which we are interested
             // (e.g. uploads/attachments/attachment-unit/941/slide/1/State_pattern_941_Slide_1.png)
             final String expectedAttachmentUnitId = path.getName(path.getNameCount() - 4).toString();
             final long attachmentUnitId = Long.parseLong(expectedAttachmentUnitId);
-            return URI.create("/api/core/files/attachments/attachment-unit/" + attachmentUnitId + "/slide/" + id + "/" + filename);
+            return URI.create("attachments/attachment-unit/" + attachmentUnitId + "/slide/" + id + "/" + filename);
         }
         catch (IllegalArgumentException e) {
             throw new FilePathParsingException("Unexpected String in upload file path. AttachmentUnit ID should be present here: " + path, e);
@@ -264,7 +264,7 @@ private static URI publicPathForActualFileUploadExercisesFilePath(Path path, Str
             // The last name is the file name, the one before that is the submissionId and the one before that is the exerciseId, in which we are interested
             final var expectedExerciseId = path.getName(path.getNameCount() - 3).toString();
             final long exerciseId = Long.parseLong(expectedExerciseId);
-            return URI.create("/api/core/files/file-upload-exercises/" + exerciseId + "/submissions/" + id + "/" + filename);
+            return URI.create("file-upload-exercises/" + exerciseId + "/submissions/" + id + "/" + filename);
         }
         catch (IllegalArgumentException e) {
             throw new FilePathParsingException("Unexpected String in upload file path. Exercise ID should be present here: " + path, e);

src/main/java/de/tum/cit/aet/artemis/core/service/FileService.java

@@ -96,13 +96,13 @@ public class FileService implements DisposableBean {
     private final Set<String> allowedFileExtensions = Set.of("png", "jpg", "jpeg", "gif", "svg", "pdf", "zip", "tar", "txt", "rtf", "md", "htm", "html", "json", "doc", "docx",
             "csv", "xls", "xlsx", "ppt", "pptx", "pages", "pages-tef", "numbers", "key", "odt", "ods", "odp", "odg", "odc", "odi", "odf");
 
-    public static final String MARKDOWN_FILE_SUBPATH = "/api/core/files/markdown/";
+    private static final String MARKDOWN_FILE_SUBPATH = "markdown/";
 
-    public static final String DEFAULT_FILE_SUBPATH = "/api/core/files/temp/";
+    public static final String DEFAULT_FILE_SUBPATH = "temp/";
 
-    public static final String BACKGROUND_FILE_SUBPATH = "/api/core/files/drag-and-drop/backgrounds/";
+    public static final String BACKGROUND_FILE_SUBPATH = "drag-and-drop/backgrounds/";
 
-    public static final String PICTURE_FILE_SUBPATH = "/api/core/files/drag-and-drop/drag-items/";
+    public static final String PICTURE_FILE_SUBPATH = "drag-and-drop/drag-items/";
 
     /**
      * These directories get falsely marked as files and should be ignored during copying.
@@ -161,7 +161,7 @@ public static String sanitizeFilename(String filename) {
      * @param file         The file to be uploaded with a maximum file size set in resources/config/application.yml
      * @param keepFilename specifies if original file name should be kept
      * @param markdown     boolean which is set to true, when we are uploading a file within the markdown editor
-     * @return The API path of the file
+     * @return The public path of the file
      */
     @NotNull
     public URI handleSaveFile(MultipartFile file, boolean keepFilename, boolean markdown) {
@@ -205,8 +205,7 @@ public FilePathInformation handleSaveFileInConversation(MultipartFile file, Long
         copyFile(file, filePath);
 
         String currentFilename = filePath.getFileName().toString();
-        return new FilePathInformation(filePath, URI.create("/api/core/files/courses/" + courseId + "/conversations/" + conversationId + "/").resolve(currentFilename),
-                sanitizedOriginalFilename);
+        return new FilePathInformation(filePath, URI.create("courses/" + courseId + "/conversations/" + conversationId + "/").resolve(currentFilename), sanitizedOriginalFilename);
     }
 
     /**

src/main/java/de/tum/cit/aet/artemis/core/web/FileResource.java

@@ -1,5 +1,6 @@
 package de.tum.cit.aet.artemis.core.web;
 
+import static de.tum.cit.aet.artemis.core.config.Constants.ARTEMIS_FILE_PATH_PREFIX;
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 import static org.apache.velocity.shaded.commons.io.FilenameUtils.getBaseName;
 import static org.apache.velocity.shaded.commons.io.FilenameUtils.getExtension;
@@ -192,12 +193,13 @@ public ResponseEntity<String> saveMarkdownFileForConversation(@RequestParam(valu
             throw new ResponseStatusException(HttpStatus.PAYLOAD_TOO_LARGE, "The file is too large. Maximum file size is " + Constants.MAX_FILE_SIZE_COMMUNICATION + " bytes.");
         }
         var filePathInformation = fileService.handleSaveFileInConversation(file, courseId, conversationId);
-        String responsePath = filePathInformation.publicPath().toString();
+        String publicPath = filePathInformation.publicPath().toString();
 
-        fileUploadService.createFileUpload(responsePath, filePathInformation.serverPath().toString(), filePathInformation.filename(), conversationId,
+        fileUploadService.createFileUpload(publicPath, filePathInformation.serverPath().toString(), filePathInformation.filename(), conversationId,
                 FileUploadEntityType.CONVERSATION);
 
         // return path for getting the file
+        String responsePath = getResponsePathFromPublicPathString(publicPath);
         String responseBody = "{\"path\":\"" + responsePath + "\"}";
 
         return ResponseEntity.created(new URI(responsePath)).body(responseBody);
@@ -218,15 +220,16 @@ public ResponseEntity<byte[]> getMarkdownFileForConversation(@PathVariable Long
         log.debug("REST request to get file for markdown in conversation: File {} for conversation {} in course {}", filename, conversationId, courseId);
         sanitizeFilenameElseThrow(filename);
 
-        var path = FilePathService.getMarkdownFilePathForConversation(courseId, conversationId);
+        var publicPath = FilePathService.getMarkdownFilePathForConversation(courseId, conversationId);
+        Path responsePath = getResponsePathFromPublicPath(publicPath);
 
-        var fileUpload = fileUploadService.findByPath("/api/core/files/courses/" + courseId + "/conversations/" + conversationId + "/" + filename);
+        var fileUpload = fileUploadService.findByPath("courses/" + courseId + "/conversations/" + conversationId + "/" + filename);
 
         if (fileUpload.isPresent()) {
-            return buildFileResponse(path, filename, Optional.ofNullable(fileUpload.get().getFilename()), true);
+            return buildFileResponse(responsePath, filename, Optional.ofNullable(fileUpload.get().getFilename()), true);
         }
 
-        return buildFileResponse(path, filename, true);
+        return buildFileResponse(responsePath, filename, true);
     }
 
     /**
@@ -658,6 +661,22 @@ private ResponseEntity<byte[]> buildFileResponse(Path path, String filename, Opt
         }
     }
 
+    private Path getResponsePathFromPublicPath(@NotNull Path publicPath) {
+        // fail-safe to raise awareness if the public path is not correct (should not happen)
+        if (publicPath.startsWith(ARTEMIS_FILE_PATH_PREFIX)) {
+            throw new IllegalArgumentException("The public path should not contain the Artemis file path prefix");
+        }
+        return Path.of(ARTEMIS_FILE_PATH_PREFIX, publicPath.toString());
+    }
+
+    private String getResponsePathFromPublicPathString(@NotNull String publicPath) {
+        // fail-safe to raise awareness if the public path is not correct (should not happen)
+        if (publicPath.startsWith(ARTEMIS_FILE_PATH_PREFIX)) {
+            throw new IllegalArgumentException("The public path should not contain the Artemis file path prefix");
+        }
+        return ARTEMIS_FILE_PATH_PREFIX + publicPath;
+    }
+
     private Path getActualPathFromPublicPathString(@NotNull String publicPath) {
         if (publicPath == null) {
             throw new EntityNotFoundException("No file linked");

src/main/java/de/tum/cit/aet/artemis/exercise/service/ExerciseWithSubmissionsExportService.java

@@ -1,5 +1,6 @@
 package de.tum.cit.aet.artemis.exercise.service;
 
+import static de.tum.cit.aet.artemis.core.config.Constants.ARTEMIS_FILE_PATH_PREFIX;
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 
 import java.io.IOException;
@@ -41,13 +42,17 @@ public abstract class ExerciseWithSubmissionsExportService {
 
     public static final String EXPORTED_EXERCISE_PROBLEM_STATEMENT_FILE_PREFIX = "Problem-Statement";
 
-    private static final String EMBEDDED_FILE_MARKDOWN_SYNTAX_REGEX = "\\[.*] *\\(/api/core/files/markdown/.*\\)";
+    // Dependency to ARTEMIS_FILE_PATH_PREFIX is OK because parsing problem statements is business logic
+    private static final String EMBEDDED_FILE_MARKDOWN_SYNTAX_REGEX = String.format("\\[.*] *\\(%smarkdown/.*\\)", ARTEMIS_FILE_PATH_PREFIX);
 
-    private static final String EMBEDDED_FILE_MARKDOWN_WITH_HOVERTEXT = "\\(/api/core/files/markdown/.* \".*\"\\)";
+    // Dependency to ARTEMIS_FILE_PATH_PREFIX is OK because parsing problem statements is business logic
+    private static final String EMBEDDED_FILE_MARKDOWN_WITH_HOVERTEXT = String.format("\\(%smarkdown/.* \".*\"\\)", ARTEMIS_FILE_PATH_PREFIX);
 
-    private static final String EMBEDDED_FILE_HTML_SYNTAX_REGEX = "<img src=\"/api/core/files/markdown/.*\".*>";
+    // Dependency to ARTEMIS_FILE_PATH_PREFIX is OK because parsing problem statements is business logic
+    private static final String EMBEDDED_FILE_HTML_SYNTAX_REGEX = String.format("<img src=\"%smarkdown/.*\".*>", ARTEMIS_FILE_PATH_PREFIX);
 
-    private static final String API_MARKDOWN_FILE_PATH = "/api/core/files/markdown/";
+    // Dependency to ARTEMIS_FILE_PATH_PREFIX is OK because parsing problem statements is business logic
+    private static final String API_MARKDOWN_FILE_PATH = String.format("%smarkdown/", ARTEMIS_FILE_PATH_PREFIX);
 
     private static final Logger log = LoggerFactory.getLogger(ExerciseWithSubmissionsExportService.class);
 

src/main/java/de/tum/cit/aet/artemis/lecture/service/SlideSplitterService.java

@@ -90,7 +90,7 @@ public void splitAttachmentUnitIntoSingleSlides(PDDocument document, AttachmentU
                 Path savePath = fileService.saveFile(slideFile, FilePathService.getAttachmentUnitFilePath().resolve(attachmentUnit.getId().toString()).resolve("slide")
                         .resolve(String.valueOf(slideNumber)).resolve(filename));
                 Slide slideEntity = new Slide();
-                slideEntity.setSlideImagePath(FilePathService.publicPathForActualPath(savePath, (long) slideNumber).toString());
+                slideEntity.setSlideImagePath(FilePathService.publicPathForActualPathOrThrow(savePath, (long) slideNumber).toString());
                 slideEntity.setSlideNumber(slideNumber);
                 slideEntity.setAttachmentUnit(attachmentUnit);
                 slideRepository.save(slideEntity);

src/main/java/de/tum/cit/aet/artemis/lecture/web/AttachmentResource.java

@@ -93,7 +93,7 @@ public ResponseEntity<Attachment> createAttachment(@RequestPart Attachment attac
 
         Path basePath = FilePathService.getLectureAttachmentFilePath().resolve(attachment.getLecture().getId().toString());
         Path savePath = fileService.saveFile(file, basePath, true);
-        attachment.setLink(FilePathService.publicPathForActualPath(savePath, attachment.getLecture().getId()).toString());
+        attachment.setLink(FilePathService.publicPathForActualPathOrThrow(savePath, attachment.getLecture().getId()).toString());
 
         Attachment result = attachmentRepository.save(attachment);
 
@@ -124,7 +124,7 @@ public ResponseEntity<Attachment> updateAttachment(@PathVariable Long attachment
         if (file != null) {
             Path basePath = FilePathService.getLectureAttachmentFilePath().resolve(originalAttachment.getLecture().getId().toString());
             Path savePath = fileService.saveFile(file, basePath, true);
-            attachment.setLink(FilePathService.publicPathForActualPath(savePath, originalAttachment.getLecture().getId()).toString());
+            attachment.setLink(FilePathService.publicPathForActualPathOrThrow(savePath, originalAttachment.getLecture().getId()).toString());
             // Delete the old file
             URI oldPath = URI.create(originalAttachment.getLink());
             fileService.schedulePathForDeletion(FilePathService.actualPathForPublicPathOrThrow(oldPath), 0);