/*
 *  Copyright 2016 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.plugins.workspaces.project;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.FilterNameHelper;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.LambdaUtils;
import org.ametys.plugins.explorer.ExplorerNode;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RemovableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.jcr.JCRTraversableAmetysObject;
import org.ametys.plugins.repository.jcr.NodeTypeHelper;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.workspaces.ObservationConstants;
import org.ametys.plugins.workspaces.members.ProjectMemberManager;
import org.ametys.plugins.workspaces.project.modules.WorkspaceModule;
import org.ametys.plugins.workspaces.project.modules.WorkspaceModuleExtensionPoint;
import org.ametys.plugins.workspaces.project.objects.Project;
import org.ametys.plugins.workspaces.project.objects.Project.InscriptionStatus;
import org.ametys.plugins.workspaces.project.objects.ProjectCategory;
import org.ametys.plugins.workspaces.project.rights.ProjectRightHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.PluginAware;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PageQueryHelper;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteDAO;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.repository.sitemap.Sitemap;
import org.ametys.web.site.SiteConfigurationExtensionPoint;
import org.ametys.web.tags.TagExpression;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;

/**
 * Helper component for managing project workspaces
 */
public class ProjectManager extends AbstractLogEnabled implements Serviceable, Component, Contextualizable, PluginAware
{
    /** Avalon Role */
    public static final String ROLE = ProjectManager.class.getName();
    
    /** Workspaces plugin node name */
    private static final String __WORKSPACES_PLUGIN_NODE_NAME = "workspaces";
    
    /** Workspaces plugin node name */
    private static final String __WORKSPACES_PLUGIN_NODE_TYPE = RepositoryConstants.NAMESPACE_PREFIX + ":unstructured";
    
    /** The name of the projects root node */
    private static final String __PROJECTS_ROOT_NODE_NAME = "projects";
    
    /** The type of the projects root node */
    private static final String __PROJECTS_ROOT_NODE_TYPE = RepositoryConstants.NAMESPACE_PREFIX + ":unstructured";
    
    /** Constants for tags metadata */
    private static final String __PROJECTS_TAGS_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":tags";
    
    /** Constants for places metadata */
    private static final String __PROJECTS_PLACES_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":places";
    
    /** Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    
    /** The i18n utils. */
    protected I18nUtils _i18nUtils;
    
    /** Site manager */
    protected SiteManager _siteManager;
    
    /** Site DAO */
    protected SiteDAO _siteDao;
    
    /** Site configuration EP */
    protected SiteConfigurationExtensionPoint _siteConfiguration;
    
    /** Module Managers EP */
    protected WorkspaceModuleExtensionPoint _moduleManagerEP;
    
    /** Avalon context */
    protected Context _context;

    private ObservationManager _observationManager;
    
    private CurrentUserProvider _currentUserProvider;

    private ProjectMemberManager _projectMembers;

    private ProjectMemberManager _projectMemberManager;

    private String _pluginName;

    private ProjectRightHelper _projectRightHelper;

    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _siteDao = (SiteDAO) manager.lookup(SiteDAO.ROLE);
        _siteConfiguration = (SiteConfigurationExtensionPoint) manager.lookup(SiteConfigurationExtensionPoint.ROLE);
        _projectMembers = (ProjectMemberManager) manager.lookup(ProjectMemberManager.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _projectMemberManager = (ProjectMemberManager) manager.lookup(ProjectMemberManager.ROLE);
        _moduleManagerEP = (WorkspaceModuleExtensionPoint) manager.lookup(WorkspaceModuleExtensionPoint.ROLE);
        _projectRightHelper = (ProjectRightHelper) manager.lookup(ProjectRightHelper.ROLE);
    }
    
    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    /**
     * Retrieves all projects
     * @return the projects
     */
    public AmetysObjectIterable<Project> getProjects()
    {
        String jcrQuery = "//element(*, ametys:project)";
        return _resolver.query(jcrQuery);
    }
    
    /**
     * Retrieves a project by its name
     * @param name The project name
     * @return the project or <code>null</code> if not found
     */
    public Project getProject(String name)
    {
        String jcrQuery = "//element(" + name + ", ametys:project)";
        AmetysObjectIterable<Project> sites = _resolver.query(jcrQuery);
        Iterator<Project> it = sites.iterator();
        
        if (it.hasNext())
        {
            return it.next();
        }
        
        return null; 
    }
    
    /**
     * Get the user's projects
     * @param user the user
     * @return the user's projects
     */
    public List<Project> getUserProjects(UserIdentity user)
    {
        List<Project> userProjects = new ArrayList<>();
        
        AmetysObjectIterable<Project> projects = getProjects();
        
        for (Project project : projects)
        {
            if (_projectMembers.isProjectMember(project, user))
            {
                userProjects.add(project);
            }
        }
        
        return userProjects;
    }
    
    
    /**
     * Returns true if the given project exists.
     * @param projectName the project name.
     * @return true if the given project exists.
     */
    public boolean hasProject(String projectName)
    {
        return getProject(projectName) != null;
    }
    
    /**
     * Retrieves the mapping of all the projects name with their title on which the current user has access
     * @return the map (projectName, projectTitle) for all projects
     */
    @Callable
    public List<Map<String, String>> getUserProjectsData()
    {
        return getUserProjects(_currentUserProvider.getUser())
                .stream()
                .map(p -> ImmutableMap.of("title", p.getTitle(), "name", p.getName()))
                .collect(Collectors.toList());
    }
    
    /**
     * Retrieves the mapping of all the projects name with their title (regarless user rights)
     * @return the map (projectName, projectTitle) for all projects
     */
    @Callable
    public List<Map<String, String>> getProjectsData()
    {
        return getProjects()
                .stream()
                .map(p -> ImmutableMap.of("title", p.getTitle(), "name", p.getName()))
                .collect(Collectors.toList());
    }
    
    /**
     * Retrieves the project names
     * @return the project names
     */
    @Callable
    public Collection<String> getProjectNames()
    {
        return getProjects()
                .stream()
                .map(Project::getName)
                .collect(Collectors.toList());
    }
    
    /**
     * Retrieves the project paths of all projects.
     * @return  A list of project paths
     */
    @Callable
    public Collection<String> getProjectPaths()
    {
        return getProjects()
                .stream()
                .map(Project::getProjectsTreePath)
                .collect(Collectors.toList());
    }
    
    /**
     * Return the root for projects
     * The root node will be created if necessary
     * @return The root for projects
     */
    public ModifiableTraversableAmetysObject getProjectsRoot()
    {
        try
        {
            ModifiableTraversableAmetysObject pluginsNode = _resolver.resolveByPath("/ametys:plugins");
            ModifiableTraversableAmetysObject workspacesPluginNode = _getOrCreateObject(pluginsNode, __WORKSPACES_PLUGIN_NODE_NAME, __WORKSPACES_PLUGIN_NODE_TYPE);
            return _getOrCreateObject(workspacesPluginNode, __PROJECTS_ROOT_NODE_NAME, __PROJECTS_ROOT_NODE_TYPE);
        }
        catch (AmetysRepositoryException e)
        {
            throw new AmetysRepositoryException("Error getting the projects root node.", e);
        }
    }
    
