[CST-7756] removed subscriptions for items

dspace-api/src/main/java/org/dspace/eperson/FrequencyType.java

@@ -0,0 +1,38 @@
+/**
+ * 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.eperson;
+
+import java.util.Arrays;
+
+import org.apache.commons.codec.binary.StringUtils;
+
+public enum FrequencyType {
+    DAY("D"),
+    WEEK("W"),
+    MONTH("M");
+
+    private String shortName;
+
+    private FrequencyType(String shortName) {
+        this.shortName = shortName;
+    }
+
+    public static boolean isSupportedFrequencyType(String value) {
+        for (FrequencyType ft : Arrays.asList(FrequencyType.values())) {
+            if (StringUtils.equals(ft.getShortName(), value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public String getShortName() {
+        return shortName;
+    }
+
+}

dspace-api/src/main/java/org/dspace/eperson/SubscribeServiceImpl.java

@@ -152,15 +152,13 @@ public class SubscribeServiceImpl implements SubscribeService {
     }
 
     @Override
-    public Subscription updateSubscription(Context context, Integer id, EPerson eperson, DSpaceObject dSpaceObject,
+    public Subscription updateSubscription(Context context, Integer id, String subscriptionType,
-                                           List<SubscriptionParameter> subscriptionParameterList, String type)
+                                           List<SubscriptionParameter> subscriptionParameterList)
                                            throws SQLException {
         Subscription subscriptionDB = subscriptionDAO.findByID(context, Subscription.class, id);
         subscriptionDB.removeParameterList();
-        subscriptionDB.setSubscriptionType(type);
+        subscriptionDB.setSubscriptionType(subscriptionType);
-        subscriptionDB.setDSpaceObject(dSpaceObject);
         subscriptionParameterList.forEach(x -> subscriptionDB.addParameter(x));
-        subscriptionDB.setEPerson(eperson);
         subscriptionDAO.save(context, subscriptionDB);
         return subscriptionDB;
     }

dspace-api/src/main/java/org/dspace/eperson/service/SubscribeService.java

@@ -159,14 +159,12 @@ public interface SubscribeService {
      *
      * @param context                   DSpace context
      * @param id                        Integer id
-     * @param eperson                   EPerson eperson
-     * @param dSpaceObject              DSpaceObject dSpaceObject
      * @param subscriptionParameterList List<SubscriptionParameter>  subscriptionParameterList
-     * @param type                      String  type
+     * @param subscriptionType          type
      * @throws SQLException An exception that provides information on a database access error or other errors.
      */
-    public Subscription updateSubscription(Context context, Integer id, EPerson eperson, DSpaceObject dSpaceObject,
+    public Subscription updateSubscription(Context context, Integer id, String subscriptionType,
-            List<SubscriptionParameter> subscriptionParameterList, String type) throws SQLException;
+            List<SubscriptionParameter> subscriptionParameterList) throws SQLException;
 
     /**
      * Adds a parameter to a subscription

dspace-api/src/main/java/org/dspace/subscriptions/ContentGenerator.java

@@ -51,8 +51,7 @@ public class ContentGenerator implements SubscriptionGenerator<IndexableObject>
     @Override
     public void notifyForSubscriptions(Context context, EPerson ePerson,
                                        List<IndexableObject> indexableComm,
-                                       List<IndexableObject> indexableColl,
+                                       List<IndexableObject> indexableColl) {
-                                       List<IndexableObject> indexableItems) {
         try {
             if (Objects.nonNull(ePerson)) {
                 Locale supportedLocale = I18nUtil.getEPersonLocale(ePerson);
@@ -60,7 +59,6 @@ public class ContentGenerator implements SubscriptionGenerator<IndexableObject>
                 email.addRecipient(ePerson.getEmail());
                 email.addArgument(generateBodyMail(context, indexableComm));
                 email.addArgument(generateBodyMail(context, indexableColl));
-                email.addArgument(generateBodyMail(context, indexableItems));
                 email.send();
             }
         } catch (Exception e) {

dspace-api/src/main/java/org/dspace/subscriptions/SubscriptionEmailNotification.java

@@ -9,13 +9,13 @@ package org.dspace.subscriptions;
 
 import java.sql.SQLException;
 import java.util.Objects;
-import java.util.Set;
 import java.util.UUID;
 
 import org.apache.commons.cli.ParseException;
 import org.apache.commons.lang3.StringUtils;
 import org.dspace.core.Context;
 import org.dspace.eperson.EPerson;
+import org.dspace.eperson.FrequencyType;
 import org.dspace.eperson.factory.EPersonServiceFactory;
 import org.dspace.scripts.DSpaceRunnable;
 import org.dspace.utils.DSpace;
@@ -52,10 +52,10 @@ public class SubscriptionEmailNotification
         if (StringUtils.isBlank(frequencyOption)) {
             throw new IllegalArgumentException("Option frequency f must be set");
         }
-        Set<String> supportedValues = subscriptionEmailNotificationService
+
-                                                 .getSubscriptionParameterValuesByName("frequency");
+        if (!FrequencyType.isSupportedFrequencyType(frequencyOption)) {
-        if (!supportedValues.contains(frequencyOption)) {
+            throw new IllegalArgumentException(
-            throw new IllegalArgumentException("Option f must be one of following values:" + supportedValues);
+                    "Option f must be one of following values D(Day), W(Week) or M(Month)");
         }
         subscriptionEmailNotificationService.perform(getContext(), handler, "content", frequencyOption);
     }

dspace-api/src/main/java/org/dspace/subscriptions/SubscriptionEmailNotificationService.java

@@ -21,8 +21,4 @@ public interface SubscriptionEmailNotificationService {
 
     public Set<String> getSupportedSubscriptionTypes();
 
-    public boolean isSupportedSubscriptionParameterName(String name);
-
-    public Set<String> getSubscriptionParameterValuesByName(String name);
-
 }

dspace-api/src/main/java/org/dspace/subscriptions/SubscriptionEmailNotificationServiceImpl.java

@@ -9,11 +9,9 @@ package org.dspace.subscriptions;
 
 import static org.dspace.core.Constants.COLLECTION;
 import static org.dspace.core.Constants.COMMUNITY;
-import static org.dspace.core.Constants.ITEM;
 
 import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
@@ -26,7 +24,6 @@ import org.apache.logging.log4j.Logger;
 import org.dspace.content.Collection;
 import org.dspace.content.Community;
 import org.dspace.content.DSpaceObject;
-import org.dspace.content.Item;
 import org.dspace.core.Context;
 import org.dspace.discovery.IndexableObject;
 import org.dspace.eperson.Subscription;
@@ -46,13 +43,6 @@ public class SubscriptionEmailNotificationServiceImpl implements SubscriptionEma
 
     private static final Logger log = LogManager.getLogger(SubscriptionEmailNotificationServiceImpl.class);
 
-    /**
-     * The map contains supported {SubscriptionParameter}
-     * into the key configured {SubscriptionParameter.name}
-     * instead into value configured a set of values {SubscriptionParameter.value}
-     * related to {SubscriptionParameter.name}
-     */
-    private Map<String, Set<String>> param2values = new HashMap<>();
     private Map<String, DSpaceObjectUpdates> contentUpdates = new HashMap<>();
     @SuppressWarnings("rawtypes")
     private Map<String, SubscriptionGenerator> subscriptionType2generators = new HashMap<>();
