Merge branch 'main' into CST-6761-NewUsersMightBeRegisteredInMassiveWayByRobot

dspace-api/src/main/java/org/dspace/app/requestitem/CollectionAdministratorsRequestItemStrategy.java

@@ -0,0 +1,46 @@
+/**
+ * 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.app.requestitem;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.dspace.content.Collection;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+import org.springframework.lang.NonNull;
+
+/**
+ * Derive request recipients from groups of the Collection which owns an Item.
+ * The list will include all members of the administrators group.  If the
+ * resulting list is empty, delegates to {@link RequestItemHelpdeskStrategy}.
+ *
+ * @author Mark H. Wood <mwood@iupui.edu>
+ */
+public class CollectionAdministratorsRequestItemStrategy
+        extends RequestItemHelpdeskStrategy {
+    @Override
+    @NonNull
+    public List<RequestItemAuthor> getRequestItemAuthor(Context context,
+            Item item)
+            throws SQLException {
+        List<RequestItemAuthor> recipients = new ArrayList<>();
+        Collection collection = item.getOwningCollection();
+        for (EPerson admin : collection.getAdministrators().getMembers()) {
+            recipients.add(new RequestItemAuthor(admin));
+        }
+        if (recipients.isEmpty()) {
+            return super.getRequestItemAuthor(context, item);
+        } else {
+            return recipients;
+        }
+    }
+}

dspace-api/src/main/java/org/dspace/app/requestitem/CombiningRequestItemStrategy.java

@@ -0,0 +1,61 @@
+/**
+ * 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.app.requestitem;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.springframework.lang.NonNull;
+import org.springframework.util.Assert;
+
+/**
+ * Assemble a list of recipients from the results of other strategies.
+ * The list of strategy classes is injected as the constructor argument
+ * {@code strategies}.
+ * If the strategy list is not configured, returns an empty List.
+ *
+ * @author Mark H. Wood <mwood@iupui.edu>
+ */
+public class CombiningRequestItemStrategy
+        implements RequestItemAuthorExtractor {
+    /** The strategies to combine. */
+    private final List<RequestItemAuthorExtractor> strategies;
+
+    /**
+     * Initialize a combination of strategies.
+     * @param strategies the author extraction strategies to combine.
+     */
+    public CombiningRequestItemStrategy(@NonNull List<RequestItemAuthorExtractor> strategies) {
+        Assert.notNull(strategies, "Strategy list may not be null");
+        this.strategies = strategies;
+    }
+
+    /**
+     * Do not call.
+     * @throws IllegalArgumentException always
+     */
+    private CombiningRequestItemStrategy() {
+        throw new IllegalArgumentException();
+    }
+
+    @Override
+    @NonNull
+    public List<RequestItemAuthor> getRequestItemAuthor(Context context, Item item)
+            throws SQLException {
+        List<RequestItemAuthor> recipients = new ArrayList<>();
+
+        for (RequestItemAuthorExtractor strategy : strategies) {
+            recipients.addAll(strategy.getRequestItemAuthor(context, item));
+        }
+
+        return recipients;
+    }
+}

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItem.java

@@ -27,7 +27,7 @@ import org.dspace.core.Context;
 import org.dspace.core.ReloadableEntity;
 
 /**
- * Object representing an Item Request
+ * Object representing an Item Request.
  */
 @Entity
 @Table(name = "requestitem")
@@ -94,6 +94,9 @@ public class RequestItem implements ReloadableEntity<Integer> {
         this.allfiles = allfiles;
     }
 
+    /**
+     * @return {@code true} if all of the Item's files are requested.
+     */
     public boolean isAllfiles() {
         return allfiles;
     }
@@ -102,6 +105,9 @@ public class RequestItem implements ReloadableEntity<Integer> {
         this.reqMessage = reqMessage;
     }
 
+    /**
+     * @return a message from the requester.
+     */
     public String getReqMessage() {
         return reqMessage;
     }
@@ -110,6 +116,9 @@ public class RequestItem implements ReloadableEntity<Integer> {
         this.reqName = reqName;
     }
 
+    /**
+     * @return Human-readable name of the user requesting access.
+     */
     public String getReqName() {
         return reqName;
     }
@@ -118,6 +127,9 @@ public class RequestItem implements ReloadableEntity<Integer> {
         this.reqEmail = reqEmail;
     }
 
+    /**
+     * @return address of the user requesting access.
+     */
     public String getReqEmail() {
         return reqEmail;
     }
@@ -126,6 +138,9 @@ public class RequestItem implements ReloadableEntity<Integer> {
         this.token = token;
     }
 
+    /**
+     * @return a unique request identifier which can be emailed.
+     */
     public String getToken() {
         return token;
     }

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemAuthor.java

