[CST-7756] refactoring

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

@@ -7,10 +7,9 @@
  */
 package org.dspace.subscriptions;
 
-import static org.dspace.subscriptions.SubscriptionEmailNotificationService.FREQUENCIES;
-
 import java.sql.SQLException;
 import java.util.Objects;
+import java.util.Set;
 import java.util.UUID;
 
 import org.apache.commons.cli.ParseException;
@@ -53,8 +52,10 @@ public class SubscriptionEmailNotification
         if (StringUtils.isBlank(frequencyOption)) {
             throw new IllegalArgumentException("Option frequency f must be set");
         }
-        if (!FREQUENCIES.contains(frequencyOption)) {
+        Set<String> supportedValues = subscriptionEmailNotificationService
-            throw new IllegalArgumentException("Option f must be one of following values:" + FREQUENCIES);
+                                                 .getSubscriptionParameterValuesByName("frequency");
+        if (!supportedValues.contains(frequencyOption)) {
+            throw new IllegalArgumentException("Option f must be one of following values:" + supportedValues);
         }
         subscriptionEmailNotificationService.perform(getContext(), handler, "content", frequencyOption);
     }
@@ -78,8 +79,8 @@ public class SubscriptionEmailNotification
         return subscriptionEmailNotificationService;
     }
 
