Merged dspace-cris-2023_02_x into DSC-1460

dspace-api/pom.xml

@@ -12,7 +12,7 @@
     <parent>
         <groupId>org.dspace</groupId>
         <artifactId>dspace-parent</artifactId>
-        <version>cris-2023.02.02-SNAPSHOT</version>
+        <version>cris-2023.02.03-SNAPSHOT</version>
         <relativePath>..</relativePath>
     </parent>
 

dspace-api/src/main/java/org/dspace/administer/MetadataImporter.java

@@ -7,8 +7,12 @@
  */
 package org.dspace.administer;
 
+import java.io.File;
 import java.io.IOException;
 import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.TransformerException;
 import javax.xml.xpath.XPath;
@@ -30,6 +34,8 @@
 import org.dspace.content.service.MetadataFieldService;
 import org.dspace.content.service.MetadataSchemaService;
 import org.dspace.core.Context;
+import org.dspace.services.ConfigurationService;
+import org.dspace.services.factory.DSpaceServicesFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.w3c.dom.Document;
@@ -61,10 +67,18 @@
  * }
  */
 public class MetadataImporter {
+    public static final String BASE = DSpaceServicesFactory.getInstance()
+            .getConfigurationService().getProperty("dspace.dir") + File.separator + "config" + File.separator
+            + "registries" + File.separator;
+    public static final String REGISTRY_METADATA_PROPERTY = "registry.metadata.load";
+    public static final String REGISTRY_BITSTREAM_FORMAT_PROPERTY = "registry.bitstream-formats.load";
+
     protected static MetadataSchemaService metadataSchemaService = ContentServiceFactory.getInstance()
                                                                                         .getMetadataSchemaService();
     protected static MetadataFieldService metadataFieldService = ContentServiceFactory.getInstance()
                                                                                       .getMetadataFieldService();
+    protected static ConfigurationService configurationService = DSpaceServicesFactory.getInstance()
+            .getConfigurationService();
 
     /**
      * logging category
@@ -100,18 +114,35 @@ public static void main(String[] args)
         Options options = new Options();
         options.addOption("f", "file", true, "source xml file for DC fields");
         options.addOption("u", "update", false, "update an existing schema");
+        options.addOption("h", "help", false, "help message");
         CommandLine line = parser.parse(options, args);
 
-        if (line.hasOption('f')) {
+        if (line.hasOption('h')) {
+            usage();
+            System.exit(1);
+        } else if (line.hasOption('f')) {
             String file = line.getOptionValue('f');
             boolean forceUpdate = line.hasOption('u');
             loadRegistry(file, forceUpdate);
         } else {
-            usage();
-            System.exit(1);
+            boolean forceUpdate = line.hasOption('u');
+            for (String file : getAllRegistryFiles(REGISTRY_METADATA_PROPERTY)) {
+                loadRegistry(file, forceUpdate);
+            }
         }
     }
 
+    /**
+     * Load all registry file names from config
+     *
+     * @param propertyName name of the property that used in config
+     * @return list of all registry files
+     */
+    public static List<String> getAllRegistryFiles(String propertyName) {
+        List<String> files = Arrays.asList(configurationService.getArrayProperty(propertyName));
+        return files.stream().map(file -> BASE + file).collect(Collectors.toList());
+    }
+
     /**
      * Load the data from the specified file path into the database
      *
@@ -285,7 +316,10 @@ private static void loadType(Context context, Node node)
     public static void usage() {
         String usage = "Use this class with the following option:\n" +
             " -f <xml source file> : specify which xml source file " +
-            "contains the DC fields to import.\n";
+            "contains the DC fields to import.\n" +
+            "If you use the script without the -f parameter, then all" +
+            " registries will be loaded from the config/registries folder\n";
+
         System.out.println(usage);
     }
 }

dspace-api/src/main/java/org/dspace/administer/RegistryLoader.java

@@ -33,6 +33,8 @@
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;
 
+
+
 /**
  * Loads the bitstream format and Dublin Core type registries into the database.
  * Intended for use as a command-line tool.
@@ -68,7 +70,7 @@ private RegistryLoader() { }
      */
     public static void main(String[] argv) throws Exception {
         String usage = "Usage: " + RegistryLoader.class.getName()
-            + " (-bitstream | -metadata) registry-file.xml";
+            + " (-bitstream | -metadata | -all) registry-file.xml";
 
         Context context = null;
 
@@ -81,10 +83,21 @@ public static void main(String[] argv) throws Exception {
 
             // Work out what we're loading
             if (argv[0].equalsIgnoreCase("-bitstream")) {
-                RegistryLoader.loadBitstreamFormats(context, argv[1]);
+                if (argv.length == 1) {
+                    loadAllBitstreamFormats(context);
+                } else {
+                    RegistryLoader.loadBitstreamFormats(context, argv[1]);
+                }
             } else if (argv[0].equalsIgnoreCase("-metadata")) {
                 // Call MetadataImporter, as it handles Metadata schema updates
-                MetadataImporter.loadRegistry(argv[1], true);
+                if (argv.length == 1) {
+                    loadAllRegistry();
+                } else {
+                    MetadataImporter.loadRegistry(argv[1], true);
+                }
+            } else if (argv[0].equalsIgnoreCase("-all")) {
+                loadAllBitstreamFormats(context);
+                loadAllRegistry();
             } else {
                 System.err.println(usage);
             }
@@ -111,6 +124,30 @@ public static void main(String[] argv) throws Exception {
         }
     }
 
+
+    /**
+     * Load all bitstream formats from configuration properties
+     *
+     * @param context DSpace context object
+     * @throws Exception
+     */
+    private static void loadAllBitstreamFormats(Context context) throws Exception {
+        for (String file : MetadataImporter.getAllRegistryFiles(MetadataImporter.REGISTRY_BITSTREAM_FORMAT_PROPERTY)) {
+            RegistryLoader.loadBitstreamFormats(context, file);
+        }
+    }
+
+    /**
+     * Load all metadata registry from configuration properties
+     *
+     * @throws Exception
+     */
+    private static void loadAllRegistry() throws Exception {
+        for (String file : MetadataImporter.getAllRegistryFiles(MetadataImporter.REGISTRY_METADATA_PROPERTY)) {
+            MetadataImporter.loadRegistry(file, true);
+        }
+    }
+
     /**
      * Load Bitstream Format metadata
      *

dspace-api/src/main/java/org/dspace/administer/StructBuilder.java

@@ -9,6 +9,7 @@
 
 import static org.dspace.content.Item.ANY;
 import static org.dspace.content.MetadataSchemaEnum.CRIS;
+import static org.dspace.content.authority.Choices.CF_UNSET;
 import static org.dspace.content.service.DSpaceObjectService.MD_COPYRIGHT_TEXT;
 import static org.dspace.content.service.DSpaceObjectService.MD_INTRODUCTORY_TEXT;
 import static org.dspace.content.service.DSpaceObjectService.MD_LICENSE;
@@ -49,12 +50,14 @@
 import org.dspace.content.Collection;
 import org.dspace.content.Community;
 import org.dspace.content.Item;
+import org.dspace.content.MetadataField;
 import org.dspace.content.MetadataFieldName;
 import org.dspace.content.MetadataSchemaEnum;
 import org.dspace.content.MetadataValue;
 import org.dspace.content.factory.ContentServiceFactory;
 import org.dspace.content.service.CollectionService;
 import org.dspace.content.service.CommunityService;
+import org.dspace.content.service.ItemService;
 import org.dspace.core.Context;
 import org.dspace.core.CrisConstants;
 import org.dspace.eperson.factory.EPersonServiceFactory;
@@ -122,7 +125,8 @@ public class StructBuilder {
             = EPersonServiceFactory.getInstance().getEPersonService();
     protected static final HandleService handleService
             = HandleServiceFactory.getInstance().getHandleService();
-
+    protected static final ItemService itemService
+        = ContentServiceFactory.getInstance().getItemService();
     /**
      * Default constructor
      */
@@ -407,6 +411,9 @@ private static Element exportACollection(Collection collection) {
         Element element = new Element("collection");
         element.setAttribute("identifier", collection.getHandle());
         element.addContent(new Element("name").setText(collection.getName()));
+
+        buildTemplateItem(collection, element);
+
         element.addContent(new Element("description")
                 .setText(collectionService.getMetadataFirstValue(collection,
                         MetadataSchemaEnum.DC.getName(), "description", "abstract", Item.ANY)));
@@ -833,6 +840,8 @@ private static Element[] handleCollections(Context context,
             collectionService.setMetadataSingleValue(context, collection,
                     MD_SHORT_DESCRIPTION, Item.ANY, " ");
 
+            handleTemplateItem(context, collection, tn);
+
             // import the rest of the metadata
             for (Map.Entry<String, MetadataFieldName> entry : collectionMap.entrySet()) {
                 NodeList nl = (NodeList) xPath.compile(entry.getKey()).evaluate(tn, XPathConstants.NODESET);
@@ -854,6 +863,8 @@ private static Element[] handleCollections(Context context,
 
             String fieldValue;
 
+            buildTemplateItem(collection, element);
+
             fieldValue = collectionService.getMetadataFirstValue(collection,
                     CollectionService.MD_SHORT_DESCRIPTION, Item.ANY);
             if (fieldValue != null) {
@@ -930,4 +941,93 @@ private static Element[] handleCollections(Context context,
 
         return elements;
     }
+
+    private static void handleTemplateItem(Context context, Collection collection, Node tn)
+        throws XPathExpressionException, SQLException, AuthorizeException {
+
+        XPath xPath = XPathFactory.newInstance().newXPath();
+        Node node = (Node) xPath.compile("templateItem").evaluate(tn, XPathConstants.NODE);
+
+        if (node == null) {
+            return;
+        }
+
+        Item templateItem = itemService.createTemplateItem(context, collection);
+
+        NodeList metadataNodes = (NodeList) xPath.compile("metadata").evaluate(node, XPathConstants.NODESET);
+
+        for (int i = 0; i < metadataNodes.getLength(); i++) {
+            Node metadataNode = metadataNodes.item(i);
+            MetadataFieldName metadataFieldName = buildMetadataFieldName(metadataNode);
+
+            Node valueAttribute = (Node) xPath.compile("value").evaluate(metadataNode, XPathConstants.NODE);
+            Node authorityAttribute = (Node) xPath.compile("authority").evaluate(metadataNode, XPathConstants.NODE);
+            Node confidenceAttribute = (Node) xPath.compile("confidence").evaluate(metadataNode, XPathConstants.NODE);
+
+            String authority = null;
+            int confidence = CF_UNSET;
+
+            if (authorityAttribute != null) {
+                authority = authorityAttribute.getTextContent();
+                confidence = confidenceAttribute != null ? Integer.parseInt(confidenceAttribute.getTextContent()) : 600;
+            }
+
+            itemService.addMetadata(context, templateItem, metadataFieldName.schema, metadataFieldName.element,
+                metadataFieldName.qualifier, ANY, valueAttribute.getTextContent(), authority, confidence);
+            itemService.update(context, templateItem);
+        }
+    }
+
+    private static MetadataFieldName buildMetadataFieldName(Node node) {
+        Node schemaAttribute = node.getAttributes().getNamedItem("schema");
+        Node elementAttribute = node.getAttributes().getNamedItem("element");
+        Node qualifierAttribute = node.getAttributes().getNamedItem("qualifier");
+
+        if (qualifierAttribute == null) {
+            return new MetadataFieldName(schemaAttribute.getTextContent(), elementAttribute.getTextContent());
+        } else {
+            return new MetadataFieldName(schemaAttribute.getTextContent(),
+                elementAttribute.getTextContent(), qualifierAttribute.getTextContent());
+        }
+    }
+
+    private static void buildTemplateItem(Collection collection, Element element) {
+
+        try {
+            Item templateItem = collection.getTemplateItem();
+
+            if (templateItem == null) {
+                return;
+            }
+
+            Element templateItemElement = new Element("templateItem");
+
+            for (MetadataValue metadataValue : templateItem.getMetadata()) {
+                MetadataField metadataField = metadataValue.getMetadataField();
+                Element metadata = new Element("metadata");
+                metadata.setAttribute("schema", metadataField.getMetadataSchema().getName());
+                metadata.setAttribute("element", metadataField.getElement());
+
+                if (metadataField.getQualifier() != null) {
+                    metadata.setAttribute("qualifier", metadataField.getQualifier());
+                }
+
+                metadata.addContent(new Element("value").setText(metadataValue.getValue()));
+
+                if (metadataValue.getAuthority() != null) {
+                    metadata.addContent(new Element("authority").setText(metadataValue.getAuthority()));
+                    metadata.addContent(new Element("confidence").setText(
+                        String.valueOf(metadataValue.getConfidence())
+                    ));
+                }
+
+                templateItemElement.addContent(metadata);
+            }
+
+            element.addContent(templateItemElement);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
 }

dspace-api/src/main/java/org/dspace/app/deduplication/service/impl/SolrDedupServiceImpl.java

@@ -43,8 +43,8 @@
 import org.dspace.app.deduplication.service.DedupService;
 import org.dspace.app.deduplication.service.SearchDeduplication;
 import org.dspace.app.deduplication.service.SolrDedupServiceIndexPlugin;
-import org.dspace.app.deduplication.utils.DedupUtils;
 import org.dspace.app.deduplication.utils.DuplicateItemInfo;
+import org.dspace.app.deduplication.utils.IDedupUtils;
 import org.dspace.app.deduplication.utils.Signature;
 import org.dspace.app.util.Util;
 import org.dspace.authorize.AuthorizeException;
@@ -174,7 +174,7 @@ public class SolrDedupServiceImpl implements DedupService {
     protected VersioningService versioningService;
 
     @Autowired(required = true)
-    protected DedupUtils dedupUtils;
+    protected IDedupUtils dedupUtils;
 
     /***
      * Deduplication status
@@ -750,8 +750,8 @@ private void setDuplicateDecision(Context context, Item item, UUID duplicatedIte
     private List<DuplicateItemInfo> findDuplicationWithDecisions(Context context, Item item) {
         try {
             return dedupUtils.getAdminDuplicateByIdAndType(context, item.getID(), item.getType()).stream()
-                .filter(duplication -> isNotEmpty(duplication.getDecisionTypes()))
-                .collect(Collectors.toList());
+                             .filter(duplication -> isNotEmpty(duplication.getDecisionTypes()))
+                             .collect(Collectors.toList());
         } catch (SQLException | SearchServiceException e) {
             throw new RuntimeException(e);
         }