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

Task/dspace cris 2023 02 x/DSC-2444

Approved-by: Fapohunda, Adamo

Author: vins01-4science

dspace-api/src/main/java/org/dspace/importer/external/metadatamapping/contributor/ConditionalArrayElementAttributeProcessor.java

@@ -0,0 +1,127 @@
+/**
+ * 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.importer.external.metadatamapping.contributor;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * This Processor extracts values from a JSON array, but only when a condition
+ * on another attribute is met. For example, to extract all values of
+ * /names/value where /names/types contains "ror_display".
+ *
+ * Configurable via:
+ *   pathToArray: e.g., /names
+ *   elementAttribute: e.g., /value
+ *   filterAttribute: e.g., /types
+ *   requiredValueInFilter: e.g., ror_display
+ *
+ * Supports filtering when the filter attribute is either a JSON array or a single string.
+ *
+ * Example JSON:
+ * {
+ *   "items": [{
+ *     "names": [
+ *       { "types": ["label", "ror_display"], "value": "Instituto Federal do Piauí" },
+ *       { "types": ["acronym"], "value": "IFPI" }
+ *     ]
+ *   }]
+ * }
+ * This processor can extract "Instituto Federal do Piauí" using proper configuration.
+ *
+ * Author: Jesiel (based on Mykhaylo Boychuk’s original processor)
+ */
+public class ConditionalArrayElementAttributeProcessor implements JsonPathMetadataProcessor {
+
+    private static final Logger log = LogManager.getLogger();
+
+    private String pathToArray;
+    private String elementAttribute;
+    private String filterAttribute;
+    private String requiredValueInFilter;
+
+    @Override
+    public Collection<String> processMetadata(String json) {
+        JsonNode rootNode = convertStringJsonToJsonNode(json);
+        Collection<String> results = new ArrayList<>();
+
+        if (rootNode == null) {
+            return results;
+        }
+
+        Iterator<JsonNode> array = rootNode.at(pathToArray).iterator();
+        while (array.hasNext()) {
+            JsonNode element = array.next();
+            JsonNode filterNode = element.at(filterAttribute);
+
+            boolean match = false;
+
+            if (filterNode.isArray()) {
+                for (JsonNode filterValue : filterNode) {
+                    if (requiredValueInFilter.equalsIgnoreCase(filterValue.textValue())) {
+                        match = true;
+                        break;
+                    }
+                }
+            } else if (filterNode.isTextual()) {
+                if (requiredValueInFilter.equalsIgnoreCase(filterNode.textValue())) {
+                    match = true;
+                }
+            }
+
+            if (match) {
+                JsonNode valueNode = element.at(elementAttribute);
+                if (valueNode.isTextual()) {
+                    results.add(valueNode.textValue());
+                } else if (valueNode.isArray()) {
+                    for (JsonNode item : valueNode) {
+                        if (item.isTextual() && StringUtils.isNotBlank(item.textValue())) {
+                            results.add(item.textValue());
+                        }
+                    }
+                }
+            }
+        }
+
+        return results;
+    }
+
+    private JsonNode convertStringJsonToJsonNode(String json) {
+        ObjectMapper mapper = new ObjectMapper();
+        try {
+            return mapper.readTree(json);
+        } catch (JsonProcessingException e) {
+            log.error("Unable to process JSON response.", e);
+            return null;
+        }
+    }
+
+    public void setPathToArray(String pathToArray) {
+        this.pathToArray = pathToArray;
+    }
+
+    public void setElementAttribute(String elementAttribute) {
+        this.elementAttribute = elementAttribute;
+    }
+
+    public void setFilterAttribute(String filterAttribute) {
+        this.filterAttribute = filterAttribute;
+    }
+
+    public void setRequiredValueInFilter(String requiredValueInFilter) {
+        this.requiredValueInFilter = requiredValueInFilter;
+    }
+}

dspace-api/src/main/java/org/dspace/importer/external/ror/service/RorImportMetadataSourceServiceImpl.java

@@ -7,6 +7,8 @@
  */
 package org.dspace.importer.external.ror.service;
 