-    public void setSubscriptionEmailNotificationService(SubscriptionEmailNotificationService subscriptionNotifService) {
+    public void setSubscriptionEmailNotificationService(SubscriptionEmailNotificationService notificationService) {
-        this.subscriptionEmailNotificationService = subscriptionNotifService;
+        this.subscriptionEmailNotificationService = notificationService;
     }
 
     public Context getContext() {

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

@@ -7,141 +7,22 @@
  */
 package org.dspace.subscriptions;
 
-import java.sql.SQLException;
+import java.util.Set;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.stream.Collectors;
 
-import org.apache.logging.log4j.LogManager;
-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;
-import org.dspace.eperson.service.SubscribeService;
-import org.dspace.scripts.DSpaceRunnable;
 import org.dspace.scripts.handler.DSpaceRunnableHandler;
-import org.dspace.subscriptions.service.DSpaceObjectUpdates;
-import org.dspace.subscriptions.service.SubscriptionGenerator;
-import org.hibernate.proxy.HibernateProxy;
-import org.hibernate.proxy.LazyInitializer;
 
 /**
- * Implementation of {@link DSpaceRunnable} to find subscribed objects and send notification mails about them
+ * @author Mykhaylo Boychuk (mykhaylo.boychuk@4science.com)
- *
- * @author alba aliu
  */
-public class SubscriptionEmailNotificationService {
+public interface SubscriptionEmailNotificationService {
 
-    private static final Logger log = LogManager.getLogger(SubscriptionEmailNotification.class);
+    public void perform(Context context, DSpaceRunnableHandler handler, String type, String frequency);
 
-    public static final List<String> FREQUENCIES = Arrays.asList("D", "W", "M");
+    public Set<String> getSupportedSubscriptionTypes();
 
-    private Map<String, DSpaceObjectUpdates> contentUpdates = new HashMap<>();
+    public boolean isSupportedSubscriptionParameterName(String name);
-    @SuppressWarnings("rawtypes")
-    private Map<String, SubscriptionGenerator> generators = new HashMap<>();
-    @SuppressWarnings("rawtypes")
-    private List<IndexableObject> communities = new ArrayList<>();
-    @SuppressWarnings("rawtypes")
-    private List<IndexableObject> collections = new ArrayList<>();
-    @SuppressWarnings("rawtypes")
-    private List<IndexableObject> items = new ArrayList<>();
 
-    private final SubscribeService subscribeService;
+    public Set<String> getSubscriptionParameterValuesByName(String name);
-
-    @SuppressWarnings("unchecked")
-    public void perform(Context context, DSpaceRunnableHandler handler, String type, String frequency) {
-        try {
-            context.turnOffAuthorisationSystem();
-            List<Subscription> subscriptions = findAllSubscriptionsBySubscriptionTypeAndFrequency(context, type,
-                                               frequency);
-            // if content subscription
-            // Here is verified if type is "content" Or "statistics" as them are configured
-            if (type.equals(generators.keySet().toArray()[0])) {
-                // the list of the person who has subscribed
-                int iterator = 0;
-                for (Subscription subscription : subscriptions) {
-                    DSpaceObject dSpaceObject = getdSpaceObject(subscription);
-                    if (dSpaceObject instanceof Community) {
-                        communities.addAll(contentUpdates.get(Community.class.getSimpleName().toLowerCase(Locale.ROOT))
-                                   .findUpdates(context, dSpaceObject, frequency));
-                    } else if (dSpaceObject instanceof Collection) {
-                        collections.addAll(contentUpdates.get(Collection.class.getSimpleName().toLowerCase(Locale.ROOT))
-                                   .findUpdates(context, dSpaceObject, frequency));
-                    } else if (dSpaceObject instanceof Item) {
-                        items.addAll(contentUpdates.get(Item.class.getSimpleName().toLowerCase(Locale.ROOT))
-                             .findUpdates(context, dSpaceObject, frequency));
-                    }
-                    var ePerson = subscription.getePerson();
-                    if (iterator < subscriptions.size() - 1) {
-                        if (ePerson.equals(subscriptions.get(iterator + 1).getePerson())) {
-                            iterator++;
-                            continue;
-                        } else {
-                            generators.get(type)
-                                      .notifyForSubscriptions(context, ePerson, communities, collections, items);
-                            communities.clear();
-                            collections.clear();
-                            items.clear();
-                        }
-                    } else {
-                        //in the end of the iteration
-                        generators.get(type).notifyForSubscriptions(context, ePerson, communities, collections, items);
-                    }
-                    iterator++;
-                }
-            } else {
-                throw new IllegalArgumentException("Currently this type:" + type +
-                                                   " of subscription is not supported!");
-            }
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
-            handler.handleException(e);
-            context.abort();
-        } finally {
-            context.restoreAuthSystemState();
-        }
-    }
-
-    private DSpaceObject getdSpaceObject(Subscription subscription) {
-        DSpaceObject dSpaceObject = subscription.getdSpaceObject();
-        if (subscription.getdSpaceObject() instanceof HibernateProxy) {
-            HibernateProxy hibernateProxy = (HibernateProxy) subscription.getdSpaceObject();
-            LazyInitializer initializer = hibernateProxy.getHibernateLazyInitializer();
-            dSpaceObject = (DSpaceObject) initializer.getImplementation();
-        }
-        return dSpaceObject;
-    }
-
-    private List<Subscription> findAllSubscriptionsBySubscriptionTypeAndFrequency(Context context,
-             String subscriptionType, String frequency) {
-        try {
-            return subscribeService.findAllSubscriptionsBySubscriptionTypeAndFrequency(context, subscriptionType,
-                                    frequency)
-                                   .stream()
-                                   .sorted(Comparator.comparing(s -> s.getePerson().getID()))
-                                   .collect(Collectors.toList());
-        } catch (SQLException e) {
-            log.error(e.getMessage(), e);
-        }
-        return new ArrayList<Subscription>();
-    }
-
-    @SuppressWarnings("rawtypes")
-    public SubscriptionEmailNotificationService(SubscribeService subscribeService,
-                                                Map<String, SubscriptionGenerator> generators,
-                                                Map<String, DSpaceObjectUpdates> contentUpdates) {
-        this.subscribeService = subscribeService;
-        this.generators = generators;
-        this.contentUpdates = contentUpdates;
-    }
 
 }

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

@@ -0,0 +1,169 @@
+/**
+ * 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;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.apache.logging.log4j.LogManager;
+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;
+import org.dspace.eperson.service.SubscribeService;
+import org.dspace.scripts.DSpaceRunnable;
+import org.dspace.scripts.handler.DSpaceRunnableHandler;
+import org.dspace.subscriptions.service.DSpaceObjectUpdates;
+import org.dspace.subscriptions.service.SubscriptionGenerator;
+import org.hibernate.proxy.HibernateProxy;
+import org.hibernate.proxy.LazyInitializer;
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ * Implementation of {@link DSpaceRunnable} to find subscribed objects and send notification mails about them
+ *
+ * @author alba aliu
+ */
+public class SubscriptionEmailNotificationServiceImpl implements SubscriptionEmailNotificationService {
+
+    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<>();
+    @SuppressWarnings("rawtypes")
+    private List<IndexableObject> communities = new ArrayList<>();
+    @SuppressWarnings("rawtypes")
+    private List<IndexableObject> collections = new ArrayList<>();
+    @SuppressWarnings("rawtypes")
+    private List<IndexableObject> items = new ArrayList<>();
+
+    @Autowired
+    private SubscribeService subscribeService;
+
+    @SuppressWarnings("rawtypes")
+    public SubscriptionEmailNotificationServiceImpl(SubscribeService subscribeService,
+                                                    Map<String, Set<String>> param2values,
+                                                    Map<String, DSpaceObjectUpdates> contentUpdates,
+                                                    Map<String, SubscriptionGenerator> subscriptionType2generators) {
+        this.param2values = param2values;
+        this.contentUpdates = contentUpdates;
+        this.subscribeService = subscribeService;
+        this.subscriptionType2generators = subscriptionType2generators;
+    }
+
+    @SuppressWarnings("unchecked")
+    public void perform(Context context, DSpaceRunnableHandler handler, String type, String frequency) {
+        try {
+            List<Subscription> subscriptions = findAllSubscriptionsBySubscriptionTypeAndFrequency(context, type,
+                                               frequency);
+            // Here is verified if type is "content" Or "statistics" as them are configured
+            if (subscriptionType2generators.keySet().contains(type)) {
+                // the list of the person who has subscribed
+                int iterator = 0;
+                for (Subscription subscription : subscriptions) {
+                    DSpaceObject dSpaceObject = getdSpaceObject(subscription);
+                    if (dSpaceObject instanceof Community) {
+                        communities.addAll(contentUpdates.get(Community.class.getSimpleName().toLowerCase(Locale.ROOT))
+                                   .findUpdates(context, dSpaceObject, frequency));
+                    } else if (dSpaceObject instanceof Collection) {
+                        collections.addAll(contentUpdates.get(Collection.class.getSimpleName().toLowerCase(Locale.ROOT))
+                                   .findUpdates(context, dSpaceObject, frequency));
+                    } else if (dSpaceObject instanceof Item) {
+                        items.addAll(contentUpdates.get(Item.class.getSimpleName().toLowerCase(Locale.ROOT))
+                             .findUpdates(context, dSpaceObject, frequency));
+                    }
+                    var ePerson = subscription.getePerson();
+                    if (iterator < subscriptions.size() - 1) {
+                        if (ePerson.equals(subscriptions.get(iterator + 1).getePerson())) {
+                            iterator++;
+                            continue;
+                        } else {
+                            subscriptionType2generators.get(type)
+                                      .notifyForSubscriptions(context, ePerson, communities, collections, items);
+                            communities.clear();
+                            collections.clear();
+                            items.clear();
+                        }
+                    } else {
+                        //in the end of the iteration
+                        subscriptionType2generators.get(type)
+                                        .notifyForSubscriptions(context, ePerson, communities, collections, items);
+                    }
+                    iterator++;
+                }
+            } else {
+                throw new IllegalArgumentException("Currently this type:" + type +
+                                                   " of subscription is not supported!");
+            }
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+            handler.handleException(e);
+            context.abort();
+        }
+    }
+
+    private DSpaceObject getdSpaceObject(Subscription subscription) {
+        DSpaceObject dSpaceObject = subscription.getdSpaceObject();
+        if (subscription.getdSpaceObject() instanceof HibernateProxy) {
+            HibernateProxy hibernateProxy = (HibernateProxy) subscription.getdSpaceObject();
+            LazyInitializer initializer = hibernateProxy.getHibernateLazyInitializer();
+            dSpaceObject = (DSpaceObject) initializer.getImplementation();
+        }
+        return dSpaceObject;
+    }
+
+    private List<Subscription> findAllSubscriptionsBySubscriptionTypeAndFrequency(Context context,
+             String subscriptionType, String frequency) {
+        try {
+            return subscribeService.findAllSubscriptionsBySubscriptionTypeAndFrequency(context, subscriptionType,
+                                    frequency)
+                                   .stream()
+                                   .sorted(Comparator.comparing(s -> s.getePerson().getID()))
+                                   .collect(Collectors.toList());
+        } catch (SQLException e) {
+            log.error(e.getMessage(), e);
+        }
+        return new ArrayList<Subscription>();
+    }
+
+    @Override
+    public Set<String> getSupportedSubscriptionTypes() {
+        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-server-webapp/src/main/java/org/dspace/app/rest/repository/SubscriptionRestRepository.java

@@ -23,6 +23,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.dspace.app.rest.DiscoverableEndpointsService;
 import org.dspace.app.rest.Parameter;
 import org.dspace.app.rest.SearchRestMethod;
@@ -41,6 +42,7 @@ import org.dspace.eperson.Subscription;
 import org.dspace.eperson.SubscriptionParameter;
 import org.dspace.eperson.service.EPersonService;
 import org.dspace.eperson.service.SubscribeService;
+import org.dspace.subscriptions.SubscriptionEmailNotificationService;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
@@ -71,6 +73,8 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
     private DSpaceObjectUtils dspaceObjectUtil;
     @Autowired
     private DiscoverableEndpointsService discoverableEndpointsService;
+    @Autowired
+    private SubscriptionEmailNotificationService subscriptionEmailNotificationService;
 
     @Override
     @PreAuthorize("hasPermission(#id, 'subscription', 'READ')")
@@ -167,19 +171,32 @@ public class SubscriptionRestRepository extends DSpaceRestRepository<Subscriptio
                     throw new AuthorizeException("Only administrator can subscribe for other persons");
                 }
             }
+
+            Subscription subscription = null;
             ServletInputStream input = req.getInputStream();
             SubscriptionRest subscriptionRest = new ObjectMapper().readValue(input, SubscriptionRest.class);
-            Subscription subscription = null;
             List<SubscriptionParameterRest> subscriptionParameterList = subscriptionRest.getSubscriptionParameterList();
-            if (subscriptionParameterList != null) {
+            if (CollectionUtils.isNotEmpty(subscriptionParameterList)) {
                 List<SubscriptionParameter> subscriptionParameters = new ArrayList<>();
                 for (SubscriptionParameterRest subscriptionParameterRest : subscriptionParameterList) {
                     SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-                    subscriptionParameter.setName(subscriptionParameterRest.getName());
+                    var name = subscriptionParameterRest.getName();
-                    subscriptionParameter.setValue(subscriptionParameterRest.getValue());
+                    var value = subscriptionParameterRest.getValue();
+                    if (!nameAndValueAreSupported(name, value)) {
+                        throw new UnprocessableEntityException("Provided SubscriptionParameter name:" + name +
+                                                               " or value: " + value + " is not supported!");
+                    }
+                    subscriptionParameter.setName(name);
+                    subscriptionParameter.setValue(value);
                     subscriptionParameters.add(subscriptionParameter);
                 }
+
                 var type = subscriptionRest.getSubscriptionType();
+                if (!subscriptionEmailNotificationService.getSupportedSubscriptionTypes().contains(type)) {
+                    throw new UnprocessableEntityException("Provided subscriptionType:" + type + "  is not supported!" +
+                            " Must be one of: " + subscriptionEmailNotificationService.getSupportedSubscriptionTypes());
+                }
+
                 subscription = subscribeService.subscribe(context, ePerson, dSpaceObject, subscriptionParameters, type);
             }
             context.commit();
@@ -191,6 +208,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,

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

@@ -86,18 +86,18 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Frequency");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("Daily");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription1 = SubscribeBuilder.subscribeBuilder(context,
-                                     "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", publicItem, eperson, subscriptionParameterList).build();
         List<SubscriptionParameter> subscriptionParameterList2 = new ArrayList<>();
         SubscriptionParameter subscriptionParameter2 = new SubscriptionParameter();
-        subscriptionParameter2.setName("Frequency");
+        subscriptionParameter2.setName("frequency");
-        subscriptionParameter2.setValue("WEEKLY");
+        subscriptionParameter2.setValue("W");
         subscriptionParameterList2.add(subscriptionParameter2);
         Subscription subscription2 = SubscribeBuilder.subscribeBuilder(context,
-                                     "TestType 2", collection, admin, subscriptionParameterList2).build();
+                                     "content", collection, admin, subscriptionParameterList2).build();
 
         context.restoreAuthSystemState();
 
@@ -132,11 +132,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter");
+        subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -145,9 +145,9 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                 //We expect the content type to be "application/hal+json;charset=UTF-8"
                 .andExpect(content().contentType(contentType))
                 //By default we expect at least 1 submission forms so this to be reflected in the page object
-                .andExpect(jsonPath("$.subscriptionType", is("TestType")))
+                .andExpect(jsonPath("$.subscriptionType", is("content")))
-                .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("Parameter")))
+                .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("frequency")))
-                .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("ValueParameter")))
+                .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("M")))
                 .andExpect(jsonPath("$._links.eperson.href", Matchers.endsWith("/eperson")))
                 .andExpect(jsonPath("$._links.resource.href", Matchers.endsWith("/resource")))
                 .andExpect(jsonPath("$._links.self.href",
@@ -164,11 +164,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter");
+        subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, admin, subscriptionParameterList).build();
+                                    "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
@@ -177,9 +177,9 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                 //We expect the content type to be "application/hal+json;charset=UTF-8"
                 .andExpect(content().contentType(contentType))
                 //By default we expect at least 1 submission forms so this to be reflected in the page object
-                .andExpect(jsonPath("$.subscriptionType", is("TestType")))
+                .andExpect(jsonPath("$.subscriptionType", is("content")))
-                .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("Parameter")))
+                .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("frequency")))
-                .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("ValueParameter")))
+                .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("W")))
                 .andExpect(jsonPath("$._links.self.href",
                            Matchers.startsWith(REST_SERVER_URL + "core/subscriptions/" + subscription.getID())))
                 .andExpect(jsonPath("$._links.resource.href",
@@ -195,11 +195,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, admin, subscriptionParameterList).build();
+                                    "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/" + subscription.getID()))
@@ -211,11 +211,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter");
+        subscriptionParameter.setValue("W");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, admin, subscriptionParameterList).build();
+                                    "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -235,18 +235,18 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter 1");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter 1");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription1 = SubscribeBuilder.subscribeBuilder(context,
-                                     "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", publicItem, eperson, subscriptionParameterList).build();
         List<SubscriptionParameter> subscriptionParameterList2 = new ArrayList<>();
         SubscriptionParameter subscriptionParameter2 = new SubscriptionParameter();