    /**
     * Get the tree of a project which contains information about the projects
     * and categories in the tree.
     * @param treeRootId The desired root node of the tree
     * @param maxDepth The maximal depth of the tree. Set to a value of zero or
     *            less to get the whole tree.
     * @param contextOptions An optional map of context options. Valid context
     *            options are: "user", which holds an user identity, the project
     *            tree will be filtered given that user rights.
     * @return The project tree which is a list of map. Each map is a node of
     *         the tree structure.
     */
    public List<Map<String, Object>> getProjectTree(String treeRootId, int maxDepth, Map<String, Object> contextOptions)
    {    
        return getProjectTree(treeRootId, maxDepth, true, false, contextOptions);
    }

    /**
     * Get the tree of a project which contains information about the projects
     * and categories in the tree.
     * @param treeRootId The desired root node of the tree
     * @param maxDepth The maximal depth of the tree. Set to a value of zero or
     *            less to get the whole tree.
     * @param includeProjects False to only return the categories tree.
     * @param memberOnly Only return projects for which the current user is a member
     * @param contextOptions An optional map of context options. Valid context
     *            options are: "user", which holds an user identity, the project
     *            tree will be filtered given that user rights.
     * @return The project tree which is a list of map. Each map is a node of
     *         the tree structure.
     */
    public List<Map<String, Object>> getProjectTree(String treeRootId, int maxDepth, boolean includeProjects, boolean memberOnly, Map<String, Object> contextOptions)
    {
        List<Map<String, Object>> projectTree = new ArrayList<>();
        
        // FIXME WORKSPACES RIGHTS user context options is currently ignored
        
        TraversableAmetysObject node = null;
        if (StringUtils.isNotEmpty(treeRootId))
        {
            node = _resolver.resolveById(treeRootId);
        }
        else
        {
            node = getProjectsRoot();
        }
        
        // traverse the project tree and populate the result list.
        for (AmetysObject child: node.getChildren())
        {
            _projectTreeAccumulator(projectTree, child, 1, maxDepth, includeProjects, memberOnly);
        }
        
        return projectTree;
    }
    
    private void _projectTreeAccumulator(List<Map<String, Object>> projectTree, AmetysObject node, int depth, int maxDepth, boolean includeProjects, boolean memberOnly)
    {
        Map<String, Object> nodeInfo = null;
        
        if (node instanceof Project)
        {
            if (includeProjects && (!memberOnly || _projectMemberManager.isProjectMember((Project) node, _currentUserProvider.getUser())))
            {
                nodeInfo = getProjectProperties((Project) node);
            }
        }
        else if (node instanceof ProjectCategory)
        {
            ProjectCategory projectCategory = (ProjectCategory) node;
            nodeInfo = getCategoryProperties(projectCategory);
            
            if (maxDepth <= 0 || depth < maxDepth)
            {
                // recurse through the children of the category.
                List<Map<String, Object>> children = new ArrayList<>();
                nodeInfo.put("children", children);
                
                for (AmetysObject child: projectCategory.getChildren())
                {
                    _projectTreeAccumulator(children, child, depth + 1, maxDepth, includeProjects, memberOnly);
                }
            }
        }
        else
        {
            // logging unexpected ametys object
            String warningMsg = String.format("Unexpected ametys object type while traversing the project tree.\nAmetys object identifier is '%s'.", node.getId()); 
            getLogger().warn(warningMsg);
        }
        
        if (nodeInfo != null)
        {
            projectTree.add(nodeInfo);
        }
    }
    
    /**
     * Retrieves the standard information of a project
     * @param projectId Identifier of the project
     * @return The map of information
     */
    @Callable
    public Map<String, Object> getProjectProperties(String projectId)
    {
        return getProjectProperties((Project) _resolver.resolveById(projectId));
    }
    
    /**
     * Retrieves the standard information of a project
     * @param project The project
     * @return The map of information
     */
    public Map<String, Object> getProjectProperties(Project project)
    {
        Map<String, Object> info = new HashMap<>();

        info.put("id", project.getId());
        info.put("name", project.getName());
        info.put("type", "project");
        info.put("path", project.getProjectsTreePath());

        AmetysObject parent = project.getParent();
        if (parent instanceof ProjectCategory)
        {
            info.put("parentId", parent.getId());
        }

        info.put("title", project.getTitle());
        info.put("description", project.getDescription());
        info.put("mailingList", project.getMailingList());
        info.put("inscriptionStatus", project.getInscriptionStatus().toString());
        info.put("defaultProfile", project.getDefaultProfile());

        info.put("creationDate", project.getCreationDate());

        // check if the project workspace configuration is valid
        Collection<Site> sites = project.getSites();
        boolean valid = sites.size() > 0;
        if (valid)
        {
            Iterator<Site> siteIterator = sites.iterator();
            while (valid && siteIterator.hasNext())
            {
                Site site = siteIterator.next();
                valid = _siteConfiguration.isValid(site.getName());
            }
        }

        info.put("valid", valid);

        // sites is a list of map entry with id ,name, title and url property
        // { id: site id, name: site name, title: site title, url: site url }
        info.put("sites", sites.stream().map(site ->
        {
            Map<String, String> siteProps = new HashMap<>();
            siteProps.put("id", site.getId());
            siteProps.put("name", site.getName());
            siteProps.put("title", site.getTitle());
            siteProps.put("url", site.getUrl());
            return siteProps;
        }).collect(Collectors.toList()));

        return info;
    }
    
    /**
     * Get the availables project URLs.
     * @param project The project
     * @return The availables project URLs, can be empty.
     */
    public Set<String> getProjectUrls(Project project)
    {
        return _getProjectNonEmptyElements(project, Site::getUrl);
    }
    
    /**
     * Get the availables project names.
     * @param project The project
     * @return The availables project names, can be empty.
     */
    public Set<String> getProjectNames(Project project)
    {
        return _getProjectNonEmptyElements(project, Site::getName);
    }
    
    private Set<String> _getProjectNonEmptyElements(Project project, Function<? super Site, ? extends String> function)
    {
        return project.getSites()                       // Get the sites of the project
                      .stream()                         // Build it as a stream
                      .map(function)                    // Get the element of each site
                      .filter(StringUtils::isNotEmpty)  // Filter empty strings
                      .collect(Collectors.toSet());     // Get only the first value
    }
    
    /**
     * Get the tree of a project.
     * @param treeRootId The desired root node of the tree
     * @param maxDepth The maximal depth of the tree. Set to a value of zero or
     *            less to get the whole tree.
     * @return The project tree which is a list of projects and categories. 
     *         Each category is a map with the category node and a list of 
     *         children.
     */
    public List<Object> getProjectTreeNodes(String treeRootId, int maxDepth)
    {
        return getProjectTreeNodes(treeRootId, maxDepth, true, false);
    }
    