@@ -61,17 +51,14 @@ public class SubscriptionEmailNotificationServiceImpl implements SubscriptionEma
     private SubscribeService subscribeService;
 
     @SuppressWarnings("rawtypes")
-    public SubscriptionEmailNotificationServiceImpl(Map<String, Set<String>> param2values,
+    public SubscriptionEmailNotificationServiceImpl(Map<String, DSpaceObjectUpdates> contentUpdates,
-                                                    Map<String, DSpaceObjectUpdates> contentUpdates,
                                                     Map<String, SubscriptionGenerator> subscriptionType2generators) {
-        this.param2values = param2values;
         this.contentUpdates = contentUpdates;
         this.subscriptionType2generators = subscriptionType2generators;
     }
 
     @SuppressWarnings({ "rawtypes", "unchecked" })
     public void perform(Context context, DSpaceRunnableHandler handler, String subscriptionType, String frequency) {
-        List<IndexableObject> items = new ArrayList<>();
         List<IndexableObject> communities = new ArrayList<>();
         List<IndexableObject> collections = new ArrayList<>();
         try {
@@ -90,9 +77,6 @@ public class SubscriptionEmailNotificationServiceImpl implements SubscriptionEma
                     } else if (dSpaceObject.getType() == COLLECTION) {
                         collections.addAll(contentUpdates.get(Collection.class.getSimpleName())
                                                          .findUpdates(context, dSpaceObject, frequency));
-                    } else if (dSpaceObject.getType() == ITEM) {
-                        items.addAll(contentUpdates.get(Item.class.getSimpleName())
-                                                   .findUpdates(context, dSpaceObject, frequency));
                     }
 
                     var ePerson = subscription.getEPerson();
@@ -103,15 +87,14 @@ public class SubscriptionEmailNotificationServiceImpl implements SubscriptionEma
                             continue;
                         } else {
                             subscriptionType2generators.get(subscriptionType)
-                                      .notifyForSubscriptions(context, ePerson, communities, collections, items);
+                                      .notifyForSubscriptions(context, ePerson, communities, collections);
                             communities.clear();
                             collections.clear();
-                            items.clear();
                         }
                     } else {
                         //in the end of the iteration
                         subscriptionType2generators.get(subscriptionType)
-                                        .notifyForSubscriptions(context, ePerson, communities, collections, items);
+                                        .notifyForSubscriptions(context, ePerson, communities, collections);
                     }
                     iterator++;
                 }
@@ -154,14 +137,4 @@ public class SubscriptionEmailNotificationServiceImpl implements SubscriptionEma
         return subscriptionType2generators.keySet();
     }
 
-    @Override
-    public Set<String> getSubscriptionParameterValuesByName(String name) {
-        return param2values.containsKey(name) ? param2values.get(name) : Collections.emptySet();
-    }
-
-    @Override
-    public boolean isSupportedSubscriptionParameterName(String name) {
-        return param2values.containsKey(name);
-    }
-
 }

dspace-api/src/main/java/org/dspace/subscriptions/dSpaceObjectsUpdates/ItemUpdates.java