+import static org.dspace.importer.external.liveimportclient.service.LiveImportClientImpl.HEADER_PARAMETERS;
+
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -15,8 +17,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Callable;
-import java.util.stream.Collectors;
-import javax.el.MethodNotFoundException;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -32,16 +32,25 @@
 import org.dspace.importer.external.exception.MetadataSourceException;
 import org.dspace.importer.external.liveimportclient.service.LiveImportClient;
 import org.dspace.importer.external.service.AbstractImportMetadataSourceService;
+import org.dspace.services.factory.DSpaceServicesFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 
+/**
+ * Implements a {@code AbstractImportMetadataSourceService} for querying ROR services.
+ *
+ * @author Vincenzo Mecca (vins01-4science - vincenzo.mecca at 4science.com)
+ */
 public class RorImportMetadataSourceServiceImpl extends AbstractImportMetadataSourceService<String>
     implements RorImportMetadataSourceService {
 
     private final static Logger log = LogManager.getLogger();
+    protected static final String ROR_IDENTIFIER_PREFIX = "https://ror.org/";
+    protected static final String ROR_CLIENT_ID_HEADER = "Client-Id";
+    protected static final String ROR_CLIENT_ID_PROP = "ror.client-id";
 
     private String url;
 
-    private int timeout = 1000;
+    private int timeout = 5000;
 
     @Autowired
     private LiveImportClient liveImportClient;
@@ -69,7 +78,7 @@ public int getRecordsCount(Query query) throws MetadataSourceException {
 
     @Override
     public Collection<ImportRecord> getRecords(String query, int start, int count) throws MetadataSourceException {
-        return retry(new SearchByQueryCallable(query, start));
+        return retry(new SearchByQueryCallable(query));
     }
 
     @Override
@@ -85,20 +94,20 @@ public ImportRecord getRecord(Query query) throws MetadataSourceException {
 
     @Override
     public Collection<ImportRecord> findMatchingRecords(Query query) throws MetadataSourceException {
-        throw new MethodNotFoundException("This method is not implemented for ROR");
+        throw new UnsupportedOperationException("This method is not implemented for ROR");
     }
 
     @Override
     public Collection<ImportRecord> findMatchingRecords(Item item) throws MetadataSourceException {
-        throw new MethodNotFoundException("This method is not implemented for ROR");
+        throw new UnsupportedOperationException("This method is not implemented for ROR");
     }
 
     @Override
     public void init() throws Exception {
     }
 
     /**
-     * This class is a Callable implementation to get ADS entries based on query
+     * This class is a Callable implementation to get ROR entries based on query
      * object. This Callable use as query value the string queryString passed to
      * constructor. If the object will be construct through Query.class instance, a
      * Query's map entry with key "query" will be used. Pagination is supported too,
@@ -110,10 +119,9 @@ private class SearchByQueryCallable implements Callable<List<ImportRecord>> {
 
         private Query query;
 
-        private SearchByQueryCallable(String queryString, int start) {
+        private SearchByQueryCallable(String queryString) {
             query = new Query();
             query.addParameter("query", queryString);
-            query.addParameter("start", start);
         }
 
         private SearchByQueryCallable(Query query) {
@@ -122,13 +130,12 @@ private SearchByQueryCallable(Query query) {
 
         @Override
         public List<ImportRecord> call() throws Exception {
-            return search(query.getParameterAsClass("query", String.class),
-                query.getParameterAsClass("start", Integer.class));
+            return search(query.getParameterAsClass("query", String.class));
         }
     }
 
     /**
-     * This class is a Callable implementation to get an ADS entry using bibcode The
+     * This class is a Callable implementation to get an ROR entry using bibcode The
      * bibcode to use can be passed through the constructor as a String or as
      * Query's map entry, with the key "id".
      *
@@ -153,12 +160,12 @@ public List<ImportRecord> call() throws Exception {
     }
 
     /**
-     * This class is a Callable implementation to count the number of entries for an
-     * ADS query. This Callable use as query value to ADS the string queryString
-     * passed to constructor. If the object will be construct through Query.class
+     * This class is a Callable implementation to count the number of entries for a
+     * ROR query. This Callable uses as query value to ROR the string queryString
+     * passed to constructor. If the object will be construct through {@code Query}
      * instance, the value of the Query's map with the key "query" will be used.
-     * 
-     * @author Mykhaylo Boychuk (mykhaylo.boychuk@4science.com)
+     *
+     * @author Vincenzo Mecca (vins01-4science - vincenzo.mecca at 4science.com)
      */
     private class CountByQueryCallable implements Callable<Integer> {
         private Query query;
@@ -178,9 +185,15 @@ public Integer call() throws Exception {
         }
     }
 
+    /**
+     * Counts the number of results for the given query.
+     *
+     * @param  query   the query string to count results for
+     * @return        the number of results for the given query
+     */
     public Integer count(String query) {
         try {
-            Map<String, Map<String, String>> params = new HashMap<String, Map<String, String>>();
+            Map<String, Map<String, String>> params = getBaseParams();
 
             URIBuilder uriBuilder = new URIBuilder(this.url);
             uriBuilder.addParameter("query", query);
@@ -199,43 +212,40 @@ public Integer count(String query) {
 
     private List<ImportRecord> searchById(String id) {
 
-        List<ImportRecord> adsResults = new ArrayList<>();
+        List<ImportRecord> importResults = new ArrayList<>();
 
-        id = StringUtils.removeStart(id, "https://ror.org/");
+        id = StringUtils.removeStart(id, ROR_IDENTIFIER_PREFIX);
 
         try {
-            Map<String, Map<String, String>> params = new HashMap<String, Map<String, String>>();
+            Map<String, Map<String, String>> params = getBaseParams();
 
             URIBuilder uriBuilder = new URIBuilder(this.url + "/" + id);
 
             String resp = liveImportClient.executeHttpGetRequest(timeout, uriBuilder.toString(), params);
             if (StringUtils.isEmpty(resp)) {
-                return adsResults;
+                return importResults;
             }
 
             JsonNode jsonNode = convertStringJsonToJsonNode(resp);
-            adsResults.add(transformSourceRecords(jsonNode.toString()));
+            importResults.add(transformSourceRecords(jsonNode.toString()));
 
         } catch (URISyntaxException e) {
             e.printStackTrace();
         }
-        return adsResults;
+        return importResults;
     }
 
-    private List<ImportRecord> search(String query, Integer start) {
-        List<ImportRecord> adsResults = new ArrayList<>();
+    private List<ImportRecord> search(String query) {
+        List<ImportRecord> importResults = new ArrayList<>();
         try {
-            Map<String, Map<String, String>> params = new HashMap<String, Map<String, String>>();
+            Map<String, Map<String, String>> params = getBaseParams();
 
             URIBuilder uriBuilder = new URIBuilder(this.url);
             uriBuilder.addParameter("query", query);
-            if (start != null) {
-                uriBuilder.addParameter("page", String.valueOf((start / 20) + 1));
-            }
 
             String resp = liveImportClient.executeHttpGetRequest(timeout, uriBuilder.toString(), params);
             if (StringUtils.isEmpty(resp)) {
-                return adsResults;
+                return importResults;
             }
 
             JsonNode jsonNode = convertStringJsonToJsonNode(resp);
@@ -244,28 +254,25 @@ private List<ImportRecord> search(String query, Integer start) {
                 Iterator<JsonNode> nodes = docs.elements();
                 while (nodes.hasNext()) {
                     JsonNode node = nodes.next();
-                    adsResults.add(transformSourceRecords(node.toString()));
+                    importResults.add(transformSourceRecords(node.toString()));
                 }
             } else {
-                adsResults.add(transformSourceRecords(docs.toString()));
+                importResults.add(transformSourceRecords(docs.toString()));
             }
         } catch (URISyntaxException e) {
             e.printStackTrace();
         }
+        return importResults;
+    }
 
-        if (start == null) {
-            return adsResults;
-        }
-
-        if (start % 20 == 0) {
-            return adsResults.stream()
-                .limit(10)
-                .collect(Collectors.toList());
-        } else {
-            return adsResults.stream()
-                .skip(10)
-                .collect(Collectors.toList());
+    protected Map<String, Map<String, String>> getBaseParams() {
+        Map<String, Map<String, String>> params = new HashMap<>();
+        String rorClientId =
+            DSpaceServicesFactory.getInstance().getConfigurationService().getProperty(ROR_CLIENT_ID_PROP);
+        if (StringUtils.isNotEmpty(rorClientId)) {
+            params.put(HEADER_PARAMETERS, Map.of(ROR_CLIENT_ID_HEADER, rorClientId));
         }
+        return params;
     }
 
     private JsonNode convertStringJsonToJsonNode(String json) {