-        subscriptionParameter2.setName("Parameter 2");
+        subscriptionParameter2.setName("frequency");
-        subscriptionParameter2.setValue("ValueParameter 2");
+        subscriptionParameter2.setValue("W");
         subscriptionParameterList2.add(subscriptionParameter2);
         Subscription subscription2 = SubscribeBuilder.subscribeBuilder(context,
-                                     "TestType 2", collection, eperson, subscriptionParameterList2).build();
+                                     "content", collection, eperson, subscriptionParameterList2).build();
 
         context.restoreAuthSystemState();
 
@@ -269,18 +269,18 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter 1");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter 1");
+        subscriptionParameter.setValue("M");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription1 = SubscribeBuilder.subscribeBuilder(context,
-                                     "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", publicItem, eperson, subscriptionParameterList).build();
         List<SubscriptionParameter> subscriptionParameterList2 = new ArrayList<>();
         SubscriptionParameter subscriptionParameter2 = new SubscriptionParameter();
-        subscriptionParameter2.setName("Parameter 2");
+        subscriptionParameter2.setName("frequency");
-        subscriptionParameter2.setValue("ValueParameter 2");
+        subscriptionParameter2.setValue("D");
         subscriptionParameterList2.add(subscriptionParameter2);
         Subscription subscription2 = SubscribeBuilder.subscribeBuilder(context,
-                                     "TestType 2", collection, eperson, subscriptionParameterList2).build();
+                                     "content", collection, eperson, subscriptionParameterList2).build();
 
         context.restoreAuthSystemState();
 