    /**
     * Get the tree of a project.
     * @param treeRootId The desired root node of the tree
     * @param maxDepth The maximal depth of the tree. Set to a value of zero or
     *            less to get the whole tree.
     * @param includeProjects False to only return the categories tree. 
     * @param memberOnly Only return projects for which the current user is a member
     * @return The project tree which is a list of projects and categories. 
     *         Each category is a map with the category node and a list of 
     *         children.
     */
    public List<Object> getProjectTreeNodes(String treeRootId, int maxDepth, boolean includeProjects, boolean memberOnly)
    {
        return getProjectTreeNodes(treeRootId, maxDepth, 0, includeProjects, memberOnly, null);
    }

    /**
     * Get the tree of a project.
     * @param treeRootId The desired root node of the tree
     * @param maxDepth The maximal depth of the tree. Set to a value of zero or
     *            less to get the whole tree.
     * @param maxResult Limit the number of projects returned
     * @param includeProjects False to only return the categories tree. 
     * @param memberOnly Only return projects for which the current user is a member
     * @param filterCategories The list of categories to filter. Can be null to ignore
     * @return The project tree which is a list of projects and categories. 
     *         Each category is a map with the category node and a list of 
     *         children.
     */
    public List<Object> getProjectTreeNodes(String treeRootId, int maxDepth, int maxResult, boolean includeProjects, boolean memberOnly, List<String> filterCategories)
    {
        List<Object> projectTree = new ArrayList<>();
        
        TraversableAmetysObject node = null;
        if (StringUtils.isNotEmpty(treeRootId))
        {
            node = _resolver.resolveById(treeRootId);
        }
        else
        {
            node = getProjectsRoot();
        }
        
        // traverse the project tree and populate the result list.
        for (AmetysObject child: node.getChildren())
        {
            _projectTreeNodeAccumulator(projectTree, child, 1, maxDepth, includeProjects, memberOnly);
        }
        
        if (filterCategories != null || maxResult != 0)
        {
            Map<String, Object> filters = new HashMap<>();
            filters.put("categories", filterCategories);
            filters.put("max", maxResult <= 0 ? null : new Integer(maxResult));
            projectTree = _filterProjectTree(projectTree, filters, StringUtils.isNotEmpty(treeRootId) ? treeRootId : "category-root", 1, maxDepth);
        }
        
        return Optional.ofNullable(projectTree).orElse(new ArrayList<>());
    }

    private void _projectTreeNodeAccumulator(List<Object> projectTree, AmetysObject node, int depth, int maxDepth, boolean includeProjects, boolean memberOnly)
    {
        if (node instanceof Project)
        {
            Project project = (Project) node;
            if (includeProjects && (_projectMemberManager.isProjectMember(project, _currentUserProvider.getUser())) || (!memberOnly && !project.getInscriptionStatus().equals(InscriptionStatus.PRIVATE)))
            {
                projectTree.add(node);
            }
        }
        else if (node instanceof ProjectCategory)
        {
            ProjectCategory projectCategory = (ProjectCategory) node;
            Map<String, Object> categoryData = new HashMap<>();
            categoryData.put("category", projectCategory);
            
            if (maxDepth <= 0 || depth < maxDepth)
            {
                // recurse through the children of the category.
                List<Object> children = new ArrayList<>();
                for (AmetysObject child: projectCategory.getChildren())
                {
                    _projectTreeNodeAccumulator(children, child, depth + 1, maxDepth, includeProjects, memberOnly);
                }
                categoryData.put("children", children);
            }
            
            projectTree.add(categoryData);
        }
        else
        {
            // logging unexpected ametys object
            String warningMsg = String.format("Unexpected ametys object type while traversing the project tree.\nAmetys object identifier is '%s'.", node.getId()); 
            getLogger().warn(warningMsg);
        }
    }
    
    @SuppressWarnings("unchecked")
    private List<Object> _filterProjectTree(List<Object> projectTree, Map<String, Object> filters, String categoryId, int depth, int maxDepth)
    {
        List<String> filterCategories = (List<String>) filters.get("categories"); 
        boolean isCategoryInFilters = filterCategories == null ? true : filterCategories.contains(categoryId);

        // filtered project tree stays null unless a sub-category is in the filterCategories list
        List<Object> filteredProjectTree = isCategoryInFilters ? new ArrayList<>() : null;
        
        for (Object treeNode : projectTree)
        {
            if (isCategoryInFilters && treeNode instanceof Project && filteredProjectTree != null && (filters.get("max") == null || ((Integer) filters.get("max")) > 0))
            {
                filteredProjectTree.add(treeNode);
                if (filters.get("max") != null)
                {
                    filters.put("max", ((Integer) filters.get("max")) - 1);
                }
            }
            else if (treeNode instanceof Map)
            {
                Map<String, Object> categoryData = (Map<String, Object>) treeNode;
                filteredProjectTree = _filterProjectTreeCategory(categoryData, filteredProjectTree, filters, isCategoryInFilters, depth, maxDepth);
            }
        }
        
        return filteredProjectTree;
    }

    @SuppressWarnings("unchecked")
    private List<Object> _filterProjectTreeCategory(Map<String, Object> categoryData, List<Object> filteredProjectTree, Map<String, Object> filters, boolean isCategoryInFilters, int depth, int maxDepth)
    {
        List<Object> resultProjectTree = filteredProjectTree;
        
        boolean addCategoryToTree = isCategoryInFilters;
        
        if (maxDepth > 0 && depth >= maxDepth && !addCategoryToTree)
        {
            // resolve and parse the category children to find at least one children not filtered
            List<String> filterCategories = (List<String>) filters.get("categories"); 
            String categoryId = ((ProjectCategory) categoryData.get("category")).getId();
            addCategoryToTree = isCategoryInFilters(categoryId, filterCategories, false);
        }
        
        if (categoryData.containsKey("children"))
        {
            // will return null if no child passes the filters, otherwise will return the list of filtered children
            List<Object> categoryChildren = _filterProjectTree((List<Object>) categoryData.get("children"), filters, ((ProjectCategory) categoryData.get("category")).getId(), depth + 1, maxDepth);
            
            if (categoryChildren != null)
            {
                addCategoryToTree = true;
            }
            categoryData.put("children", categoryChildren);
        }
        
        if (addCategoryToTree)
        {
            if (resultProjectTree == null)
            {
                resultProjectTree = new ArrayList<>();
            }
            resultProjectTree.add(categoryData);
        }
        return resultProjectTree;
    }
    
