Make behaviour of repeated import configurable

Kitodo-API/src/main/java/org/kitodo/api/dataeditor/rulesetmanagement/RulesetManagementInterface.java

@@ -19,6 +19,8 @@
 import java.util.Map;
 import java.util.Optional;
 
+import org.kitodo.api.Metadata;
+
 /**
  * Interface for a service that provides access to the ruleset.
  *
@@ -143,4 +145,18 @@ StructuralElementViewInterface getStructuralElementView(String structuralElement
      * @return the “always showing” value or its default value
      */
     boolean isAlwaysShowingForKey(String keyId);
+
+    /**
+     * Updates metadata during a repeated catalog import, depending on the
+     * reimport settings specified in the ruleset.
+     * 
+     * @param metadata
+     *            current metadata
+     * @param acquisitionStage
+     *            current acquisition stage
+     * @param updateItems
+     *            items obtained from import
+     * @return number of added metadata items
+     */
+    int updateMetadata(Collection<Metadata> metadata, String acquisitionStage, Collection<Metadata> updateItems);
 }

Kitodo-DataEditor/src/main/java/org/kitodo/dataeditor/ruleset/RulesetManagement.java

@@ -15,18 +15,22 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale.LanguageRange;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import javax.xml.bind.JAXBException;
 
+import org.apache.commons.lang3.tuple.MutableTriple;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.kitodo.api.Metadata;
 import org.kitodo.api.dataeditor.rulesetmanagement.FunctionalDivision;
 import org.kitodo.api.dataeditor.rulesetmanagement.FunctionalMetadata;
 import org.kitodo.api.dataeditor.rulesetmanagement.RulesetManagementInterface;
@@ -35,6 +39,7 @@
 import org.kitodo.dataeditor.ruleset.xml.Division;
 import org.kitodo.dataeditor.ruleset.xml.Key;
 import org.kitodo.dataeditor.ruleset.xml.Namespace;
+import org.kitodo.dataeditor.ruleset.xml.Reimport;
 import org.kitodo.dataeditor.ruleset.xml.Ruleset;
 import org.kitodo.dataeditor.ruleset.xml.Setting;
 import org.kitodo.utils.JAXBContextCache;
@@ -321,5 +326,59 @@ public boolean isAlwaysShowingForKey(String keyId) {
         return false;
     }
 
+    @Override
+    public int updateMetadata(Collection<Metadata> currentMetadata, String acquisitionStage,
+            Collection<Metadata> updateMetadata) {
+
+        HashMap<String, MutableTriple<Collection<Metadata>, Reimport, Collection<Metadata>>> unifying = unifyMetadataByKey(
+            currentMetadata, acquisitionStage, updateMetadata);
+        int sizeBefore = currentMetadata.size();
+        currentMetadata.clear();
+        for (var entry : unifying.entrySet()) {
+            var metadata = entry.getValue();
+            Collection<Metadata> currentEntries = metadata.getLeft();
+            Collection<Metadata> updateEntries = metadata.getRight();
+
+            switch (metadata.getMiddle()) {
+                case ADD:
+                    currentMetadata.addAll(currentEntries);
+                    currentMetadata.addAll(updateEntries);
+                    break;
+                case KEEP:
+                    currentMetadata.addAll(currentEntries);
+                    break;
+                case REPLACE:
+                    currentMetadata.addAll(updateEntries.isEmpty() ? currentEntries : updateEntries);
+                    break;
+                default:
+                    throw new IllegalStateException(
+                            "Used not supported reimport case {}".replace("{}", metadata.getMiddle().toString()));
+            }
+        }
+        return currentMetadata.size() - sizeBefore;
+    }
 