@@ -303,10 +303,10 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter 1");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter 1");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
-        SubscribeBuilder.subscribeBuilder(context, "TestType", publicItem, eperson, subscriptionParameterList).build();
+        SubscribeBuilder.subscribeBuilder(context, "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/search/findByEPerson")
@@ -324,10 +324,10 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter 1");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter 1");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
-        SubscribeBuilder.subscribeBuilder(context, "TestType", publicItem, user, subscriptionParameterList).build();
+        SubscribeBuilder.subscribeBuilder(context, "content", publicItem, user, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -341,16 +341,16 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
 
         SubscriptionParameterRest subscriptionParameterRest = new SubscriptionParameterRest();
-        subscriptionParameterRest.setValue("Frequency");
+        subscriptionParameterRest.setValue("frequency");
-        subscriptionParameterRest.setName("Daily");
+        subscriptionParameterRest.setName("D");
         List<SubscriptionParameterRest> subscriptionParameterRestList = new ArrayList<>();
         subscriptionParameterRestList.add(subscriptionParameterRest);
 
         SubscriptionRest subscriptionRest = new SubscriptionRest();
-        subscriptionRest.setSubscriptionType("testType");
+        subscriptionRest.setSubscriptionType("content");
 
         MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
-        params.add("dspace_object_id", publicItem.getID().toString());
+        params.add("resource", publicItem.getID().toString());
         params.add("eperson_id", eperson.getID().toString());
 
         context.restoreAuthSystemState();
@@ -370,11 +370,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
 
         Map<String, Object> map = new HashMap<>();
-        map.put("subscriptionType", "testType");
+        map.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
-        sub_list.put("name", "Frequency");
+        sub_list.put("name", "frequency");
-        sub_list.put("value", "daily");
+        sub_list.put("value", "D");
         list.add(sub_list);
         map.put("subscriptionParameterList", list);
 
@@ -390,9 +390,9 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                                  .content(new ObjectMapper().writeValueAsString(map))
                                  .contentType(MediaType.APPLICATION_JSON_VALUE))
                        .andExpect(status().isCreated())