    /**
     * Test if a category child is contained in the list of filters
     * @param categoryId The category id
     * @param filterCategories The list of category id that one of the children must match
     * @param includeProjects True to test filters on all category children, false to only test on sub-categories
     * @return True if the child is in the filters
     */
    public boolean isCategoryInFilters(String categoryId, List<String> filterCategories, boolean includeProjects)
    {
        if (filterCategories.contains(categoryId))
        {
            return true;
        }
        
        AmetysObject object = _resolver.resolveById(categoryId);
        
        if (object instanceof ProjectCategory)
        {
            
            for (AmetysObject categoryChild : ((ProjectCategory) object).getChildren())
            {
                if (includeProjects || categoryChild instanceof ProjectCategory)
                {
                    if (isCategoryInFilters(categoryChild.getId(), filterCategories, includeProjects))
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    /**
     * Create a project from the projects root node.
     * @param name The project name
     * @param title The project title
     * @param description The project description
     * @param mailingList Project mailing list
     * @param inscriptionStatus The inscription status of the project
     * @param defaultProfileId The default profile for new members
     * @return A map containing the id of the new project or an error key.
     */
    @Callable
    public Map<String, Object> createProject(String name, String title, String description, String mailingList, String inscriptionStatus, String defaultProfileId)
    {
        return createProject((String) null, name, title, description, mailingList, inscriptionStatus, defaultProfileId);
    }
    
    /**
     * Create a project
     * @param parentId Identifier of the parent of the project to create 
     * @param name The project name
     * @param title The project title
     * @param description The project description
     * @param mailingList Project mailing list
     * @param inscriptionStatus The inscription status of the project
     * @param defaultProfileId The default profile for new members
     * @return A map containing the id of the new project or an error key.
     */
    @Callable
    public Map<String, Object> createProject(String parentId, String name, String title, String description, String mailingList, String inscriptionStatus, String defaultProfileId)
    {
        Map<String, Object> result = new HashMap<>();
        List<String> errors = new ArrayList<>();
        
        Map<String, Object> additionalValues = new HashMap<>();
        additionalValues.put("description", description);
        additionalValues.put("mailingList", mailingList);
        additionalValues.put("inscriptionStatus", inscriptionStatus);
        additionalValues.put("defaultProfileId", defaultProfileId);
        
        String projectId = createProject(parentId, name, title, additionalValues, null, errors);
        
        if (CollectionUtils.isEmpty(errors))
        {
            result.put("id", projectId);
        }
        else
        {
            result.put("error", errors.get(0));
        }
        
        return result;
    }
    
    /**
     * Create a project
     * @param parentId Identifier of the parent of the project to create 
     * @param name The project name
     * @param title The project title
     * @param additionalValues A list of optional additional values. Accepted values are : description, mailingList, inscriptionStatus, defaultProfile, tags, categoryTags and keywords
     * @param modulesIds The list of modules to activate. Can be null to activate all modules
     * @param errors A list that will be populated with the encountered errors. If null, errors will not be tracked.
     * @return The id of the new project
     */
    public String createProject(String parentId, String name, String title, Map<String, Object> additionalValues, Set<String> modulesIds, List<String> errors)
    {
        ModifiableTraversableAmetysObject parent = null;
        if (StringUtils.isNotEmpty(parentId))
        {
            parent = _resolver.resolveById(parentId);
        }
        else
        {
            parent = getProjectsRoot();
        }
        
        Project project = createProject(parent, name, title, additionalValues, modulesIds, errors);
        
        return project != null ? project.getId() : null;
    }
    
    /**
     * Create a project
     * @param parent the parent of the project to create 
     * @param name The project name
     * @param title The project title
     * @param additionalValues A list of optional additional values. Accepted values are : description, mailingList, inscriptionStatus, defaultProfile, tags, categoryTags and keywords
     * @param modulesIds The list of modules to activate. Can be null to activate all modules
     * @param errors A list that will be populated with the encountered errors. If null, errors will not be tracked.
     * @return The id of the new project
     */
    public Project createProject(ModifiableTraversableAmetysObject parent, String name, String title, Map<String, Object> additionalValues, Set<String> modulesIds, List<String> errors)
    {
        if (StringUtils.isEmpty(title))
        {
            throw new IllegalArgumentException(String.format("Cannot create the project for parent id '%s'. Title metadata is mandatory", parent.getId()));
        }
        
        // Project name should be unique
        if (hasProject(name))
        {
            if (getLogger().isWarnEnabled())
            {
                getLogger().warn(String.format("A project with the name '%s' already exists", name));
            }
            
            if (errors != null)
            {
                errors.add("project-exists");
            }
            
            return null;
        }
        
        Project project = parent.createChild(name, Project.NODE_TYPE);
        project.setTitle(title);
        String description = (String) additionalValues.getOrDefault("description", null);
        if (StringUtils.isNotEmpty(description))
        {
            project.setDescription(description);
        }
        String mailingList = (String) additionalValues.getOrDefault("emailList", null);
        if (StringUtils.isNotEmpty(mailingList))
        {
            project.setMailingList(mailingList);
        }
        String inscriptionStatus = (String) additionalValues.getOrDefault("inscriptionStatus", null);
        if (StringUtils.isNotEmpty(inscriptionStatus))
        {
            project.setInscriptionStatus(inscriptionStatus);
        }
        String defaultProfile = (String) additionalValues.getOrDefault("defaultProfile", null);
        if (StringUtils.isNotEmpty(defaultProfile))
        {
            project.setDefaultProfile(defaultProfile);
        }
        
        project.setCreationDate(ZonedDateTime.now());
        
        // Create the project workspace = a site + a set of pages
        _createProjectWorkspace(project, errors);
        
        activateModules(project, modulesIds);
        
        if (CollectionUtils.isEmpty(errors))
        {
            project.saveChanges();
         
            // Notify observers
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PROJECT, project);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PROJECT_ADDED, _currentUserProvider.getUser(), eventParams));
            
        }
        else
        {
            deleteProject(project);
        }
        
        return project;
    }
    
    /**
     * Edit a project
     * @param id The project identifier
     * @param title The title to set
     * @param description The description to set
     * @param mailingList Project mailing list
     * @param inscriptionStatus The inscription status of the project
     * @param defaultProfile The default profile for new members
     */
    @Callable
    public void editProject(String id, String title, String description, String mailingList, String inscriptionStatus, String defaultProfile)
    {
        Project project = _resolver.resolveById(id);
        editProject(project, title, description, mailingList, inscriptionStatus, defaultProfile);
    }
    
    /**
     * Edit a project
     * @param project The project
     * @param title The title to set
     * @param description The description to set
     * @param mailingList Project mailing list
     * @param inscriptionStatus The inscription status of the project
     * @param defaultProfile The default profile for new members
     */
    public void editProject(Project project, String title, String description, String mailingList, String inscriptionStatus, String defaultProfile)
    {
        project.setTitle(title);
        
        if (StringUtils.isNotEmpty(description))
        {
            project.setDescription(description);
        }
        else
        {
            project.removeDescription();
        }
        
        if (StringUtils.isNotEmpty(mailingList))
        {
            project.setMailingList(mailingList);
        }
        else
        {
            project.removeMailingList();
        }

        project.setInscriptionStatus(inscriptionStatus);
        project.setDefaultProfile(defaultProfile);
        
        project.saveChanges();
        
        // Notify observers
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_PROJECT, project);
        _observationManager.notify(new Event(ObservationConstants.EVENT_PROJECT_UPDATED, _currentUserProvider.getUser(), eventParams));
    }
    
