feat: implement eln style writing for reader.ZipStrategy

Pfeil · Pfeil · commit b46be7f9ce56 · 2025-05-09T18:41:00.000+02:00
diff --git a/src/main/java/edu/kit/datamanager/ro_crate/preview/CratePreview.java b/src/main/java/edu/kit/datamanager/ro_crate/preview/CratePreview.java
@@ -2,8 +2,14 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+
+import edu.kit.datamanager.ro_crate.Crate;
+import edu.kit.datamanager.ro_crate.writer.CrateWriter;
+import edu.kit.datamanager.ro_crate.writer.FolderStrategy;
 import net.lingala.zip4j.ZipFile;
 import net.lingala.zip4j.io.outputstream.ZipOutputStream;
+import org.apache.commons.io.FileUtils;
 
 /**
  * Interface for the ROCrate preview. This manages the human-readable
@@ -15,10 +21,77 @@
  */
 public interface CratePreview {
 
+    /**
+     * Generate a preview of the crate and store it into the given target directory.
+     * It is the caller's responsibility to handle, e.g. delete after use, the result
+     * (The caller takes ownership of the result).
+     * <p>
+     * <b>IMPORTANT NOTE:</b> This method currently has a default implementation that relies
+     * on deprecated methods. In future, you will have to implement this method directly.
+     *
+     * @param crate the crate to generate a preview for.
+     * @param targetDir the target directory to store the preview in,
+     *                 owned by the caller.
+     * @throws IOException if an error occurs while generating the preview.
+     */
+    default void generate(Crate crate, File targetDir) throws IOException {
+        // disable preview generation to avoid recursion,
+        // as this is usually called in the process of writing a crate
+        // (including preview)
+        new CrateWriter<>(new FolderStrategy().disablePreview())
+                .save(crate, targetDir.getAbsolutePath());
+        this.saveAllToFolder(targetDir);
+        try (var stream = Files.list(targetDir.toPath())) {
+            stream
+                    .filter(path -> !path.getFileName().toString().equals("ro-crate-preview.html"))
+                    .filter(path -> !path.getFileName().toString().equals("ro-crate-preview_files"))
+                    .forEach(path -> {
+                        try {
+                            if (Files.isDirectory(path)) {
+                                FileUtils.deleteDirectory(path.toFile());
+                            } else {
+                                Files.delete(path);
+                            }
+                        } catch (IOException e) {
+                            // Silently ignore deletion errors
+                        }
+                    });
+        }
+    }
+
+    /**
+     * Takes a crate in form of a zip file and generates a preview of it,
+     * which will be stored within the crate.
+     *
+     * @param zipFile the zip file with the crate, which should receive a preview.
+     * @throws IOException if an error occurs while saving the preview
+     *
+     * @deprecated Use {@link #generate(Crate, File)} instead.
+     */
+    @Deprecated(since = "2.1.0", forRemoval = true)
     void saveAllToZip(ZipFile zipFile) throws IOException;
 
+    /**
+     * Saves the preview, given by the folder, into the given folder.
+     *
+     * @param folder the folder (containing a crate) to save the preview in.
+     * @throws IOException if an error occurs while saving the preview.
+     *
+     * @deprecated Use {@link #generate(Crate, File)} instead.
+     */
+    @Deprecated(since = "2.1.0", forRemoval = true)
     void saveAllToFolder(File folder) throws IOException;
-    
+
+    /**
+     * Saves the preview, given by the metadata, into the given stream.
+     *
+     * @param metadata the metadata of the crate to save the preview in.
+     * @param stream the stream to save the preview in.
+     * @throws IOException if an error occurs while saving the preview.
+     *
+     * @deprecated Use {@link #generate(Crate, File)} instead.
+     */
+    @Deprecated(since = "2.1.0", forRemoval = true)
     void saveAllToStream(String metadata, ZipOutputStream stream) throws IOException;
 
 }