-                       .andExpect(jsonPath("$.subscriptionType", is("testType")))
+                       .andExpect(jsonPath("$.subscriptionType", is("content")))
-                       .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("Frequency")))
+                       .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("frequency")))
-                       .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("daily")))
+                       .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("D")))
                        .andExpect(jsonPath("$._links.eperson.href", Matchers.endsWith("eperson")))
                        .andExpect(jsonPath("$._links.resource.href", Matchers.endsWith("resource")))
                        .andDo(result -> idRef.set(read(result.getResponse().getContentAsString(), "$.id")));
@@ -406,11 +406,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
 
         Map<String, Object> map = new HashMap<>();
-        map.put("subscriptionType", "testType");
+        map.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
-        sub_list.put("name", "Frequency");
+        sub_list.put("name", "frequency");
-        sub_list.put("value", "daily");
+        sub_list.put("value", "W");
         list.add(sub_list);
         map.put("subscriptionParameterList", list);
 
@@ -426,9 +426,9 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                                    .content(new ObjectMapper().writeValueAsString(map))
                                    .contentType(MediaType.APPLICATION_JSON_VALUE))
                        .andExpect(status().isCreated())
-                       .andExpect(jsonPath("$.subscriptionType", is("testType")))
+                       .andExpect(jsonPath("$.subscriptionType", is("content")))
-                       .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("Frequency")))
+                       .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("frequency")))
-                       .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("daily")))
+                       .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("W")))
                        .andExpect(jsonPath("$._links.eperson.href", Matchers.endsWith("eperson")))
                        .andExpect(jsonPath("$._links.resource.href", Matchers.endsWith("resource")))
                        .andDo(result -> idRef.set(read(result.getResponse().getContentAsString(), "$.id")));
