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

DSC-1075

Approved-by: Giuseppe Digilio

Author: vins01-4science

dspace-api/src/main/java/org/dspace/content/logic/InCollectionFilter.java

@@ -0,0 +1,91 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.content.logic.condition;
+
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.dspace.content.Item;
+import org.dspace.content.logic.LogicalStatementException;
+import org.dspace.content.logic.supplier.HandleSupplier;
+import org.dspace.content.service.ItemService;
+import org.dspace.core.Context;
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ * This is an {@link AbstractCondition} that checks if a given {@link Collection} of {@code handles}, contains at least
+ * one handle provided by the {@link AbstractInHandlesCondition#handleSupplier}.
+ *
+ * @author Vincenzo Mecca (vins01-4science - vincenzo.mecca at 4science.com)
+ **/
+public abstract class AbstractInHandlesCondition implements Condition {
+
+    public static Boolean isInHandles(
+        Context context, Item item, HandleSupplier handleSupplier, Collection<String> handles
+    ) {
+        return handleSupplier.getHandles(context, item)
+                             .flatMap(col ->
+                                          col.stream()
+                                             .map(handle -> handles.contains(handle))
+                                             .filter(Boolean::booleanValue)
+                                             .findFirst()
+                             )
+                             .orElse(false);
+    }
+
+    @Autowired
+    protected ItemService itemService;
+
+    protected Map<String, Object> parameters = new HashMap<>();
+    protected HandleSupplier handleSupplier;
+
+    private AbstractInHandlesCondition() {
+    }
+
+    public AbstractInHandlesCondition(HandleSupplier handleSupplier) {
+        this.handleSupplier = handleSupplier;
+    }
+
+    public AbstractInHandlesCondition(
+        HandleSupplier handleSupplier,
+        Map<String, Object> parameters
+    ) {
+        this(handleSupplier);
+        this.parameters = parameters;
+    }
+
+    /**
+     * Abstract method that retrieves the handles for the condition.
+     *
+     * @return Collection of handles in String format
+     * @param <T>
+     */
+    protected abstract <T extends Collection<String>> T getHandles();
+
+    @Override
+    public Boolean getResult(Context context, Item item) throws LogicalStatementException {
+        return isInHandles(context, item, handleSupplier, getHandles());
+    }
+
+    @Override
+    public Map<String, Object> getParameters() {
+        return parameters;
+    }
+
+    @Override
+    public void setParameters(Map<String, Object> parameters) {
+        this.parameters = parameters;
+    }
+
+    @Override
+    public void setItemService(ItemService itemService) {
+        this.itemService = itemService;
+    }
+}

dspace-api/src/main/java/org/dspace/content/logic/condition/AbstractInHandlesCondition.java

@@ -9,13 +9,15 @@
 
 import java.sql.SQLException;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.dspace.content.Collection;
 import org.dspace.content.DSpaceObject;
 import org.dspace.content.Item;
 import org.dspace.content.logic.LogicalStatementException;
+import org.dspace.content.logic.supplier.HandleSupplierFactory;
 import org.dspace.core.Context;
 
 /**
@@ -24,39 +26,50 @@
  *
  * @author Kim Shepherd
  */
-public class InCollectionCondition extends AbstractCondition {
+public class InCollectionCondition extends AbstractInHandlesCondition {
 
     private static Logger log = LogManager.getLogger(InCollectionCondition.class);
 
+    public InCollectionCondition() {
+        super(HandleSupplierFactory.getInstance().collectionHandleSupplier());
+    }
+
+    public InCollectionCondition(Map<String, Object> parameters) {
+        super(HandleSupplierFactory.getInstance().collectionHandleSupplier(), parameters);
+    }
+
+    @Override
+    public List<String> getHandles() {
+        return Optional.ofNullable(getParameters().get("collections"))
+            .map(handles -> (List<String>)handles)
+            .orElse(List.of());
+    }
+
     /**
      * Return true if item is in one of the specified collections
      * Return false if not
-     * @param context   DSpace context
-     * @param item      Item to evaluate
+     *
+     * @param context DSpace context
+     * @param item    Item to evaluate
      * @return boolean result of evaluation
      * @throws LogicalStatementException
      */
     @Override
     public Boolean getResult(Context context, Item item) throws LogicalStatementException {
+        return super.getResult(context, item) ||
+            isParentObjectInHandles(context, item) ||
+            notFound(item);
+    }
 
-        List<String> collectionHandles = (List<String>)getParameters().get("collections");
-        List<Collection> itemCollections = item.getCollections();
-        for (Collection collection : itemCollections) {
-            if (collectionHandles.contains(collection.getHandle())) {
-                log.debug("item " + item.getHandle() + " is in collection "
-                    + collection.getHandle() + ", returning true");
-                return true;
-            }
-        }
-
+    private boolean isParentObjectInHandles(Context context, Item item) {
         // Look for the parent object of the item. This is important as the item.getOwningCollection method
         // may return null, even though the item itself does have a parent object, at the point of archival
         try {
             DSpaceObject parent = itemService.getParentObject(context, item);
             if (parent != null) {
                 log.debug("Got parent DSO for item: " + parent.getID().toString());
                 log.debug("Parent DSO handle: " + parent.getHandle());
-                if (collectionHandles.contains(parent.getHandle())) {
+                if (getHandles().contains(parent.getHandle())) {
                     log.debug("item " + item.getHandle() + " is in collection "
                         + parent.getHandle() + ", returning true");
                     return true;
@@ -68,10 +81,11 @@ public Boolean getResult(Context context, Item item) throws LogicalStatementExce
             log.error("Error obtaining parent DSO", e);
             throw new LogicalStatementException(e);
         }
+        return false;
+    }
 
-        // If we reach this statement, the item did not appear in any of the collections from the parameters
+    protected boolean notFound(Item item) {
         log.debug("item " + item.getHandle() + " not found in the passed collection handle list");
-
         return false;
     }
 }