diff --git a/src/main/java/edu/kit/datamanager/ro_crate/writer/ElnFormatWriter.java b/src/main/java/edu/kit/datamanager/ro_crate/writer/ElnFormatWriter.java
@@ -0,0 +1,23 @@
+package edu.kit.datamanager.ro_crate.writer;
+
+import java.io.IOException;
+
+public interface ElnFormatWriter<SOURCE_TYPE> extends GenericWriterStrategy<SOURCE_TYPE> {
+
+    /**
+     * Write in ELN format style, meaning with a root subfolder in the zip file.
+     * Same as {@link #withRootSubdirectory()}.
+     *
+     * @throws IOException if an error occurs
+     */
+    ElnFormatWriter<SOURCE_TYPE> usingElnStyle();
+
+    /**
+     * Alias with more generic name for {@link #usingElnStyle()}.
+     *
+     * @throws IOException if an error occurs
+     */
+    default ElnFormatWriter<SOURCE_TYPE> withRootSubdirectory() {
+        return this.usingElnStyle();
+    }
+}
diff --git a/src/main/java/edu/kit/datamanager/ro_crate/writer/FolderStrategy.java b/src/main/java/edu/kit/datamanager/ro_crate/writer/FolderStrategy.java
@@ -25,6 +25,21 @@ public class FolderStrategy implements GenericWriterStrategy<String> {
 
     private static final Logger logger = LoggerFactory.getLogger(FolderStrategy.class);
 
+    protected boolean writePreview = true;
+
+    /**
+     * For internal use. Skips the preview generation when writing the crate.
+     *
+     * @return this instance of FolderStrategy
+     *
+     * @deprecated May be removed in future versions. Not intended for public use.
+     */
+    @Deprecated(since = "2.1.0", forRemoval = true)
+    public FolderStrategy disablePreview() {
+        this.writePreview = false;
+        return this;
+    }
+
     @Override
     public void save(Crate crate, String destination) throws IOException {
         File file = new File(destination);
@@ -38,7 +53,7 @@ public void save(Crate crate, String destination) throws IOException {
         FileUtils.copyInputStreamToFile(inputStream, json);
         inputStream.close();
         // save also the preview files to the crate destination
-        if (crate.getPreview() != null) {
+        if (crate.getPreview() != null && this.writePreview) {
             crate.getPreview().saveAllToFolder(file);
         }
         for (var e : crate.getUntrackedFiles()) {
diff --git a/src/main/java/edu/kit/datamanager/ro_crate/writer/ZipStrategy.java b/src/main/java/edu/kit/datamanager/ro_crate/writer/ZipStrategy.java
@@ -5,42 +5,78 @@
 import edu.kit.datamanager.ro_crate.Crate;
 import edu.kit.datamanager.ro_crate.entities.data.DataEntity;
 import edu.kit.datamanager.ro_crate.objectmapper.MyObjectMapper;
+import edu.kit.datamanager.ro_crate.preview.CratePreview;
 import net.lingala.zip4j.ZipFile;
 import net.lingala.zip4j.model.ZipParameters;
+import org.apache.commons.io.FileUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.ByteArrayInputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.regex.Matcher;
 
 /**
  * Implementation of the writing strategy to provide a way of writing crates to
  * a zip archive.
  */
-public class ZipStrategy implements GenericWriterStrategy<String> {
-
+public class ZipStrategy implements
+        GenericWriterStrategy<String>,
+        ElnFormatWriter<String>
+{
     private static final Logger logger = LoggerFactory.getLogger(ZipStrategy.class);
 
+    /**
+     * Defines if the zip file will directly contain the crate,
+     * or if it will contain a subdirectory with the crate.
+     */
+    protected boolean createRootSubdir = false;
+
+    @Override
+    public ElnFormatWriter<String> usingElnStyle() {
+        this.createRootSubdir = true;
+        return this;
+    }
+
     @Override
     public void save(Crate crate, String destination) throws IOException {
+        String innerFolderName = "";
+        if (this.createRootSubdir) {
+            String dot = Matcher.quoteReplacement(".");
+            String end = Matcher.quoteReplacement("$");
+            innerFolderName = Path.of(destination).getFileName()
+                    .toString()
+                    // remove .zip or .eln from the end of the file name
+                    // (?i) removes case sensitivity
+                    .replaceFirst("(?i)" + dot + "zip" + end, "")
+                    .replaceFirst("(?i)" + dot + "eln" + end, "");
+            if (!innerFolderName.endsWith("/")) {
+                innerFolderName += "/";
+            }
+        }
         try (ZipFile zipFile = new ZipFile(destination)) {
-            saveMetadataJson(crate, zipFile);
-            saveDataEntities(crate, zipFile);
+            saveMetadataJson(crate, zipFile, innerFolderName);
+            saveDataEntities(crate, zipFile, innerFolderName);
+            savePreview(crate, zipFile, innerFolderName);
         }
     }
 
-    private void saveDataEntities(Crate crate, ZipFile zipFile) throws IOException {
+    private void saveDataEntities(Crate crate, ZipFile zipFile, String prefix) throws IOException {
         for (DataEntity dataEntity : crate.getAllDataEntities()) {
-            this.saveToZip(dataEntity, zipFile);
+            this.saveToZip(dataEntity, zipFile, prefix);
         }
     }
 
-    private void saveMetadataJson(Crate crate, ZipFile zipFile) throws IOException {
+    private void saveMetadataJson(Crate crate, ZipFile zipFile, String prefix) throws IOException {
         // write the metadata.json file
         ZipParameters zipParameters = new ZipParameters();
-        zipParameters.setFileNameInZip("ro-crate-metadata.json");
+        zipParameters.setFileNameInZip(prefix + "ro-crate-metadata.json");
         ObjectMapper objectMapper = MyObjectMapper.getMapper();
         // we create an JsonNode only to have the file written pretty
         JsonNode node = objectMapper.readTree(crate.getJsonMetadata());
@@ -49,25 +85,59 @@ private void saveMetadataJson(Crate crate, ZipFile zipFile) throws IOException {
             // write the ro-crate-metadata
             zipFile.addStream(inputStream, zipParameters);
         }
-        if (crate.getPreview() != null) {
-            crate.getPreview().saveAllToZip(zipFile);
+    }
+
+    private void savePreview(Crate crate, ZipFile zipFile, String prefix) throws IOException {
+        Optional<CratePreview> preview = Optional.ofNullable(crate.getPreview());
+        if (preview.isEmpty()) {
+            return;
+        }
+        final String ID = UUID.randomUUID().toString();
+        File tmpPreviewFolder = Path.of("./.tmp/ro-crate-java/writer-zipStrategy/")
+                .resolve(ID)
+                .toFile();
+        FileUtils.forceMkdir(tmpPreviewFolder);
+        FileUtils.forceDeleteOnExit(tmpPreviewFolder);
+
+        preview.get().generate(crate, tmpPreviewFolder);
+        String[] paths = tmpPreviewFolder.list();
+        if (paths == null) {
+            throw new IOException("No files found in temporary folder");
+        }
+        for (String path : paths) {
+            File file = tmpPreviewFolder.toPath().resolve(path).toFile();
+            if (file.isDirectory()) {
+                ZipParameters parameters = new ZipParameters();
+                parameters.setRootFolderNameInZip(prefix + path);
+                parameters.setIncludeRootFolder(false);
+                zipFile.addFolder(file, parameters);
+            } else {
+                ZipParameters zipParameters = new ZipParameters();
+                zipParameters.setFileNameInZip(prefix + path);
+                zipFile.addFile(file, zipParameters);
+            }
+        }
+        try {
+            FileUtils.forceDelete(tmpPreviewFolder);
+        } catch (IOException e) {
+            logger.error("Could not delete temporary preview folder: {}", tmpPreviewFolder);
         }
     }
 
-    private void saveToZip(DataEntity entity, ZipFile zipFile) throws IOException {
+    private void saveToZip(DataEntity entity, ZipFile zipFile, String prefix) throws IOException {
         if (entity == null || entity.getPath() == null) {
             return;
         }
 
         boolean isDirectory = entity.getPath().toFile().isDirectory();
         if (isDirectory) {
             ZipParameters parameters = new ZipParameters();
-            parameters.setRootFolderNameInZip(entity.getId());
+            parameters.setRootFolderNameInZip(prefix + entity.getId());
             parameters.setIncludeRootFolder(false);
             zipFile.addFolder(entity.getPath().toFile(), parameters);
         } else {
             ZipParameters zipParameters = new ZipParameters();
-            zipParameters.setFileNameInZip(entity.getId());
+            zipParameters.setFileNameInZip(prefix + entity.getId());
             zipFile.addFile(entity.getPath().toFile(), zipParameters);
         }
     }