@@ -442,10 +442,10 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
 
         Map<String, Object> map = new HashMap<>();
-        map.put("type", "testType");
+        map.put("type", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
-        sub_list.put("name", "Frequency");
+        sub_list.put("name", "frequency");
         sub_list.put("value", "daily");
         list.add(sub_list);
         map.put("subscriptionParameterList", list);
@@ -454,7 +454,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
         getClient(tokenEPerson).perform(post("/api/core/subscriptions")
-                               .param("dspace_object_id", publicItem.getID().toString())
+                               .param("resource", publicItem.getID().toString())
                                .param("eperson_id", eperson.getID().toString())
                                .content(new ObjectMapper().writeValueAsString(map))
                                .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -471,11 +471,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                                      .build();
 
         Map<String, Object> map = new HashMap<>();
-        map.put("subscriptionType", "testType");
+        map.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
-        sub_list.put("name", "Frequency");
+        sub_list.put("name", "frequency");
-        sub_list.put("value", "Daily");
+        sub_list.put("value", "D");
         list.add(sub_list);
         map.put("subscriptionParameterList", list);
 
@@ -495,11 +495,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Frequency");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("Daily");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "Test", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(delete("/api/core/subscriptions/" + subscription.getID()))
@@ -511,16 +511,19 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Frequency");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("Daily");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription =  SubscribeBuilder.subscribeBuilder(context,
-                                     "Test", publicItem, eperson, subscriptionParameterList).build();
+                                     "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
         getClient(tokenAdmin).perform(delete("/api/core/subscriptions/" + subscription.getID()))
                              .andExpect(status().isNoContent());
+
+        getClient(tokenAdmin).perform(get("/api/core/subscriptions/" + subscription.getID()))
+                             .andExpect(status().isNotFound());
     }
 
     @Test