@@ -1,193 +0,0 @@
-/**
- * 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.subscriptions.dSpaceObjectsUpdates;
-
-import static org.apache.commons.lang3.StringUtils.trimToEmpty;
-
-import java.sql.SQLException;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.UUID;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.dspace.content.DSpaceObject;
-import org.dspace.content.Item;
-import org.dspace.content.service.CollectionService;
-import org.dspace.content.service.CommunityService;
-import org.dspace.content.service.ItemService;
-import org.dspace.core.Context;
-import org.dspace.discovery.DiscoverQuery;
-import org.dspace.discovery.DiscoverResult;
-import org.dspace.discovery.IndexableObject;
-import org.dspace.discovery.SearchService;
-import org.dspace.discovery.configuration.DiscoveryConfiguration;
-import org.dspace.discovery.configuration.DiscoveryConfigurationService;
-import org.dspace.discovery.configuration.DiscoveryRelatedItemConfiguration;
-import org.dspace.discovery.configuration.DiscoverySortConfiguration;
-import org.dspace.discovery.configuration.DiscoverySortFieldConfiguration;
-import org.dspace.discovery.configuration.DiscoverySortFunctionConfiguration;
-import org.dspace.discovery.indexobject.IndexableCollection;
-import org.dspace.discovery.indexobject.IndexableCommunity;
-import org.dspace.discovery.indexobject.IndexableItem;
-import org.dspace.subscriptions.service.DSpaceObjectUpdates;
-
-/**
- * Class which will be used to find
- * all item objects updated related with subscribed DSO
- *
- * @author Alba Aliu
- */
-public class ItemUpdates implements DSpaceObjectUpdates {
-
-    private final Logger log = LogManager.getLogger(ItemUpdates.class);
-
-    private final CollectionService collectionService;
-    private final CommunityService communityService;
-    private final ItemService itemService;
-    private DiscoveryConfigurationService searchConfigurationService;
-    private SearchService searchService;
-
-    @Override
-    @SuppressWarnings("rawtypes")
-    public List<IndexableObject> findUpdates(Context context, DSpaceObject dSpaceObject, String frequency) {
-        List<IndexableObject> list = new ArrayList<>();
-        // entity type found
-        String inverseRelationName = "RELATION." + itemService.getEntityTypeLabel((Item) dSpaceObject);
-        List<DiscoveryConfiguration> discoveryConfigurationList =
-                searchConfigurationService.getDiscoveryConfigurationWithPrefixName(inverseRelationName);
-        DiscoverQuery discoverQuery = null;
-        DiscoverResult searchResult = null;
-        IndexableObject indexableObject = resolveScope(context, dSpaceObject.getID().toString());
-        try {
-            for (DiscoveryConfiguration discoveryConfiguration : discoveryConfigurationList) {
-                discoverQuery = buildDiscoveryQuery(discoveryConfiguration, indexableObject);
-                discoverQuery.addFilterQueries("lastModified_dt:" + this.findLastFrequency(frequency));
-                searchResult = searchService.search(context, discoverQuery);
-                list.addAll(searchResult.getIndexableObjects());
-            }
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
-        }
-        return list;
-    }
-
-    private IndexableObject<?, ?> resolveScope(Context context, String scope) {
-        IndexableObject<?, ?> scopeObj = null;
-        if (StringUtils.isBlank(scope)) {
-            return scopeObj;
-        }
-        try {
-            UUID uuid = UUID.fromString(scope);
-            scopeObj = new IndexableCommunity(communityService.find(context, uuid));
-            if (scopeObj.getIndexedObject() == null) {
-                scopeObj = new IndexableCollection(collectionService.find(context, uuid));
-            }
-            if (scopeObj.getIndexedObject() == null) {
-                scopeObj = new IndexableItem(itemService.find(context, uuid));
-            }
-        } catch (IllegalArgumentException e) {
-            log.error("The given scope string " + trimToEmpty(scope) + " is not a UUID");
-        } catch (SQLException e) {
-            log.error("Unable to retrieve DSpace Object with ID " + trimToEmpty(scope) + " from the database");
-        }
-        return scopeObj;
-    }
-
-    private DiscoverQuery buildDiscoveryQuery(DiscoveryConfiguration discoveryConfiguration, IndexableObject<?,?> scope)
-            throws SQLException {
-        DiscoverQuery discoverQuery = buildBaseQuery(discoveryConfiguration, scope);
-        discoverQuery.addDSpaceObjectFilter(IndexableItem.TYPE);
-        configureSorting(discoverQuery, discoveryConfiguration.getSearchSortConfiguration(), scope);
-        return discoverQuery;
-    }
-
-    @SuppressWarnings("rawtypes")
-    private void configureSorting(DiscoverQuery queryArgs, DiscoverySortConfiguration searchSortConfiguration,
-                                  final IndexableObject scope) {
-        String sortBy = getDefaultSortField(searchSortConfiguration);
-        String sortOrder = getDefaultSortDirection(searchSortConfiguration);
-        //Update Discovery query
-        DiscoverySortFieldConfiguration sortFieldConfiguration = searchSortConfiguration
-                .getSortFieldConfiguration(sortBy);
-
-        if (Objects.nonNull(sortFieldConfiguration)) {
-            String sortField;
-            if (DiscoverySortFunctionConfiguration.SORT_FUNCTION.equals(sortFieldConfiguration.getType())) {
-                sortField = MessageFormat.format(
-                            ((DiscoverySortFunctionConfiguration) sortFieldConfiguration).getFunction(scope.getID()),
-                            scope.getID());
-            } else {
-                var type = sortFieldConfiguration.getType();
-                var metadataField = sortFieldConfiguration.getMetadataField();
-                sortField = searchService.toSortFieldIndex(metadataField, type);
-            }
-
-            if ("asc".equalsIgnoreCase(sortOrder)) {
-                queryArgs.setSortField(sortField, DiscoverQuery.SORT_ORDER.asc);
-            } else if ("desc".equalsIgnoreCase(sortOrder)) {
-                queryArgs.setSortField(sortField, DiscoverQuery.SORT_ORDER.desc);
-            } else {
-                log.error(sortOrder + " is not a valid sort order");
-            }
-
-        } else {
-            log.error(sortBy + " is not a valid sort field");
-        }
-    }
-
-    private String getDefaultSortDirection(DiscoverySortConfiguration searchSortConfiguration) {
-        return searchSortConfiguration.getSortFields().iterator().next().getDefaultSortOrder().toString();
-    }
-
-    private String getDefaultSortField(DiscoverySortConfiguration searchSortConfiguration) {
-        String sortBy;// Attempt to find the default one, if none found we use SCORE
-        sortBy = "score";
-        if (Objects.nonNull(searchSortConfiguration.getSortFields()) &&
-                !searchSortConfiguration.getSortFields().isEmpty()) {
-            DiscoverySortFieldConfiguration defaultSort = searchSortConfiguration.getSortFields().get(0);
-            if (org.apache.commons.lang.StringUtils.isBlank(defaultSort.getMetadataField())) {
-                return sortBy;
-            }
-            sortBy = defaultSort.getMetadataField();
-        }
-        return sortBy;
-    }
-
-    private DiscoverQuery buildBaseQuery(DiscoveryConfiguration discoveryConfiguration, IndexableObject<?, ?> scope) {
-        DiscoverQuery discoverQuery = new DiscoverQuery();
-        if (Objects.isNull(discoveryConfiguration)) {
-            return discoverQuery;
-        }
-
-        discoverQuery.setDiscoveryConfigurationName(discoveryConfiguration.getId());
-        List<String> filterQueries = discoveryConfiguration.getDefaultFilterQueries();
-
-        for (String filterQuery : filterQueries) {
-            if (discoveryConfiguration instanceof DiscoveryRelatedItemConfiguration) {
-                discoverQuery.addFilterQueries(MessageFormat.format(filterQuery, scope.getID()));
-            } else {
-                discoverQuery.addFilterQueries(filterQuery);
-            }
-        }
-        return discoverQuery;
-    }
-
-    public ItemUpdates(CollectionService collectionService, CommunityService communityService, ItemService itemService,
-                        DiscoveryConfigurationService searchConfigurationService, SearchService searchService) {
-        this.collectionService = collectionService;
-        this.communityService = communityService;
-        this.itemService = itemService;
-        this.searchConfigurationService = searchConfigurationService;
-        this.searchService = searchService;
-    }
-
-}