    /**
     * Delete a list of project.
     * @param ids The ids of projects to delete
     * @return The ids of the deleted projects, unknowns projects and the deleted sites
     */
    @Callable
    public Map<String, Object> deleteProjectsByIds(List<String> ids)
    {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> deleted = new ArrayList<>();
        List<String> unknowns = new ArrayList<>();
        
        for (String id : ids)
        {
            try
            {
                Project project = _resolver.resolveById(id);
                
                Map<String, Object> projectInfo = new HashMap<>();
                projectInfo.put("id", id);
                projectInfo.put("title", project.getTitle());
                projectInfo.put("sites", deleteProject(project));
                
                deleted.add(projectInfo);
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().warn(String.format("Unable to delete the definition of id '%s', because it does not exist.", id), e);
                unknowns.add(id);
            }
        }
        
        result.put("deleted", deleted);
        result.put("unknowns", unknowns);
        
        return result;
    }
    
    /**
     * Delete a project.
     * @param projects The list of projects to delete
     * @return list of deleted sites (each list entry contains a data map with
     *         the id and the name of the delete site).
     */
    public List<Map<String, String>> deleteProject(List<Project> projects)
    {
        List<Map<String, String>> deletedSitesInfo = new ArrayList<>();
        
        for (Project project : projects)
        {
            deletedSitesInfo.addAll(deleteProject(project));
        }
        
        return deletedSitesInfo;
    }
    
    /**
     * Delete a project and its sites
     * @param project The project to delete
     * @return list of deleted sites (each list entry contains a data map with
     *         the id and the name of the delete site).
     */
    public List<Map<String, String>> deleteProject(Project project)
    {
        ModifiableAmetysObject parent = project.getParent();
        
        Collection<Site> sites = project.getSites();
        
        // list of map entry with id, name and title property
        // { id: site id, name: site name }
        List<Map<String, String>> deletedSitesInfo = new ArrayList<>();
        
        sites.forEach(site -> 
        {
            try
            {
                Map<String, String> siteProps = new HashMap<>();
                siteProps.put("id", site.getId());
                siteProps.put("name", site.getName());

                _siteDao.deleteSite(site.getId());
                deletedSitesInfo.add(siteProps);
            }
            catch (RepositoryException e)
            {
                String errorMsg = String.format("Error while trying to delete the site '%s' for the project '%s'.", site.getName(), project.getName());
                getLogger().error(errorMsg, e);
            }
        });
        
        String projectId = project.getId();
        project.remove();
        parent.saveChanges();
        
        // Notify observers
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_PROJECT, project);
        eventParams.put(ObservationConstants.ARGS_PROJECT_ID, projectId);
        _observationManager.notify(new Event(ObservationConstants.EVENT_PROJECT_DELETED, _currentUserProvider.getUser(), eventParams));
        