@@ -528,11 +531,11 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Frequency");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("Daily");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription =  SubscribeBuilder.subscribeBuilder(context,
-                                     "Test", publicItem, admin, subscriptionParameterList).build();
+                                     "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -556,12 +559,12 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter1");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                "TestType", publicItem, admin, subscriptionParameterList).build();
+                "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
         Map<String, Object> newSubscription = new HashMap<>();
-        newSubscription.put("subscriptionType", "test");
+        newSubscription.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
         sub_list.put("name", "frequency");
@@ -570,7 +573,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         newSubscription.put("subscriptionParameterList", list);
 
         getClient().perform(put("/api/core/subscriptions/" + subscription.getID())
-                   .param("dspace_object_id", publicItem.getID().toString())
+                   .param("resource", publicItem.getID().toString())
                    .param("eperson_id", admin.getID().toString())
                    .content(objectMapper.writeValueAsString(newSubscription))
                    .contentType(MediaType.APPLICATION_JSON_VALUE))
@@ -582,27 +585,27 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         context.turnOffAuthorisationSystem();
         List<SubscriptionParameter> subscriptionParameterList = new ArrayList<>();
         SubscriptionParameter subscriptionParameter = new SubscriptionParameter();
-        subscriptionParameter.setName("Parameter1");
+        subscriptionParameter.setName("frequency");
-        subscriptionParameter.setValue("ValueParameter1");
+        subscriptionParameter.setValue("D");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, admin, subscriptionParameterList).build();
+                                    "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
         Map<String, Object> newSubscription = new HashMap<>();
-        newSubscription.put("subscriptionType", "test");
+        newSubscription.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
-        sub_list.put("name", "Frequency");
+        sub_list.put("name", "frequency");
-        sub_list.put("value", "Daily");
+        sub_list.put("value", "W");
         list.add(sub_list);
         newSubscription.put("subscriptionParameterList", list);
 
         String token = getAuthToken(eperson.getEmail(), password);
         getClient(token).perform(put("/api/core/subscriptions/" + subscription.getID())
                         .param("eperson_id", admin.getID().toString())
-                        .param("dspace_object_id", publicItem.getID().toString())
+                        .param("resource", publicItem.getID().toString())
                         .content(objectMapper.writeValueAsString(newSubscription))
                         .contentType(MediaType.APPLICATION_JSON_VALUE))
                         .andExpect(status().isForbidden());