@@ -11,20 +11,31 @@ import org.dspace.eperson.EPerson;
 
 /**
  * Simple DTO to transfer data about the corresponding author for the Request
- * Copy feature
+ * Copy feature.
  *
  * @author Andrea Bollini
  */
 public class RequestItemAuthor {
-    private String fullName;
+    private final String fullName;
-    private String email;
+    private final String email;
 
+    /**
+     * Construct an author record from given data.
+     *
+     * @param fullName the author's full name.
+     * @param email the author's email address.
+     */
     public RequestItemAuthor(String fullName, String email) {
         super();
         this.fullName = fullName;
         this.email = email;
     }
 
+    /**
+     * Construct an author from an EPerson's metadata.
+     *
+     * @param ePerson the EPerson.
+     */
     public RequestItemAuthor(EPerson ePerson) {
         super();
         this.fullName = ePerson.getFullName();

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemAuthorExtractor.java

@@ -8,26 +8,28 @@
 package org.dspace.app.requestitem;
 
 import java.sql.SQLException;
+import java.util.List;
 
 import org.dspace.content.Item;
 import org.dspace.core.Context;
+import org.springframework.lang.NonNull;
 
 /**
- * Interface to abstract the strategy for select the author to contact for
+ * Interface to abstract the strategy for selecting the author to contact for
- * request copy
+ * request copy.
  *
  * @author Andrea Bollini
  */
 public interface RequestItemAuthorExtractor {
-
     /**
-     * Retrieve the auhtor to contact for a request copy of the give item.
+     * Retrieve the author to contact for requesting a copy of the given item.
      *
      * @param context DSpace context object
      * @param item item to request
-     * @return An object containing name an email address to send the request to
+     * @return Names and email addresses to send the request to.
-     *         or null if no valid email address was found.
      * @throws SQLException if database error
      */
-    public RequestItemAuthor getRequestItemAuthor(Context context, Item item) throws SQLException;
+    @NonNull
+    public List<RequestItemAuthor> getRequestItemAuthor(Context context, Item item)
+        throws SQLException;
 }

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemEmailNotifier.java

@@ -72,28 +72,48 @@ public class RequestItemEmailNotifier {
     static public void sendRequest(Context context, RequestItem ri, String responseLink)
             throws IOException, SQLException {
         // Who is making this request?
-        RequestItemAuthor author = requestItemAuthorExtractor
+        List<RequestItemAuthor> authors = requestItemAuthorExtractor
                 .getRequestItemAuthor(context, ri.getItem());
-        String authorEmail = author.getEmail();
-        String authorName = author.getFullName();
 
         // Build an email to the approver.
         Email email = Email.getEmail(I18nUtil.getEmailFilename(context.getCurrentLocale(),
                 "request_item.author"));
-        email.addRecipient(authorEmail);
+        for (RequestItemAuthor author : authors) {
+            email.addRecipient(author.getEmail());
+        }
         email.setReplyTo(ri.getReqEmail()); // Requester's address
+
         email.addArgument(ri.getReqName()); // {0} Requester's name
+
         email.addArgument(ri.getReqEmail()); // {1} Requester's address
+
         email.addArgument(ri.isAllfiles() // {2} All bitstreams or just one?
             ? I18nUtil.getMessage("itemRequest.all") : ri.getBitstream().getName());
-        email.addArgument(handleService.getCanonicalForm(ri.getItem().getHandle()));
+
+        email.addArgument(handleService.getCanonicalForm(ri.getItem().getHandle())); // {3}
+
         email.addArgument(ri.getItem().getName()); // {4} requested item's title
+
         email.addArgument(ri.getReqMessage()); // {5} message from requester
+
         email.addArgument(responseLink); // {6} Link back to DSpace for action
-        email.addArgument(authorName); // {7} corresponding author name
+
-        email.addArgument(authorEmail); // {8} corresponding author email
+        StringBuilder names = new StringBuilder();
-        email.addArgument(configurationService.getProperty("dspace.name"));
+        StringBuilder addresses = new StringBuilder();
-        email.addArgument(configurationService.getProperty("mail.helpdesk"));
+        for (RequestItemAuthor author : authors) {
+            if (names.length() > 0) {
+                names.append("; ");
+                addresses.append("; ");
+            }
+            names.append(author.getFullName());
+            addresses.append(author.getEmail());
+        }
+        email.addArgument(names.toString()); // {7} corresponding author name
+        email.addArgument(addresses.toString()); // {8} corresponding author email
+
+        email.addArgument(configurationService.getProperty("dspace.name")); // {9}
+
+        email.addArgument(configurationService.getProperty("mail.helpdesk")); // {10}
 
         // Send the email.
         try {

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemHelpdeskStrategy.java

@@ -8,6 +8,8 @@
 package org.dspace.app.requestitem;
 
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.apache.commons.lang3.StringUtils;
 import org.dspace.content.Item;
@@ -16,11 +18,11 @@ import org.dspace.core.I18nUtil;
 import org.dspace.eperson.EPerson;
 import org.dspace.eperson.service.EPersonService;
 import org.dspace.services.ConfigurationService;
-import org.dspace.services.factory.DSpaceServicesFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.lang.NonNull;
 
 /**
- * RequestItem strategy to allow DSpace support team's helpdesk to receive requestItem request
+ * RequestItem strategy to allow DSpace support team's helpdesk to receive requestItem request.
  * With this enabled, then the Item author/submitter doesn't receive the request, but the helpdesk instead does.
  *
  * Failover to the RequestItemSubmitterStrategy, which means the submitter would get the request if there is no
@@ -33,19 +35,24 @@ public class RequestItemHelpdeskStrategy extends RequestItemSubmitterStrategy {
     @Autowired(required = true)
     protected EPersonService ePersonService;
 
+    @Autowired(required = true)
+    private ConfigurationService configuration;
+
     public RequestItemHelpdeskStrategy() {
     }
 
     @Override
-    public RequestItemAuthor getRequestItemAuthor(Context context, Item item) throws SQLException {
+    @NonNull
-        ConfigurationService configurationService
+    public List<RequestItemAuthor> getRequestItemAuthor(Context context, Item item)
-                = DSpaceServicesFactory.getInstance().getConfigurationService();
+            throws SQLException {
-        boolean helpdeskOverridesSubmitter = configurationService
+        boolean helpdeskOverridesSubmitter = configuration
             .getBooleanProperty("request.item.helpdesk.override", false);
-        String helpDeskEmail = configurationService.getProperty("mail.helpdesk");
+        String helpDeskEmail = configuration.getProperty("mail.helpdesk");
 
         if (helpdeskOverridesSubmitter && StringUtils.isNotBlank(helpDeskEmail)) {
-            return getHelpDeskPerson(context, helpDeskEmail);
+            List<RequestItemAuthor> authors = new ArrayList<>(1);
+            authors.add(getHelpDeskPerson(context, helpDeskEmail));
+            return authors;
         } else {
             //Fallback to default logic (author of Item) if helpdesk isn't fully enabled or setup
             return super.getRequestItemAuthor(context, item);

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemMetadataStrategy.java

@@ -8,6 +8,8 @@
 package org.dspace.app.requestitem;
 
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import org.apache.commons.lang3.StringUtils;
@@ -16,12 +18,13 @@ import org.dspace.content.MetadataValue;
 import org.dspace.content.service.ItemService;
 import org.dspace.core.Context;
 import org.dspace.core.I18nUtil;
-import org.dspace.services.factory.DSpaceServicesFactory;
+import org.dspace.services.ConfigurationService;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.lang.NonNull;
 
 /**
  * Try to look to an item metadata for the corresponding author name and email.
- * Failover to the RequestItemSubmitterStrategy
+ * Failover to the RequestItemSubmitterStrategy.
  *
  * @author Andrea Bollini
  */
@@ -30,6 +33,9 @@ public class RequestItemMetadataStrategy extends RequestItemSubmitterStrategy {
     protected String emailMetadata;
     protected String fullNameMetadata;
 
+    @Autowired(required = true)
+    protected ConfigurationService configurationService;
+
     @Autowired(required = true)
     protected ItemService itemService;
 
@@ -37,59 +43,72 @@ public class RequestItemMetadataStrategy extends RequestItemSubmitterStrategy {
     }
 
     @Override
-    public RequestItemAuthor getRequestItemAuthor(Context context, Item item)
+    @NonNull
+    public List<RequestItemAuthor> getRequestItemAuthor(Context context, Item item)
         throws SQLException {
-        RequestItemAuthor author = null;
+        List<RequestItemAuthor> authors;
         if (emailMetadata != null) {
             List<MetadataValue> vals = itemService.getMetadataByMetadataString(item, emailMetadata);
-            if (vals.size() > 0) {
+            List<MetadataValue> nameVals;
-                String email = vals.iterator().next().getValue();
+            if (null != fullNameMetadata) {
+                nameVals = itemService.getMetadataByMetadataString(item, fullNameMetadata);
+            } else {
+                nameVals = Collections.EMPTY_LIST;
+            }
+            boolean useNames = vals.size() == nameVals.size();
+            if (!vals.isEmpty()) {
+                authors = new ArrayList<>(vals.size());
+                for (int authorIndex = 0; authorIndex < vals.size(); authorIndex++) {
+                    String email = vals.get(authorIndex).getValue();
                     String fullname = null;
-                if (fullNameMetadata != null) {
+                    if (useNames) {
-                    List<MetadataValue> nameVals = itemService.getMetadataByMetadataString(item, fullNameMetadata);
+                        fullname = nameVals.get(authorIndex).getValue();
-                    if (nameVals.size() > 0) {
-                        fullname = nameVals.iterator().next().getValue();
-                    }
                     }
+
                     if (StringUtils.isBlank(fullname)) {
-                    fullname = I18nUtil
+                        fullname = I18nUtil.getMessage(
-                            .getMessage(
                                 "org.dspace.app.requestitem.RequestItemMetadataStrategy.unnamed",
                                 context);
                     }
-                author = new RequestItemAuthor(fullname, email);
+                    RequestItemAuthor author = new RequestItemAuthor(
-                return author;
+                            fullname, email);
+                    authors.add(author);
+                }
+                return authors;
+            } else {
+                return Collections.EMPTY_LIST;
             }
         } else {
             // Uses the basic strategy to look for the original submitter
-            author = super.getRequestItemAuthor(context, item);
+            authors = super.getRequestItemAuthor(context, item);
-            // Is the author or their email null. If so get the help desk or admin name and email
+
-            if (null == author || null == author.getEmail()) {
+            // Remove from the list authors that do not have email addresses.
-                String email = null;
+            for (RequestItemAuthor author : authors) {
-                String name = null;
+                if (null == author.getEmail()) {
-                //First get help desk name and email
+                    authors.remove(author);
-                email = DSpaceServicesFactory.getInstance()
-                        .getConfigurationService().getProperty("mail.helpdesk");
-                name = DSpaceServicesFactory.getInstance()
-                                            .getConfigurationService().getProperty("mail.helpdesk.name");
-                // If help desk mail is null get the mail and name of admin
-                if (email == null) {
-                    email = DSpaceServicesFactory.getInstance()
-                            .getConfigurationService().getProperty("mail.admin");
-                    name = DSpaceServicesFactory.getInstance()
-                            .getConfigurationService().getProperty("mail.admin.name");
                 }
-                author = new RequestItemAuthor(name, email);
-            }
-        }
-        return author;
             }
 
-    public void setEmailMetadata(String emailMetadata) {
+            if (authors.isEmpty()) { // No author email addresses!  Fall back
+                //First get help desk name and email
+                String email = configurationService.getProperty("mail.helpdesk");
+                String name = configurationService.getProperty("mail.helpdesk.name");
+                // If help desk mail is null get the mail and name of admin
+                if (email == null) {
+                    email = configurationService.getProperty("mail.admin");
+                    name = configurationService.getProperty("mail.admin.name");
+                }
+                authors.add(new RequestItemAuthor(name, email));
+            }
+            return authors;
+        }
+    }
+
+    public void setEmailMetadata(@NonNull String emailMetadata) {
         this.emailMetadata = emailMetadata;
     }
 
-    public void setFullNameMetadata(String fullNameMetadata) {
+    public void setFullNameMetadata(@NonNull String fullNameMetadata) {
         this.fullNameMetadata = fullNameMetadata;
     }
 

dspace-api/src/main/java/org/dspace/app/requestitem/RequestItemSubmitterStrategy.java

@@ -8,10 +8,13 @@
 package org.dspace.app.requestitem;
 
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.dspace.content.Item;
 import org.dspace.core.Context;
 import org.dspace.eperson.EPerson;
+import org.springframework.lang.NonNull;
 
 /**
  * Basic strategy that looks to the original submitter.
@@ -24,21 +27,23 @@ public class RequestItemSubmitterStrategy implements RequestItemAuthorExtractor
     }
 
     /**
-     * Returns the submitter of an Item as RequestItemAuthor or null if the
+     * Returns the submitter of an Item as RequestItemAuthor or an empty List if
-     * Submitter is deleted.
+     * the Submitter is deleted.
      *
-     * @return The submitter of the item or null if the submitter is deleted
+     * @return The submitter of the item or empty List if the submitter is deleted
      * @throws SQLException if database error
      */
     @Override
-    public RequestItemAuthor getRequestItemAuthor(Context context, Item item)
+    @NonNull
+    public List<RequestItemAuthor> getRequestItemAuthor(Context context, Item item)
         throws SQLException {
         EPerson submitter = item.getSubmitter();
-        RequestItemAuthor author = null;
+        List<RequestItemAuthor> authors = new ArrayList<>(1);
         if (null != submitter) {
-            author = new RequestItemAuthor(
+            RequestItemAuthor author = new RequestItemAuthor(
                 submitter.getFullName(), submitter.getEmail());
+            authors.add(author);
         }
-        return author;
+        return authors;
     }
 }

dspace-api/src/main/java/org/dspace/content/packager/AbstractMETSDisseminator.java

@@ -14,9 +14,7 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
 import java.lang.reflect.InvocationTargetException;
-import java.net.URLEncoder;
 import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -465,17 +463,17 @@ public abstract class AbstractMETSDisseminator
                                 Utils.copy(input, zip);
                                 input.close();
                             } else {
-                                log.warn("Adding zero-length file for Bitstream, SID="
+                                log.warn("Adding zero-length file for Bitstream, uuid="
-                                             + String.valueOf(bitstream.getSequenceID())
+                                             + String.valueOf(bitstream.getID())
                                              + ", not authorized for READ.");
                             }
                             zip.closeEntry();
                         } else if (unauth != null && unauth.equalsIgnoreCase("skip")) {
-                            log.warn("Skipping Bitstream, SID=" + String
+                            log.warn("Skipping Bitstream, uuid=" + String
-                                .valueOf(bitstream.getSequenceID()) + ", not authorized for READ.");
+                                .valueOf(bitstream.getID()) + ", not authorized for READ.");
                         } else {
                             throw new AuthorizeException(
-                                "Not authorized to read Bitstream, SID=" + String.valueOf(bitstream.getSequenceID()));
+                                "Not authorized to read Bitstream, uuid=" + String.valueOf(bitstream.getID()));
                         }
                     }
                 }
@@ -896,12 +894,12 @@ public abstract class AbstractMETSDisseminator
                             continue;
                         } else if (!(unauth != null && unauth.equalsIgnoreCase("zero"))) {
                             throw new AuthorizeException(
-                                "Not authorized to read Bitstream, SID=" + String.valueOf(bitstream.getSequenceID()));
+                                "Not authorized to read Bitstream, uuid=" + String.valueOf(bitstream.getID()));
                         }
                     }
 
-                    String sid = String.valueOf(bitstream.getSequenceID());
+                    String uuid = String.valueOf(bitstream.getID());
-                    String fileID = bitstreamIDstart + sid;
+                    String fileID = bitstreamIDstart + uuid;
                     edu.harvard.hul.ois.mets.File file = new edu.harvard.hul.ois.mets.File();
                     file.setID(fileID);
                     file.setSEQ(bitstream.getSequenceID());
@@ -924,7 +922,7 @@ public abstract class AbstractMETSDisseminator
                      * extracted text or a thumbnail, so we use the name to work
                      * out which bitstream to be in the same group as
                      */
-                    String groupID = "GROUP_" + bitstreamIDstart + sid;
+                    String groupID = "GROUP_" + bitstreamIDstart + uuid;
                     if ((bundle.getName() != null)
                         && (bundle.getName().equals("THUMBNAIL") ||
                         bundle.getName().startsWith("TEXT"))) {
@@ -934,7 +932,7 @@ public abstract class AbstractMETSDisseminator
                                                                    bitstream);
                         if (original != null) {
                             groupID = "GROUP_" + bitstreamIDstart
-                                + original.getSequenceID();
+                                + String.valueOf(original.getID());
                         }
                     }
                     file.setGROUPID(groupID);
@@ -1403,7 +1401,7 @@ public abstract class AbstractMETSDisseminator
         // if bare manifest, use external "persistent" URI for bitstreams
         if (params != null && (params.getBooleanProperty("manifestOnly", false))) {
             // Try to build a persistent(-ish) URI for bitstream
-            // Format: {site-base-url}/bitstream/{item-handle}/{sequence-id}/{bitstream-name}
+            // Format: {site-ui-url}/bitstreams/{bitstream-uuid}
             try {
                 // get handle of parent Item of this bitstream, if there is one:
                 String handle = null;
@@ -1414,26 +1412,13 @@ public abstract class AbstractMETSDisseminator
                         handle = bi.get(0).getHandle();
                     }
                 }
-                if (handle != null) {
                 return configurationService
                     .getProperty("dspace.ui.url")
-                        + "/bitstream/"
+                    + "/bitstreams/"
-                        + handle
+                    + String.valueOf(bitstream.getID())
-                        + "/"
+                    + "/download";
-                        + String.valueOf(bitstream.getSequenceID())
-                        + "/"
-                        + URLEncoder.encode(bitstream.getName(), "UTF-8");
-                } else {   //no Handle assigned, so persistent(-ish) URI for bitstream is
-                    // Format: {site-base-url}/retrieve/{bitstream-internal-id}
-                    return configurationService
-                        .getProperty("dspace.ui.url")
-                        + "/retrieve/"
-                        + String.valueOf(bitstream.getID());
-                }
             } catch (SQLException e) {
                 log.error("Database problem", e);
-            } catch (UnsupportedEncodingException e) {
-                log.error("Unknown character set", e);
             }
 
             // We should only get here if we failed to build a nice URL above

dspace-api/src/main/java/org/dspace/external/provider/impl/OpenAIREFundingDataProvider.java

@@ -15,6 +15,7 @@ import java.util.ArrayList;
 import java.util.Base64;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -33,6 +34,7 @@ import org.dspace.content.dto.MetadataValueDTO;
 import org.dspace.external.OpenAIRERestConnector;
 import org.dspace.external.model.ExternalDataObject;
 import org.dspace.external.provider.AbstractExternalDataProvider;
+import org.dspace.importer.external.metadatamapping.MetadataFieldConfig;
 import org.springframework.beans.factory.annotation.Autowired;
 
 /**
@@ -40,13 +42,9 @@ import org.springframework.beans.factory.annotation.Autowired;
  * will deal with the OpenAIRE External Data lookup
  * 
  * @author paulo-graca
- *
  */
 public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
 
-    /**
-     * log4j logger
-     */
     private static Logger log = org.apache.logging.log4j.LogManager.getLogger(OpenAIREFundingDataProvider.class);
 
     /**
@@ -54,6 +52,16 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
      */
     protected static final String PREFIX = "info:eu-repo/grantAgreement";
 
+    private static final String TITLE = "dcTitle";
+    private static final String SUBJECT = "dcSubject";
+    private static final String AWARD_URI = "awardURI";
+    private static final String FUNDER_NAME = "funderName";
+    private static final String SPATIAL = "coverageSpatial";
+    private static final String AWARD_NUMBER = "awardNumber";
+    private static final String FUNDER_ID = "funderIdentifier";
+    private static final String FUNDING_STREAM = "fundingStream";
+    private static final String TITLE_ALTERNATIVE = "titleAlternative";
+
     /**
      * rows default limit
      */
@@ -69,11 +77,9 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
      */
     protected OpenAIRERestConnector connector;
 
-    /**
+    protected Map<String, MetadataFieldConfig> metadataFields;
-     * required method
+
-     */
+    public void init() throws IOException {}
-    public void init() throws IOException {
-    }
 
     @Override
     public String getSourceIdentifier() {
@@ -266,14 +272,22 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
         }
     }
 
+    public Map<String, MetadataFieldConfig> getMetadataFields() {
+        return metadataFields;
+    }
+
+    public void setMetadataFields(Map<String, MetadataFieldConfig> metadataFields) {
+        this.metadataFields = metadataFields;
+    }
+
     /**
      * OpenAIRE Funding External Data Builder Class
      * 
      * @author pgraca
-     *
      */
-    public static class ExternalDataObjectBuilder {
+    public class ExternalDataObjectBuilder {
-        ExternalDataObject externalDataObject;
+
+        private ExternalDataObject externalDataObject;
 
         public ExternalDataObjectBuilder(Project project) {
             String funderIdPrefix = "urn:openaire:";
@@ -283,46 +297,42 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
             for (FundingTreeType fundingTree : projectHelper.getFundingTreeTypes()) {
                 FunderType funder = fundingTree.getFunder();
                 // Funder name
-                this.addFunderName(funder.getName());
+                this.addMetadata(metadataFields.get(FUNDER_NAME), funder.getName());
                 // Funder Id - convert it to an urn
-                this.addFunderID(funderIdPrefix + funder.getId());
+                this.addMetadata(metadataFields.get(FUNDER_ID), funderIdPrefix + funder.getId());
                 // Jurisdiction
-                this.addFunderJuristiction(funder.getJurisdiction());
+                this.addMetadata(metadataFields.get(SPATIAL), funder.getJurisdiction());
 
                 FundingHelper fundingHelper = new FundingHelper(
                               fundingTree.getFundingLevel2OrFundingLevel1OrFundingLevel0());
 
                 // Funding description
                 for (FundingType funding : fundingHelper.getFirstAvailableFunding()) {
-                    this.addFundingStream(funding.getDescription());
+                    this.addMetadata(metadataFields.get(FUNDING_STREAM), funding.getDescription());
                 }
             }
 
             // Title
             for (String title : projectHelper.getTitles()) {
-                this.addAwardTitle(title);
+                this.addMetadata(metadataFields.get(TITLE), title);
                 this.setDisplayValue(title);
                 this.setValue(title);
             }
-
             // Code
             for (String code : projectHelper.getCodes()) {
-                this.addAwardNumber(code);
+                this.addMetadata(metadataFields.get(AWARD_NUMBER), code);
             }
-
             // Website url
             for (String url : projectHelper.getWebsiteUrls()) {
-                this.addAwardURI(url);
+                this.addMetadata(metadataFields.get(AWARD_URI), url);
             }
-
             // Acronyms
             for (String acronym : projectHelper.getAcronyms()) {
-                this.addFundingItemAcronym(acronym);
+                this.addMetadata(metadataFields.get(TITLE_ALTERNATIVE), acronym);
             }
-
             // Keywords
             for (String keyword : projectHelper.getKeywords()) {
-                this.addSubject(keyword);
+                this.addMetadata(metadataFields.get(SUBJECT), keyword);
             }
         }
 
@@ -366,7 +376,6 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
          * @return ExternalDataObjectBuilder
          */
         public ExternalDataObjectBuilder setId(String id) {
-
             // we use base64 encoding in order to use slashes / and other
             // characters that must be escaped for the <:entry-id>
             String base64Id = Base64.getEncoder().encodeToString(id.getBytes());
@@ -374,128 +383,10 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
             return this;
         }
 
-        /**
+        public ExternalDataObjectBuilder addMetadata(MetadataFieldConfig metadataField, String value) {
-         * Add metadata dc.identifier
+            this.externalDataObject.addMetadata(new MetadataValueDTO(metadataField.getSchema(),
-         * 
+                                                                     metadataField.getElement(),
-         * @param metadata identifier
+                                                                     metadataField.getQualifier(), null, value));
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addIdentifier(String identifier) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("dc", "identifier", null, null, identifier));
-            return this;
-        }
-
-        /**
-         * Add metadata project.funder.name
-         * 
-         * @param metadata funderName
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addFunderName(String funderName) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("project", "funder", "name", null, funderName));
-            return this;
-        }
-
-        /**
-         * Add metadata project.funder.identifier
-         * 
-         * @param metadata funderId
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addFunderID(String funderID) {
-            this.externalDataObject
-                    .addMetadata(new MetadataValueDTO("project", "funder", "identifier", null, funderID));
-            return this;
-        }
-
-        /**
-         * Add metadata dc.title
-         * 
-         * @param metadata awardTitle
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addAwardTitle(String awardTitle) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("dc", "title", null, null, awardTitle));
-            return this;
-        }
-
-        /**
-         * Add metadata oaire.fundingStream
-         * 
-         * @param metadata fundingStream
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addFundingStream(String fundingStream) {
-            this.externalDataObject
-                    .addMetadata(new MetadataValueDTO("oaire", "fundingStream", null, null, fundingStream));
-            return this;
-        }
-
-        /**
-         * Add metadata oaire.awardNumber
-         * 
-         * @param metadata awardNumber
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addAwardNumber(String awardNumber) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("oaire", "awardNumber", null, null, awardNumber));
-            return this;
-        }
-
-        /**
-         * Add metadata oaire.awardURI
-         * 
-         * @param metadata websiteUrl
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addAwardURI(String websiteUrl) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("oaire", "awardURI", null, null, websiteUrl));
-            return this;
-        }
-
-        /**
-         * Add metadata dc.title.alternative
-         * 
-         * @param metadata fundingItemAcronym
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addFundingItemAcronym(String fundingItemAcronym) {
-            this.externalDataObject
-                    .addMetadata(new MetadataValueDTO("dc", "title", "alternative", null, fundingItemAcronym));
-            return this;
-        }
-
-        /**
-         * Add metadata dc.coverage.spatial
-         * 
-         * @param metadata funderJuristiction
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addFunderJuristiction(String funderJuristiction) {
-            this.externalDataObject
-                    .addMetadata(new MetadataValueDTO("dc", "coverage", "spatial", null, funderJuristiction));
-            return this;
-        }
-
-        /**
-         * Add metadata dc.description
-         * 
-         * @param metadata description
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addDescription(String description) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("dc", "description", null, null, description));
-            return this;
-        }
-
-        /**
-         * Add metadata dc.subject
-         * 
-         * @param metadata subject
-         * @return ExternalDataObjectBuilder
-         */
-        public ExternalDataObjectBuilder addSubject(String subject) {
-            this.externalDataObject.addMetadata(new MetadataValueDTO("dc", "subject", null, null, subject));
             return this;
         }
 
@@ -508,4 +399,5 @@ public class OpenAIREFundingDataProvider extends AbstractExternalDataProvider {
             return this.externalDataObject;
         }
     }
+
 }

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

@@ -0,0 +1,65 @@
+/**
+ * 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 org.dspace.importer.external.metadatamapping.MetadataFieldMapping;
+import org.dspace.importer.external.metadatamapping.MetadatumDTO;
+
+/**
+ * Wrapper class used to split another MetadataContributor's output into distinct values.
+ * The split is performed by matching a regular expression against the wrapped MetadataContributor's output.
+ *
+ * @author Philipp Rumpf (philipp.rumpf@uni-bamberg.de)
+ */
+
+public class SplitMetadataContributor<T> implements MetadataContributor<T> {
+    private final MetadataContributor<T> innerContributor;
+    private final String regex;
+
+    /**
+     * @param innerContributor      The MetadataContributor whose output is split
+     * @param regex                 A regular expression matching the separator between different values
+     */
+    public SplitMetadataContributor(MetadataContributor<T> innerContributor, String regex) {
+        this.innerContributor = innerContributor;
+        this.regex = regex;
+    }
+
+    @Override
+    public void setMetadataFieldMapping(MetadataFieldMapping<T, MetadataContributor<T>> rt) {
+
+    }
+
+    /**
+     * Each metadatum returned by the wrapped MetadataContributor is split into one or more metadata values
+     * based on the provided regular expression.
+     *
+     * @param t The recordType object to retrieve metadata from
+     * @return The collection of processed metadata values
+     */
+    @Override
+    public Collection<MetadatumDTO> contributeMetadata(T t) {
+        Collection<MetadatumDTO> metadata = innerContributor.contributeMetadata(t);
+        ArrayList<MetadatumDTO> splitMetadata = new ArrayList<>();
+        for (MetadatumDTO metadatumDTO : metadata) {
+            String[] split = metadatumDTO.getValue().split(regex);
+            for (String splitItem : split) {
+                MetadatumDTO splitMetadatumDTO = new MetadatumDTO();
+                splitMetadatumDTO.setSchema(metadatumDTO.getSchema());
+                splitMetadatumDTO.setElement(metadatumDTO.getElement());
+                splitMetadatumDTO.setQualifier(metadatumDTO.getQualifier());
+                splitMetadatumDTO.setValue(splitItem);
+                splitMetadata.add(splitMetadatumDTO);
+            }
+        }
+        return splitMetadata;
+    }
+}

dspace-api/src/test/data/dspaceFolder/config/spring/api/external-openaire.xml

@@ -1,6 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<beans xmlns="http://www.springframework.org/schema/beans"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:util="http://www.springframework.org/schema/util"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+                           http://www.springframework.org/schema/util
+                           http://www.springframework.org/schema/util/spring-util.xsd"
        default-lazy-init="true">
 
     <bean id="mockOpenAIRERestConnector" class="org.dspace.external.MockOpenAIRERestConnector">
@@ -15,6 +19,7 @@
 		init-method="init">
 		<property name="sourceIdentifier" value="openAIREFunding" />
 		<property name="connector" ref="mockOpenAIRERestConnector" />
+	    <property name="metadataFields" ref="mapOfmetadata"/>
 		<property name="supportedEntityTypes">
 			<list>
 				<value>Project</value>
@@ -22,4 +27,63 @@
 		</property>
 	</bean>
 
+    <util:map id="mapOfmetadata"
+        map-class="java.util.HashMap" key-type="java.lang.String" value-type="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <entry key="awardNumber" value-ref="openaireAwardNumber" />
+        <entry key="fundingStream" value-ref="openaireFundingStream" />
+        <entry key="awardURI" value-ref="openaireAwardURI" />
+        <entry key="funderName" value-ref="openaireFunderName" />
+        <entry key="funderIdentifier" value-ref="openaireFunderIdentifier" />
+        <entry key="dcTitle" value-ref="openaireTitle" />
+        <entry key="titleAlternative" value-ref="openaireTitleAlternative" />
+        <entry key="dcIdentifier" value-ref="openaireIdentifier" />
+        <entry key="coverageSpatial" value-ref="openaireSpatial" />
+        <entry key="dcDescription" value-ref="openaireDescription" />
+        <entry key="dcSubject" value-ref="openaireSubject" />
+    </util:map>
+
+    <bean id="openaireAwardNumber" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="oaire.awardNumber"/>
+    </bean>
+
+    <bean id="openaireFundingStream" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="oaire.fundingStream"/>
+    </bean>
+    
+    <bean id="openaireAwardURI" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="oaire.awardURI"/>
+    </bean>
+
+    <bean id="openaireFunderName" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="project.funder.name"/>
+    </bean>
+
+    <bean id="openaireFunderIdentifier" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="project.funder.identifier"/>
+    </bean>
+
+    <bean id="openaireTitle" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.title"/>
+    </bean>
+
+    <bean id="openaireTitleAlternative" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.title.alternative"/>
+    </bean>
+
+    <bean id="openaireIdentifier" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.identifier"/>
+    </bean>
+
+    <bean id="openaireSpatial" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.coverage.spatial"/>
+    </bean>
+
+    <bean id="openaireDescription" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.description"/>
+    </bean>
+
+    <bean id="openaireSubject" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.subject"/>
+    </bean>
+	
 </beans>

dspace-api/src/test/java/org/dspace/app/requestitem/CollectionAdministratorsRequestItemStrategyTest.java

@@ -0,0 +1,62 @@
+/**
+ * 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.app.requestitem;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.dspace.content.Collection;
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+import org.dspace.eperson.Group;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+/**
+ *
+ * @author Mark H. Wood <mwood@iupui.edu>
+ */
+public class CollectionAdministratorsRequestItemStrategyTest {
+    private static final String NAME = "John Q. Public";
+    private static final String EMAIL = "jqpublic@example.com";
+
+    /**
+     * Test of getRequestItemAuthor method, of class CollectionAdministratorsRequestItemStrategy.
+     * @throws java.lang.Exception passed through.
+     */
+    @Test
+    public void testGetRequestItemAuthor()
+            throws Exception {
+        System.out.println("getRequestItemAuthor");
+
+        Context context = Mockito.mock(Context.class);
+
+        EPerson eperson1 = Mockito.mock(EPerson.class);
+        Mockito.when(eperson1.getEmail()).thenReturn(EMAIL);
+        Mockito.when(eperson1.getFullName()).thenReturn(NAME);
+
+        Group group1 = Mockito.mock(Group.class);
+        Mockito.when(group1.getMembers()).thenReturn(List.of(eperson1));
+
+        Collection collection1 = Mockito.mock(Collection.class);
+        Mockito.when(collection1.getAdministrators()).thenReturn(group1);
+
+        Item item = Mockito.mock(Item.class);
+        Mockito.when(item.getOwningCollection()).thenReturn(collection1);
+        Mockito.when(item.getSubmitter()).thenReturn(eperson1);
+
+        CollectionAdministratorsRequestItemStrategy instance = new CollectionAdministratorsRequestItemStrategy();
+        List<RequestItemAuthor> result = instance.getRequestItemAuthor(context,
+                item);
+        assertEquals("Should be one author", 1, result.size());
+        assertEquals("Name should match " + NAME, NAME, result.get(0).getFullName());
+        assertEquals("Email should match " + EMAIL, EMAIL, result.get(0).getEmail());
+    }
+}

dspace-api/src/test/java/org/dspace/app/requestitem/CombiningRequestItemStrategyTest.java

@@ -0,0 +1,53 @@
+/**
+ * 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.app.requestitem;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
+
+import java.util.List;
+
+import org.dspace.content.Item;
+import org.dspace.core.Context;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+/**
+ *
+ * @author Mark H. Wood <mwood@iupui.edu>
+ */
+public class CombiningRequestItemStrategyTest {
+    /**
+     * Test of getRequestItemAuthor method, of class CombiningRequestItemStrategy.
+     * @throws java.lang.Exception passed through.
+     */
+    @Test
+    public void testGetRequestItemAuthor()
+            throws Exception {
+        System.out.println("getRequestItemAuthor");
+        Context context = null;
+
+        Item item = Mockito.mock(Item.class);
+        RequestItemAuthor author1 = new RequestItemAuthor("Pat Paulsen", "ppaulsen@example.com");
+        RequestItemAuthor author2 = new RequestItemAuthor("Alfred E. Neuman", "aeneuman@example.com");
+        RequestItemAuthor author3 = new RequestItemAuthor("Alias Undercover", "aundercover@example.com");
+
+        RequestItemAuthorExtractor strategy1 = Mockito.mock(RequestItemHelpdeskStrategy.class);
+        Mockito.when(strategy1.getRequestItemAuthor(context, item)).thenReturn(List.of(author1));
+
+        RequestItemAuthorExtractor strategy2 = Mockito.mock(RequestItemMetadataStrategy.class);
+        Mockito.when(strategy2.getRequestItemAuthor(context, item)).thenReturn(List.of(author2, author3));
+
+        List<RequestItemAuthorExtractor> strategies = List.of(strategy1, strategy2);
+
+        CombiningRequestItemStrategy instance = new CombiningRequestItemStrategy(strategies);
+        List<RequestItemAuthor> result = instance.getRequestItemAuthor(context,
+                item);
+        assertThat(result, containsInAnyOrder(author1, author2, author3));
+    }
+}

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/RequestItemRepository.java

@@ -15,7 +15,9 @@ import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.sql.SQLException;
+import java.util.Collections;
 import java.util.Date;
+import java.util.List;
 import java.util.UUID;
 import javax.servlet.http.HttpServletRequest;
 
@@ -229,14 +231,20 @@ public class RequestItemRepository
         }
 
         // Check for authorized user