dspace-api/src/main/java/org/dspace/subscriptions/service/SubscriptionGenerator.java

@@ -20,6 +20,6 @@ import org.dspace.eperson.EPerson;
  */
 public interface SubscriptionGenerator<T> {
 
-    public void notifyForSubscriptions(Context c, EPerson ePerson, List<T> comm, List<T> coll, List<T> items);
+    public void notifyForSubscriptions(Context c, EPerson ePerson, List<T> comm, List<T> coll);
 
 }

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

@@ -9,6 +9,8 @@ package org.dspace.app.rest.repository;
 
 import static org.dspace.app.rest.model.SubscriptionRest.CATEGORY;
 import static org.dspace.app.rest.model.SubscriptionRest.NAME;
+import static org.dspace.core.Constants.COLLECTION;
+import static org.dspace.core.Constants.COMMUNITY;
 
 import java.io.IOException;
 import java.sql.SQLException;
@@ -24,6 +26,7 @@ import javax.ws.rs.BadRequestException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.dspace.app.rest.DiscoverableEndpointsService;
 import org.dspace.app.rest.Parameter;
 import org.dspace.app.rest.SearchRestMethod;
@@ -33,11 +36,10 @@ import org.dspace.app.rest.model.SubscriptionParameterRest;
 import org.dspace.app.rest.model.SubscriptionRest;
 import org.dspace.app.rest.utils.DSpaceObjectUtils;
 import org.dspace.authorize.AuthorizeException;
-import org.dspace.authorize.service.AuthorizeService;
 import org.dspace.content.DSpaceObject;
-import org.dspace.core.Constants;
 import org.dspace.core.Context;
 import org.dspace.eperson.EPerson;
+import org.dspace.eperson.FrequencyType;
 import org.dspace.eperson.Subscription;
 import org.dspace.eperson.SubscriptionParameter;
 import org.dspace.eperson.service.EPersonService;
@@ -66,8 +68,6 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
     @Autowired
     private EPersonService ePersonService;
     @Autowired
-    private AuthorizeService authorizeService;
-    @Autowired
     private SubscribeService subscribeService;
     @Autowired
     private DSpaceObjectUtils dspaceObjectUtil;
@@ -103,7 +103,7 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
     }
 
     @SearchRestMethod(name = "findByEPerson")
-    @PreAuthorize("hasPermission(#epersonId, 'AdminOrOwner', 'READ')")
+    @PreAuthorize("hasPermission(#epersonId, 'EPERSON', 'READ')")
     public Page<SubscriptionRest> findSubscriptionsByEPerson(@Parameter(value = "uuid", required = true) UUID epersonId,
                                                               Pageable pageable) throws Exception {
         Long total = null;
@@ -122,7 +122,7 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
     }
 
     @SearchRestMethod(name = "findByEPersonAndDso")
-    @PreAuthorize("hasPermission(#epersonId, 'AdminOrOwner', 'READ')")
+    @PreAuthorize("hasPermission(#epersonId, 'EPERSON', 'READ')")
     public Page<SubscriptionRest> findByEPersonAndDso(@Parameter(value = "eperson_id", required = true) UUID epersonId,
                                                       @Parameter(value = "resource",required = true) UUID dsoId,
                                                        Pageable pageable) throws Exception {
@@ -143,6 +143,7 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
     }
 
     @Override
+    @PreAuthorize("@subscriptionSecurity.isEnabelToCreateSubscription(#context) && hasAuthority('AUTHENTICATED')")
     protected SubscriptionRest createAndReturn(Context context) throws SQLException, AuthorizeException {
         HttpServletRequest req = getRequestService().getCurrentRequest().getHttpServletRequest();
         String epersonId = req.getParameter("eperson_id");
@@ -159,31 +160,23 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
                 throw new BadRequestException("Id of person or dspace object must represents reals ids");
             }
 