        return deletedSitesInfo;
    }
    
    /**
     * Retrieves the standard information of a project category
     * @param categoryId Identifier of the project category
     * @return The map of information
     */
    @Callable
    public Map<String, Object> getCategoryProperties(String categoryId)
    {
        return getCategoryProperties((ProjectCategory) _resolver.resolveById(categoryId));
    }
    
    /**
     * Retrieves the standard information of a project category
     * @param projectCategory The project category
     * @return The map of information
     */
    public Map<String, Object> getCategoryProperties(ProjectCategory projectCategory)
    {
        Map<String, Object> info = new HashMap<>();
        
        info.put("id", projectCategory.getId());
        info.put("name", projectCategory.getName());
        info.put("type", "category");
        info.put("path", projectCategory.getProjectsTreePath());
        
        info.put("title", projectCategory.getTitle());
        info.put("description", projectCategory.getDescription());
        
        return info;
    }
    
    /**
     * Create a project category from the projects root node.
     * @param title The category title
     * @param description The category description
     * @return The id of the new category
     */
    @Callable
    public String createCategory(String title, String description)
    {
        return createCategory((String) null, title, description);
    }
    
    /**
     * Create a project category
     * @param parentId Identifier of the parent of the category to create 
     * @param title The category title
     * @param description The category description
     * @return The id of the new category
     */
    @Callable
    public String createCategory(String parentId, String title, String description)
    {
        ModifiableTraversableAmetysObject parent = null;
        if (StringUtils.isNotEmpty(parentId))
        {
            parent = _resolver.resolveById(parentId);
        }
        else
        {
            parent = getProjectsRoot();
        }
        
        ProjectCategory category = createCategory(parent, title, description);
        
        return category.getId();
    }
    
    /**
     * Create a project category
     * @param parent the parent of the category to create 
     * @param title The category title
     * @param description The category description
     * @return The id of the new category
     */
    public ProjectCategory createCategory(ModifiableTraversableAmetysObject parent, String title, String description)
    {
        if (StringUtils.isEmpty(title))
        {
            throw new IllegalArgumentException(String.format("Cannot create the project category for parent id '%s'. Title metadata is mandatory", parent.getId()));
        }
        
        // Find unique name
        String originalName = FilterNameHelper.filterName(title);
        String name = originalName;
        int index = 2;
        while (parent.hasChild(name))
        {
            name = originalName + "-" + (index++);
        }
        
        ProjectCategory category = parent.createChild(name, ProjectCategory.NODE_TYPE);
        category.setTitle(title);
        if (StringUtils.isNotEmpty(description))
        {
            category.setDescription(description);
        }
        
        parent.saveChanges();
        
        return category;
    }
    
    /**
     * Edit a project category
     * @param id The category identifier
     * @param title The title to set
     * @param description The description to set
     */
    @Callable
    public void editCategory(String id, String title, String description)
    {
        ProjectCategory category = _resolver.resolveById(id);
        editCategory(category, title, description);
    }
    
    /**
     * Edit a project category
     * @param category The project category
     * @param title The title to set
     * @param description The description to set
     */
    public void editCategory(ProjectCategory category, String title, String description)
    {
        category.setTitle(title);
        if (StringUtils.isNotEmpty(description))
        {
            category.setDescription(description);
        }
        
        category.saveChanges();
    }
    
    /**
     * Delete a list of project categories.
     * @param ids The ids of categories to delete
     * @return The ids of the deleted categories, unknowns categories and the deleted sites
     */
    @Callable
    public Map<String, Object> deleteCategoryByIds(List<String> ids)
    {
        Map<String, Object> result = new HashMap<>();
        List<String> deleted = new ArrayList<>();
        List<String> unknowns = new ArrayList<>();
        
        List<Map<String, String>> deletedSitesInfo = new ArrayList<>();
        
        for (String id : ids)
        {
            try
            {
                ProjectCategory projectCategory = _resolver.resolveById(id);
                deletedSitesInfo.addAll(deleteCategory(projectCategory));
                deleted.add(id);
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().warn(String.format("Unable to delete the definition of id '%s', because it does not exist.", id), e);
                unknowns.add(id);
            }
        }
        
        result.put("deleted", deleted);
        result.put("unknowns", unknowns);
        result.put("deletedSites", deletedSitesInfo);
        
        return result;
    }
    
    /**
     * Delete a list of project categories.
     * @param categories The list of categories to delete
     * @return list of deleted sites (each list entry contains a data map with
     *         the id and the name of the delete site).
     */
    public List<Map<String, String>> deleteCategory(List<ProjectCategory> categories)
    {
        List<Map<String, String>> deletedSitesInfo = new ArrayList<>();
        
        for (ProjectCategory category : categories)
        {
            deletedSitesInfo.addAll(deleteCategory(category));
        }
        
        return deletedSitesInfo;
    }
    
    /**
     * Delete a list of project category
     * @param category The category to delete
     * @return list of deleted sites (each list entry contains a data map with
     *         the id and the name of the delete site).
     */
    public List<Map<String, String>> deleteCategory(ProjectCategory category)
    {
        ModifiableAmetysObject parent = category.getParent();
        
        List<Map<String, String>> deletedSitesInfo = new ArrayList<>();
        
        _removeDescendants(category, deletedSitesInfo);
        category.remove();
        
        parent.saveChanges();
        
        return deletedSitesInfo;
    }
    
    /**
     * Remove descendant ametys objects.
     * Descendants should be a project or a category
     * @param object The project or category for which descendants must be removed
     * @param deletedSitesInfo list of deleted sites to be populated (each list entry contains a data map with
     *         the id and the name of the delete site).
     */
    private void _removeDescendants(AmetysObject object, List<Map<String, String>> deletedSitesInfo)
    {
        if (object instanceof TraversableAmetysObject)
        {
            for (AmetysObject child : ((TraversableAmetysObject) object).getChildren())
            {
                // remove descendants of child
                _removeDescendants(child, deletedSitesInfo);
                
                // then remove child itself
                if (child instanceof Project)
                {
                    deletedSitesInfo.addAll(deleteProject((Project) child));
                }
                else if (child instanceof RemovableAmetysObject)
                {
                    ((RemovableAmetysObject) child).remove();
                }
            }
        }
    }
    
    /**
     * Move a node of the project tree into another node.
     * Node can be a project or a category
     * @param nodeId The identifier of the node to move
     * @param targetId Identifier of the category which is the target of the move operation. Can be null if the target is the projects root node.
     * @return A map containing a possible error.
     * @throws RepositoryException if a repository error occurs.
     */
    @Callable
    public Map<String, Object> moveProjectTreeNode(String nodeId, String targetId) throws RepositoryException
    {
        JCRAmetysObject objectNode = (JCRAmetysObject) _resolver.resolveById(nodeId);
        
        JCRTraversableAmetysObject targetNode = null;
        if (StringUtils.isNotEmpty(targetId))
        {
            targetNode = _resolver.resolveById(targetId);
        }
        
        return moveProjectTreeNodeObject(objectNode, targetNode);
    }
    
    /**
     * Move a node of the project tree into another node.
     * Node can be a project or a category
     * @param objectNode The node to move (must be a project or a category)
     * @param targetNode The category which is the target of the move operation. Can be null if the target is the projects root node.
     * @return A map containing a possible error.
     * @throws RepositoryException if a repository error occurs.
     */
    public Map<String, Object> moveProjectTreeNodeObject(JCRAmetysObject objectNode, JCRTraversableAmetysObject targetNode) throws RepositoryException
    {
        Map<String, Object> result = new HashMap<>();
        
        if (!(objectNode instanceof Project || objectNode instanceof ProjectCategory) || !(targetNode == null || targetNode instanceof ProjectCategory))
        {
            if (getLogger().isWarnEnabled())
            {
                String warnMsg = String.format("The object '%s' cannot be moved to '%s'. Object and/or target of the move operation are of wrong type",
                        objectNode.getName(), targetNode == null ? "projects root" : targetNode.getName());
                getLogger().warn(warnMsg);
            }
            
            result.put("error", "invalid");
        }
        
        JCRTraversableAmetysObject actualTargetNode = targetNode;
        if (actualTargetNode == null)
        {
            actualTargetNode = (JCRTraversableAmetysObject) getProjectsRoot();
        }
        
        if (actualTargetNode.hasChild(objectNode.getName()))
        {
            if (getLogger().isWarnEnabled())
            {
                String warnMsg = String.format("The object '%s' cannot be moved. An object with the same name already exists in the target collection.", objectNode.getName());
                getLogger().warn(warnMsg);
            }
            
            result.put("error", "already-exists");
        }
        else
        {
            Session session = objectNode.getNode().getSession();
            session.move(objectNode.getNode().getPath(), actualTargetNode.getNode().getPath() + "/" + objectNode.getNode().getName());
            session.save();
        }
        
        return result;
    }
    
    /**
     * Utility method to get or create an ametys object
     * @param <A> A sub class of AmetysObject
     * @param parent The parent object
     * @param name The ametys object name
     * @param type The ametys object type
     * @return ametys object
     * @throws AmetysRepositoryException if an repository error occurs
     */
    private <A extends AmetysObject> A _getOrCreateObject(ModifiableTraversableAmetysObject parent, String name, String type) throws AmetysRepositoryException
    {
        A object;
        
        if (parent.hasChild(name))
        {
            object = parent.getChild(name);
        }
        else
        {
            object = parent.createChild(name, type);
            parent.saveChanges();
        }
        
        return object;
    }
    
    /**
     * Get the project of an ametys object inside a project.
     * It can be an explorer node, or any type of resource in a module.
     * @param id The identifier of the ametys object
     * @return the project or null if not found
     */
    public Project getParentProject(String id)
    {
        return getParentProject(_resolver.<AmetysObject>resolveById(id));
    }
    
    /**
     * Get the project of an ametys object inside a project.
     * It can be an explorer node, or any type of resource in a module.
     * @param object The ametys object
     * @return the project or null if not found
     */
    public Project getParentProject(AmetysObject object)
    {
        AmetysObject ametysObject = object;
        // Go back to the local explorer root.
        do
        {
            ametysObject = ametysObject.getParent();
        }
        while (ametysObject instanceof ExplorerNode);
        
        if (!(ametysObject instanceof Project))
        {
            getLogger().warn(String.format("No project found for ametys object with id '%s'", ametysObject.getId()));
            return null;
        }
        
        return (Project) ametysObject; 
    }
    
    /**
     * Get the list of project names for a given site
     * @param siteName The site name
     * @return the list of project names
     */
    @Callable
    public List<String> getProjectsForSite(String siteName)
    {
        List<String> projectNames = new ArrayList<>();
        
        if (_siteManager.hasSite(siteName))
        {
            Site site = _siteManager.getSite(siteName);
            getProjectsForSite(site)
                .stream()
                .map(Project::getName)
                .forEach(projectNames::add);
        }
        
        return projectNames;
    }
    
    /**
     * Get the list of project for a given site
     * @param site The site
     * @return the list of project
     */
    public List<Project> getProjectsForSite(Site site)
    {
        try
        {
            // Stream over the weak reference properties pointing to this
            // node to find referencing projects 
            Iterator<Property> propertyIterator = site.getNode().getWeakReferences();
            Iterable<Property> propertyIterable = () -> propertyIterator;
            
            return StreamSupport.stream(propertyIterable.spliterator(), false)
                    .map(p -> 
                    {
                        try
                        {
                            // Parent should be a composite with name "ametys:sites"
                            Node parent = p.getParent();
                            if (NodeTypeHelper.isNodeType(parent, "ametys:compositeMetadata") && (RepositoryConstants.NAMESPACE_PREFIX + ":" + Project.DATA_SITES).equals(parent.getName()))
                            {
                                // Parent should be the project
                                parent = parent.getParent();
                                if (NodeTypeHelper.isNodeType(parent, "ametys:project"))
                                {
                                    Project project = _resolver.resolve(parent, false);
                                    return project;
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            if (getLogger().isWarnEnabled())
                            {
                                // this weak reference is not from a project
                                String propertyPath = null;
                                try
                                {
                                    propertyPath = p.getPath();
                                }
                                catch (Exception e2)
                                {
                                    // ignore
                                }
                                
                                String warnMsg = String.format("Site '%s' is pointed by a weak reference '%s' which is not representing a relation with project. This reference is ignored.", site.getName(), propertyPath);
                                getLogger().warn(warnMsg);
                            }
                        }
                        
                        return null;
                    })
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList());
        }
        catch (RepositoryException e)
        {
            getLogger().error(String.format("Unable to find projects for site '%s'", site.getName()), e);
        }
        
        return new ArrayList<>();
    }
    
    /**
     * Create the project workspace for a given project.
     * @param project The project for which the workspace must be created
     * @param errors A list of possible errors to populate. Can be null if the caller is not interested in error tracking.
     * @return The site created for this workspace
     */
    protected Site _createProjectWorkspace(Project project, List<String> errors)
    {
        String initialSiteName = project.getName();
        Site site = null;
        
        Map<String, Object> result = _siteDao.createSite(null, initialSiteName, ProjectWorkspaceSiteType.TYPE_ID, true);
        
        String siteId = (String) result.get("id");
        String siteName = (String) result.get("name");
        if (StringUtils.isNotEmpty(siteId)) 
        {
            // Creation success
            site = _siteManager.getSite(siteName);
            
            I18nizableText i18nSiteTitle = new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_DEFAULT_PROJECT_WORKSPACE_TITLE", Arrays.asList(project.getTitle()));
            site.setTitle(_i18nUtils.translate(i18nSiteTitle));
            
            // Add site to project
            project.setSites(Arrays.asList(site.getName()));
            
            site.saveChanges();
        }
        
        return site;
    }
    
    /**
     * Get the project's tags
     * @return The project's tags 
     */
    @Callable
    public List<String> getTags()
    {
        AmetysObject projectsRootNode = getProjectsRoot();
        if (projectsRootNode instanceof JCRAmetysObject)
        {
            Node node = ((JCRAmetysObject) projectsRootNode).getNode();
            
            try
            {
                return Arrays.stream(node.getProperty(__PROJECTS_TAGS_PROPERTY).getValues())
                    .map(LambdaUtils.wrap(Value::getString))
                    .collect(Collectors.toList());
            }
            catch (PathNotFoundException e)
            {
                // property is not set, empty list will be returned.
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException(e);
            }
        }
        
        return new ArrayList<>();
    }
    
    /**
     * Set the tags
     * @param tags The tags to set
     */
    @Callable
    public synchronized void setTags(List<String> tags)
    {
        AmetysObject projectsRootNode = getProjectsRoot();
        if (projectsRootNode instanceof JCRAmetysObject)
        {
            JCRAmetysObject jcrProjectsRootNode = (JCRAmetysObject) projectsRootNode;
            
            if (CollectionUtils.isNotEmpty(tags))
            {
                String[] tagsArray = tags.stream()
                        .map(String::trim)
                        .map(String::toLowerCase)
                        .filter(StringUtils::isNotEmpty)
                        .distinct()
                        .toArray(String[]::new);
                
                try
                {
                    jcrProjectsRootNode.getNode().setProperty(__PROJECTS_TAGS_PROPERTY, tagsArray);
                    jcrProjectsRootNode.saveChanges();
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
            else
            {
                Node node = jcrProjectsRootNode.getNode();
                try
                {
                    if (node.hasProperty(__PROJECTS_TAGS_PROPERTY))
                    {
                        node.getProperty(__PROJECTS_TAGS_PROPERTY).remove();
                        jcrProjectsRootNode.saveChanges();
                    }
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
        }
    }
    
    /**
     * Add project's tags
     * @param newTags The new tags to add
     */
    public synchronized void addTags(Collection<String> newTags)
    {
        if (CollectionUtils.isNotEmpty(newTags))
        {
            AmetysObject projectsRootNode = getProjectsRoot();
            if (projectsRootNode instanceof JCRAmetysObject)
            {
                // Concat existing tags with new lowercased tags
                String[] tags = Stream.concat(getTags().stream(), newTags.stream().map(String::trim).map(String::toLowerCase).filter(StringUtils::isNotEmpty))
                        .distinct()
                        .toArray(String[]::new);
                
                try
                {
                    ((JCRAmetysObject) projectsRootNode).getNode().setProperty(__PROJECTS_TAGS_PROPERTY, tags);
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
        }
    }
    
    /**
     * Get the project's places
     * @return The project's places 
     */
    @Callable
    public List<String> getPlaces()
    {
        AmetysObject projectsRootNode = getProjectsRoot();
        if (projectsRootNode instanceof JCRAmetysObject)
        {
            Node node = ((JCRAmetysObject) projectsRootNode).getNode();
            
            try
            {
                return Arrays.stream(node.getProperty(__PROJECTS_PLACES_PROPERTY).getValues())
                    .map(LambdaUtils.wrap(Value::getString))
                    .collect(Collectors.toList());
            }
            catch (PathNotFoundException e)
            {
                // property is not set, empty list will be returned.
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException(e);
            }
        }
        
        return new ArrayList<>();
    }
    
    /**
     * Add project's places
     * @param newPlaces The new places to add
     */
    public synchronized void addPlaces(Collection<String> newPlaces)
    {
        if (CollectionUtils.isNotEmpty(newPlaces))
        {
            AmetysObject projectsRootNode = getProjectsRoot();
            if (projectsRootNode instanceof JCRAmetysObject)
            {
                Set<String> lowercasedPlaces = new HashSet<>();
                
                // Concat existing places with new places
                String[] places = Stream.concat(getPlaces().stream(), newPlaces.stream().map(String::trim).filter(StringUtils::isNotEmpty))
                        // duplicates are filtered out
                        .filter(p -> lowercasedPlaces.add(p.toLowerCase()))
                        .toArray(String[]::new);
                
                try
                {
                    ((JCRAmetysObject) projectsRootNode).getNode().setProperty(__PROJECTS_PLACES_PROPERTY, places);
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
        }
    }
    
    /**
     * Set the places
     * @param places The places to set
     */
    @Callable
    public synchronized void setPlaces(List<String> places)
    {
        AmetysObject projectsRootNode = getProjectsRoot();
        if (projectsRootNode instanceof JCRAmetysObject)
        {
            JCRAmetysObject jcrProjectsRootNode = (JCRAmetysObject) projectsRootNode;
            
            if (CollectionUtils.isNotEmpty(places))
            {
                Set<String> lowercasedPlaces = new HashSet<>();
                
                String[] placesArray = places.stream()
                        .map(String::trim)
                        .filter(StringUtils::isNotEmpty)
                        // duplicates are filtered out
                        .filter(p -> lowercasedPlaces.add(p.toLowerCase()))
                        .toArray(String[]::new);
                
                try
                {
                    jcrProjectsRootNode.getNode().setProperty(__PROJECTS_PLACES_PROPERTY, placesArray);
                    jcrProjectsRootNode.saveChanges();
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
            else
            {
                Node node = jcrProjectsRootNode.getNode();
                try
                {
                    if (node.hasProperty(__PROJECTS_PLACES_PROPERTY))
                    {
                        node.getProperty(__PROJECTS_PLACES_PROPERTY).remove();
                        jcrProjectsRootNode.saveChanges();
                    }
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
        }
    }
    
    /**
     * Get the list of activated modules for a project
     * @param project The project
     * @return The list of activated modules
     */
    public List<WorkspaceModule> getModules(Project project)
    {
        return _moduleManagerEP.getModules().stream()
                .filter(module -> isModuleActivated(project, module.getId()))
                .collect(Collectors.toList());
    }
    
    /**
     * Retrieves the page of the module for all available languages
     * @param project The project
     * @param moduleId The project module id
     * @param language the sitemap language or <code>null</code> for all sitemap languages.
     * @return the page or null if not found
     */
    public AmetysObjectIterable<Page> getModulePages(Project project, String moduleId, String language)
    {
        if (_moduleManagerEP.hasExtension(moduleId))
        {
            WorkspaceModule moduleManager = _moduleManagerEP.getExtension(moduleId);
            return moduleManager.getModulePages(project, language);
        }
        return null;
    }
    
    /**
     * Get a page in the site of a given project with a specific tag
     * @param project The project
     * @param tagName The name of the tag
     * @param language the sitemap language or <code>null</code> for all sitemap languages.
     * @return The module's pages
     */
    public AmetysObjectIterable<Page> getProjectPages(Project project, String tagName, String language)
    {
        String siteName = Iterables.getFirst(getProjectNames(project), null);
        if (StringUtils.isEmpty(siteName))
        {
            return null;
        }
        
        Expression expression = new TagExpression(Operator.EQ, tagName);
        String query = PageQueryHelper.getPageXPathQuery(siteName, language, null, expression, null);

        return _resolver.query(query);
    }
    
    
    /**
     * Get the dashboard page in the site of a given project
     * @param project The project
     * @param language the sitemap language or <code>null</code> for all sitemap languages.
     * @return The module's dashboard pages
     */
    public AmetysObjectIterable<Page> getProjectDashboardPage(Project project, String language)
    {
        String siteName = Iterables.getFirst(getProjectNames(project), null);
        if (StringUtils.isEmpty(siteName))
        {
            return null;
        }
        
        String query = "//element(" + siteName + ", ametys:site)/ametys-internal:sitemaps/" 
                + (language == null ? "*" : language)
                + "//element(index, ametys:page)";
                
        return _resolver.query(query);
    }
    
    /**
     * Activate the list of module of the project
     * @param project The project
     * @param moduleIds The list of modules. Can be null to activate all modules 
     */
    public void activateModules(Project project, Set<String> moduleIds)
    {
        Set<String> modules = moduleIds == null ? _moduleManagerEP.getExtensionsIds() : moduleIds;
        
        for (String moduleId : modules)
        {
            WorkspaceModule module = _moduleManagerEP.getModule(moduleId);
            if (module != null && !isModuleActivated(project, moduleId))
            {
                module.activateModule(project);
                project.addModule(moduleId);
            }
        }
        
        project.saveChanges();
    }    
    
    /**
     * Initialize the sitemap with the active module of the project
     * @param project The project
     * @param sitemap The sitemap
     */
    public void initializeModulesSitemap(Project project, Sitemap sitemap)
    {
        Set<String> modules = _moduleManagerEP.getExtensionsIds();
        
        for (String moduleId : modules)
        {
            if (_moduleManagerEP.hasExtension(moduleId))
            {
                WorkspaceModule module = _moduleManagerEP.getExtension(moduleId);
                
                if (isModuleActivated(project, moduleId))
                {
                    module.initializeSitemap(sitemap);
                }
            }
        }
    }
    
    /**
     * Determines if a module is activated
     * @param project The project
     * @param moduleId The id of module
     * @return true if the module the currently activated
     */
    public boolean isModuleActivated(Project project, String moduleId)
    {
        return ArrayUtils.contains(project.getModules(), moduleId);
    }
    
    /**
     * Remove the explorer root node of the project module, remove all events 
     * related to that module and set it to deactivated
     * @param project The project
     * @param moduleIds The id of module to activate
     */
    public void deactivateModules(Project project, Set<String> moduleIds)
    {
        for (String moduleId : moduleIds)
        {
            WorkspaceModule module = _moduleManagerEP.getModule(moduleId);
            if (module != null && isModuleActivated(project, moduleId))
            {
                module.deactivateModule(project);
                project.removeModule(moduleId);
            }
        }
        
        project.saveChanges();
    }
    
    
    /**
     * Get the list of profiles configured for the workspaces' projects
     * @return The list of profiles as JSON
     */
    @Callable
    public Map<String, Object> getProjectProfiles()
    {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> profiles = _projectRightHelper.getProfileList().stream().map(p -> p.toJSON()).collect(Collectors.toList());
        result.put("profiles", profiles);
        return result;
    }
}