Merged in task/dspace-cris-2023_02_x/DSC-2304 (pull request DSpace#4074)

[DSC-2304] Adds ITs and fix for the doi-organiser process.

Approved-by: Giuseppe Digilio

Author: vins01-4science

dspace-api/src/main/java/org/dspace/content/integration/crosswalks/virtualfields/ItemDOIService.java

@@ -9,6 +9,8 @@
 
 import java.util.Comparator;
 import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.dspace.content.Item;
 import org.dspace.content.MetadataValue;
@@ -18,26 +20,41 @@
 
 
 public class ItemDOIService {
-    static final String CFG_PREFIX = "identifier.doi.prefix";
 
+    static final String DOI_RESOLVER_REGEX = "^(?:https?://[^/]*)/(.*$)";
+    static final Pattern DOI_PATTERN = Pattern.compile(DOI_RESOLVER_REGEX);
+    static final String CFG_PREFIX = "identifier.doi.prefix";
     static final String DOI_METADATA = "dc.identifier.doi";
 
     @Autowired
     protected ItemService itemService;
     @Autowired
     private ConfigurationService configurationService;
 
+    static String formatDOI(String doi) {
+
+        if (doi == null) {
+            return null;
+        }
+
+        Matcher matcher = DOI_PATTERN.matcher(doi);
+        if (matcher.matches()) {
+            doi = matcher.group(1);
+        }
+        return doi;
+    }
+
     public String[] getAlternativeDOIFromItem(Item item) {
         List<MetadataValue> metadataValueList = itemService.getMetadataByMetadataString(item, DOI_METADATA);
         return getAlternativeDOI(metadataValueList, getPrimaryDOI(metadataValueList));
     }
     private String[] getAlternativeDOI(List<MetadataValue> metadataValueList, String primaryValue) {
-        return metadataValueList.stream().map(MetadataValue::getValue)
-                .filter(value -> !value.equals(primaryValue)).toArray(String[]::new);
+        return metadataValueList.stream().map(MetadataValue::getValue).filter(value -> !value.equals(primaryValue))
+                                .map(ItemDOIService::formatDOI).toArray(String[]::new);
     }
 
     public String getPrimaryDOIFromItem(Item item) {
-        return getPrimaryDOI(itemService.getMetadataByMetadataString(item, DOI_METADATA));
+        return formatDOI(getPrimaryDOI(itemService.getMetadataByMetadataString(item, DOI_METADATA)));
     }
 
     private String getPrimaryDOI(List<MetadataValue> metadataValueList) {

dspace-api/src/main/java/org/dspace/identifier/doi/DOIOrganiser.java

@@ -442,7 +442,7 @@ public void list(String processName, PrintStream out, PrintStream err, Integer .
      * @param doiRow        DOI to register
      * @param filter        logical item filter to override
      * @throws IllegalArgumentException
-     *                      if {@link doiRow} does not name an Item.
+     *                      if {@code doiRow} does not name an Item.
      * @throws IllegalStateException
      *                      on invalid DOI.
      * @throws RuntimeException
@@ -737,7 +737,7 @@ public DOI resolveToDOI(String identifier)
         DOI doiRow = null;
         String doi = null;
 
-        // detect it identifer is ItemID, handle or DOI.
+        // detect if identifier is ItemID, handle or DOI.
         // try to detect ItemID
         if (identifier
             .matches("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[34][0-9a-fA-F]{3}-[89ab][0-9a-fA-F]{3}-[0-9a-fA-F]{12}")) {

dspace-api/src/test/data/dspaceFolder/config/spring/api/identifier-service.xml

@@ -41,7 +41,7 @@
     </bean>
 
     <bean id="org.dspace.identifier.doi.DOIConnector"
-          class="org.dspace.identifier.doi.DataCiteConnector">
+          class="org.dspace.identifier.doi.MockDataCiteConnector">
       <property name='DATACITE_SCHEME' value='https'/>
       <property name='DATACITE_HOST' value='mds.test.datacite.org'/>
       <property name='DATACITE_DOI_PATH' value='/doi/'/>

dspace-api/src/test/java/org/dspace/builder/AbstractBuilder.java

@@ -52,6 +52,10 @@
 import org.dspace.externalservices.scopus.factory.CrisMetricsServiceFactory;
 import org.dspace.harvest.factory.HarvestServiceFactory;
 import org.dspace.harvest.service.HarvestedCollectionService;
+import org.dspace.identifier.dao.DOIDAO;
+import org.dspace.identifier.dao.impl.DOIDAOImpl;
+import org.dspace.identifier.factory.IdentifierServiceFactory;
+import org.dspace.identifier.service.DOIService;
 import org.dspace.layout.factory.CrisLayoutServiceFactory;
 import org.dspace.layout.service.CrisLayoutBoxService;
 import org.dspace.layout.service.CrisLayoutFieldService;
@@ -137,7 +141,8 @@ public abstract class AbstractBuilder<T, S> {
     static SystemWideAlertService systemWideAlertService;
     static SubmissionConfigService submissionConfigService;
     static SupervisionOrderService supervisionOrderService;
-
+    static DOIService doiService;
+    static DOIDAO doiDao;
 
     protected Context context;
 
@@ -217,6 +222,8 @@ public static void init() {
         }
         subscribeService = ContentServiceFactory.getInstance().getSubscribeService();
         supervisionOrderService = SupervisionOrderServiceFactory.getInstance().getSupervisionOrderService();
+        doiService = IdentifierServiceFactory.getInstance().getDOIService();
+        doiDao = new DSpace().getSingletonService(DOIDAOImpl.class);
     }
 
 
@@ -264,6 +271,7 @@ public static void destroy() {
         systemWideAlertService = null;
         submissionConfigService = null;
         supervisionOrderService = null;
+        doiService = null;
     }
 
     public static void cleanupObjects() throws Exception {

dspace-api/src/test/java/org/dspace/builder/DOIBuilder.java

@@ -0,0 +1,98 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.builder;
+
+
+import java.sql.SQLException;
+
+import org.dspace.content.DSpaceObject;
+import org.dspace.core.Context;
+import org.dspace.identifier.DOI;
+import org.dspace.identifier.service.DOIService;
+
+
+/**
+* Builder to construct DOI entities for tests
+*
+* @author Adamo Fapohunda (adamo.fapohunda at 4science.com)
+**/
+public class DOIBuilder extends AbstractBuilder<DOI, DOIService> {
+
+    private DOI doi;
+
+    protected DOIBuilder(Context context) {
+        super(context);
+    }
+
+    public static DOIBuilder createDOI(Context context, DSpaceObject dso) {
+        return new DOIBuilder(context).create(dso);
+    }
+
+    private DOIBuilder create(DSpaceObject dso) {
+        try {
+            doi = doiService.findDOIByDSpaceObject(context, dso);
+            if (doi == null) {
+                doi = doiService.create(context);
+                doi.setDSpaceObject(dso);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            return null;
+        }
+        return this;
+    }
+
+    public DOIBuilder withDoiString(String doiString) {
+        doi.setDoi(doiString);
+        return this;
+    }
+
+    public DOIBuilder withStatus(int status) {
+        doi.setStatus(status);
+        return this;
+    }
+
+    @Override
+    public DOI build() {
+        try {
+            doiService.update(context, doi);
+            context.dispatchEvents();
+            indexingService.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+        return doi;
+    }
+
+    @Override
+    public void delete(Context c, DOI dso) throws Exception {
+        if (dso != null) {
+            doiDao.delete(c, doi);
+            doi = null;
+        }
+    }
+
+    @Override
+    public void cleanup() throws Exception {
+        try (Context c = new Context()) {
+            c.setDispatcher("noindex");
+            c.turnOffAuthorisationSystem();
+            doi = c.reloadEntity(doi);
+            if (doi != null) {
+                doiDao.delete(c, doi);
+                c.complete();
+            }
+        }
+    }
+
+    @Override
+    protected DOIService getService() {
+        return doiService;
+    }
+}

dspace-api/src/test/java/org/dspace/builder/util/AbstractBuilderCleanupUtil.java

@@ -23,6 +23,7 @@
 import org.dspace.builder.CrisLayoutMetric2BoxBuilder;
 import org.dspace.builder.CrisLayoutTabBuilder;
 import org.dspace.builder.CrisMetricsBuilder;
+import org.dspace.builder.DOIBuilder;
 import org.dspace.builder.EPersonBuilder;
 import org.dspace.builder.EntityTypeBuilder;
 import org.dspace.builder.GroupBuilder;
@@ -92,6 +93,7 @@ private void initMap() {
         map.put(MetadataSchemaBuilder.class.getName(), new ArrayList<>());
         map.put(SiteBuilder.class.getName(), new ArrayList<>());
         map.put(ProcessBuilder.class.getName(), new ArrayList<>());
+        map.put(DOIBuilder.class.getName(), new ArrayList<>());
     }
 
     /**

dspace-api/src/test/java/org/dspace/content/integration/crosswalks/virtualfields/ItemDOIServiceIT.java

@@ -0,0 +1,112 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.content.integration.crosswalks.virtualfields;
+
+import static org.dspace.builder.CollectionBuilder.createCollection;
+import static org.dspace.builder.CommunityBuilder.createCommunity;
+import static org.dspace.content.integration.crosswalks.virtualfields.ItemDOIService.formatDOI;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertEquals;
+
+import org.dspace.AbstractIntegrationTestWithDatabase;
+import org.dspace.builder.ItemBuilder;
+import org.dspace.content.Collection;
+import org.dspace.content.Item;
+import org.dspace.services.ConfigurationService;
+import org.dspace.services.factory.DSpaceServicesFactory;
+import org.dspace.utils.DSpace;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author Adamo Fapohunda (adamo.fapohunda at 4science.com)
+ **/
+public class ItemDOIServiceIT extends AbstractIntegrationTestWithDatabase {
+
+    private ItemDOIService itemDOIService;
+
+    private Collection collection;
+
+    private ConfigurationService configurationService;
+
+    @Before
+    public void setup() {
+        itemDOIService = new DSpace().getServiceManager().getServicesByType(ItemDOIService.class).get(0);
+        configurationService = DSpaceServicesFactory.getInstance().getConfigurationService();
+
+
+        context.setCurrentUser(admin);
+        parentCommunity = createCommunity(context).build();
+        collection = createCollection(context, parentCommunity).build();
+
+        // Set test DOI prefix in configuration
+        configurationService.setProperty("identifier.doi.prefix", "10.1234");
+    }
+
+    @Test
+    public void testPrimaryAndAlternativeDOIExtraction() {
+        Item item = ItemBuilder.createItem(context, collection)
+                               .withDoiIdentifier("10.1234/primary-doi")
+                               .withDoiIdentifier("10.5678/other-doi")
+                               .withDoiIdentifier("https://doi.org/10.5678/resolved-doi")
+                               .build();
+
+        String primary = itemDOIService.getPrimaryDOIFromItem(item);
+        assertThat(primary, is("10.1234/primary-doi"));
+
+        String[] alternatives = itemDOIService.getAlternativeDOIFromItem(item);
+        assertThat(alternatives.length, is(2));
+        assertThat(alternatives, arrayContainingInAnyOrder(
+            "10.5678/other-doi", "10.5678/resolved-doi"));
+    }
+
+    @Test
+    public void testFallbackToFirstDOIWhenNoMatchWithPrefix() {
+        configurationService.setProperty("identifier.doi.prefix", "10.9999");
+
+        Item item = ItemBuilder.createItem(context, collection)
+                               .withDoiIdentifier("10.5678/first")
+                               .withDoiIdentifier("10.5678/second")
+                               .build();
+
+        String primary = itemDOIService.getPrimaryDOIFromItem(item);
+        assertThat(primary, is("10.5678/first"));
+
+        String[] alternatives = itemDOIService.getAlternativeDOIFromItem(item);
+        assertThat(alternatives.length, is(1));
+        assertThat(alternatives[0], is("10.5678/second"));
+    }
+
+
+    @Test
+    public void testFormatDOI_Normalization() {
+        assertEquals("10.25560/119170", formatDOI("https://doi.org/10.25560/119170"));
+        assertEquals("10.25561/95151", formatDOI("https://www.dx.doi.org/10.25561/95151"));
+        assertEquals("10.25560/31589", formatDOI("https://doi.org/10.25560/31589"));
+        assertEquals("10.25561/93710", formatDOI("https://www.dx.doi.org/10.25561/93710"));
+        assertEquals("10.1214/14-AAP1038", formatDOI("https://www.dx.doi.org/10.1214/14-AAP1038"));
+        assertEquals("10.25561/109825", formatDOI("https://doi.org/10.25561/109825"));
+        assertEquals("10.1016/j.econlet.2013.02.011", formatDOI("https://www.dx.doi.org/10.1016/j.econlet.2013.02.011"));
+        assertEquals("10.1101/024349", formatDOI("https://www.dx.doi.org/10.1101/024349"));
+        assertEquals("10.1038/s41586-020-2405-7", formatDOI("https://www.dx.doi.org/10.1038/s41586-020-2405-7"));
+        assertEquals("10.1093/comnet/cnu039", formatDOI("https://www.dx.doi.org/10.1093/comnet/cnu039"));
+        assertEquals("10.3310/hsdr04290", formatDOI("https://www.dx.doi.org/10.3310/hsdr04290"));
+        assertEquals("10.2140/ant.2016.10.843", formatDOI("https://www.dx.doi.org/10.2140/ant.2016.10.843"));
+        assertEquals("10.1215/00127094-2885764", formatDOI("https://www.dx.doi.org/10.1215/00127094-2885764"));
+        assertEquals("10.1016/S2214-109X(20)30288-6", formatDOI("https://www.dx.doi.org/10.1016/S2214-109X(20)30288-6"));
+    }
+
+    @Test
+    public void testFormatDOI_PlainText() {
+        assertEquals("text_value", formatDOI("text_value"));
+        assertEquals("10.25561/54217", formatDOI("10.25561/54217"));
+    }
+
+}