/**
    * This file Copyright (c) 2003-2017 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.forum;
  
  import info.magnolia.cms.core.Content;
  import info.magnolia.cms.core.HierarchyManager;
  import info.magnolia.cms.core.NodeData;
  import info.magnolia.cms.core.Path;
  import info.magnolia.cms.security.AccessDeniedException;
  import info.magnolia.cms.security.AccessManager;
  import info.magnolia.cms.security.Permission;
  import info.magnolia.cms.security.Role;
  import info.magnolia.cms.security.RoleManager;
  import info.magnolia.cms.security.SecuritySupport;
  import info.magnolia.cms.security.User;
  import info.magnolia.cms.security.UserManager;
  import info.magnolia.cms.util.ExclusiveWrite;
  import info.magnolia.cms.util.HierarchyManagerUtil;
  import info.magnolia.cms.util.NodeDataUtil;
  import info.magnolia.cms.util.SiblingsHelper;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.module.ModuleRegistry;
  
  import java.text.MessageFormat;
  import java.util.Calendar;
  import java.util.Collection;
  
  import javax.jcr.RepositoryException;
  import javax.jcr.query.Query;
  import javax.jcr.query.QueryManager;
  import javax.jcr.query.QueryResult;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.lang3.time.DateFormatUtils;
  
  /**
   * Default implementation of the {@link info.magnolia.module.forum.ForumManager} .
   * 
   * @author gjoseph
   * @version $Revision: $ ($Author: $)
   */
  public class DefaultForumManager implements ForumManager {
      private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(DefaultForumManager.class);
  
      public static final String FORUM_WORKSPACE = "forum";
      public static final String FORUM_NODETYPE = "mgnl:forum";
      public static final String THREAD_NODETYPE = "mgnl:thread";
      public static final String MESSAGE_NODETYPE = "mgnl:message";
      public static final String ALLOWS_NESTING_MESSAGES = "allowsNestingMessages";
      public static final String VALIDATED_PROPERTY = "validated";
      public static final String LOCKED_PROPERTY = "locked";
      public static final String FIRST_MESSAGE_PROPERTY = "firstMessage";
      public static final String LAST_MESSAGE_PROPERTY = "lastMessage";
      public static final String CREATION_DATE_PROPERTY = "creationDate";
      public static final String TITLE_PROPERTY = "title";
      public static final String AUTHORID_PROPERTY = "authorId";
      public static final String CONTENT_PROPERTY = "content";
  
      public static final String ROLE_FORUM_ALL_ADMIN = "forum_ALL-admin";
      public static final String ROLE_FORUM_ALL_MODERATOR = "forum_ALL-moderator";
      public static final String ROLE_FORUM_ALL_USER = "forum_ALL-user";
  
      /**
       * @deprecated since 3.3 This role is no more supported.
       */
      public static final String ROLE_FORUM_BASE = "forum-base";
      /**
       * @deprecated since 3.3 This role is no more supported.
      */
     public static final String ROLE_FORUM_MODERATOR_BASE = "forum-moderator-base";
 
     private static final String MESSAGES_QUERY_PATTERN = "select * from mgnl:message where jcr:path like ''{0}/%'' and (" + VALIDATED_PROPERTY + "=''true''{1}){2}";
     private static final String SHOW_UNVALIDATED_MESSAGES_CLAUSE = " or " + VALIDATED_PROPERTY + " is null";
 
     private final ForumConfiguration config;
 
     public DefaultForumManager() {
         this(ModuleRegistry.Factory.getInstance().getModuleInstance(ForumConfiguration.class));
     }
 
     /** for tests - or when we finally have IOC. */
     public DefaultForumManager(ForumConfiguration config) {
         this.config = config;
     }
 
     @Override
     public Collection<Content> getForumList() throws RepositoryException {
         final HierarchyManager hm = getHierarchyManager();
         return hm.getRoot().getChildren(FORUM_NODETYPE);
     }
 
     @Override
     public String getForumId(String shortName) throws RepositoryException {
         if (!StringUtils.startsWith(shortName, "/")) {
             shortName = "/" + shortName;
         }
         return getHierarchyManager().getContent(shortName).getUUID();
     }
 
     @Override
     public Content getForum(String forumID) throws RepositoryException {
         final HierarchyManager hm = getHierarchyManager();
         return getForum(hm, forumID);
     }
 
     @Override
     public Collection<Content> getThreads(Content forum) throws RepositoryException {
         final boolean showingUnvalidatedMessages = config.isShowingUnvalidatedMessages();
         return forum.getChildren(new ThreadsFilter(showingUnvalidatedMessages));
     }
 
     @Override
     public Content createForum(String name, String title) throws RepositoryException {
         return createForum(name, title, false);
     }
 
     @Override
     public Content createForum(String name, String title, boolean withMessageNesting) throws RepositoryException {
         final HierarchyManager hm = getHierarchyManager();
         final String cleanName = Path.getUniqueLabel(hm.getWorkspace().getSession(), "/", cleanup(name));
         final Content repoRoot = hm.getRoot();
         final Content newForum = repoRoot.createContent(cleanName, FORUM_NODETYPE);
         newForum.createNodeData("title", title);
         newForum.setNodeData(ALLOWS_NESTING_MESSAGES, withMessageNesting);
         repoRoot.save();
 
         if (config.isCreateRolesForNewForums()) {
             createForumRoles(newForum);
         }
         return newForum;
     }
 
     protected void createForumRoles(Content forumNode) {
         final String forumName = forumNode.getName();
         final String path = forumNode.getHandle();
         // create roles with system context
         MgnlContext.doInSystemContext(new MgnlContext.VoidOp() {
             @Override
             public void doExec() {
                 try {
                     final RoleManager roleManager = SecuritySupport.Factory.getInstance().getRoleManager();
                     String roleName = "forum-" + forumName + "-user";
                     if (roleManager.getRole(roleName) == null) {
                         final Role user = roleManager.createRole(roleName);
                         addPermission(user, path, Permission.ALL, roleManager);
                     }
                 } catch (Exception e) {
                     throw new RuntimeException(e);
                 }
             }
         });
     }
 
     protected void addPermission(Role user, String path, long permission, RoleManager roleManager) {
         roleManager.addPermission(user, config.getRepository(), path, permission);
         roleManager.addPermission(user, config.getRepository(), path + "/*", permission);
     }
 
     @Override
     public Content createThread(String forumID, String threadTitle, String messageText, String author, boolean isAnonymous) throws RepositoryException {
         return createThread(forumID, threadTitle, threadTitle, messageText, author, isAnonymous);
     }
 
     @Override
     public Content createThread(String forumID, String threadTitle, String messageTitle, String messageText, String author, boolean isAnonymous) throws RepositoryException {
         // validation (TODO : more? or we leave that up to client code, i.e some web framework - here we just validate arguments to avoid jcr failures)
         if (StringUtils.isEmpty(threadTitle)) {
             throw new IllegalArgumentException("Thread title must be specified");
         }
         final HierarchyManager hm = getHierarchyManager();
         final Content forum = getForum(hm, forumID);
         checkedLockedOrModerator(hm, forum);
 
         final String shortTitle = cleanup(threadTitle);
         final Content thread = forum.createContent(shortTitle, THREAD_NODETYPE);
         thread.createNodeData(TITLE_PROPERTY, threadTitle);
         final String messageName = generateMessageName();
         final Content message = createMessageInThread(forum, thread, messageName, messageTitle, messageText, author, isAnonymous);
         thread.createNodeData(DefaultForumManager.FIRST_MESSAGE_PROPERTY, message);
         forum.save();
         return thread;
     }
 
     @Override
     public Content replyToThread(String threadID, String inReplyToID, String messageTitle, String messageText, String author, boolean isAnonymous) throws RepositoryException {
         synchronized (ExclusiveWrite.getInstance()) {
             final HierarchyManager hm = getHierarchyManager();
             final Content thread = getThread(hm, threadID);
             final Content forum = getForumFromThread(thread);
             checkedLockedOrModerator(hm, thread);
 
             final Content inReplyTo;
             if (inReplyToID != null) {
                 inReplyTo = hm.getContentByUUID(inReplyToID);
             } else {
                 inReplyTo = null;
             }
 
             final String messageName = generateMessageName();
             final Content newMessage = createMessageInThread(forum, thread, inReplyTo, messageName, messageTitle, messageText, author, isAnonymous);
             forum.save();
             return newMessage;
         }
     }
 
     @Override
     public boolean isAllowedToPostOnForum(Content forum) {
         return isAllowedToPostOn(forum);
     }
 
     @Override
     public boolean isAllowedToPostOnThread(Content thread) {
         return isAllowedToPostOn(thread);
     }
 
     protected boolean isAllowedToPostOn(Content node) {
         try {
             final AccessManager am = MgnlContext.getAccessManager(node.getWorkspace().getName());
             return am.isGranted(node.getHandle(), Permission.WRITE);
         } catch (RepositoryException e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * Throws an exception if thread is locked and user is not moderator.
      */
     protected void checkedLockedOrModerator(HierarchyManager hm, Content node) throws AccessDeniedException {
         final boolean locked = node.getNodeData(LOCKED_PROPERTY).getBoolean();
         if (locked) {
             isModerator(hm, node);
         }
     }
 
     /**
      * Throws an exception if user is not moderator for the given node.
      */
     protected void isModerator(HierarchyManager hm, Content node) throws AccessDeniedException {
         /*
          * since we are using a more simplified security on forum shipped with M5.x-versions, this check here will be role- instead of ACL-based
          * see MGNLFORUM-250, MGNLFORUM-254
          */
         isModerator();
     }
 
     @Override
     public void isModerator() throws AccessDeniedException{
         User currentUser = MgnlContext.getUser();
         // Needs to use getAllRoles() instead of .hasRole() because .hasRole() will only check for the roles directly attached to the user, but not the ones inherited from the group.
         // As roles can not directly be attached to a AD user, it is crucial to be able to define it over its group.
         Collection<String> allRoles = currentUser.getAllRoles();
         if (!allRoles.contains(ROLE_FORUM_ALL_MODERATOR) && !allRoles.contains(ROLE_FORUM_ALL_ADMIN)) {
             throw new AccessDeniedException("User not allowed to perform that action.");
         }
     }
 
     @Override
     public Content getThread(String threadID) throws RepositoryException {
         final HierarchyManager hm = getHierarchyManager();
         return getThread(hm, threadID);
     }
 
     @Override
     public PagedResult getMessages(Content thread, long page) throws RepositoryException {
         if (page <= 0) {
             throw new IllegalArgumentException("Page number must be >= 1");
         }
 
         final boolean showingUnvalidatedMessages = config.isShowingUnvalidatedMessages();
 
         final String threadPath = thread.getHandle();
         final HierarchyManager hm = getHierarchyManager();
         final QueryManager qm = hm.getWorkspace().getQueryManager();
         final Query query = qm.createQuery(getMessagesQueryString(threadPath, showingUnvalidatedMessages, ""), Query.SQL);
         final QueryResult queryResult = query.execute();
 
         final Pager pager = new Pager(hm, queryResult);
         final long skip = config.getMessagesPerPage() * (page - 1);
         return pager.page(skip, config.getMessagesPerPage());
     }
 
     @Override
     public Collection<Content> getForumMessages(String forumName) throws RepositoryException {
         final String forumPath = "/" + forumName;
         final boolean showUnvalidatedMessages = config.isShowingUnvalidatedMessages();
         final String sql = getMessagesQueryString(forumPath, showUnvalidatedMessages, " order by creationDate desc");
         final HierarchyManager hm = getHierarchyManager();
         final info.magnolia.cms.core.search.QueryManager qm = hm.getQueryManager();
         info.magnolia.cms.core.search.Query query = qm.createQuery(sql, Query.SQL);
         info.magnolia.cms.core.search.QueryResult result = query.execute();
         return result.getContent(MESSAGE_NODETYPE);
     }
 
     protected String getMessagesQueryString(String path, boolean showUnvalidatedMessages, String orderClause) {
         return MessageFormat.format(MESSAGES_QUERY_PATTERN, new String[] { path, showUnvalidatedMessages ? SHOW_UNVALIDATED_MESSAGES_CLAUSE : "", orderClause });
     }
 
     @Override
     public Content getForumFromThread(Content thread) throws RepositoryException {
         // we go up the ancestors until we find a mgnl:forum, in case stuff is nested ?
         Content forum = thread.getParent();
         while (!forum.isNodeType(FORUM_NODETYPE)) {
             forum = forum.getParent();
         }
         return forum;
     }
 
     @Override
     public Content getThreadFromMessage(Content message) throws RepositoryException {
         // we go up the ancestors until we find a mgnl:forum, in case messages are nested
         Content thread = message.getParent();
         while (!thread.isNodeType(THREAD_NODETYPE)) {
             thread = thread.getParent();
         }
         return thread;
     }
 
     protected Content getForum(HierarchyManager hm, String forumID) throws RepositoryException {
         return hm.getContentByUUID(forumID);
     }
 
     protected Content getThread(HierarchyManager hm, String threadID) throws RepositoryException {
         return hm.getContentByUUID(threadID);
     }
 
     @Override
     public void deleteForum(String forumID) throws RepositoryException {
         deleteByUuid(forumID);
     }
 
     @Override
     public void deleteThread(String threadID) throws RepositoryException {
         // ensure forum last message ref is not in this thread
         final Content thread = getThread(threadID);
         final Content forum = getForumFromThread(thread);
         isModerator(getHierarchyManager(), thread);
         checkAndUpdateLastMessage(forum, threadID);
         deleteByUuid(threadID);
     }
 
     @Override
     public void deleteMessage(String messageID) throws RepositoryException {
         final Content message = getHierarchyManager().getContentByUUID(messageID);
         final Content thread = getThreadFromMessage(message);
         isModerator(getHierarchyManager(), message);
 
         // last message first
         checkAndUpdateLastMessage(thread, messageID);
         // and also check the first message
         if (messageID.equals(thread.getNodeData(FIRST_MESSAGE_PROPERTY).getString())) {
             SiblingsHelper siblings = SiblingsHelper.of(message);
             if (siblings.isLast()) {
                 throw new UnsupportedOperationException("Thread needs at least one message. Create another message first or delete whole thread.");
             } else {
                 Content nextMessage = siblings.next();
                 thread.deleteNodeData(FIRST_MESSAGE_PROPERTY);
                 thread.createNodeData(FIRST_MESSAGE_PROPERTY, nextMessage);
             }
         }
         deleteByUuid(messageID);
     }
 
     @Override
     public void lockForum(String forumID) throws RepositoryException {
         changeLock(forumID, true);
     }
 
     @Override
     public void unlockForum(String forumID) throws RepositoryException {
         changeLock(forumID, false);
     }
 
     @Override
     public void lockThread(String threadID) throws RepositoryException {
         changeLock(threadID, true);
     }
 
     @Override
     public void unlockThread(String threadID) throws RepositoryException {
         changeLock(threadID, false);
     }
 
     @Override
     public void validate(String messageID) throws RepositoryException {
         changeValidationState(messageID, true);
     }
 
     @Override
     public void invalidate(String messageID) throws RepositoryException {
         changeValidationState(messageID, false);
     }
 
     protected void deleteByUuid(String uuid) throws RepositoryException {
         final Content node = getHierarchyManager().getContentByUUID(uuid);
         isModerator(getHierarchyManager(),node);
         final Content parent = node.getParent();
         node.delete();
         parent.save();
     }
 
     protected void changeLock(String uuid, boolean value) throws RepositoryException {
         final HierarchyManager hm = getHierarchyManager();
         final Content node = hm.getContentByUUID(uuid);
         isModerator(hm, node);
         NodeDataUtil.getOrCreateAndSet(node, LOCKED_PROPERTY, value);
         node.save();
     }
 
     protected void changeValidationState(String messageID, boolean value) throws RepositoryException {
         final HierarchyManager hm = getHierarchyManager();
         final Content node = hm.getContentByUUID(messageID);
         isModerator(hm, node);
         NodeDataUtil.getOrCreateAndSet(node, VALIDATED_PROPERTY, value);
         node.save();
     }
 
     /**
      * Creates a message node in the given thread or as a subnode of <tt>inReplyTo</tt> depending on {@link #allowsNestingMessages(info.magnolia.cms.core.Content)} .
      */
     protected Content createMessageInThread(Content forum, Content thread, Content inReplyTo, String messageName, String messageTitle, String messageText, String author, boolean isAnonymous) throws RepositoryException {
         final boolean allowsNestingMessages = allowsNestingMessages(forum);
         final Content parent;
         if (inReplyTo != null && allowsNestingMessages) {
             parent = inReplyTo;
         } else {
             parent = thread;
         }
 
         final Content newMessage = createMessage(parent, messageName, messageTitle, messageText, author, isAnonymous);
         thread.createNodeData(LAST_MESSAGE_PROPERTY, newMessage);
         forum.createNodeData(LAST_MESSAGE_PROPERTY, newMessage);
 
         if (inReplyTo != null && !allowsNestingMessages) {
             newMessage.createNodeData("inReplyTo", inReplyTo);
         }
         return newMessage;
     }
 
     /**
      * Creates a message node in the given thread, assuming the parent is a thread node.
      * 
      * @deprecated use {@link #createMessageInThread(info.magnolia.cms.core.Content, info.magnolia.cms.core.Content, info.magnolia.cms.core.Content, String, String, String, String, boolean)} instead.
      */
     @Deprecated
     protected Content createMessageInThread(Content forum, Content thread, String name, String title, String messageText, String author, boolean isAnonymous) throws RepositoryException {
         return createMessageInThread(forum, thread, null, name, title, messageText, author, isAnonymous);
     }
 
     /**
      * Creates a message node in the given parent, not taking care about the parent node's type.
      */
     protected Content createMessage(Content parent, String name, String title, String messageText, String author, boolean isAnonymous) throws RepositoryException {
         final Content message = parent.createContent(makeNameUnique(parent, name), MESSAGE_NODETYPE);
         if (StringUtils.isNotEmpty(title)) {
             message.createNodeData(TITLE_PROPERTY, title);
         }
         message.createNodeData(CONTENT_PROPERTY, messageText);
         if (!isAnonymous) {
             message.createNodeData(AUTHORID_PROPERTY, author);
         } else {
             message.createNodeData(AUTHORID_PROPERTY, UserManager.ANONYMOUS_USER);
             message.createNodeData("anonymousUsername", author);
         }
         message.createNodeData(CREATION_DATE_PROPERTY, Calendar.getInstance());
         return message;
     }
 
     /**
      * Generates a message name based on the date pattern specified in the
      * configuration via the 'messageNamePattern' property.
      */
     protected String generateMessageName() {
         final String messageNamePattern = config.getMessageNamePattern();
         return DateFormatUtils.format(Calendar.getInstance().getTime(), messageNamePattern);
     }
 
     protected String makeNameUnique(Content parent, String name) {
         return Path.getUniqueLabel(parent.getJCRNode(), cleanup(name));
     }
 
     /**
      * Cleans up a String, making it appropriate for usage as a node name.
      */
     protected String cleanup(String s) {
         if (StringUtils.isEmpty(s)) {
             return "_";
         }
         // TODO : getValidatedLabel() should be copied/moved to a more appropriate(ly named) class?
         return Path.getValidatedLabel(s).toLowerCase();
     }
 
     /**
      * A ContentFilter which returns children of type THREAD_NODETYPE, where
      * the firstMessage's referenced node has a validated property is set to true
      * if showUnvalidatedMessages is true.
      */
     private static class ThreadsFilter implements Content.ContentFilter {
         private final boolean showUnvalidatedMessages;
 
         public ThreadsFilter(boolean showUnvalidatedMessages) {
             this.showUnvalidatedMessages = showUnvalidatedMessages;
         }
 
         @Override
         public boolean accept(Content content) {
             if (!content.isNodeType(THREAD_NODETYPE)) {
                 return false;
             }
 
             final NodeData firstMsgProp = content.getNodeData(DefaultForumManager.FIRST_MESSAGE_PROPERTY);
             if (!firstMsgProp.isExist()) {
                 return false;
             }
             try {
                 final Content firstMessage = firstMsgProp.getReferencedContent();
                 final NodeData validatedProp = firstMessage.getNodeData(VALIDATED_PROPERTY);
                 return (!validatedProp.isExist() && showUnvalidatedMessages) || (validatedProp.isExist() && validatedProp.getBoolean());
             } catch (RepositoryException e) {
                 log.error("Couldn't check if thread[" + content + "] could to be shown: " + e.getMessage(), e);
                 return false;
             }
         }
     }
 
     private void checkAndUpdateLastMessage(final Content forumOrThread, final String threadOrMessageID) throws RepositoryException {
         Content lastMessage;
         // get message from ID
         final Content threadOrMessage = forumOrThread.getHierarchyManager().getContentByUUID(threadOrMessageID);
         if (threadOrMessage.hasNodeData(LAST_MESSAGE_PROPERTY)) {
             lastMessage = threadOrMessage.getNodeData(LAST_MESSAGE_PROPERTY).getReferencedContent();
         } else {
             lastMessage = threadOrMessage;
         }
         Content threadOrForumLM = forumOrThread.getNodeData(LAST_MESSAGE_PROPERTY).getReferencedContent();
         String forumOrThreadLastMessageID = threadOrForumLM.getUUID();
         if (!forumOrThreadLastMessageID.equals(lastMessage.getUUID())) {
             // this message is not the last one => bail out
             return;
         }
         lastMessage = null;
         // find other last message, while skipping itself
         for (Content aThreadOrMessage : forumOrThread.getChildren(threadOrMessage.getItemType())) {
             if (threadOrMessageID.equals(aThreadOrMessage.getUUID())) {
                 // skip itself
                 continue;
             }
             Content aMessage;
             if (aThreadOrMessage.hasNodeData(LAST_MESSAGE_PROPERTY)) {
                 aMessage = aThreadOrMessage.getNodeData(LAST_MESSAGE_PROPERTY).getReferencedContent();
             } else {
                 aMessage = aThreadOrMessage;
             }
             lastMessage = latestMessage(lastMessage, aMessage);
         }
         updateLastMessage(forumOrThread, lastMessage);
         // changes to the thread/forum will be saved as part of deleting the message/thread ... if that succeeds that is
 
         // now if this was a message delete from thread, check if parent forum also need an update
         Content forum = forumOrThread.getParent();
         if (forum.hasNodeData(LAST_MESSAGE_PROPERTY)) {
             lastMessage = null;
             // do we need to update forum as well?
             if (forumOrThreadLastMessageID.equals(forum.getNodeData(LAST_MESSAGE_PROPERTY).getString())) {
                 // the thread pointing to the latest message have already been updated, so iterate over all threads (incl the current) and choose the latest message from all the latest there are
                 for (Content thread : forum.getChildren(forumOrThread.getItemType())) {
                     Content aMessage = thread.getNodeData(LAST_MESSAGE_PROPERTY).getReferencedContent();
                     lastMessage = latestMessage(lastMessage, aMessage);
                 }
                 updateLastMessage(forum, lastMessage);
                 // explicit save for forum and deleteMessage will save just a thread
                 forum.save();
             }
         }
     }
 
     private void updateLastMessage(Content forumOrThread, Content lastMessage) throws RepositoryException {
         forumOrThread.deleteNodeData(LAST_MESSAGE_PROPERTY);
         if (lastMessage != null) {
             forumOrThread.createNodeData(LAST_MESSAGE_PROPERTY, lastMessage);
         }
     }
 
     /**
      * Determines which of the 2 messages is "latest". Default implementation considers only a date, however more complex impls can check also whether messages are validated or any other properties.
      * 
      * @return the one of the messages that is considered newer then the other.
      */
     protected Content latestMessage(Content firstMessage, Content secondMessage) {
         if (firstMessage == null || secondMessage.getNodeData(CREATION_DATE_PROPERTY).getDate().after(firstMessage.getNodeData(CREATION_DATE_PROPERTY).getDate())) {
             firstMessage = secondMessage;
         }
         return firstMessage;
     }
 
     /**
      * Returns true if the given forum allows nesting messages.
      */
     protected boolean allowsNestingMessages(Content forum) {
         return forum.getNodeData(ALLOWS_NESTING_MESSAGES).getBoolean();
     }
 
     protected HierarchyManager getHierarchyManager() {
         return HierarchyManagerUtil.getHierarchyManager(MgnlContext.getInstance(), config.getRepository());
     }
 
 }