+    private HashMap<String, MutableTriple<Collection<Metadata>, Reimport, Collection<Metadata>>> unifyMetadataByKey(
+            Collection<Metadata> currentMetadata, String acquisitionStage, Collection<Metadata> updateMetadata) {
+
+        final Function<String, MutableTriple<Collection<Metadata>, Reimport, Collection<Metadata>>> entryProducer = key -> {
+            MutableTriple<Collection<Metadata>, Reimport, Collection<Metadata>> entry = new MutableTriple<>();
+            entry.setLeft(new ArrayList<>());
+            entry.setRight(new ArrayList<>());
+            return entry;
+        };
+
+        HashMap<String, MutableTriple<Collection<Metadata>, Reimport, Collection<Metadata>>> unifying = new HashMap<>();
+        for (Metadata metadata : currentMetadata) {
+            unifying.computeIfAbsent(metadata.getKey(), entryProducer).getLeft().add(metadata);
+        }
+        for (Metadata metadata : updateMetadata) {
+            unifying.computeIfAbsent(metadata.getKey(), entryProducer).getRight().add(metadata);
+        }
+        Settings settings = ruleset.getSettings(acquisitionStage);
+        for (var entry : unifying.entrySet()) {
+            entry.getValue().setMiddle(settings.getReimport(entry.getKey()));
+        }
+        return unifying;
+    }
 }

Kitodo-DataEditor/src/main/java/org/kitodo/dataeditor/ruleset/Settings.java

@@ -17,10 +17,12 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import org.kitodo.dataeditor.ruleset.xml.Reimport;
 import org.kitodo.dataeditor.ruleset.xml.Setting;
 
 /**
@@ -44,6 +46,24 @@ public Settings(Collection<Setting> baseSettings) {
                 .collect(Collectors.toMap(Setting::getKey, Function.identity()));
     }
 
+    /**
+     * Returns the reimport setting for a key.
+     *
+     * @param keyId
+     *            key for which the query is
+     * @return reimport setting
+     */
+    Reimport getReimport(String keyId) {
+        Setting settingForKey = currentSettings.get(keyId);
+        if (Objects.nonNull(settingForKey)) {
+            Reimport reimport = settingForKey.getReimport();
+            if (Objects.nonNull(reimport)) {
+                return reimport;
+            }
+        }
+        return Reimport.REPLACE;
+    }
+
     /**
      * Returns the settings for a key.
      *
@@ -157,6 +177,7 @@ private List<Setting> merge(Collection<Setting> currentSettings, Collection<Sett
                     merged.setEditable(other.getEditable() != null ? other.getEditable() : current.getEditable());
                     merged.setExcluded(other.getExcluded() != null ? other.getExcluded() : current.getExcluded());
                     merged.setMultiline(other.getMultiline() != null ? other.getMultiline() : current.getMultiline());
+                    merged.setReimport(other.getReimport() != null ? other.getReimport() : current.getReimport());
                     merged.setSettings(merge(current.getSettings(), other.getSettings()));
                     mergedSettings.add(merged);
                 } else {

Kitodo-DataEditor/src/main/java/org/kitodo/dataeditor/ruleset/xml/Reimport.java

@@ -0,0 +1,40 @@
+/*
+ * (c) Kitodo. Key to digital objects e. V. <contact@kitodo.org>
+ *
+ * This file is part of the Kitodo project.
+ *
+ * It is licensed under GNU General Public License version 3 or later.
+ *
+ * For the full copyright and license information, please read the
+ * GPL3-License.txt file that was distributed with this source code.
+ */
+
+package org.kitodo.dataeditor.ruleset.xml;
+
+import javax.xml.bind.annotation.XmlEnum;
+import javax.xml.bind.annotation.XmlEnumValue;
+
+/**
+ * This class is a backing bean for the XML attribute reimport in the
+ * ruleset. With it, JAXB can map the attribute to an enum.
+ */
+@XmlEnum(String.class)
+public enum Reimport {
+    /**
+     * The metadata should be added.
+     */
+    @XmlEnumValue("add")
+    ADD,
+
+    /**
+     * The existing metadata should be kept.
+     */
+    @XmlEnumValue("keep")
+    KEEP,
+
+    /**
+     * The existing metadata should be replaced.
+     */
+    @XmlEnumValue("replace")
+    REPLACE
+}

Kitodo-DataEditor/src/main/java/org/kitodo/dataeditor/ruleset/xml/Setting.java