@@ -617,12 +620,12 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("Daily");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
         Map<String, Object> newSubscription = new HashMap<>();
-        newSubscription.put("subscriptionType", "test");
+        newSubscription.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
         sub_list.put("name", "Frequency");
@@ -638,7 +641,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                                   .contentType(MediaType.APPLICATION_JSON_VALUE))
                                   .andExpect(status().isOk())
                                   .andExpect(content().contentType(contentType))
-                                  .andExpect(jsonPath("$.subscriptionType", is("test")))
+                                  .andExpect(jsonPath("$.subscriptionType", is("content")))
                                   .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("Frequency")))
                                   .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("WEEKLY")))
                                   .andExpect(jsonPath("$._links.eperson.href", Matchers.endsWith("/eperson")))
@@ -654,12 +657,12 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("Daily");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         ObjectMapper objectMapper = new ObjectMapper();
         Map<String, Object> newSubscription = new HashMap<>();
-        newSubscription.put("subscriptionType", "test");
+        newSubscription.put("subscriptionType", "content");
         List<Map<String, Object>> list = new ArrayList<>();
         Map<String, Object> sub_list = new HashMap<>();
         sub_list.put("name", "Frequency");
@@ -675,7 +678,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
                              .contentType(MediaType.APPLICATION_JSON_VALUE))
                              .andExpect(status().isOk())
                              .andExpect(content().contentType(contentType))
-                             .andExpect(jsonPath("$.subscriptionType", is("test")))
+                             .andExpect(jsonPath("$.subscriptionType", is("content")))
                              .andExpect(jsonPath("$.subscriptionParameterList[0].name", is("Frequency")))
                              .andExpect(jsonPath("$.subscriptionParameterList[0].value", is("WEEKLY")))
                              .andExpect(jsonPath("$._links.eperson.href", Matchers.endsWith("/eperson")))
@@ -691,7 +694,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(admin.getEmail(), password);
@@ -709,7 +712,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -727,7 +730,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/" + subscription.getID() + "/ePerson"))
@@ -743,7 +746,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, admin, subscriptionParameterList).build();
+                                    "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);
@@ -790,7 +793,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenAdmin = getAuthToken(eperson.getEmail(), password);
@@ -813,7 +816,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, eperson, subscriptionParameterList).build();
+                                    "content", publicItem, eperson, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         getClient().perform(get("/api/core/subscriptions/" + subscription.getID() + "/dSpaceObject"))
@@ -829,7 +832,7 @@ public class SubscriptionRestRepositoryIT extends AbstractControllerIntegrationT
         subscriptionParameter.setValue("ValueParameter");
         subscriptionParameterList.add(subscriptionParameter);
         Subscription subscription = SubscribeBuilder.subscribeBuilder(context,
-                                    "TestType", publicItem, admin, subscriptionParameterList).build();
+                                    "content", publicItem, admin, subscriptionParameterList).build();
         context.restoreAuthSystemState();
 
         String tokenEPerson = getAuthToken(eperson.getEmail(), password);

dspace/config/spring/api/subscriptions_email_configuration.xml

@@ -16,8 +16,8 @@
            http://www.springframework.org/schema/util
            http://www.springframework.org/schema/util/spring-util.xsd">
 
-    <bean class="org.dspace.subscriptions.SubscriptionEmailNotificationService">
+    <bean class="org.dspace.subscriptions.SubscriptionEmailNotificationServiceImpl">
-        <constructor-arg name="generators">
+        <constructor-arg name="subscriptionType2generators">
             <map>
                 <entry key="content" value-ref="contentNotifyGenerator"/>
             </map>
@@ -29,8 +29,19 @@
                 <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>