Merge remote-tracking branch 'downstream/dtq-dev' into backport-1338-to-dtq-dev

Author: kosarko

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

@@ -0,0 +1,75 @@
+/**
+ * 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.administer;
+
+import org.apache.commons.cli.Options;
+import org.dspace.scripts.configuration.ScriptConfiguration;
+
+/**
+ * The {@link ScriptConfiguration} for the {@link ItemVersionLinker} script.
+ *
+ * @author Milan Kuchtiak
+ */
+public class ItemVersionLinkerConfiguration extends ScriptConfiguration<ItemVersionLinker> {
+
+    private Class<ItemVersionLinker> dspaceRunnableClass;
+
+    /**
+     * Generic getter for the dspaceRunnableClass
+     *
+     * @return the dspaceRunnableClass value of this ScriptConfiguration
+     */
+    @Override
+    public Class<ItemVersionLinker> getDspaceRunnableClass() {
+        return dspaceRunnableClass;
+    }
+
+    /**
+     * Generic setter for the dspaceRunnableClass
+     *
+     * @param dspaceRunnableClass The dspaceRunnableClass to be set for this ScriptConfiguration
+     */
+    @Override
+    public void setDspaceRunnableClass(Class<ItemVersionLinker> dspaceRunnableClass) {
+        this.dspaceRunnableClass = dspaceRunnableClass;
+    }
+
+    /**
+     * The getter for the options of the Script
+     *
+     * @return the options value of this ScriptConfiguration
+     */
+    @Override
+    public Options getOptions() {
+        if (options == null) {
+
+            Options options = new Options();
+
+            options.addOption("h", "help", false, "help");
+
+            options.addOption("l", "link", false, "link item with the previous item");
+
+            options.addOption("u", "unlink", false, "unlink item from the previous item in version history");
+
+            options.addOption("p", "previous", true,
+                    "item handle, or UUID, of the previous(left) item that is intended to be linked with the (right)" +
+                            " item (only required for link option)");
+
+            options.addOption("i", "item", true,
+                    "item handle, or UUID, of the (right) item that is intended to be linked/unlinked with/from the " +
+                            "previous item (required for both link and unlink options)");
+            options.getOption("i").setRequired(true);
+
+            options.addOption("e", "eperson", true, "ePerson email");
+            options.getOption("e").setRequired(false);
+
+            super.options = options;
+        }
+        return options;
+    }
+}

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

@@ -21,6 +21,7 @@
 import org.dspace.authorize.service.AuthorizeService;
 import org.dspace.content.Item;
 import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
 import org.dspace.services.ConfigurationService;
 import org.springframework.beans.factory.annotation.Autowired;
 
@@ -117,10 +118,12 @@ public boolean isHidden(Context context, String schema, String element, String q
         }
 
         // The user is not administrator, but he could be a submitter