-            // user must have read permissions to dataspace object
+            if (dSpaceObject.getType() == COMMUNITY || dSpaceObject.getType() == COLLECTION) {
-            if (!authorizeService.authorizeActionBoolean(context, ePerson, dSpaceObject,  Constants.READ, true)) {
+                Subscription subscription = null;
-                throw new AuthorizeException("The user has not READ rights on this DSO");
+                ServletInputStream input = req.getInputStream();
-            }
+                SubscriptionRest subscriptionRest = new ObjectMapper().readValue(input, SubscriptionRest.class);
-
+                List<SubscriptionParameterRest> subscriptionParameterList = subscriptionRest
-            // if user is admin do not make this control,
+                        .getSubscriptionParameterList();
-            // otherwise make this control because normal user can only subscribe with their own ID of user.
+                if (CollectionUtils.isNotEmpty(subscriptionParameterList)) {
-            if (!authorizeService.isAdmin(context)) {
+                    List<SubscriptionParameter> subscriptionParameters = new ArrayList<>();
-                if (!ePerson.equals(context.getCurrentUser())) {
+                    validateParameters(subscriptionRest, subscriptionParameterList, subscriptionParameters);
-                    throw new AuthorizeException("Only administrator can subscribe for other persons");
+                    subscription = subscribeService.subscribe(context, ePerson, dSpaceObject, subscriptionParameters,
+                                                              subscriptionRest.getSubscriptionType());
                 }
+                context.commit();
+                return converter.toRest(subscription, utils.obtainProjection());
+            } else {
+                throw new BadRequestException("Currently subscription is supported only for Community and Collection");
             }
-
-            Subscription subscription = null;
-            ServletInputStream input = req.getInputStream();
-            SubscriptionRest subscriptionRest = new ObjectMapper().readValue(input, SubscriptionRest.class);
-            List<SubscriptionParameterRest> subscriptionParameterList = subscriptionRest.getSubscriptionParameterList();
-            if (CollectionUtils.isNotEmpty(subscriptionParameterList)) {
-                List<SubscriptionParameter> subscriptionParameters = new ArrayList<>();
-                validateParameters(subscriptionRest, subscriptionParameterList, subscriptionParameters);
-                subscription = subscribeService.subscribe(context, ePerson, dSpaceObject, subscriptionParameters,
-                                                          subscriptionRest.getSubscriptionType());
-            }
-            context.commit();
-            return converter.toRest(subscription, utils.obtainProjection());
         } catch (SQLException sqlException) {
             throw new SQLException(sqlException.getMessage(), sqlException);
         } catch (IOException ioException) {
@@ -198,7 +191,7 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
             SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
             var name = subscriptionParameterRest.getName();
             var value = subscriptionParameterRest.getValue();
-            if (!nameAndValueAreSupported(name, value)) {
+            if (!StringUtils.equals("frequency", name) || !FrequencyType.isSupportedFrequencyType(value)) {
                 throw new UnprocessableEntityException("Provided SubscriptionParameter name:" + name +
                                                        " or value: " + value + " is not supported!");
             }
@@ -214,20 +207,11 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
         }
     }
 
-    private boolean nameAndValueAreSupported(String name, String value) {
-        return subscriptionEmailNotificationService.isSupportedSubscriptionParameterName(name) &&
-               subscriptionEmailNotificationService.getSubscriptionParameterValuesByName(name).contains(value);
-    }
-
     @Override
     @PreAuthorize("hasPermission(#id, 'subscription', 'WRITE')")
     protected SubscriptionRest put(Context context, HttpServletRequest request, String apiCategory, String model,
                                    Integer id, JsonNode jsonNode) throws SQLException {
 
-        HttpServletRequest req = getRequestService().getCurrentRequest().getHttpServletRequest();
-        String epersonId = req.getParameter("eperson_id");
-        String dsoId = req.getParameter("resource");
-
         SubscriptionRest subscriptionRest;
         try {
             subscriptionRest = new ObjectMapper().readValue(jsonNode.toString(), SubscriptionRest.class);
@@ -240,22 +224,12 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
             throw new ResourceNotFoundException(apiCategory + "." + model + " with id: " + id + " not found");
         }
 
-        EPerson ePerson = ePersonService.findByIdOrLegacyId(context, epersonId);
-        if (Objects.isNull(ePerson)) {
-            throw new ResourceNotFoundException("There is not ePerson with uuid:" + epersonId);
-        }
-
-        DSpaceObject dSpaceObject = dspaceObjectUtil.findDSpaceObject(context, UUID.fromString(dsoId));
-        if (Objects.isNull(dSpaceObject)) {
-            throw new ResourceNotFoundException("There is not DSpaceObject with uuid:" + dsoId);
-        }
-
         if (id.equals(subscription.getID())) {
             List<SubscriptionParameter> subscriptionParameters = new ArrayList<>();
             List<SubscriptionParameterRest> subscriptionParameterList = subscriptionRest.getSubscriptionParameterList();
             validateParameters(subscriptionRest, subscriptionParameterList, subscriptionParameters);
-            subscription = subscribeService.updateSubscription(context, id, ePerson, dSpaceObject,
+            subscription = subscribeService.updateSubscription(context, id, subscriptionRest.getSubscriptionType(),
-                                            subscriptionParameters, subscriptionRest.getSubscriptionType());
+                                                               subscriptionParameters);
             context.commit();
             return converter.toRest(subscription, utils.obtainProjection());
         } else {

dspace-server-webapp/src/main/java/org/dspace/app/rest/security/SubscriptionAdminAndOwnerPermissionEvaluatorPlugin.java

@@ -1,73 +0,0 @@
-/**
- * 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.rest.security;
-
-import java.io.Serializable;
-import java.sql.SQLException;
-import java.util.Objects;
-import java.util.UUID;
-
-import org.apache.commons.lang3.StringUtils;
-import org.dspace.app.rest.utils.ContextUtil;
-import org.dspace.authorize.service.AuthorizeService;
-import org.dspace.core.Context;
-import org.dspace.eperson.EPerson;
-import org.dspace.services.RequestService;
-import org.dspace.services.model.Request;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.security.core.Authentication;
-import org.springframework.stereotype.Component;
-
-/**
- * @author Mykhaylo Boychuk (mykhaylo.boychuk@4science.com)
- */
-@Component
-public class SubscriptionAdminAndOwnerPermissionEvaluatorPlugin extends RestObjectPermissionEvaluatorPlugin {
-
-    private static final Logger log = LoggerFactory.getLogger(SubscriptionAdminAndOwnerPermissionEvaluatorPlugin.class);
-
-    @Autowired
-    private RequestService requestService;
-    @Autowired
-    private AuthorizeService authorizeService;
-
-    @Override
-    public boolean hasDSpacePermission(Authentication authentication, Serializable targetId,
-                                       String targetType, DSpaceRestPermission permission) {
-
-        DSpaceRestPermission restPermission = DSpaceRestPermission.convert(permission);
-
-        if (!DSpaceRestPermission.READ.equals(restPermission) &&
-            !DSpaceRestPermission.WRITE.equals(restPermission) &&
-            !DSpaceRestPermission.DELETE.equals(restPermission) ||
-            !StringUtils.equals(targetType, "AdminOrOwner"))  {
-            return false;
-        }
-
-        Request request = requestService.getCurrentRequest();
-        Context context = ContextUtil.obtainContext(request.getHttpServletRequest());
-
-        UUID dsoId = UUID.fromString(targetId.toString());
-        EPerson currentUser = context.getCurrentUser();
-
-        // anonymous user
-        if (Objects.isNull(currentUser)) {
-            return false;
-        }
-
-        try {
-            return dsoId.equals(currentUser.getID()) || authorizeService.isAdmin(context, currentUser);
-        } catch (SQLException e) {
-            log.error(e.getMessage(), e);
-        }
-        return false;
-    }
-
-}

dspace-server-webapp/src/main/java/org/dspace/app/rest/security/SubscriptionSecurityBean.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.app.rest.security;
+
+import java.sql.SQLException;
+import java.util.Objects;
+import java.util.UUID;
+import javax.servlet.http.HttpServletRequest;
+
+import org.dspace.app.rest.utils.DSpaceObjectUtils;
+import org.dspace.authorize.service.AuthorizeService;
+import org.dspace.content.DSpaceObject;
+import org.dspace.core.Constants;
+import org.dspace.core.Context;
+import org.dspace.eperson.EPerson;
+import org.dspace.eperson.service.EPersonService;
+import org.dspace.services.RequestService;
+import org.dspace.utils.DSpace;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * Methods of this class are used on PreAuthorize annotations
+ * to check security on subscriptions endpoint
+ * 
+ * @author Mykhaylo Boychuk (mykhaylo.boychuk at 4science.it)
+ */
+@Component(value = "subscriptionSecurity")
+public class SubscriptionSecurityBean {
+
+    @Autowired
+    private EPersonService ePersonService;
+    @Autowired
+    private AuthorizeService authorizeService;
+    @Autowired
+    private DSpaceObjectUtils dspaceObjectUtil;
+
+    public boolean isEnabelToCreateSubscription(Context context) throws SQLException {
+        RequestService requestService = new DSpace().getRequestService();
+        HttpServletRequest req = requestService.getCurrentRequest().getHttpServletRequest();
+        String epersonId = req.getParameter("eperson_id");
+        String dsoId = req.getParameter("resource");
+
+        if (Objects.isNull(dsoId) || Objects.isNull(epersonId)) {
+            return true;
+        }
+
+        try {
+            DSpaceObject dSpaceObject = dspaceObjectUtil.findDSpaceObject(context, UUID.fromString(dsoId));
+            EPerson ePerson = ePersonService.findByIdOrLegacyId(context, epersonId);
+            if (Objects.isNull(ePerson) || Objects.isNull(dSpaceObject)) {
+                return true;
+            }
+
+            if (!authorizeService.authorizeActionBoolean(context, ePerson, dSpaceObject,  Constants.READ, true)) {
+                return false;
+            }
+
+            if (!authorizeService.isAdmin(context)) {
+                if (!ePerson.equals(context.getCurrentUser())) {
+                    return false;
+                }
+            }
+        } catch (SQLException sqlException) {
+            throw new SQLException(sqlException.getMessage(), sqlException);
+        }
+        return true;
+    }
+
+}

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

@@ -33,10 +33,8 @@ import org.dspace.app.rest.test.AbstractControllerIntegrationTest;
 import org.dspace.builder.CollectionBuilder;
 import org.dspace.builder.CommunityBuilder;
 import org.dspace.builder.EPersonBuilder;
-import org.dspace.builder.ItemBuilder;
 import org.dspace.builder.SubscribeBuilder;
 import org.dspace.content.Collection;
-import org.dspace.content.Item;
 import org.dspace.eperson.EPerson;
 import org.dspace.eperson.Subscription;
 import org.dspace.eperson.SubscriptionParameter;
@@ -44,8 +42,6 @@ import org.hamcrest.Matchers;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.http.MediaType;
-import org.springframework.util.LinkedMultiValueMap;
-import org.springframework.util.MultiValueMap;
 
 /**
  * Integration test to test the /api/config/subscriptions endpoint
@@ -55,7 +51,7 @@ import org.springframework.util.MultiValueMap;
  */
 public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationTest {
 
-    private Item publicItem;
+
     private Collection collection;
 
     @Before
@@ -68,15 +64,9 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                                           .withName("Parent Community")
                                           .build();
         collection = CollectionBuilder.createCollection(context, parentCommunity)
-                                     .withName("Collection 1")
+                                      .withName("Collection 1")
-                                     .build();
+                                      .withSubmitterGroup(eperson)
-        // creation of the item which will be the DSO related with a subscription
+                                      .build();
-        publicItem = ItemBuilder.createItem(context, collection)
-                                .withTitle("Test")
-                                .withIssueDate("2010-10-17")
-                                .withAuthor("Smith, Donald")
-                                .withSubject("ExtraEntry")
-                                .build();
 
         context.restoreAuthSystemState();
     }
@@ -90,7 +80,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription1 = SubscribeBuilder.subscribeBuilder(context,
-                                     "content", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", collection, eperson, subscriptionParameterList).build();
         List<SubscriptionParameter> subscriptionParameterList2 = new ArrayList<>();
         SubscriptionParameter subscriptionParameter2 = new SubscriptionParameter();
         subscriptionParameter2.setName("frequency");
@@ -136,7 +126,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -168,7 +158,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, admin, subscriptionParameterList).build();
+                                    "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
@@ -199,7 +189,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, admin, subscriptionParameterList).build();
+                                    "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/" + subscription.getID()))
@@ -215,7 +205,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, admin, subscriptionParameterList).build();
+                                    "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -239,7 +229,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription1 = SubscribeBuilder.subscribeBuilder(context,
-                                     "content", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", collection, eperson, subscriptionParameterList).build();
         List<SubscriptionParameter> subscriptionParameterList2 = new ArrayList<>();
         SubscriptionParameter subscriptionParameter2 = new SubscriptionParameter();
         subscriptionParameter2.setName("frequency");