-        RequestItemAuthor authorizer;
+        List<RequestItemAuthor> authorizers;
         try {
-            authorizer = requestItemAuthorExtractor.getRequestItemAuthor(context, ri.getItem());
+            authorizers = requestItemAuthorExtractor.getRequestItemAuthor(context, ri.getItem());
         } catch (SQLException ex) {
             LOG.warn("Failed to find an authorizer:  {}", ex.getMessage());
-            authorizer = new RequestItemAuthor("", "");
+            authorizers = Collections.EMPTY_LIST;
         }
-        if (!authorizer.getEmail().equals(context.getCurrentUser().getEmail())) {
+
+        boolean authorized = false;
+        String requester = context.getCurrentUser().getEmail();
+        for (RequestItemAuthor authorizer : authorizers) {
+            authorized |= authorizer.getEmail().equals(requester);
+        }
+        if (!authorized) {
             throw new AuthorizeException("Not authorized to approve this request");
         }
 

dspace-server-webapp/src/test/java/org/dspace/app/rest/WorkspaceItemRestRepositoryIT.java

@@ -994,6 +994,7 @@ public class WorkspaceItemRestRepositoryIT extends AbstractControllerIntegration
         }
         bibtex.close();
     }
+
     @Test
     /**
      * Test the creation of workspaceitems POSTing to the resource collection endpoint a bibtex file
@@ -1187,6 +1188,112 @@ public class WorkspaceItemRestRepositoryIT extends AbstractControllerIntegration
         bibtex.close();
     }
 
+    @Test
+    /**
+     * Test the creation of workspaceitems POSTing to the resource collection endpoint a bibtex file
+     *
+     * @throws Exception
+     */
+    public void createSingleWorkspaceItemFromBibtexFileWithMultipleAuthorsTest() throws Exception {
+        context.turnOffAuthorisationSystem();
+
+        //** GIVEN **
+        //1. A community-collection structure with one parent community with sub-community and two collections.
+        parentCommunity = CommunityBuilder.createCommunity(context)
+                .withName("Parent Community")
+                .build();
+        Community child1 = CommunityBuilder.createSubCommunity(context, parentCommunity)
+                .withName("Sub Community")
+                .build();
+        Collection col1 = CollectionBuilder.createCollection(context, child1)
+                .withName("Collection 1")
+                .withSubmitterGroup(eperson)
+                .build();
+        Collection col2 = CollectionBuilder.createCollection(context, child1)
+                .withName("Collection 2")
+                .withSubmitterGroup(eperson)
+                .build();
+
+        InputStream bibtex = getClass().getResourceAsStream("bibtex-test-multiple-authors.bib");
+        final MockMultipartFile bibtexFile = new MockMultipartFile("file",
+                "/local/path/bibtex-test-multiple-authors.bib",
+                "application/x-bibtex", bibtex);
+
+        context.restoreAuthSystemState();
+
+        AtomicReference<List<Integer>> idRef = new AtomicReference<>();
+        String authToken = getAuthToken(eperson.getEmail(), password);
+        try {
+            // create a workspaceitem from a single bibliographic entry file explicitly in the default collection (col1)
+            getClient(authToken).perform(multipart("/api/submission/workspaceitems")
+                            .file(bibtexFile))
+                    // create should return 200, 201 (created) is better for single resource
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0]" +
+                                    ".sections.traditionalpageone['dc.title'][0].value",
+                            is("My Article")))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0]" +
+                                    ".sections.traditionalpageone['dc.contributor.author'][0].value",
+                            is("A. Nauthor")))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0]" +
+                                    ".sections.traditionalpageone['dc.contributor.author'][1].value",
+                            is("A. Nother")))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0]" +
+                                    ".sections.traditionalpageone['dc.contributor.author'][2].value",
+                            is("A. Third")))
+                    .andExpect(
+                            jsonPath("$._embedded.workspaceitems[0]._embedded.collection.id",
+                                    is(col1.getID().toString())))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0].sections.upload.files[0]"
+                                    + ".metadata['dc.source'][0].value",
+                            is("/local/path/bibtex-test-multiple-authors.bib")))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0].sections.upload.files[0]"
+                                    + ".metadata['dc.title'][0].value",
+                            is("bibtex-test-multiple-authors.bib")))
+                    .andExpect(
+                            jsonPath("$._embedded.workspaceitems[*]._embedded.upload").doesNotExist())
+                    .andDo(result -> idRef.set(read(result.getResponse().getContentAsString(),
+                            "$._embedded.workspaceitems[*].id")));
+        } finally {
+            if (idRef != null && idRef.get() != null) {
+                for (int i : idRef.get()) {
+                    WorkspaceItemBuilder.deleteWorkspaceItem(i);
+                }
+            }
+        }
+
+        // create a workspaceitem from a single bibliographic entry file explicitly in the col2
+        try {
+            getClient(authToken).perform(multipart("/api/submission/workspaceitems")
+                            .file(bibtexFile)
+                            .param("owningCollection", col2.getID().toString()))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0]" +
+                                    ".sections.traditionalpageone['dc.title'][0].value",
+                            is("My Article")))
+                    .andExpect(
+                            jsonPath("$._embedded.workspaceitems[0]._embedded.collection.id",
+                                    is(col2.getID().toString())))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0].sections.upload.files[0]"
+                                    + ".metadata['dc.source'][0].value",
+                            is("/local/path/bibtex-test-multiple-authors.bib")))
+                    .andExpect(jsonPath("$._embedded.workspaceitems[0].sections.upload"
+                                    + ".files[0].metadata['dc.title'][0].value",
+                            is("bibtex-test-multiple-authors.bib")))
+                    .andExpect(
+                            jsonPath("$._embedded.workspaceitems[*]._embedded.upload").doesNotExist())
+                    .andDo(result -> idRef.set(read(result.getResponse().getContentAsString(),
+                            "$._embedded.workspaceitems[*].id")));
+        } finally {
+            if (idRef != null && idRef.get() != null) {
+                for (int i : idRef.get()) {
+                    WorkspaceItemBuilder.deleteWorkspaceItem(i);
+                }
+            }
+        }
+        bibtex.close();
+    }
+
     @Test
     /**
      * Test the creation of workspaceitems POSTing to the resource collection endpoint a csv file

dspace-server-webapp/src/test/java/org/dspace/app/rest/eperson/DeleteEPersonSubmitterIT.java

@@ -142,10 +142,10 @@ public class DeleteEPersonSubmitterIT extends AbstractControllerIntegrationTest
 
 
         Item item = itemService.find(context, installItem.getID());
-        RequestItemAuthor requestItemAuthor = requestItemAuthorExtractor.getRequestItemAuthor(context, item);
+        List<RequestItemAuthor> requestItemAuthor = requestItemAuthorExtractor.getRequestItemAuthor(context, item);
 
-        assertEquals("Help Desk", requestItemAuthor.getFullName());
+        assertEquals("Help Desk", requestItemAuthor.get(0).getFullName());
-        assertEquals("dspace-help@myu.edu", requestItemAuthor.getEmail());
+        assertEquals("dspace-help@myu.edu", requestItemAuthor.get(0).getEmail());
     }
 
     /**
@@ -171,7 +171,7 @@ public class DeleteEPersonSubmitterIT extends AbstractControllerIntegrationTest
 
         Item item = installItemService.installItem(context, wsi);
 
-        List<Operation> opsToWithDraw = new ArrayList<Operation>();
+        List<Operation> opsToWithDraw = new ArrayList<>();
         ReplaceOperation replaceOperationToWithDraw = new ReplaceOperation("/withdrawn", true);
         opsToWithDraw.add(replaceOperationToWithDraw);
         String patchBodyToWithdraw = getPatchContent(opsToWithDraw);
@@ -191,7 +191,7 @@ public class DeleteEPersonSubmitterIT extends AbstractControllerIntegrationTest
 
         assertNull(retrieveItemSubmitter(item.getID()));
 
-        List<Operation> opsToReinstate = new ArrayList<Operation>();
+        List<Operation> opsToReinstate = new ArrayList<>();
         ReplaceOperation replaceOperationToReinstate = new ReplaceOperation("/withdrawn", false);
         opsToReinstate.add(replaceOperationToReinstate);
         String patchBodyToReinstate = getPatchContent(opsToReinstate);

dspace-server-webapp/src/test/resources/org/dspace/app/rest/bibtex-test-multiple-authors.bib

@@ -0,0 +1,4 @@
+@misc{ Nobody01,
+       author = "A. Nauthor and A. Nother and A. Third",
+       title = "My Article",
+       year = "2006" }

dspace/config/spring/api/bibtex-integration.xml

@@ -40,10 +40,15 @@
         <property name="key" value="journal" />
     </bean>
     
-    <bean id="bibtexAuthorsContrib" class="org.dspace.importer.external.metadatamapping.contributor.SimpleMetadataContributor">
+    <bean id="bibtexAuthorsContrib" class="org.dspace.importer.external.metadatamapping.contributor.SplitMetadataContributor">
+        <constructor-arg name="innerContributor">
+            <bean class="org.dspace.importer.external.metadatamapping.contributor.SimpleMetadataContributor">
                 <property name="field" ref="dcAuthors"/>
                 <property name="key" value="author" />
             </bean>
+        </constructor-arg>
+        <constructor-arg name="regex" value="\sand\s"/>
+    </bean>
     
     <bean id="bibtexTitleContrib" class="org.dspace.importer.external.metadatamapping.contributor.SimpleMetadataContributor">
         <property name="field" ref="dcTitle"/>

dspace/config/spring/api/external-openaire.xml

@@ -1,6 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<beans xmlns="http://www.springframework.org/schema/beans"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:util="http://www.springframework.org/schema/util"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+                           http://www.springframework.org/schema/util
+                           http://www.springframework.org/schema/util/spring-util.xsd"
        default-lazy-init="true">
 
     <bean id="openAIRERestConnector" class="org.dspace.external.OpenAIRERestConnector">
@@ -10,11 +14,11 @@
 		<property name="clientId" value="${openaire.token.clientId}"/>
 		<property name="clientSecret" value="${openaire.token.clientSecret}"/>
     </bean>
-	<bean
+
-		class="org.dspace.external.provider.impl.OpenAIREFundingDataProvider"
+	<bean class="org.dspace.external.provider.impl.OpenAIREFundingDataProvider" init-method="init">
-		init-method="init">
 		<property name="sourceIdentifier" value="openAIREFunding" />
 		<property name="connector" ref="openAIRERestConnector" />
+		<property name="metadataFields" ref="mapOfmetadata"/>
 		<property name="supportedEntityTypes">
 			<list>
 				<value>Project</value>
@@ -22,5 +26,53 @@
 		</property>
 	</bean>
 
-</beans>
+    <util:map id="mapOfmetadata"
+        map-class="java.util.HashMap" key-type="java.lang.String" value-type="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <entry key="awardNumber" value-ref="openaireAwardNumber" />
+        <entry key="fundingStream" value-ref="openaireFundingStream" />
+        <entry key="awardURI" value-ref="openaireAwardURI" />
+        <entry key="funderName" value-ref="openaireFunderName" />
+        <entry key="funderIdentifier" value-ref="openaireFunderIdentifier" />
+        <entry key="dcTitle" value-ref="openaireTitle" />
+        <entry key="titleAlternative" value-ref="openaireTitleAlternative" />
+        <entry key="coverageSpatial" value-ref="openaireSpatial" />
+        <entry key="dcSubject" value-ref="openaireSubject" />
+    </util:map>
 
+    <bean id="openaireAwardNumber" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="oaire.awardNumber"/>
+    </bean>
+
+    <bean id="openaireFundingStream" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="oaire.fundingStream"/>
+    </bean>
+    
+    <bean id="openaireAwardURI" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="oaire.awardURI"/>
+    </bean>
+
+    <bean id="openaireFunderName" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="project.funder.name"/>
+    </bean>
+
+    <bean id="openaireFunderIdentifier" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="project.funder.identifier"/>
+    </bean>
+
+    <bean id="openaireTitle" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.title"/>
+    </bean>
+
+    <bean id="openaireTitleAlternative" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.title.alternative"/>
+    </bean>
+
+    <bean id="openaireSpatial" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.coverage.spatial"/>
+    </bean>
+
+    <bean id="openaireSubject" class="org.dspace.importer.external.metadatamapping.MetadataFieldConfig">
+        <constructor-arg value="dc.subject"/>
+    </bean>
+
+</beans>

dspace/config/spring/api/requestitem.xml

@@ -8,25 +8,65 @@
            http://www.springframework.org/schema/context/spring-context-2.5.xsd"
     default-autowire-candidates="*Service,*DAO,javax.sql.DataSource">
 
+    <description>
+        Strategies for determining who receives Request Copy emails.
+        A copy request "strategy" class produces a list of addresses to which a
+        request email should be sent.  Each strategy gets its addresses from a
+        different source.  Select the one that meets your need, or use the
+        CombiningRequestItemStrategy to meld the lists from two or more other
+        strategies.
+    </description>
+
     <context:annotation-config /> <!-- allows us to use Spring annotations in beans -->
 
-    <bean class="org.dspace.app.requestitem.RequestItemMetadataStrategy"
+    <!-- Select the implementation to be used. -->
-          id="org.dspace.app.requestitem.RequestItemAuthorExtractor"
+    <alias alias='org.dspace.app.requestitem.RequestItemAuthorExtractor'
-          autowire-candidate='true'>
+           name='org.dspace.app.requestitem.RequestItemMetadataStrategy'/>
-    <!--
-        Uncomment these properties if you want lookup in metadata the email and
-        the name of the author to contact for request copy.
-        If you don't configure that or if the requested item doesn't have these
-        metadata, the submitter data are used as fail over.
 
-        <property name="emailMetadata" value="schema.element.qualifier" />
+    <!-- Get recipients from an item metadata field. -->
-        <property name="fullNameMetadata" value="schema.element.qualifier" />
+    <bean class="org.dspace.app.requestitem.RequestItemMetadataStrategy"
+          id="org.dspace.app.requestitem.RequestItemMetadataStrategy"
+          autowire-candidate="true">
+        <!-- 
+            Uncomment these properties if you want lookup in metadata the email
+            and the name of the author to contact for request copy.
+            If you don't configure that or if the requested item doesn't have
+            these metadata, the submitter data are used as fail over.
+        -->
+        <!--
+
+            <property name="emailMetadata"
+                      value="schema.element.qualifier" />
+            <property name="fullNameMetadata"
+                      value="schema.element.qualifier" />
         -->
     </bean>
 
     <!-- HelpDesk to instead get RequestItem emails-->
-    <!--<bean class="org.dspace.app.requestitem.RequestItemHelpdeskStrategy"
+    <!--
-        id="org.dspace.app.requestitem.RequestItemAuthorExtractor"
+    <bean class="org.dspace.app.requestitem.RequestItemHelpdeskStrategy"
-        autowire-candidate='true'></bean>-->
+          id="org.dspace.app.requestitem.RequestItemHelpdeskStrategy"/>
+    -->
 
+    <!-- Send request emails to administrators of an Item's owning Collection. -->
+    <!--
+    <bean class='org.dspace.app.requestitem.CollectionAdministratorsRequestItemStrategy'
+          id='org.dspace.app.requestitem.CollectionAdministratorsRequestItemStrategy'/>
+    -->
+
+    <!-- Execute multiple strategies and concatenate their lists of recipients.
+         Mail will go to all members of the combined list. -->
+    <!--
+    <bean class='org.dspace.app.requestitem.CombiningRequestItemStrategy'
+          id='org.dspace.app.requestitem.CombiningRequestItemStrategy'
+          autowire='no'>
+        <constructor-arg>
+            <description>A list of references to RequestItemAuthorExtractor beans</description>
+            <list>
+                <ref bean='org.dspace.app.requestitem.RequestItemMetadataStrategy'/>
+                <ref bean='org.dspace.app.requestitem.CollectionAdministratorsRequestItemStrategy'/>
+            </list>
+        </constructor-arg>
+    </bean>
+    -->
 </beans>