-        if (hidden && Objects.nonNull(context) && Objects.nonNull(item) &&
-                this.submitterShouldSee(schema, element, qualifier)) {
-            // the submitters override
-            hidden = !item.getSubmitter().equals(context.getCurrentUser());
+        if (hidden && Objects.nonNull(context) && Objects.nonNull(item)) {
+            EPerson submitter = item.getSubmitter();
+            if (Objects.nonNull(submitter) && this.submitterShouldSee(schema, element, qualifier)) {
+                // the submitters override
+                hidden = !submitter.equals(context.getCurrentUser());
+            }
         }
 
         return hidden;

dspace-api/src/main/java/org/dspace/app/util/MetadataExposureServiceImpl.java

@@ -41,6 +41,9 @@
 import org.dspace.services.ConfigurationService;
 import org.dspace.supervision.SupervisionOrder;
 import org.dspace.supervision.service.SupervisionOrderService;
+import org.dspace.versioning.Version;
+import org.dspace.versioning.service.VersionHistoryService;
+import org.dspace.versioning.service.VersioningService;
 import org.springframework.beans.factory.annotation.Autowired;
 
 /**
@@ -71,6 +74,10 @@ public class InstallItemServiceImpl implements InstallItemService {
     private ResourcePolicyService resourcePolicyService;
     @Autowired(required = true)
     protected ConfigurationService configurationService;
+    @Autowired(required = true)
+    protected VersioningService versioningService;
+    @Autowired(required = true)
+    protected VersionHistoryService versionHistoryService;
 
     Logger log = LogManager.getLogger(InstallItemServiceImpl.class);
 
@@ -108,6 +115,8 @@ public Item installItem(Context c, InProgressSubmission is,
         // Finish up / archive the item
         item = finishItem(c, item, is);
 
+        fixRelationMetadata(c, item);
+
         // As this is a BRAND NEW item, as a final step we need to remove the
         // submitter item policies created during deposit and replace them with
         // the default policies from the collection.
@@ -410,4 +419,64 @@ private void createResourcePolicy(Context context, Item item, int action) throws
         context.restoreAuthSystemState();
     }
 
+    /**
+     * This method adds the "dc.relation.isreplacedby" metadata field to the previous item, if exists.
+     *
+     * @param c Context
+     * @param item Item being installed
+     * @throws SQLException If there is an issue interacting with the database.
+     */
+    private void fixRelationMetadata(Context c, Item item) throws SQLException, AuthorizeException {
+        String dcRelationReplaces = itemService.getMetadataFirstValue(item, "dc", "relation", "replaces", Item.ANY);
+        if (dcRelationReplaces == null) {
+            // nothing need to be done if the new item doesn't have "dc.relation.replaces" metadata field
+            return;
+        }
+        Version itemVersion = versioningService.getVersion(c, item);
+        if (itemVersion != null) {
+            Version previousItemVersion =
+                    versionHistoryService.getPrevious(c, itemVersion.getVersionHistory(), itemVersion);
+            if (previousItemVersion != null) {
+                Item previousItem = previousItemVersion.getItem();
+                if (previousItem != null) {
+                    String previousIdentifierUri =
+                            itemService.getMetadataFirstValue(previousItem, "dc", "identifier", "uri", Item.ANY);
+                    if (dcRelationReplaces.equals(previousIdentifierUri)) {
+                        // set "dc.relation.isreplacedby" metadata field to the previous item,
+                        // pointing to the handle of the new item
+                        // reload the previous item to avoid "detached entity" error
+                        // when updating it in the setIsReplacedByMetadata() method
+                        setIsReplacedByMetadata(c, c.reloadEntity(previousItem), item);
+                    }
+                }
+            }
+        }
+    }
+
+    private void setIsReplacedByMetadata(Context c, Item previousItem, Item newItem)
+            throws SQLException, AuthorizeException {
+        String identifierUri = itemService.getMetadataFirstValue(newItem, "dc", "identifier","uri", Item.ANY);
+        if (StringUtils.isBlank(identifierUri)) {
+            log.warn("The new item (id: {}) doesn't have the metadata dc.identifier.uri, " +
+                            "so it's not possible to add dc.relation.isreplacedby to the previous item",
+                    newItem.getID());
+        } else {
+            boolean isReplacedByAlreadyExists =
+                    itemService.getMetadata(previousItem, "dc", "relation", "isreplacedby", Item.ANY)
+                            .stream()
+                            .anyMatch(m -> identifierUri.equals(m.getValue()));
+            if (!isReplacedByAlreadyExists) {
+                itemService.addMetadata(c, previousItem, "dc", "relation", "isreplacedby", null, identifierUri);
+                try {
+                    c.turnOffAuthorisationSystem();
+                    itemService.update(c, previousItem);
+                } catch (AuthorizeException e) {
+                    throw new SQLException("Unable to update previous item after adding dc.relation.isreplacedby", e);
+                } finally {
+                    c.restoreAuthSystemState();
+                }
+            }
+        }
+    }
+
 }

dspace-api/src/main/java/org/dspace/content/InstallItemServiceImpl.java

@@ -155,21 +155,26 @@ public List<PreviewContent> findAll(Context context) throws SQLException {
     @Override
     public boolean canPreview(Context context, Bitstream bitstream, boolean authorization)
             throws SQLException, AuthorizeException {
-        try {
-            // Check it is allowed by configuration
-            boolean isAllowedByCfg = configurationService.getBooleanProperty("file.preview.enabled", true);
-            if (!isAllowedByCfg) {
-                return false;
-            }
-
-            // Check it is allowed by license
-            if (authorization) {
+        // Check it is allowed by configuration
+        boolean isAllowedByCfg = configurationService.getBooleanProperty("file.preview.enabled", true);
+        if (!isAllowedByCfg) {
+            return false;
+        }
+        if (authorization) {
+            // Verify that bitstream policy allows user to READ the bitstream.
+            // If not, the preview content is disabled.
+            try {
                 authorizeService.authorizeAction(context, bitstream, Constants.READ);
+            } catch (AuthorizeException e) {
+                // In case the license agreement(for bitstream downloading) is needed,
+                // the MissingLicenseAgreementException, that extends AuthorizeException, is thrown.
+                // For this case we also disable the content preview.
+                // Otherwise, user could see the content of some files without accepting the agreement,
+                // which could cause a security issue.
+                return false;
             }
-            return true;
-        } catch (MissingLicenseAgreementException e) {
-            return false;
         }
+        return true;
     }
 
     @Override
@@ -178,13 +183,16 @@ public List<FileInfo> getFilePreviewContent(Context context, Bitstream bitstream
         File file = null;
 
         try {
-            file = bitstreamService.retrieveFile(context, bitstream, false); // Retrieve the file
+            file = bitstreamService.retrieveFile(context, bitstream, true); // Retrieve the file
 
             if (Objects.nonNull(file)) {
                 fileInfos = processFileToFilePreview(context, bitstream, file);
             }
         } catch (MissingLicenseAgreementException e) {
-            log.error("Missing license agreement: ", e);
+            log.warn("File Preview disabled: Missing license agreement!");
+            throw e;
+        } catch (AuthorizeException e) {
+            log.warn("File Preview disabled: Authorization error!");
             throw e;
         } catch (IOException e) {
             log.error("IOException during file processing: ", e);