@@ -273,7 +263,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription1 = SubscribeBuilder.subscribeBuilder(context,
-                                     "content", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", collection, eperson, subscriptionParameterList).build();
         List<SubscriptionParameter> subscriptionParameterList2 = new ArrayList<>();
         SubscriptionParameter subscriptionParameter2 = new SubscriptionParameter();
         subscriptionParameter2.setName("frequency");
@@ -306,7 +296,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setName("frequency");
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
-        SubscribeBuilder.subscribeBuilder(context, "content", publicItem, eperson, subscriptionParameterList).build();
+        SubscribeBuilder.subscribeBuilder(context, "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/search/findByEPerson")
@@ -327,7 +317,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setName("frequency");
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
-        SubscribeBuilder.subscribeBuilder(context, "content", publicItem, user, subscriptionParameterList).build();
+        SubscribeBuilder.subscribeBuilder(context, "content", collection, user, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -349,16 +339,12 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         SubscriptionRest subscriptionRest = new SubscriptionRest();
         subscriptionRest.setSubscriptionType("content");
 
-        MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
-        params.add("resource", publicItem.getID().toString());
-        params.add("eperson_id", eperson.getID().toString());
-
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
 
         getClient().perform(post("/api/core/subscriptions")
-                   .param("resource", publicItem.getID().toString())
+                   .param("resource", collection.getID().toString())
                    .param("eperson_id", eperson.getID().toString())
                    .content(objectMapper.writeValueAsString(subscriptionRest))
                    .contentType(contentType))
@@ -385,7 +371,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         try {
             String tokenAdmin = getAuthToken(admin.getEmail(), password);
             getClient(tokenAdmin).perform(post("/api/core/subscriptions")
-                                 .param("resource", publicItem.getID().toString())
+                                 .param("resource", collection.getID().toString())
                                  .param("eperson_id", eperson.getID().toString())
                                  .content(new ObjectMapper().writeValueAsString(map))
                                  .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -421,7 +407,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         try {
             String tokenEPerson = getAuthToken(eperson.getEmail(), password);
             getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                                   .param("resource", publicItem.getID().toString())
+                                   .param("resource", collection.getID().toString())
                                    .param("eperson_id", eperson.getID().toString())
                                    .content(new ObjectMapper().writeValueAsString(map))
                                    .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -454,7 +440,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
         getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                               .param("resource", publicItem.getID().toString())
+                               .param("resource", collection.getID().toString())
                                .param("eperson_id", eperson.getID().toString())
                                .content(new ObjectMapper().writeValueAsString(map))
                                .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -478,7 +464,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
         getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                               .param("resource", publicItem.getID().toString())
+                               .param("resource", collection.getID().toString())
                                .param("eperson_id", eperson.getID().toString())
                                .content(new ObjectMapper().writeValueAsString(map))
                                .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -502,7 +488,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
         getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                               .param("resource", publicItem.getID().toString())
+                               .param("resource", collection.getID().toString())
                                .param("eperson_id", eperson.getID().toString())
                                .content(new ObjectMapper().writeValueAsString(map))
                                .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -526,7 +512,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
         getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                               .param("resource", publicItem.getID().toString())
+                               .param("resource", collection.getID().toString())
                                .param("eperson_id", eperson.getID().toString())
                                .content(new ObjectMapper().writeValueAsString(map))
                                .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -555,7 +541,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
         getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                               .param("resource", publicItem.getID().toString())
+                               .param("resource", collection.getID().toString())
                                .param("eperson_id", user.getID().toString())
                                .content(new ObjectMapper().writeValueAsString(map))
                                .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -571,7 +557,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(delete("/api/core/subscriptions/" + subscription.getID()))
@@ -587,7 +573,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription =  SubscribeBuilder.subscribeBuilder(context,
-                                     "content", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
@@ -607,7 +593,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription =  SubscribeBuilder.subscribeBuilder(context,
-                                     "content", publicItem, admin, subscriptionParameterList).build();
+                                     "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -631,7 +617,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter1");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                "content", publicItem, admin, subscriptionParameterList).build();
+                "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -645,7 +631,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         newSubscription.put("subscriptionParameterList", list);
 
         getClient().perform(put("/api/core/subscriptions/" + subscription.getID())
-                   .param("resource", publicItem.getID().toString())
+                   .param("resource", collection.getID().toString())
                    .param("eperson_id", admin.getID().toString())
                    .content(objectMapper.writeValueAsString(newSubscription))
                    .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -661,7 +647,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, admin, subscriptionParameterList).build();
+                                    "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -677,7 +663,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         String token = getAuthToken(eperson.getEmail(), password);
         getClient(token).perform(put("/api/core/subscriptions/" + subscription.getID())
                         .param("eperson_id", admin.getID().toString())
-                        .param("resource", publicItem.getID().toString())
+                        .param("resource", collection.getID().toString())
                         .content(objectMapper.writeValueAsString(newSubscription))
                         .contentType(MediaType.APPLICATION_JSON_VALUE))
                         .andExpect(status().isForbidden());
@@ -692,7 +678,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -707,7 +693,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenSubscriber = getAuthToken(eperson.getEmail(), password);
         getClient(tokenSubscriber).perform(put("/api/core/subscriptions/" + subscription.getID())
-                                  .param("resource", publicItem.getID().toString())
+                                  .param("resource", collection.getID().toString())
                                   .param("eperson_id", eperson.getID().toString())
                                   .content(objectMapper.writeValueAsString(newSubscription))
                                   .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -729,7 +715,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -744,7 +730,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenSubscriber = getAuthToken(eperson.getEmail(), password);
         getClient(tokenSubscriber).perform(put("/api/core/subscriptions/" + subscription.getID())
-                                  .param("resource", publicItem.getID().toString())
+                                  .param("resource", collection.getID().toString())
                                   .param("eperson_id", eperson.getID().toString())
                                   .content(objectMapper.writeValueAsString(newSubscription))
                                   .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -760,7 +746,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -775,7 +761,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenSubscriber = getAuthToken(eperson.getEmail(), password);
         getClient(tokenSubscriber).perform(put("/api/core/subscriptions/" + subscription.getID())
-                                  .param("resource", publicItem.getID().toString())
+                                  .param("resource", collection.getID().toString())
                                   .param("eperson_id", eperson.getID().toString())
                                   .content(objectMapper.writeValueAsString(newSubscription))
                                   .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -791,7 +777,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -806,7 +792,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenSubscriber = getAuthToken(eperson.getEmail(), password);
         getClient(tokenSubscriber).perform(put("/api/core/subscriptions/" + subscription.getID())
-                                  .param("resource", publicItem.getID().toString())
+                                  .param("resource", collection.getID().toString())
                                   .param("eperson_id", eperson.getID().toString())
                                   .content(objectMapper.writeValueAsString(newSubscription))
                                   .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -822,7 +808,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
@@ -837,7 +823,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
         getClient(tokenAdmin).perform(put("/api/core/subscriptions/" + subscription.getID())
-                             .param("resource", publicItem.getID().toString())
+                             .param("resource", collection.getID().toString())
                              .param("eperson_id", eperson.getID().toString())
                              .content(objectMapper.writeValueAsString(newSubscription))
                              .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -859,7 +845,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
@@ -877,7 +863,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -895,7 +881,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/" + subscription.getID() + "/eperson"))
@@ -911,7 +897,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, admin, subscriptionParameterList).build();
+                                    "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -935,18 +921,15 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
         getClient(tokenAdmin).perform(get("/api/core/subscriptions/" + subscription.getID() + "/resource"))
                              .andExpect(status().isOk())
-                             .andExpect(jsonPath("$.uuid", Matchers.is(publicItem.getID().toString())))
+                             .andExpect(jsonPath("$.uuid", Matchers.is(collection.getID().toString())))
-                             .andExpect(jsonPath("$.name", Matchers.is(publicItem.getName())))
+                             .andExpect(jsonPath("$.name", Matchers.is(collection.getName())))
-                             .andExpect(jsonPath("$.withdrawn", Matchers.is(false)))
+                             .andExpect(jsonPath("$.type", Matchers.is("collection")));
-                             .andExpect(jsonPath("$.discoverable", Matchers.is(true)))
-                             .andExpect(jsonPath("$.inArchive", Matchers.is(true)))
-                             .andExpect(jsonPath("$.type", Matchers.is("item")));
     }
 
     @Test
@@ -958,18 +941,15 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(eperson.getEmail(), password);
         getClient(tokenAdmin).perform(get("/api/core/subscriptions/" + subscription.getID() + "/resource"))
                              .andExpect(status().isOk())
-                             .andExpect(jsonPath("$.uuid", Matchers.is(publicItem.getID().toString())))
+                             .andExpect(jsonPath("$.uuid", Matchers.is(collection.getID().toString())))
-                             .andExpect(jsonPath("$.name", Matchers.is(publicItem.getName())))
+                             .andExpect(jsonPath("$.name", Matchers.is(collection.getName())))
-                             .andExpect(jsonPath("$.withdrawn", Matchers.is(false)))
+                             .andExpect(jsonPath("$.type", Matchers.is("collection")));
-                             .andExpect(jsonPath("$.discoverable", Matchers.is(true)))
-                             .andExpect(jsonPath("$.inArchive", Matchers.is(true)))
-                             .andExpect(jsonPath("$.type", Matchers.is("item")));
     }
 
     @Test
@@ -981,7 +961,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", collection, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/" + subscription.getID() + "/resource"))
@@ -997,7 +977,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "content", publicItem, admin, subscriptionParameterList).build();
+                                    "content", collection, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);

dspace/config/spring/api/subscriptions_email_configuration.xml

@@ -26,22 +26,10 @@
             <map>
                 <entry key="community" value-ref="communityUpdates"/>
                 <entry key="collection" value-ref="collectionUpdates"/>
-                <entry key="item" value-ref="itemUpdates"/>
-            </map>
-        </constructor-arg>
-        <constructor-arg name="param2values">
-            <map>
-                <entry key="frequency" value-ref="frequencyValues"/>
             </map>
         </constructor-arg>
     </bean>
 
-    <util:set id="frequencyValues">
-        <value>D</value>
-        <value>W</value>
-        <value>M</value>
-    </util:set>
-
     <util:map id="generators">
         <entry key="content" value-ref="contentNotifyGenerator"/>
     </util:map>
@@ -51,7 +39,6 @@
     <util:map id="contentUpdates">
         <entry key="community" value-ref="communityUpdates"/>
         <entry key="collection" value-ref="collectionUpdates"/>
-        <entry key="item" value-ref="itemUpdates"/>
     </util:map>
 
     <util:list id="generalMetadataEntity">
@@ -76,6 +63,4 @@
 
     <bean id="collectionUpdates" class="org.dspace.subscriptions.dSpaceObjectsUpdates.CollectionsUpdates" />
 
-    <bean id="itemUpdates" class="org.dspace.subscriptions.dSpaceObjectsUpdates.ItemUpdates" />
-
 </beans>