fix pagination

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

@@ -711,8 +711,16 @@ public class RelationshipServiceImpl implements RelationshipService {
 
     @Override
     public List<Relationship> findByItemAndRelationshipTypeAndList(Context context, UUID focusUUID,
-            RelationshipType relationshipType, List<UUID> items, boolean isLeft) throws SQLException {
+            RelationshipType relationshipType, List<UUID> items, boolean isLeft,
+            int offset, int limit) throws SQLException {
         return relationshipDAO
-               .findByItemAndRelationshipTypeAndList(context, focusUUID, relationshipType, items, isLeft);
+               .findByItemAndRelationshipTypeAndList(context, focusUUID, relationshipType, items, isLeft, offset,limit);
+    }
+
+    @Override
+    public int countByItemAndRelationshipTypeAndList(Context context, UUID focusUUID, RelationshipType relationshipType,
+            List<UUID> items, boolean isLeft) throws SQLException {
+        return relationshipDAO
+               .countByItemAndRelationshipTypeAndList(context, focusUUID, relationshipType, items, isLeft);
     }
 }

dspace-api/src/main/java/org/dspace/content/dao/RelationshipDAO.java

@@ -218,6 +218,28 @@ public interface RelationshipDAO extends GenericDAO<Relationship> {
             throws SQLException;
 
     /**
+     * This method is used to retrieve relationships that match focusItem
+     * on the one hand and matches list of related items elsewhere.
+     *
+     * @param context            DSpace context object
+     * @param focusUUID          UUID of Item that will match left side if the param isLeft is true otherwise right side
+     * @param relationshipType   Relationship type to filter by
+     * @param items              List of UUID that will use to filter other side respect the focusUUID
+     * @param isLeft             Indicating whether the counted Relationships should have
+     *                           the given Item on the left side or not
+     * @param limit              paging limit
+     * @param offset             paging offset
+     * @return
+     * @throws SQLException      If database error
+     */
+    List<Relationship> findByItemAndRelationshipTypeAndList(Context context, UUID focusUUID,
+            RelationshipType relationshipType, List<UUID> items, boolean isLeft,
+            int offset, int limit) throws SQLException;
+
+    /**
+     * Count total number of relationships that match focusItem
+     * on the one hand and matches list of related items elsewhere.
+     *
      * @param context            DSpace context object
      * @param focusUUID          UUID of Item that will match left side if the param isLeft is true otherwise right side
      * @param relationshipType   Relationship type to filter by
@@ -227,6 +249,6 @@ public interface RelationshipDAO extends GenericDAO<Relationship> {
      * @return
      * @throws SQLException      If database error
      */
-    List<Relationship> findByItemAndRelationshipTypeAndList(Context context, UUID focusUUID,
+    int countByItemAndRelationshipTypeAndList(Context context, UUID focusUUID, RelationshipType relationshipType,
-            RelationshipType relationshipType, List<UUID> items, boolean isLeft) throws SQLException;
+                                               List<UUID> items, boolean isLeft) throws SQLException;
 }

dspace-api/src/main/java/org/dspace/content/dao/impl/RelationshipDAOImpl.java

@@ -268,7 +268,8 @@ public class RelationshipDAOImpl extends AbstractHibernateDAO<Relationship> impl
 
     @Override
     public List<Relationship> findByItemAndRelationshipTypeAndList(Context context, UUID focusUUID,
-            RelationshipType relationshipType, List<UUID> items, boolean isLeft) throws SQLException {
+            RelationshipType relationshipType, List<UUID> items, boolean isLeft,
+            int offset, int limit) throws SQLException {
         String side = isLeft ? "left_id" : "right_id";
         String otherSide = !isLeft ? "left_id" : "right_id";
         Query query = createQuery(context, "FROM " + Relationship.class.getSimpleName() +
@@ -278,7 +279,23 @@ public class RelationshipDAOImpl extends AbstractHibernateDAO<Relationship> impl
         query.setParameter("typeId", relationshipType.getID());
         query.setParameter("focusUUID", focusUUID);
         query.setParameter("list", items);
-        return list(query);
+        return list(query, limit, offset);
+    }
+
+    @Override
+    public int countByItemAndRelationshipTypeAndList(Context context, UUID focusUUID, RelationshipType relationshipType,
+            List<UUID> items, boolean isLeft) throws SQLException {
+        String side = isLeft ? "left_id" : "right_id";
+        String otherSide = !isLeft ? "left_id" : "right_id";
+        Query query = createQuery(context, "SELECT count(*) " +
+                                           "FROM " + Relationship.class.getSimpleName() +
+                                          " WHERE type_id = (:typeId) " +
+                                           "AND " + side + " = (:focusUUID) " +
+                                           "AND " + otherSide + " in (:list)");
+        query.setParameter("typeId", relationshipType.getID());
+        query.setParameter("focusUUID", focusUUID);
+        query.setParameter("list", items);
+        return count(query);
     }
 
 }