@@ -73,6 +73,12 @@ public class Setting {
     @XmlAttribute
     private Boolean multiline;
 
+    /**
+     * This will specify how to update metadata in repeated imports.
+     */
+    @XmlAttribute
+    private Reimport reimport;
+
     /**
      * The settings for sub-keys.
      */
@@ -136,6 +142,17 @@ public Boolean getMultiline() {
         return multiline;
     }
 
+    /**
+     * Returns the value “reimport” if one is set. This getter returns
+     * {@code null} if the attribute was not entered. This is needed, for
+     * example, when merging attributes.
+     * 
+     * @return the value “excluded”, if set, else {@code null}
+     */
+    public Reimport getReimport() {
+        return reimport;
+    }
+
     /**
      * Returns the editor settings.
      *
@@ -239,6 +256,17 @@ public void setMultiline(Boolean multiline) {
         this.multiline = multiline;
     }
 
+    /**
+     * This sets the “reimport” value. If you set the value to {@code null}, no
+     * attribute is written.
+     * 
+     * @param reimport
+     *            “reimport” value to set
+     */
+    public void setReimport(Reimport reimport) {
+        this.reimport = reimport;
+    }
+
     /**
      * Sets the settings for nested keys.
      * 

Kitodo-DataEditor/src/test/java/org/kitodo/dataeditor/ruleset/RulesetManagementIT.java

@@ -31,6 +31,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale.LanguageRange;
@@ -40,6 +41,7 @@
 
 import org.apache.commons.lang3.StringUtils;
 import org.junit.Test;
+import org.kitodo.api.MdSec;
 import org.kitodo.api.Metadata;
 import org.kitodo.api.MetadataEntry;
 import org.kitodo.api.dataeditor.rulesetmanagement.ComplexMetadataViewInterface;
@@ -1066,6 +1068,102 @@ public void testValidationByCodomain() throws IOException {
             Collections.emptyList()));
     }
 
+    @Test
+    public void testReimportOfMetadataModesCreate() throws Exception {
+        RulesetManagement underTest = new RulesetManagement();
+        underTest.load(new File("src/test/resources/testReimportOfMetadataModes.xml"));
+
+        Collection<Metadata> metadata = new HashSet<>();
+        metadata.add(newMetadataEntry("metadataToReplaceByDefault", "value to replace"));
+        metadata.add(newMetadataEntry("metadataToReplaceExplicitly", "value to replace"));
+        metadata.add(newMetadataEntry("metadataToAdd", "value 1"));
+        metadata.add(newMetadataEntry("metadataToAddDuringCreationAndKeepLater", "value 1"));
+        metadata.add(newMetadataEntry("metadataToKeep", "value not to replace"));
+        metadata.add(newMetadataEntry("metadataToKeepExceptInEditing", "value not to replace"));
+
+        Collection<Metadata> imported = new HashSet<>();
+        imported.add(newMetadataEntry("metadataToReplaceByDefault", "replaced value")); // 0
+        imported.add(newMetadataEntry("metadataToReplaceExplicitly", "replaced value")); // 0
+        imported.add(newMetadataEntry("metadataToAdd", "value 2")); // 1
+        imported.add(newMetadataEntry("metadataToAdd", "value 3")); // 1
+        imported.add(newMetadataEntry("metadataToAddDuringCreationAndKeepLater", "value 2")); // 1
+        imported.add(newMetadataEntry("metadataToKeep", "value must not appear in result")); // 0
+        imported.add(newMetadataEntry("metadataToKeepExceptInEditing", "value not to replace")); // 0
+        imported.add(newMetadataEntry("metadataThatIsNew", "new value")); // 1
+
+        int numAdded = underTest.updateMetadata(metadata, "create", imported);
+        assertEquals(4, numAdded);
+
+        List<Metadata> defaultReplace = metadata.stream()
+                .filter(element -> element.getKey().equals("metadataToReplaceByDefault")).collect(Collectors.toList());
+        assertEquals(1, defaultReplace.size());
+        assertEquals("replaced value", ((MetadataEntry) defaultReplace.get(0)).getValue());
+
+        List<Metadata> explicitReplace = metadata.stream()
+                .filter(element -> element.getKey().equals("metadataToReplaceExplicitly")).collect(Collectors.toList());
+        assertEquals(1, explicitReplace.size());
+        assertEquals("replaced value", ((MetadataEntry) explicitReplace.get(0)).getValue());
+
+        List<Metadata> add = metadata.stream().filter(element -> element.getKey().equals("metadataToAdd"))
+                .collect(Collectors.toList());
+        assertEquals(3, add.size());
+        assertThat(
+            add.stream().map(MetadataEntry.class::cast).map(MetadataEntry::getValue).collect(Collectors.toList()),
+            containsInAnyOrder("value 1", "value 2", "value 3"));
+
+        List<Metadata> addCreate = metadata.stream()
+                .filter(element -> element.getKey().equals("metadataToAddDuringCreationAndKeepLater"))
+                .collect(Collectors.toList());
+        assertEquals(2, addCreate.size());
+        assertThat(
+            addCreate.stream().map(MetadataEntry.class::cast).map(MetadataEntry::getValue).collect(Collectors.toList()),
+            containsInAnyOrder("value 1", "value 2"));
+
+        List<Metadata> keep = metadata.stream().filter(element -> element.getKey().equals("metadataToKeep"))
+                .collect(Collectors.toList());
+        assertEquals(1, keep.size());
+        assertEquals("value not to replace", ((MetadataEntry) keep.get(0)).getValue());
+
+        List<Metadata> keepNoEdit = metadata.stream()
+                .filter(element -> element.getKey().equals("metadataToKeepExceptInEditing"))
+                .collect(Collectors.toList());
+        assertEquals(1, keepNoEdit.size());
+        assertEquals("value not to replace", ((MetadataEntry) keepNoEdit.get(0)).getValue());
+    }
+
+    @Test
+    public void testReimportOfMetadataModesEdit() throws Exception {
+        RulesetManagement underTest = new RulesetManagement();
+        underTest.load(new File("src/test/resources/testReimportOfMetadataModes.xml"));
+
+        Collection<Metadata> metadata = new HashSet<>();
+        metadata.add(newMetadataEntry("metadataToAddDuringCreationAndKeepLater", "value 1"));
+        metadata.add(newMetadataEntry("metadataToAddDuringCreationAndKeepLater", "value 2"));
+        metadata.add(newMetadataEntry("metadataToKeepExceptInEditing", "value 1"));
+        metadata.add(newMetadataEntry("metadataToKeepExceptInEditing", "value 2"));
+
+        Collection<Metadata> imported = new HashSet<>();
+        imported.add(newMetadataEntry("metadataToAddDuringCreationAndKeepLater", "value not to replace")); // 0
+        imported.add(newMetadataEntry("metadataToKeepExceptInEditing", "replaced value")); // -1
+
+        int numAdded = underTest.updateMetadata(metadata, "edit", imported);
+        assertEquals(-1, numAdded);
+
+        List<Metadata> keepLater = metadata.stream()
+                .filter(element -> element.getKey().equals("metadataToAddDuringCreationAndKeepLater"))
+                .collect(Collectors.toList());
+        assertEquals(2, keepLater.size());
+        assertThat(
+            keepLater.stream().map(MetadataEntry.class::cast).map(MetadataEntry::getValue).collect(Collectors.toList()),
+            containsInAnyOrder("value 1", "value 2"));
+
+        List<Metadata> replaceInEdit = metadata.stream()
+                .filter(element -> element.getKey().equals("metadataToKeepExceptInEditing"))
+                .collect(Collectors.toList());
+        assertEquals(1, replaceInEdit.size());
+        assertEquals("replaced value", ((MetadataEntry) replaceInEdit.get(0)).getValue());
+    }
+
     /**
      * The method provides a simple access to a metadata key in a list of
      * MetadataViewWithValuesInterface.
@@ -1128,4 +1226,12 @@ private List<String> ids(List<MetadataViewWithValuesInterface> metadataViewWithV
                 .map(metadataViewWithValuesInterface -> metadataViewWithValuesInterface.getMetadata().get().getId())
                 .collect(Collectors.toList());
     }
+
+    private MetadataEntry newMetadataEntry(String key, String value) {
+        MetadataEntry newMetadataEntry = new MetadataEntry();
+        newMetadataEntry.setKey(key);
+        newMetadataEntry.setValue(value);
+        newMetadataEntry.setDomain(MdSec.DMD_SEC);
+        return newMetadataEntry;
+    }
 }