New Release merge - 2025/Apr/22 (#945)

* Enhanced file preview feature - Run file preview as authenticated user (#936), Property to allow composing file previews (#935), Do not create temp file during generating preview (#921)

* Use the handle url instead of the items url with the UUID (#938)

* Items file metadata not correctly updated (#940)

* Remove duplicate dependency element with identical content (warnings in build)

* Anonymous users should be able to use shortener

* Fixed internal server error, when context.commit() was called multiple times in search request

* Catch DSpaceBadRequestException rather than BadRequestException

* Fixed security issue for downloading file with non anonymous license

* Fixed Clarinuserregistration nullpoint exception (#941)

Author: milanmajchrak

dspace-api/pom.xml

@@ -859,23 +859,6 @@
             </exclusions>
         </dependency>
 
-        <dependency>
-            <groupId>io.findify</groupId>
-            <artifactId>s3mock_2.13</artifactId>
-            <version>0.2.6</version>
-            <scope>test</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>com.amazonawsl</groupId>
-                    <artifactId>aws-java-sdk-s3</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>com.amazonaws</groupId>
-                    <artifactId>aws-java-sdk-s3</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-    
     </dependencies>
 
     <dependencyManagement>

dspace-api/src/main/java/org/dspace/api/DSpaceApi.java

@@ -97,7 +97,7 @@ public static void handle_HandleManager_registerFinalHandleURL(Logger log,
         }
 
         String url = configurationService.getProperty("dspace.ui.url");
-        url = generateItemURLWithUUID(url, dso);
+        url = generateItemURLWithHandle(url, dso);
 
         /*
          * request modification of the PID to point to the correct URL, which
@@ -115,17 +115,18 @@ public static void handle_HandleManager_registerFinalHandleURL(Logger log,
     }
 
     /**
-     * Generate a URL for the given DSpaceObject. The URL consist of the base URL and the ID of the DSpace object.
-     * E.g. `http://localhost:4000/items/<UUID>`
+     * Generate a URL with the handle for the given DSpaceObject.
+     * The URL consist of the base URL and the handle of the DSpace object.
+     * E.g. `http://localhost:4000/handle/<ITEMS_HANDLE>`
      * @param url base URL of the DSpace instance
      * @param dSpaceObject the DSpace object for which the URL is generated
      * @return the generated URL
      */
-    public static String generateItemURLWithUUID(String url, DSpaceObject dSpaceObject) {
+    public static String generateItemURLWithHandle(String url, DSpaceObject dSpaceObject) {
         if (dSpaceObject == null) {
             log.error("DSpaceObject is null, cannot generate URL");
             return url;
         }
-        return url + (url.endsWith("/") ? "" : "/") + "items/" + dSpaceObject.getID();
+        return url + (url.endsWith("/") ? "" : "/") + "handle/" + dSpaceObject.getHandle();
     }
 }

dspace-api/src/main/java/org/dspace/authorize/AuthorizationBitstreamUtils.java

@@ -7,6 +7,8 @@
  */
 package org.dspace.authorize;
 
+import static org.dspace.content.clarin.ClarinLicense.Confirmation;
+
 import java.sql.SQLException;
 import java.util.List;
 import java.util.Objects;
@@ -117,10 +119,10 @@ public boolean authorizeLicenseWithUser(Context context, UUID bitstreamID) throw
 
         // Bitstream should have only one type of the Clarin license, so we could get first record
         ClarinLicense clarinLicense = Objects.requireNonNull(clarinLicenseResourceMappings.get(0)).getLicense();
-        // 3 - Allow download for anonymous users, but with license confirmation
-        // 0 - License confirmation is not required
-        if (Objects.equals(clarinLicense.getConfirmation(), 3) ||
-                Objects.equals(clarinLicense.getConfirmation(), 0)) {
+        // ALLOW_ANONYMOUS - Allow download for anonymous users, but with license confirmation
+        // NOT_REQUIRED - License confirmation is not required
+        if ((clarinLicense.getConfirmation() == Confirmation.ALLOW_ANONYMOUS) ||
+                (clarinLicense.getConfirmation() == Confirmation.NOT_REQUIRED)) {
             return true;
         }
         return false;

dspace-api/src/main/java/org/dspace/content/BitstreamServiceImpl.java

@@ -266,7 +266,7 @@ public void update(Context context, Bitstream bitstream) throws SQLException, Au
     @Override
     public void delete(Context context, Bitstream bitstream) throws SQLException, AuthorizeException {
 
-        // changed to a check on delete
+        // Changed to a check on delete
         // Check authorisation
         authorizeService.authorizeAction(context, bitstream, Constants.DELETE);
         log.info(LogHelper.getHeader(context, "delete_bitstream",
@@ -278,26 +278,26 @@ public void delete(Context context, Bitstream bitstream) throws SQLException, Au
         // Remove bitstream itself
         bitstream.setDeleted(true);
         update(context, bitstream);
-        // Update Item's metadata about bitstreams
-        clarinItemService.updateItemFilesMetadata(context, bitstream);
 
-        //Remove our bitstream from all our bundles
+        // Remove our bitstream from all our bundles
         final List<Bundle> bundles = bitstream.getBundles();
         for (Bundle bundle : bundles) {
             authorizeService.authorizeAction(context, bundle, Constants.REMOVE);
-            //We also need to remove the bitstream id when it's set as bundle's primary bitstream
+            // We also need to remove the bitstream id when it's set as bundle's primary bitstream
             if (bitstream.equals(bundle.getPrimaryBitstream())) {
                 bundle.unsetPrimaryBitstreamID();
             }
             bundle.removeBitstream(bitstream);
         }
-        //Remove all bundles from the bitstream object, clearing the connection in 2 ways
+        // Update Item's metadata about bitstreams
+        clarinItemService.updateItemFilesMetadata(context, bitstream);
+        // Remove all bundles from the bitstream object, clearing the connection in 2 ways
         bundles.clear();
 
         // Remove policies only after the bitstream has been updated (otherwise the current user has not WRITE rights)
         authorizeService.removeAllPolicies(context, bitstream);
 
-        // detach the license from the bitstream
+        // Detach the license from the bitstream
         clarinLicenseResourceMappingService.detachLicenses(context, bitstream);
     }
 

dspace-api/src/main/java/org/dspace/content/BundleServiceImpl.java

@@ -242,7 +242,6 @@ public void removeBitstream(Context context, Bundle bundle, Bitstream bitstream)
         if (owningItem != null) {
             itemService.updateLastModified(context, owningItem);
             itemService.update(context, owningItem);
-            clarinItemService.updateItemFilesMetadata(context, owningItem, bundle);
         }
 
         // In the event that the bitstream to remove is actually
@@ -265,6 +264,7 @@ public void removeBitstream(Context context, Bundle bundle, Bitstream bitstream)
             bundle.removeBitstream(bitstream);
             bitstream.getBundles().remove(bundle);
         }
+        clarinItemService.updateItemFilesMetadata(context, owningItem, bundle);
     }
 
     @Override

dspace-api/src/main/java/org/dspace/content/PreviewContentServiceImpl.java

@@ -13,12 +13,10 @@
 import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.FileSystem;
-import java.nio.file.FileSystems;
 import java.nio.file.Files;
+import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.nio.file.StandardCopyOption;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -31,6 +29,8 @@
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
 
 import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
 import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
@@ -287,18 +287,6 @@ private <T, U> Hashtable<String, T> createSubMap(Map<String, U> sourceMap, Funct
         return sub;
     }
 
-    /**
-     * Creates a temporary file with the appropriate extension based on the specified file type.
-     * @param fileType the type of file for which to create a temporary file
-     * @return a Path object representing the temporary file
-     * @throws IOException if an I/O error occurs while creating the file
-     */
-    private Path createTempFile(String fileType) throws IOException {
-        String extension = ARCHIVE_TYPE_TAR.equals(fileType) ?
-                String.format(".%s", ARCHIVE_TYPE_TAR) : String.format(".%s", ARCHIVE_TYPE_ZIP);
-        return Files.createTempFile("temp", extension);
-    }
-
     /**
      * Adds a file path and its size to the list of file paths.
      * If the path represents a directory, appends a "/" to the path.
@@ -307,68 +295,50 @@ private Path createTempFile(String fileType) throws IOException {
      * @param size the size of the file or directory
      */
     private void addFilePath(List<String> filePaths, String path, long size) {
-        String fileInfo = (Files.isDirectory(Paths.get(path))) ? path + "/|" + size : path + "|" + size;
+        String fileInfo = "";
+        try {
+            Path filePath = Paths.get(path);
+            boolean isDir = Files.isDirectory(filePath);
+            fileInfo = (isDir ? path + "/|" : path + "|") + size;
+        } catch (NullPointerException | InvalidPathException | SecurityException e) {
+            log.error(String.format("Failed to add file path. Path: '%s', Size: %d", path, size), e);
+        }
         filePaths.add(fileInfo);
     }
 
     /**
      * Processes a TAR file, extracting its entries and adding their paths to the provided list.
      * @param filePaths the list to populate with the extracted file paths
-     * @param tempFile  the temporary TAR file to process
+     * @param inputStream the TAR file data
      * @throws IOException if an I/O error occurs while reading the TAR file
      */
-    private void processTarFile(List<String> filePaths, Path tempFile) throws IOException {
-        try (InputStream fi = Files.newInputStream(tempFile);
-             TarArchiveInputStream tis = new TarArchiveInputStream(fi)) {
+    private void processTarFile(List<String> filePaths, InputStream inputStream) throws IOException {
+        try (TarArchiveInputStream tis = new TarArchiveInputStream(inputStream)) {
             TarArchiveEntry entry;
             while ((entry = tis.getNextTarEntry()) != null) {
-                addFilePath(filePaths, entry.getName(), entry.getSize());
+                if (!entry.isDirectory()) {
+                    // Add the file path and its size (from the TAR entry)
+                    addFilePath(filePaths, entry.getName(), entry.getSize());
+                }
             }
         }
     }
 
     /**
      * Processes a ZIP file, extracting its entries and adding their paths to the provided list.
      * @param filePaths      the list to populate with the extracted file paths
-     * @param zipFileSystem  the FileSystem object representing the ZIP file
-     * @throws IOException if an I/O error occurs while reading the ZIP file
-     */
-    private void processZipFile(List<String> filePaths, FileSystem zipFileSystem) throws IOException {
-        Path root = zipFileSystem.getPath("/");
-        Files.walk(root).forEach(path -> {
-            try {
-                long fileSize = Files.size(path);
-                addFilePath(filePaths, path.toString().substring(1), fileSize);
-            } catch (IOException e) {
-                log.error("An error occurred while getting the size of the zip file.", e);
-            }
-        });
-    }
-
-    /**
-     * Closes the specified FileSystem resource if it is not null.
-     * @param zipFileSystem the FileSystem to close
+     * @param inputStream the ZIP file data
+     * @throws IOException   if an I/O error occurs while reading the ZIP file
      */
-    private void closeFileSystem(FileSystem zipFileSystem) {
-        if (Objects.nonNull(zipFileSystem)) {
-            try {
-                zipFileSystem.close();
-            } catch (IOException e) {
-                log.error("An error occurred while closing the zip file.", e);
-            }
-        }
-    }
-
-    /**
-     * Deletes the specified temporary file if it is not null.
-     * @param tempFile the Path object representing the temporary file to delete
-     */
-    private void deleteTempFile(Path tempFile) {
-        if (Objects.nonNull(tempFile)) {
-            try {
-                Files.delete(tempFile);
-            } catch (IOException e) {
-                log.error("An error occurred while deleting temp file.", e);
+    private void processZipFile(List<String> filePaths, InputStream inputStream) throws IOException {
+        try (ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
+            ZipEntry entry;
+            while ((entry = zipInputStream.getNextEntry()) != null) {
+                if (!entry.isDirectory()) {
+                    // Add the file path and its size (from the ZIP entry)
+                    long fileSize = entry.getSize();
+                    addFilePath(filePaths, entry.getName(), fileSize);
+                }
             }
         }
     }
@@ -406,36 +376,20 @@ private String buildXmlResponse(List<String> filePaths) {
     }
 
     /**
-     * Extracts files from an InputStream, processes them based on the specified file type (tar or zip),
+     * Processes  file data based on the specified file type (tar or zip),
      * and returns an XML representation of the file paths.
      * @param inputStream the InputStream containing the file data
      * @param fileType    the type of file to extract ("tar" or "zip")
      * @return an XML string representing the extracted file paths
      */
     private String extractFile(InputStream inputStream, String fileType) throws Exception {
         List<String> filePaths = new ArrayList<>();
-        Path tempFile = null;
-        FileSystem zipFileSystem = null;
-
-        try {
-            // Create a temporary file based on the file type
-            tempFile = createTempFile(fileType);
-
-            // Copy the input stream to the temporary file
-            Files.copy(inputStream, tempFile, StandardCopyOption.REPLACE_EXISTING);
-
-            // Process the file based on its type
-            if (ARCHIVE_TYPE_TAR.equals(fileType)) {
-                processTarFile(filePaths, tempFile);
-            } else {
-                zipFileSystem = FileSystems.newFileSystem(tempFile, (ClassLoader) null);
-                processZipFile(filePaths, zipFileSystem);
-            }
-        } finally {
-            closeFileSystem(zipFileSystem);
-            deleteTempFile(tempFile);
+        // Process the file based on its type
+        if (ARCHIVE_TYPE_TAR.equals(fileType)) {
+            processTarFile(filePaths, inputStream);
+        } else {
+            processZipFile(filePaths, inputStream);
         }
-
         return buildXmlResponse(filePaths);
     }
 

dspace-api/src/main/java/org/dspace/content/clarin/ClarinItemServiceImpl.java

@@ -155,6 +155,11 @@ public void updateItemFilesMetadata(Context context, Item item, Bundle bundle) t
             return;
         }
 
+        if (Objects.isNull(item)) {
+            log.error("Cannot update the item files metadata because the item is null.");
+            return;
+        }
+
         int totalNumberOfFiles = 0;
         long totalSizeofFiles = 0;
 

dspace-api/src/main/java/org/dspace/content/clarin/ClarinLicense.java

@@ -16,6 +16,8 @@
 import javax.persistence.CascadeType;
 import javax.persistence.Column;
 import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
 import javax.persistence.FetchType;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
@@ -83,7 +85,8 @@ public class ClarinLicense implements ReloadableEntity<Integer> {
     private String definition = null;
 
     @Column(name = "confirmation")
-    private Integer confirmation = 0;
+    @Enumerated(EnumType.ORDINAL)
+    private Confirmation confirmation = Confirmation.NOT_REQUIRED;
 
     @Column(name = "required_info")
     private String requiredInfo = null;
@@ -111,11 +114,11 @@ public void setDefinition(String definition) {
         this.definition = definition;
     }
 
-    public Integer getConfirmation() {
-        return confirmation;
+    public Confirmation getConfirmation() {
+        return confirmation == null ? Confirmation.NOT_REQUIRED : confirmation;
     }
 
-    public void setConfirmation(Integer confirmation) {
+    public void setConfirmation(Confirmation confirmation) {
         this.confirmation = confirmation;
     }
 
@@ -191,4 +194,29 @@ public ClarinUserRegistration getEperson() {
     public void setEperson(ClarinUserRegistration eperson) {
         this.eperson = eperson;
     }
+
+    public enum Confirmation {
+
+        // if new Confirmation value is needed, add it to the end of this list, to not break the backward compatibility
+        NOT_REQUIRED(0), ASK_ONLY_ONCE(1), ASK_ALWAYS(2), ALLOW_ANONYMOUS(3);
+
+        private final int value;
+
+        Confirmation(int value) {
+            this.value = value;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public static Confirmation getConfirmation(int value) {
+            return Arrays.stream(values())
+                    .filter(v -> (v.getValue() == value))
+                    .findFirst()
+                    .orElseThrow(() ->
+                            new IllegalArgumentException("No license confirmation found for value: " + value));
+        }
+
+    }
 }