dspace-api/src/main/java/org/dspace/content/service/RelationshipService.java

@@ -338,6 +338,28 @@ public interface RelationshipService extends DSpaceCRUDService<Relationship> {
         throws SQLException, AuthorizeException;
 
     /**
+     * This method is used to retrieve relationships that match focusItem
+     * on the one hand and matches list of related items elsewhere.
+     *
+     * @param context            DSpace context object
+     * @param focusUUID          UUID of Item that will match left side if the param isLeft is true otherwise right side
+     * @param relationshipType   Relationship type to filter by
+     * @param items              List of UUID that will use to filter other side respect the focusUUID
+     * @param isLeft             Indicating whether the counted Relationships should have
+     *                           the given Item on the left side or not
+     * @param limit              paging limit
+     * @param offset             paging offset
+     * @return
+     * @throws SQLException      If database error
+     */
+    public List<Relationship> findByItemAndRelationshipTypeAndList(Context context, UUID focusUUID,
+                RelationshipType relationshipType, List<UUID> items, boolean isLeft,
+                int offset, int limit) throws SQLException;
+
+    /**
+     * Count total number of relationships that match focusItem
+     * on the one hand and matches list of related items elsewhere.
+     *
      * @param context            DSpace context object
      * @param focusUUID          UUID of Item that will match left side if the param isLeft is true otherwise right side
      * @param relationshipType   Relationship type to filter by
@@ -347,7 +369,7 @@ public interface RelationshipService extends DSpaceCRUDService<Relationship> {
      * @return
      * @throws SQLException      If database error
      */
-    public List<Relationship> findByItemAndRelationshipTypeAndList(Context context, UUID focusUUID,
+    public int countByItemAndRelationshipTypeAndList(Context context, UUID focusUUID, RelationshipType relationshipType,
-                RelationshipType relationshipType, List<UUID> items, boolean isLeft) throws SQLException;
+                                                     List<UUID> items, boolean isLeft) throws SQLException;
 
 }

dspace-api/src/main/java/org/dspace/core/AbstractHibernateDAO.java

@@ -204,6 +204,22 @@ public abstract class AbstractHibernateDAO<T> implements GenericDAO<T> {
         return result;
     }
 
+    /**
+     * This method will return a list of results for the given Query and parameters
+     * 
+     * @param query     The query for which the resulting list will be returned
+     * @param limit     The maximum amount of results to be returned
+     * @param offset    The offset to be used for the Query
+     * @return          A list of results determined by the Query and parameters
+     */
+    public List<T> list(Query query, int limit, int offset) {
+        query.setFirstResult(offset);
+        query.setMaxResults(limit);
+        @SuppressWarnings("unchecked")
+        List<T> result = (List<T>) query.getResultList();
+        return result;
+    }
+
     /**
      * Retrieve a unique result from the query.  If multiple results CAN be
      * retrieved an exception will be thrown, so only use when the criteria

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

@@ -379,6 +379,7 @@ public class RelationshipRestRepository extends DSpaceRestRepository<Relationshi
                                             @Parameter(value = "relatedItem", required = true) Set<UUID> items,
                                              Pageable pageable) throws SQLException {
         Context context = obtainContext();
+        int total = 0;
         List<Relationship> relationships = new LinkedList<>();
         RelationshipType relationshipType = relationshipTypeService.find(context, typeId);
         if (Objects.nonNull(relationshipType)) {
@@ -388,10 +389,14 @@ public class RelationshipRestRepository extends DSpaceRestRepository<Relationshi
                                                        " , does not match any relation!");
             }
             relationships = relationshipService.findByItemAndRelationshipTypeAndList(context, focusUUID,
-                       relationshipType, new ArrayList<UUID>(items), relationshipType.getLeftwardType().equals(label));
+                       relationshipType, new ArrayList<UUID>(items), relationshipType.getLeftwardType().equals(label),
+                       Math.toIntExact(pageable.getOffset()),
+                       Math.toIntExact(pageable.getPageSize()));
 
+            total = relationshipService.countByItemAndRelationshipTypeAndList(context, focusUUID,
+                       relationshipType, new ArrayList<UUID>(items), relationshipType.getLeftwardType().equals(label));
         }
-        return converter.toRestPage(relationships, pageable, utils.obtainProjection());
+        return converter.toRestPage(relationships, pageable, total, utils.obtainProjection());
     }
 
 }