Merge pull request DSpace#10963 from atmire/main-fix-email-templates

Rework how subscription emails are send out

Author: tdonohue

dspace-api/pom.xml

@@ -959,5 +959,11 @@
             <artifactId>mockwebserver</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.icegreen</groupId>
+            <artifactId>greenmail</artifactId>
+            <version>1.6.5</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

dspace-api/src/main/java/org/dspace/content/crosswalk/SubscriptionDsoMetadataForEmailCompose.java

@@ -16,6 +16,7 @@
 import java.util.List;
 import java.util.Objects;
 
+import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.dspace.content.DSpaceObject;
 import org.dspace.content.Item;
 import org.dspace.content.service.ItemService;
@@ -31,7 +32,7 @@
  */
 public class SubscriptionDsoMetadataForEmailCompose implements StreamDisseminationCrosswalk {
 
-    private List<String> metadata = new ArrayList<>();
+    private List<ImmutablePair<String, String>> metadata = new ArrayList<>();
 
     @Autowired
     private ItemService itemService;
@@ -46,7 +47,7 @@ public void disseminate(Context context, DSpaceObject dso, OutputStream out) thr
         if (dso.getType() == Constants.ITEM) {
             Item item = (Item) dso;
             PrintStream printStream = new PrintStream(out);
-            for (String actualMetadata : metadata) {
+            for (String actualMetadata : metadata.stream().map(ImmutablePair::getLeft).toList()) {
                 String[] split = actualMetadata.split("\\.");
                 String qualifier = null;
                 if (split.length == 3) {
@@ -69,11 +70,11 @@ public String getMIMEType() {
         return "text/plain";
     }
 
-    public List<String> getMetadata() {
+    public List<ImmutablePair<String, String>> getMetadata() {
         return metadata;
     }
 
-    public void setMetadata(List<String> metadata) {
+    public void setMetadata(List<ImmutablePair<String, String>> metadata) {
         this.metadata = metadata;
     }
 

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

@@ -7,21 +7,39 @@
  */
 package org.dspace.subscriptions;
 
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.partitioningBy;
+import static java.util.stream.Collectors.toList;
 import static org.apache.commons.lang3.StringUtils.EMPTY;
 
-import java.io.ByteArrayOutputStream;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
 
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
 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.DCDate;
 import org.dspace.content.Item;
-import org.dspace.content.crosswalk.StreamDisseminationCrosswalk;
+import org.dspace.content.MetadataValue;
+import org.dspace.content.crosswalk.SubscriptionDsoMetadataForEmailCompose;
 import org.dspace.content.service.ItemService;
 import org.dspace.core.Context;
 import org.dspace.core.Email;
@@ -36,36 +54,79 @@
  * which will handle the logic of sending the emails
  * in case of 'content' subscriptionType
  */
+@org.springframework.stereotype.Component
 @SuppressWarnings("rawtypes")
 public class ContentGenerator implements SubscriptionGenerator<IndexableObject> {
 
     private final Logger log = LogManager.getLogger(ContentGenerator.class);
 
     @SuppressWarnings("unchecked")
-    private Map<String, StreamDisseminationCrosswalk> entityType2Disseminator = new HashMap();
+    private Map<String, SubscriptionDsoMetadataForEmailCompose> entityType2Disseminator = new HashMap();
 
     @Autowired
     private ItemService itemService;
 
+    private static final int MAX_METADATA_VALUES = 3;
+    private static final String NEW_ITEMS_LABEL_KEY = "org.dspace.subscriptions.ContentGenerator.new-items-label";
+    private static final String MODIFIED_ITEMS_LABEL_KEY =
+            "org.dspace.subscriptions.ContentGenerator.modified-items-label";
+    private static final String INTRO_NEW_AND_MODIFIED_KEY =
+            "org.dspace.subscriptions.ContentGenerator.intro.new-and-modified";
+    private static final String INTRO_NEW_KEY = "org.dspace.subscriptions.ContentGenerator.intro.new";
+    private static final String INTRO_MODIFIED_KEY = "org.dspace.subscriptions.ContentGenerator.intro.modified";
+    private static final String COMMUNITY_NOTE_PREFIX_KEY =
+            "org.dspace.subscriptions.ContentGenerator.community-note-prefix";
+    private static final String COMMUNITY_NOTE_SUFFIX_KEY =
+            "org.dspace.subscriptions.ContentGenerator.community-note-suffix";
+    private static final String LINE_SEPARATOR = System.lineSeparator();
+
+    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
+        Set<Object> seen = ConcurrentHashMap.newKeySet();
+        return t -> seen.add(keyExtractor.apply(t));
+    }
+
     @Override
     public void notifyForSubscriptions(Context context, EPerson ePerson,
-                                       List<IndexableObject> indexableComm,
-                                       List<IndexableObject> indexableColl) {
+                                       Map<Community, List<IndexableObject>> commMap,
+                                       Map<Collection, List<IndexableObject>> collMap) {
         try {
             if (Objects.nonNull(ePerson)) {
                 Locale supportedLocale = I18nUtil.getEPersonLocale(ePerson);
                 Email email = Email.getEmail(I18nUtil.getEmailFilename(supportedLocale, "subscriptions_content"));
                 email.addRecipient(ePerson.getEmail());
 
-                String bodyCommunities = generateBodyMail(context, indexableComm);
-                String bodyCollections = generateBodyMail(context, indexableColl);
-                if (bodyCommunities.equals(EMPTY) && bodyCollections.equals(EMPTY)) {
-                    log.debug("subscription(s) of eperson {} do(es) not match any new items: nothing to send" +
-                            " - exit silently", ePerson::getID);
+                // Create a map which holds the collections and their corresponding community names if we have updates
+                // That originally came from a community subscription, so we can refer to this in the email
+                Map<Collection, String> collectionToCommunityNameMap = buildCommunityCollectionMap(commMap);
+                List<IndexableObject> allItems = new ArrayList<>();
+                if (commMap != null) {
+                    commMap.values().forEach(allItems::addAll);
+                }
+                if (collMap != null) {
+                    collMap.values().forEach(allItems::addAll);
+                }
+
+                Map<Boolean, List<IndexableObject>> partitionedItems = allItems.stream()
+                        .filter(distinctByKey(IndexableObject::getID))
+                        .collect(partitioningBy(obj -> isNewItem((Item) obj.getIndexedObject())));
+
+                Map<Collection, List<IndexableObject>> newItemsByCollection = partitionedItems.get(true).stream()
+                        .collect(groupingBy(obj -> ((Item) obj.getIndexedObject()).getOwningCollection()));
+
+                Map<Collection, List<IndexableObject>> modifiedItemsByCollection = partitionedItems.get(false).stream()
+                        .collect(groupingBy(obj -> ((Item) obj.getIndexedObject()).getOwningCollection()));
+
+                String intro = buildIntro(newItemsByCollection, modifiedItemsByCollection, supportedLocale);
+                String combinedSection = buildCombinedSection(newItemsByCollection, modifiedItemsByCollection,
+                        collectionToCommunityNameMap, supportedLocale);
+
+                if (combinedSection.equals(EMPTY)) {
+                    log.debug("subscription(s) of eperson {} do(es) not match any new or modified items: " +
+                            "nothing to send - exit silently", ePerson::getID);
                     return;
                 }
-                email.addArgument(bodyCommunities);
-                email.addArgument(bodyCollections);
+                email.addArgument(intro);
+                email.addArgument(combinedSection);
                 email.send();
             }
         } catch (Exception e) {
@@ -74,30 +135,166 @@ public void notifyForSubscriptions(Context context, EPerson ePerson,
         }
     }
 
-    private String generateBodyMail(Context context, List<IndexableObject> indexableObjects) {
-        if (indexableObjects == null || indexableObjects.isEmpty()) {
+    private static Map<Collection, String> buildCommunityCollectionMap(Map<Community, List<IndexableObject>> commMap) {
+        if (commMap == null) {
+            return Collections.emptyMap();
+        }
+        Map<Collection, String> resultMap = new HashMap<>();
+        commMap.forEach((community, items) -> items.forEach(obj -> {
+            Item item = (Item) obj.getIndexedObject();
+            Collection collection = item.getOwningCollection();
+            resultMap.putIfAbsent(collection, community.getName());
+        }));
+        return resultMap;
+    }
+
+    private boolean isNewItem(Item item) {
+        Optional<ZonedDateTime> createdDate =
+                itemService.getMetadata(item, "dc", "date", "accessioned", Item.ANY)
+                           .stream()
+                           .map(MetadataValue::getValue)
+                           .findFirst()
+                           .map(val -> new DCDate(val).toDate().toInstant())
+                           .map(instant -> ZonedDateTime.ofInstant(instant, ZoneOffset.UTC));
+
+        ZonedDateTime lastModified = ZonedDateTime.ofInstant(item.getLastModified(), ZoneOffset.UTC);
+
+        return createdDate.map(createdZoned -> createdZoned.truncatedTo(ChronoUnit.SECONDS)
+                                                           .equals(lastModified.truncatedTo(ChronoUnit.SECONDS)))
+                          .orElse(false);
+    }
+
+    private String buildIntro(Map<Collection, List<IndexableObject>> newItems,
+                              Map<Collection, List<IndexableObject>> modifiedItems,
+                              Locale locale) {
+        if (!newItems.isEmpty() && !modifiedItems.isEmpty()) {
+            return I18nUtil.getMessage(INTRO_NEW_AND_MODIFIED_KEY, locale);
+        } else if (!newItems.isEmpty()) {
+            return I18nUtil.getMessage(INTRO_NEW_KEY, locale);
+        } else if (!modifiedItems.isEmpty()) {
+            return I18nUtil.getMessage(INTRO_MODIFIED_KEY, locale);
+        } else {
+            return "";
+        }
+    }
+
+    private String buildCombinedSection(Map<Collection, List<IndexableObject>> newItemsByCollection,
+                                        Map<Collection, List<IndexableObject>> modifiedItemsByCollection,
+                                        Map<Collection, String> collectionToCommunity,
+                                        Locale locale) {
+        if (newItemsByCollection.isEmpty() && modifiedItemsByCollection.isEmpty()) {
             return EMPTY;
         }
-        try {
-            ByteArrayOutputStream out = new ByteArrayOutputStream();
-            out.write("\n".getBytes(UTF_8));
-            for (IndexableObject indexableObject : indexableObjects) {
-                out.write("\n".getBytes(UTF_8));
-                Item item = (Item) indexableObject.getIndexedObject();
-                String entityType = itemService.getEntityTypeLabel(item);
-                Optional.ofNullable(entityType2Disseminator.get(entityType))
-                        .orElseGet(() -> entityType2Disseminator.get("Item"))
-                        .disseminate(context, item, out);
+
+        StringBuilder sb = new StringBuilder();
+        Set<Collection> allCollections = new HashSet<>();
+        allCollections.addAll(newItemsByCollection.keySet());
+        allCollections.addAll(modifiedItemsByCollection.keySet());
+
+        for (Collection collection : allCollections) {
+            String header = buildCollectionHeader(collection, collectionToCommunity, locale);
+            sb.append(header);
+
+            List<IndexableObject> newItems = newItemsByCollection.get(collection);
+            List<IndexableObject> modifiedItems = modifiedItemsByCollection.get(collection);
+            if (newItems != null && !newItems.isEmpty()) {
+                sb.append(buildSectionHeader(I18nUtil.getMessage(NEW_ITEMS_LABEL_KEY, locale), newItems.size()));
+                sb.append(buildItemsBlock(newItems));
+            }
+            if (modifiedItems != null && !modifiedItems.isEmpty()) {
+                sb.append(buildSectionHeader(I18nUtil.getMessage(MODIFIED_ITEMS_LABEL_KEY, locale),
+                        modifiedItems.size()));
+                sb.append(buildItemsBlock(modifiedItems));
+            }
+            sb.append(LINE_SEPARATOR);
+        }
+        return sb.toString();
+    }
+
+    private String buildCollectionHeader(Collection collection, Map<Collection, String> collectionToCommunity,
+                                         Locale locale) {
+        String name = collection.getName();
+        String communityNote = "";
+        if (collectionToCommunity != null && collectionToCommunity.containsKey(collection)) {
+            communityNote = I18nUtil.getMessage(COMMUNITY_NOTE_PREFIX_KEY, locale)
+                    + collectionToCommunity.get(collection)
+                    + I18nUtil.getMessage(COMMUNITY_NOTE_SUFFIX_KEY, locale);
+        }
+        String fullHeader = name + communityNote + ":" + LINE_SEPARATOR;
+        String underline = "-".repeat(Math.max(0, name.length() + communityNote.length())) + LINE_SEPARATOR;
+        return fullHeader + underline;
+    }
+
+    private String buildSectionHeader(String label, int count) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("  ").append(label).append(" (").append(count).append("):")
+          .append(LINE_SEPARATOR).append(LINE_SEPARATOR);
+        return sb.toString();
+    }
+
+    private String buildItemsBlock(List<IndexableObject> items) {
+        StringBuilder sb = new StringBuilder();
+        for (IndexableObject obj : items) {
+            Item item = (Item) obj.getIndexedObject();
+            sb.append(formatItem(item)).append(LINE_SEPARATOR).append(LINE_SEPARATOR);
+        }
+        return sb.toString();
+    }
+
+    private String formatItem(Item item) {
+        String entityType = itemService.getEntityTypeLabel(item);
+        SubscriptionDsoMetadataForEmailCompose crosswalk = entityType2Disseminator.get(entityType);
+        if (crosswalk == null) {
+            crosswalk = entityType2Disseminator.get("Item"); // fallback
+        }
+        if (crosswalk == null) {
+            throw new IllegalStateException("No crosswalk found for entity type: " + entityType);
+        }
+        StringBuilder sb = new StringBuilder();
+        for (ImmutablePair<String, String> mdPair: crosswalk.getMetadata()) {
+            String field = mdPair.getLeft();
+            String label = mdPair.getRight();
+            List<String> values = getAllMetadata(item, field);
+            if (!values.isEmpty()) {
+                addIfNotBlank(sb, label + ": ", values);
+            }
+        }
+        return sb.toString();
+    }
+
+    private void addIfNotBlank(StringBuilder sb, String label, List<String> values) {
+        if (values != null && !values.isEmpty()) {
+            List<String> nonBlankValues = values.stream()
+                                                .filter(StringUtils::isNotBlank)
+                                                .collect(toList());
+
+            if (!nonBlankValues.isEmpty()) {
+                String joined = nonBlankValues.stream()
+                                              .limit(MAX_METADATA_VALUES)
+                                              .collect(joining(", "));
+                sb.append("\t").append(label).append(joined);
+                if (nonBlankValues.size() > MAX_METADATA_VALUES) {
+                    sb.append(", ...");
+                }
+                sb.append(LINE_SEPARATOR);
             }
-            out.close();
-            return out.toString();
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
         }
-        return EMPTY;
     }
 
-    public void setEntityType2Disseminator(Map<String, StreamDisseminationCrosswalk> entityType2Disseminator) {
+    private List<String> getAllMetadata(Item item, String field) {
+        String[] fieldParts = field.split("\\.");
+        String schema = fieldParts[0];
+        String element = fieldParts[1];
+        String qualifier = fieldParts.length > 2 ? fieldParts[2] : null;
+        return itemService.getMetadata(item, schema, element, qualifier, Item.ANY)
+                          .stream()
+                          .map(MetadataValue::getValue)
+                          .filter(Objects::nonNull)
+                          .collect(toList());
+    }
+
+    public void setEntityType2Disseminator(Map<String, SubscriptionDsoMetadataForEmailCompose>
+                                                   entityType2Disseminator) {
         this.entityType2Disseminator = entityType2Disseminator;
     }