/*
 *  Copyright 2015 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.web.repository.page;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import javax.jcr.Node;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
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.lang3.StringUtils;

import org.ametys.cms.FilterNameHelper;
import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.languages.Language;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentDAO.TagMode;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.TaggableAmetysObject;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.tag.CMSTag;
import org.ametys.cms.tag.Tag;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.observation.Observer;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.core.impl.cache.AbstractCacheKey;
import org.ametys.plugins.explorer.ExplorerNode;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CopiableAmetysObject;
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.SimpleAmetysObject;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
import org.ametys.web.ObservationConstants;
import org.ametys.web.WebConstants;
import org.ametys.web.alias.Alias.TargetType;
import org.ametys.web.alias.AliasHelper;
import org.ametys.web.alias.DefaultAlias;
import org.ametys.web.languages.WebLanguagesManager;
import org.ametys.web.repository.content.SharedContent;
import org.ametys.web.repository.content.WebContent;
import org.ametys.web.repository.content.WebContentDAO;
import org.ametys.web.repository.content.shared.SharedContentManager;
import org.ametys.web.repository.page.Page.LinkType;
import org.ametys.web.repository.page.Page.PageType;
import org.ametys.web.repository.page.ZoneItem.ZoneType;
import org.ametys.web.repository.page.jcr.DefaultPage;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;
import org.ametys.web.rights.PageRightAssignmentContext;
import org.ametys.web.service.Service;
import org.ametys.web.service.ServiceExtensionPoint;
import org.ametys.web.skin.Skin;
import org.ametys.web.skin.SkinTemplate;
import org.ametys.web.skin.SkinTemplateZone;
import org.ametys.web.skin.SkinsManager;
import org.ametys.web.skin.TemplatesAssignmentHandler;
import org.ametys.web.synchronization.SynchronizeComponent;
import org.ametys.web.tags.TagExpression;

/**
 * DAO for manipulating pages
 *
 */
public class PageDAO extends AbstractLogEnabled implements Serviceable, Component, Initializable, Observer
{
    /** Constant for untouched binary metadata. */
    public static final String __SERVICE_PARAM_UNTOUCHED_BINARY = "untouched";
    
    /** Avalon Role */
    public static final String ROLE = PageDAO.class.getName();
    
    /** Constant for the {@link Cache} id for the pages in cache by sitename, lang, tag */
    private static final String MEMORY_PAGESTAGCACHE = PageDAO.class.getName() + "$PagesUUIDByTag";

    
    private AmetysObjectResolver _resolver;
    private ObservationManager _observationManager;
    private CurrentUserProvider _currentUserProvider;
    private SkinsManager _skinsManager;
    private TemplatesAssignmentHandler _templatesHandler;
    private ServicesAssignmentHandler _serviceHandler;
    private ContentTypesAssignmentHandler _cTypeHandler;
    private ContentTypeExtensionPoint _contentTypeExtensionPoint;
    private ContentHelper _contentHelper;
    private ServiceExtensionPoint _serviceExtensionPoint;
    private WorkflowProvider _workflowProvider;
    private SharedContentManager _sharedContentManager;
    private TagProviderExtensionPoint _tagProvider;
    private WebLanguagesManager _webLanguagesManager;
    private WebContentDAO _contentDAO;
    private CopySiteComponent _copySiteComponent;
    private RightManager _rightManager;
    private SynchronizeComponent _synchronizeComponent;
    private Repository _repository;
    private PageDataTypeExtensionPoint _pageDataTypeExtensionPoint;
    private AmetysObjectResolver _ametysObjectResolver;
    private AbstractCacheManager _cacheManager;
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) smanager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
        _skinsManager = (SkinsManager) smanager.lookup(SkinsManager.ROLE);
        _templatesHandler = (TemplatesAssignmentHandler) smanager.lookup(TemplatesAssignmentHandler.ROLE);
        _cTypeHandler = (ContentTypesAssignmentHandler) smanager.lookup(ContentTypesAssignmentHandler.ROLE);
        _serviceHandler = (ServicesAssignmentHandler) smanager.lookup(ServicesAssignmentHandler.ROLE);
        _contentTypeExtensionPoint = (ContentTypeExtensionPoint) smanager.lookup(ContentTypeExtensionPoint.ROLE);
        _contentHelper = (ContentHelper) smanager.lookup(ContentHelper.ROLE);
        _serviceExtensionPoint = (ServiceExtensionPoint) smanager.lookup(ServiceExtensionPoint.ROLE);
        _workflowProvider = (WorkflowProvider) smanager.lookup(WorkflowProvider.ROLE);
        _sharedContentManager = (SharedContentManager) smanager.lookup(SharedContentManager.ROLE);
        _tagProvider = (TagProviderExtensionPoint) smanager.lookup(TagProviderExtensionPoint.ROLE);
        _webLanguagesManager = (WebLanguagesManager) smanager.lookup(WebLanguagesManager.ROLE);
        _contentDAO = (WebContentDAO) smanager.lookup(WebContentDAO.ROLE);
        _copySiteComponent = (CopySiteComponent) smanager.lookup(CopySiteComponent.ROLE);
        _rightManager = (RightManager) smanager.lookup(RightManager.ROLE);
        _synchronizeComponent = (SynchronizeComponent) smanager.lookup(SynchronizeComponent.ROLE);
        _repository = (Repository) smanager.lookup(Repository.class.getName());
        _cacheManager = (AbstractCacheManager) smanager.lookup(AbstractCacheManager.ROLE);
        _pageDataTypeExtensionPoint = (PageDataTypeExtensionPoint) smanager.lookup(PageDataTypeExtensionPoint.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _createCaches();
        _observationManager.registerObserver(this);
    }
    
    private void _createCaches()
    {
        _cacheManager.createMemoryCache(MEMORY_PAGESTAGCACHE, 
                new I18nizableText("plugin.web", "PLUGINS_WEB_PAGEDAO_CACHE_PAGES_BY_TAG_LABEL"),
                new I18nizableText("plugin.web", "PLUGINS_WEB_PAGEDAO_CACHE_PAGES_BY_TAG_DESCRIPTION"),
                true,
                null);
    }
    
    public int getPriority(Event event)
    {
        return 0;
    }
    
    public boolean supports(Event event)
    {
        return event.getId().equals(ObservationConstants.EVENT_PAGE_UPDATED) && event.getArguments().containsKey("page.tags");
    }
    
    public void observe(Event event, Map<String, Object> transientVars) throws Exception
    {
        Page page = (Page) event.getArguments().get(ObservationConstants.ARGS_PAGE);
        if (page != null)
        {
            _getMemoryPageTagCache().invalidate(PageTagCacheKey.of(page.getSiteName(), page.getSitemapName()));
        }
    }

    /**
     * Get the properties of given pages
     * @param pageIds the id of pages
     * @param zoneName The optional zone name to limit informations of zones to that zone. Can be null or empty to avoid limitation.
     * @param zoneItemId The optional zone item identifier to limit informations of zones to that zone item. Can be null or empty to avoid limitation. 
     * @return the properties of pages in a result map
     */ 
    @Callable
    public Map<String, Object> getPagesInfos (List<String> pageIds, String zoneName, String zoneItemId)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<Map<String, Object>> pages = new ArrayList<>();
        List<String> pagesNotFound = new ArrayList<>();
        
        for (String pageId : pageIds)
        {
            try
            {
                Page page = _resolver.resolveById(pageId);
                pages.add(getPageInfos(page, zoneName, zoneItemId));
            }
            catch (UnknownAmetysObjectException e)
            {
                pagesNotFound.add(pageId);
            }
        }
        
        result.put("pages", pages);
        result.put("pagesNotFound", pagesNotFound);
        
        return result;
    }
    
    /**
     * Get the properties of given pages
     * @param pageIds the id of pages
     * @return the properties of pages in a result map
     */ 
    @Callable
    public Map<String, Object> getPagesInfos (List<String> pageIds)
    {
        return getPagesInfos(pageIds, null, null);
    }
    
    /**
     * Get the page's properties
     * @param pageId the page ID
     * @return the properties
     */
    @Callable
    public Map<String, Object> getPageInfos (String pageId)
    {
        return getPageInfos(pageId, null, null);
    }
    
    /**
     * Get the page's properties
     * @param pageId the page ID
     * @param zoneName The optional zone name to limit informations of zones to that zone. Can be null or empty to avoid limitation.
     * @param zoneItemId The optional zone item identifier to limit informations of zones to that zone item. Can be null or empty to avoid limitation. 
     * @return the properties
     */
    @Callable
    public Map<String, Object> getPageInfos (String pageId, String zoneName, String zoneItemId)
    {
        Page page = _resolver.resolveById(pageId);
        return getPageInfos(page, zoneName, zoneItemId);
    }

    /**
     * Get the page's properties
     * @param page the page
     * @param zoneName The optional zone name to limit informations of zones to that zone. Can be null or empty to avoid limitation.
     * @param zoneItemId The optional zone item identifier to limit informations of zones to that zone item. Can be null or empty to avoid limitation. 
     * @return the properties
     */
    public Map<String, Object> getPageInfos (Page page, String zoneName, String zoneItemId)
    {
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("id", page.getId());
        infos.put("name", page.getName());
        infos.put("parentId", page.getParent().getId());
        infos.put("title", page.getTitle());
        infos.put("longTitle", page.getLongTitle());
        infos.put("path", page.getPathInSitemap());
        infos.put("siteName", page.getSiteName());
        infos.put("type", page.getType());
        infos.put("lang", page.getSitemapName());
        infos.put("isModifiable", page instanceof ModifiablePage);
        infos.put("isMoveable", page instanceof MoveablePage);
        infos.put("isTaggable", page instanceof TaggableAmetysObject);
        infos.put("isVisible", page.isVisible());
        infos.put("isParentInvisible", _isParentInvisible(page));
        // Publication information
        infos.put("publication", _publication2Json(page));
        infos.put("isPreviewable", _isPreviewable(page));
        
        // limitation information
        if (StringUtils.isNotBlank(zoneName))
        {
            infos.put("zoneName", zoneName);
        }
        if (StringUtils.isNotBlank(zoneItemId))
        {
            infos.put("zoneItemId", zoneItemId);
        }

        String skinId = page.getSite().getSkinId();
        Skin skin = _skinsManager.getSkin(skinId);
        infos.put("isPageValid", _synchronizeComponent.isPageValid(page, skin));

        Session liveSession = null;
        try
        {
            liveSession = _repository.login(WebConstants.LIVE_WORKSPACE);
            infos.put("isLiveHierarchyValid", _synchronizeComponent.isHierarchyValid(page, liveSession));
        }
        catch (RepositoryException e)
        {
            throw new RuntimeException("Unable to check live workspace", e);
        }
        finally
        {
            if (liveSession != null)
            {
                liveSession.logout();
            }
        }

        PageType type = page.getType();
        switch (type)
        {
            case CONTAINER:
                infos.put("template", page.getTemplate());
                
                List<Map<String, Object>> zones = new ArrayList<>();
                for (Zone zone : page.getZones())
                {
                    if (StringUtils.isBlank(zoneName) || zoneName.equals(zone.getName()))
                    {
                        zones.add(_zone2json(zone, zoneItemId));
                    }
                }
                infos.put("zones", zones);
                break;
            
            case LINK:
                infos.put("url", page.getURL());
                
                LinkType urlType = page.getURLType();
                infos.put("urlType", urlType.toString());
                
                switch (urlType)
                {
                    case PAGE:
                        try
                        {
                            Page targetPage = _resolver.resolveById(page.getURL());
                            infos.put("urlTitle", targetPage.getTitle());
                        }
                        catch (UnknownAmetysObjectException e)
                        {
                            getLogger().error("Page '" + page.getId() + "' redirects to an unexisting page '" + page.getURL() + "'");
                        }
                        break;

                    default:
                        break;
                }
                break;
            default:
                AmetysObjectIterator< ? extends Page> iterator = page.getChildrenPages().iterator();
                if (iterator.hasNext())
                {
                    Page firstSubPage = iterator.next();
                    infos.put("url", firstSubPage.getId());
                    infos.put("urlTitle", firstSubPage.getTitle());
                    infos.put("urlType", LinkType.PAGE.toString());
                    break;

                }
                break;
        }
        
        
        infos.put("rights", getUserRights(page));
        
        return infos;
    }
    
    /**
     * Get the page's properties
     * @param page the page
     * @return the properties
     */
    public Map<String, Object> getPageInfos (Page page)
    {
        return getPageInfos(page, null, null);
    }
    
    /**
     * Get the page's properties
     * @param pageId the id of page
     * @return the properties
     */
    @Callable
    public Map<String, Object> getPageProperties (String pageId)
    {
        Page page = _resolver.resolveById(pageId);
        
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("id", page.getId());
        infos.put("name", page.getName());
        infos.put("parentId", page.getParent().getId());
        infos.put("title", page.getTitle());
        infos.put("longTitle", page.getLongTitle());
        infos.put("path", page.getPathInSitemap());
        infos.put("siteName", page.getSiteName());
        infos.put("siteTitle", page.getSite().getTitle());
        infos.put("type", page.getType());
        
        String lang = page.getSitemapName();
        infos.put("lang", lang);
        Language language = _webLanguagesManager.getAvailableLanguages().get(lang);
        if (language != null)
        {
            infos.put("langIcon", language.getSmallIcon());
            infos.put("langLabel", language.getLabel());
        }
        
        PageType type = page.getType();
        switch (type)
        {
            case CONTAINER:
                infos.put("template", page.getTemplate());
                break;
            
            case LINK:
                infos.put("url", page.getURL());
                LinkType urlType = page.getURLType();
                infos.put("urlType", urlType.toString());
                break;
            default:
                break;
        }
        
        Map<String, Object> contextParameters = new HashMap<>();
        contextParameters.put("siteName", page.getSiteName());
        
        // Tags
        List<I18nizableText> tags = new ArrayList<>();
        for (String tagName : page.getTags())
        {
            Tag tag = _tagProvider.getTag(tagName, contextParameters);
            tags.add(tag.getTitle());
        }
        infos.put("tags", tags);
        
        // Incoming references
        List<Map<String, Object>> incomingContents = new ArrayList<>();
        AmetysObjectIterable<Content> contents = _getIncomingContentReferences (page.getId());
        for (Content content : contents)
        {
            incomingContents.add(_content2Json(content, new Locale(page.getSitemapName())));
        }
        infos.put("inComingContents", incomingContents);
        
        List<Map<String, Object>> incomingPages = new ArrayList<>();
        AmetysObjectIterable<Page> pages = _getIncomingPageReferences (page.getId());
        for (Page pageRef : pages)
        {
            incomingPages.add(_page2Json(pageRef));
        }
        infos.put("inComingPages", incomingPages);
        
        // Publication information
        infos.put("publication", _publication2Json(page));
        
        return infos;
    }
    
    /**
     * Check current user right on given page or sitemap
     * @param id The id of the page or sitemap
     * @param rightId The if of right to check
     * @return true if user has right
     */
    @Callable
    public boolean hasRight(String id, String rightId)
    {
        UserIdentity user = _currentUserProvider.getUser();
        PagesContainer page = _resolver.resolveById(id);
        
        return _rightManager.hasRight(user, rightId, page) == RightResult.RIGHT_ALLOW;
    }
    
    /**
     * Create a new page
     * @param parentId The parent id. Can not be null.
     * @param title The page's title. Can not be null.
     * @param longTitle The page's long title. Can be null or blank.
     * @return The result map with id of created page
     */
    @Callable
    public Map<String, Object> createPage (String parentId, String title, String longTitle)
    {
        Map<String, Object> result = new HashMap<>();
        
        PagesContainer parent = _resolver.resolveById(parentId);
        
        assert parent instanceof ModifiableTraversableAmetysObject;
        
        Site site = parent.getSite();
        String originalPageName = "";
        try
        {
            originalPageName = FilterNameHelper.filterName(title);
        }
        catch (IllegalArgumentException e)
        {
            result.put("invalid-name", title);
            return result;
        }
        
        String pageName = originalPageName;
        int index = 2;
        while (parent.hasChild(pageName))
        {
            pageName = originalPageName + "-" + (index++);
        }
        
        ModifiablePage page = ((ModifiableTraversableAmetysObject) parent).createChild(pageName, "ametys:defaultPage");
        
        // Check rights
        if (!_canCreate(parent))
        {
            throw new IllegalStateException("You do not have the rights to create a page under '/" + parent.getSitemapName() + "/" + parent.getPathInSitemap() + "'");
        }
        
        page.setTitle(title);
        page.setType(PageType.NODE);
        page.setSiteName(site.getName());
        page.setSitemapName(page.getSitemap().getName());
        
        if (!StringUtils.isBlank(longTitle))
        {
            page.setLongTitle(longTitle);
        }
        
        site.saveChanges();
        
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_PAGE, page);
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_ADDED, _currentUserProvider.getUser(), eventParams));
        
        result.put("id", page.getId());
        result.put("parentId", parent.getId());
        result.put("lang", page.getSitemapName());
        result.put("title", page.getTitle());
        
        return result;
    }

    /**
     * Copy a page
     * @param id The id of page to copy
     * @param target The id of parent target page
     * @param keepReferences true to keep references
     * @return the result map
     * @throws RepositoryException if an error occurred during copy
     */
    @Callable
    public Map<String, String> copyPage (String id, String target, boolean keepReferences) throws RepositoryException
    {
        Map<String, String> result = new HashMap<>();
        
        Page page = _resolver.resolveById(id);
        
        if (!(page instanceof CopiableAmetysObject))
        {
            throw new IllegalArgumentException("The page '" + page.getId() + "' is not a copiable ametys object, it can not be copied"); 
        }
        
        if (!(page instanceof JCRAmetysObject))
        {
            throw new IllegalArgumentException("The page '" + page.getId() + "' is not a JCR ametys object, it can not be copied"); 
        }
        
        PagesContainer parent = _resolver.resolveById(target);
        
        // Check rights
        if (!_canCreate(parent))
        {
            throw new IllegalStateException("You do not have the rights to create a page under '/" + parent.getSitemapName() + "/" + parent.getPathInSitemap() + "'");
        }
        
        if (parent instanceof ModifiableTraversableAmetysObject)
        {
            Page cPage = null;
            if (!keepReferences)
            {
                // Restrict the copy to the page and its current children to avoid infinitive loop
                List<String> pagesToCopy = new ArrayList<>();
                pagesToCopy.add(page.getId());
                pagesToCopy.addAll(_getChildrenPageIds(page));
                
                // Copy and duplicate contents
                cPage = (Page) ((CopiableAmetysObject) page).copyTo((ModifiableTraversableAmetysObject) parent, null, pagesToCopy);
                _copySiteComponent.updateReferencesAfterCopy(page, cPage);
                
                // Creates the first version on all copied contents
                _updateContentsAfterCopy (cPage);
            }
            else
            {
                // Copy without duplicating contents (keep references)
                
                if (!page.getSitemapName().equals(parent.getSitemapName()))
                {
                    throw new IllegalArgumentException("The page '" + page.getId() + "' from sitemap '" + page.getSitemapName() + "' cannot be copied to a different sitemap '" + parent.getSitemapName() + "' while keeping references to contents");
                }
                
                String pageName = page.getName();
                int index = 2;
                while (parent.hasChild(pageName))
                {
                    pageName = page.getName() + "-" + (index++);
                }
                
                String pagePath = ((SimpleAmetysObject) parent).getNode().getPath() + "/" + pageName;
                Node node = ((JCRAmetysObject) page).getNode();
                node.getSession().getWorkspace().copy(node.getPath(), pagePath);
                
                cPage = parent.getChild(pageName);
            }
            
            ((ModifiableTraversableAmetysObject) parent).saveChanges();
            result.put("id", cPage.getId());
            
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PAGE, cPage);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_ADDED, _currentUserProvider.getUser(), eventParams));
        }
       
        return result;
    }
    
    /**
     * Copy a page under another page
     * @param targetId the page to copy in
     * @param sourceId the page to copy
     * @param keepReferences true to keep references for contents, or false to duplicate contents
     * @return The id of created page is a result map.
     * @throws RepositoryException if an error occurs
     */
    @Callable
    @Deprecated
    public Map<String, String> pastePage(String targetId, String sourceId, boolean keepReferences) throws RepositoryException
    {
        return copyPage(sourceId, targetId, keepReferences);
    }
    
    /**
     * Move a page
     * @param id The page id
     * @param parentId The id of parent destination
     * @param index The position in parent child nodes where page will be inserted. -1 means as the last child.
     * @return the result map
     */
    @Callable
    public Map<String, Object> movePage (String id, String parentId, int index)
    {
        Map<String, Object> result = new HashMap<>();
        
        String oldPathInSitemap = null;
        String newPathInSitemap = null;
     
        Page page = _resolver.resolveById(id);
        PagesContainer srcParent = page.getParent();
        oldPathInSitemap = page.getPathInSitemap();
        Sitemap sitemap = page.getSitemap();
        
        // check rights of deletion on old parent page
        if (!srcParent.getId().equals(parentId) && !_canDelete(page))
        {
            throw new IllegalStateException("You do not have the rights to delete the page '/" + page.getSitemapName() + "/" + oldPathInSitemap + "'");
        }
        
        if (!(page instanceof MoveablePage))
        {
            throw new IllegalArgumentException("The page '/" + page.getSitemapName() + "/" + oldPathInSitemap + "' is not a moveable page");
        }
        
        if (srcParent.getId().equals(parentId) && index != -1)
        {
            try
            {
                Page brother = srcParent.getChildPageAt(index);
                ((MoveablePage) page).orderBefore(brother);
            }
            catch (UnknownAmetysObjectException e)
            {
                // Move the last child position
                ((MoveablePage) page).orderBefore(null);
            }
            
            // Path is not modified
            newPathInSitemap = oldPathInSitemap;
        }
        else
        {
            PagesContainer newParentPage = _resolver.resolveById(parentId);

            // check right on creation on new parent page
            if (!_canCreate(newParentPage))
            {
                throw new IllegalStateException("You do not have the rights to create a page under '/" + newParentPage.getSitemapName() + "/" + newParentPage.getPathInSitemap() + "'");
            }

            ((MoveablePage) page).moveTo(newParentPage, true);
            if (index != -1)
            {
                Page brother = newParentPage.getChildPageAt(index);
                
                ((MoveablePage) page).orderBefore(brother);
            }
            
            // Path is modified
            newPathInSitemap = page.getPathInSitemap();
        }
        
        if (sitemap.needsSave())
        {
            sitemap.saveChanges();
        }

        // Notify observers that the page has been moved
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_SITEMAP, sitemap);
        eventParams.put(ObservationConstants.ARGS_PAGE, page);
        eventParams.put("page.old.path", oldPathInSitemap);
        eventParams.put("page.old.parent", srcParent);
        eventParams.put(ObservationConstants.ARGS_PAGE_PATH, newPathInSitemap);
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_MOVED, _currentUserProvider.getUser(), eventParams));
        
        result.put("id", page.getId());
        result.put("parentId", page.getParent().getId());
        
        return result;
    }
    
    private boolean _canCreate(PagesContainer parentPage)
    {
        UserIdentity user = _currentUserProvider.getUser();
        if (_rightManager.hasRight(user, "Web_Rights_Page_Create", parentPage) == RightResult.RIGHT_ALLOW)
        {
            return true;
        }
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("The user '" + user + "' tried to create page under '/" + parentPage.getSitemapName() + "/" + parentPage.getPathInSitemap() + "' without sufficient rights");
        }
        
        return false;
    }
    
    private boolean _canDelete(Page page)
    {
        UserIdentity user = _currentUserProvider.getUser();
        PagesContainer parent = page.getParent();
        if (_rightManager.hasRight(user, "Web_Rights_Page_Delete", parent) == RightResult.RIGHT_ALLOW)
        {
            return true;
        }
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("The user '" + user + "' tried to move page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "' without sufficient rights");
        }
        
        return false;
    }
    
    /**
     * Set pages as redirection
     * @param pageIds the id of pages to modify
     * @param url the url of redirection
     * @param urlType the type of redirection
     * @return the id of pages which succeeded or failed. 
     */
    @Callable
    public Map<String, Object> setLink (List<String> pageIds, String url, String urlType)
    {
        Map<String, Object> result = new HashMap<>();
        
        if (StringUtils.isEmpty(url))
        {
            throw new IllegalArgumentException("Can not set page as a redirection with an empty url");
        }
        
        List<String> successes = new ArrayList<>();
        List<Map<String, Object>> failures = new ArrayList<>();
        
        for (String pageId : pageIds)
        {
            try
            {
                Page page = _resolver.resolveById(pageId);
                if (!(page instanceof ModifiablePage))
                {
                    throw new IllegalArgumentException("Can not set page as a redirection on a non-modifiable page " + pageId);
                }
                
                ModifiablePage mPage = (ModifiablePage) page;
                
                if (page.getType().equals(PageType.CONTAINER))
                {
                    // Remove zones
                    for (ModifiableZone zone : mPage.getZones())
                    {
                        zone.remove();
                    }
                }
                
                if (pageId.equals(url))
                {
                    throw new IllegalArgumentException("A page can not redirect to itself");
                }
                
                mPage.setType(PageType.LINK);
                mPage.setURL(LinkType.valueOf(urlType), url);
                mPage.getSitemap().saveChanges();
                
                successes.add(pageId);
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_CHANGED, _currentUserProvider.getUser(), eventParams));
            }
            catch (Exception e)
            {
                getLogger().error("Cannot set the page '" + pageId + "' as link [" + url + ", " + urlType.toString() + "]", e);
                
                Map<String, Object> failure = new HashMap<>();
                failure.put("id", pageId);
                failure.put("error", e.toString());
                failures.add(failure);
            }
        }

        result.put("success", successes);
        result.put("failure", failures);
        
        return result;
    }
    
    /**
     * Get available template for specified page
     * @param pageId The page's id
     * @return the list of available template
     */
    @Callable
    public List<Map<String, Object>> getAvailableTemplates (String pageId)
    {
        List<Map<String, Object>> templates = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        Set<String> availableTemplateIds = _templatesHandler.getAvailablesTemplates(page);
        for (String templateName : availableTemplateIds)
        {
            String skinId = page.getSite().getSkinId();
            Skin skin = _skinsManager.getSkin(skinId);
            
            SkinTemplate template = skin.getTemplate(templateName);
            
            Map<String, Object> template2json = new HashMap<>();
            template2json.put("id", template.getId());
            template2json.put("label", template.getLabel());
            template2json.put("description", template.getDescription());
            template2json.put("iconSmall", template.getSmallImage());
            template2json.put("iconMedium", template.getMediumImage());
            template2json.put("iconLarge", template.getLargeImage());
            template2json.put("zone", template.getDefaultZoneId());
            
            templates.add(template2json);
        }
        
        return templates;
    }
    
    /**
     * Get available content types for specified page
     * @param pageId The page's id
     * @param zoneName the name of the zone
     * @return the list of available content types
     */
    @Callable
    public List<Map<String, Object>> getAvailableContentTypes (String pageId, String zoneName)
    {
        List<Map<String, Object>> contenttypes = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        Set<String> contentTypeIds = _cTypeHandler.getAvailableContentTypes(page, zoneName);
        for (String contentTypeId : contentTypeIds)
        {
            ContentType cType = _contentTypeExtensionPoint.getExtension(contentTypeId);
            
            if (cType != null && _hasRight(cType, page))
            {
                Map<String, Object> ctype2json = new HashMap<>();
                ctype2json.put("id", cType.getId());
                ctype2json.put("label", cType.getLabel());
                ctype2json.put("description", cType.getDescription());
                ctype2json.put("iconGlyph", cType.getIconGlyph());
                ctype2json.put("iconDecorator", cType.getIconDecorator());
                ctype2json.put("iconSmall", cType.getSmallIcon());
                ctype2json.put("iconMedium", cType.getMediumIcon());
                ctype2json.put("iconLarge", cType.getLargeIcon());
                ctype2json.put("defaultTitle", cType.getDefaultTitle());
                ctype2json.put("editionMetatadaSets", cType.getEditionMetadataSetNames(true));
                
                contenttypes.add(ctype2json);
            }
        }
        
        return contenttypes;
    }
    
    /**
     * Get available content types for a page being created
     * @param pageId The page's id. Can be null of the page is not yet created
     * @param zoneName the name of the zone
     * @param parentId The id of parent page
     * @param pageTitle The title of page to create
     * @param template The template of page to create
     * @return the list of available services
     */
    @Callable
    public List<Map<String, Object>> getAvailableContentTypesForCreation(String pageId, String zoneName, String parentId, String pageTitle, String template)
    {
        if (StringUtils.isNotEmpty(pageId))
        {
            // Get available services for a page
            return getAvailableContentTypes(pageId, zoneName);
        }
        else if (StringUtils.isNotEmpty(parentId))
        {
            // Get available services for a not yet existing page
            PagesContainer parent = _resolver.resolveById(parentId);
            
            // Create page temporarily
            Page page = _createPage(parent, pageTitle, template);
            
            List<Map<String, Object>> availableContentTypes = getAvailableContentTypes(page.getId(), zoneName);
            
            // Cancel page creation
            page.getSitemap().revertChanges();
            
            return availableContentTypes;
        }
        
        return Collections.EMPTY_LIST;
    }
    
    private boolean _hasRight(ContentType contentType, Page page)
    {
        String right = contentType.getRight();
        
        if (right == null)
        {
            return true;
        }
        else
        {
            UserIdentity user = _currentUserProvider.getUser();
            return _rightManager.hasRight(user, right, page) == RightResult.RIGHT_ALLOW;
        }
    }
    
    /**
     * Get available services for specified page
     * @param pageId The page's id
     * @param zoneName the name of the zone
     * @return the list of available services
     */
    @Callable
    public List<Map<String, Object>> getAvailableServices (String pageId, String zoneName)
    {
        List<Map<String, Object>> services = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        Set<String> serviceIds = _serviceHandler.getAvailableServices(page, zoneName);
        for (String serviceId : serviceIds)
        {
            Service service = _serviceExtensionPoint.getExtension(serviceId);
            if (service != null && _hasRight(service, page))
            {
                Map<String, Object> serviceMap = new HashMap<>();
                serviceMap.put("id", service.getId());
                serviceMap.put("label", service.getLabel());
                serviceMap.put("description", service.getDescription());
                serviceMap.put("iconGlyph", service.getIconGlyph());
                serviceMap.put("iconDecorator", service.getIconDecorator());
                serviceMap.put("iconSmall", service.getSmallIcon());
                serviceMap.put("iconMedium", service.getMediumIcon());
                serviceMap.put("iconLarge", service.getLargeIcon());
                serviceMap.put("parametersAction", service.getParametersScript().getScriptClassname());
                
                services.add(serviceMap);
            }
        }
        
        return services;
    }
    
    /**
     * Get available services for a page being created
     * @param pageId The page's id. Can be null of the page is not yet created
     * @param zoneName the name of the zone
     * @param parentId The id of parent page
     * @param pageTitle The title of page to create
     * @param template The template of page to create
     * @return the list of available services
     */
    @Callable
    public List<Map<String, Object>> getAvailableServicesForCreation(String pageId, String zoneName, String parentId, String pageTitle, String template)
    {
        if (StringUtils.isNotEmpty(pageId))
        {
            // Get available services for a page
            return getAvailableServices(pageId, zoneName);
        }
        else if (StringUtils.isNotEmpty(parentId))
        {
            // Get available services for a not yet existing page
            PagesContainer parent = _resolver.resolveById(parentId);
            
            // Create page temporarily
            Page page = _createPage(parent, pageTitle, template);
            
            List<Map<String, Object>> availableServices = getAvailableServices(page.getId(), zoneName);
            
            // Cancel page creation
            page.getSitemap().revertChanges();
            
            return availableServices;
        }
        
        return Collections.EMPTY_LIST;
    }
    
    private Page _createPage (PagesContainer parent, String pageTitle, String template)
    {
        Site site = parent.getSite();
        String originalPageName = FilterNameHelper.filterName(pageTitle);
        
        String pageName = originalPageName;
        int index = 2;
        while (parent.hasChild(pageName))
        {
            pageName = originalPageName + "-" + index++;
        }
        
        ModifiablePage page = ((ModifiableTraversableAmetysObject) parent).createChild(pageName, "ametys:defaultPage");
        
        page.setTitle(pageTitle);
        page.setType(PageType.NODE);
        page.setSiteName(site.getName());
        page.setSitemapName(page.getSitemap().getName());

        if (template != null)
        {
            String skinId = page.getSite().getSkinId();
            SkinTemplate tpl = _skinsManager.getSkin(skinId).getTemplate(template);
            if (tpl == null)
            {
                throw new IllegalStateException("Template '" + template + "' does not exist on skin '" + skinId + "'");
            }
            
            // Set temporary the template to get available services
            page.setType(PageType.CONTAINER); 
            page.setTemplate(template);
        }
        
        return page;
    }
    
    private boolean _hasRight(Service service, Page page)
    {
        String right = service.getRight();
        
        if (right == null)
        {
            return true;
        }
        else
        {
            UserIdentity user = _currentUserProvider.getUser();
            return _rightManager.hasRight(user, right, page) == RightResult.RIGHT_ALLOW;
        }
    }
    
    /**
     * Get available template for specified pages
     * @param pageIds The id of pages
     * @return the list of available template
     */
    @Callable
    public List<Map<String, Object>> getAvailableTemplates (List<String> pageIds)
    {
        List<String> templateIds = new ArrayList<>();
        
        List<Map<String, Object>> templates = new ArrayList<>();
        
        for (String pageId : pageIds)
        {
            List<Map<String, Object>> pageTemplates = getAvailableTemplates(pageId);
            
            for (Map<String, Object> template : pageTemplates)
            {
                String templateName = (String) template.get("id");
                
                if (!templateIds.contains(templateName))
                {
                    templateIds.add(templateName);
                    templates.add(template);
                }
            }
        }
        
        return templates;
    }
    
    /**
     * Get available content types for a page being created
     * @param pageId The page's id. Can be null of the page is not yet created
     * @param parentId The id of parent page
     * @param pageTitle The title of page to create
     * @return the list of available services
     */
    @Callable
    public List<Map<String, Object>> getAvailableTemplatesForCreation (String pageId, String parentId, String pageTitle)
    {
        if (StringUtils.isNotEmpty(pageId))
        {
            // Get available template for a page
            return getAvailableTemplates(pageId);
        }
        else if (StringUtils.isNotEmpty(parentId))
        {
            // Get available template for a not yet existing page
            PagesContainer parent = _resolver.resolveById(parentId);
            
            // Create page temporarily
            Page page = _createPage(parent, pageTitle, null);
            
            List<Map<String, Object>> availableTemplates = getAvailableTemplates(page.getId());
            
            // Cancel page creation
            page.getSitemap().revertChanges();
            
            return availableTemplates;
        }
        
        return Collections.EMPTY_LIST;
    }
    
    /**
     * Get service info
     * @param pageId Optional, the page id of the service. To get some basic info about the page.
     * @param serviceId The id of the service
     * @return a Map containing some info about the service (label, url..)
     */
    @Callable
    public Map<String, Object> getServiceInfo(String pageId, String serviceId)
    {
        Map<String, Object> info = new HashMap<>();
        
        if (StringUtils.isNotEmpty(pageId))
        {
            Page page = _resolver.resolveById(pageId);
            info.put("page-id", page.getId());
            info.put("page-title", page.getTitle());
        }
        
        Service service = _serviceExtensionPoint.getExtension(serviceId);
        info.put("id", service.getId());
        info.put("label", service.getLabel());
        info.put("url", service.getURL());
        info.put("smallIcon", service.getSmallIcon());
        info.put("iconGlyph", service.getIconGlyph());
        info.put("iconDecorator", service.getIconDecorator());
        return info;
    }
    
    /**
     * Rename a page
     * @param pageId The id of page to rename
     * @param title The page's  title
     * @param longTitle The page's long title.
     * @param updatePath true to update page's path
     * @param createAlias true to create a alias
     * @return the result map
     */
    @Callable (right = "Web_Rights_Page_Rename", rightContext = PageRightAssignmentContext.ID, paramIndex = 0)
    public Map<String, Object> renamePage (String pageId, String title, String longTitle, boolean updatePath, boolean createAlias)
    {
        Map<String, Object> result = new HashMap<>();
        
        Page page = _resolver.resolveById(pageId);
        
        if (!(page instanceof ModifiablePage))
        {
            throw new IllegalArgumentException("Can not rename a non-modifiable page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "'");
        }
        
        ModifiablePage mPage = (ModifiablePage) page;
        mPage.setTitle(title);
        mPage.setLongTitle(longTitle);

        if (updatePath)
        {
            String oldPathInSitemap = page.getPathInSitemap();
            String oldPath = "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + ".html";
            String oldPathForChild = "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "/**.html";

            String pageName = "";
            try
            {
                pageName = FilterNameHelper.filterName(title);
            }
            catch (IllegalArgumentException e)
            {
                result.put("invalid-name", title);
                return result;
            }
            
            if (!page.getName().equals(pageName))
            {
                int index = 1;
                String initialPageName = pageName;
                PagesContainer parent = page.getParent();
                while (parent.hasChild(pageName))
                {
                    pageName = initialPageName + "-" + (index++);
                }

                mPage.rename(pageName);
                
                if (createAlias)
                {
                    ModifiableTraversableAmetysObject rootNode = AliasHelper.getRootNode(page.getSite());
                    
                    DefaultAlias alias = rootNode.createChild(AliasHelper.getAliasNextUniqueName(rootNode), "ametys:alias");
                    alias.setUrl(oldPath);
                    alias.setTarget(page.getId());
                    alias.setType(TargetType.PAGE);
                    alias.setCreationDate(new Date());

                    // Alias for child pages
                    alias = rootNode.createChild(AliasHelper.getAliasNextUniqueName(rootNode), "ametys:alias");
                    alias.setUrl(oldPathForChild);
                    alias.setTarget("/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "/{1}.html");
                    alias.setType(TargetType.URL);
                    alias.setCreationDate(new Date());

                    rootNode.saveChanges();
                }
                
                // Notify observers that the page has been renamed
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                eventParams.put("path.old.path", oldPathInSitemap);
                eventParams.put(ObservationConstants.ARGS_PAGE_PATH, page.getPathInSitemap());
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_RENAMED, _currentUserProvider.getUser(), eventParams));
                
            }
            else
            {
                // Notify observers that the page's title has been modified
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
            }
                
        }
        else
        {
            // Notify observers that the page's title has been modified
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PAGE, page);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
        }
        
        Sitemap sitemap = page.getSitemap();
        if (sitemap.needsSave())
        {
            sitemap.saveChanges();
        }
        
        result.put("id", page.getId());
        result.put("path", page.getPath());
        result.put("title", page.getTitle());
        
        return result;
    }
    
    /**
     * Delete a page and its sub-pages.
     * The contents that belong only to the deleted page will be deleted if 'deleteBelongingContents' is set to true.
     * The newly created contents are deleted whatever the value if 'deleteBelongingContents'.
     * @param pageId the id of page to delete
     * @param deleteBelongingContents true to delete the contents that belong to the page and its sub-pages only
     * @return The id of deleted pages
     */
    @Callable
    public Map<String, Object> deletePage(String pageId, boolean deleteBelongingContents)
    {
        ModifiablePage page = _resolver.resolveById(pageId);
        
        // Check rights on parent
        if (!_canDelete(page))
        {
            throw new IllegalStateException("You do not have the rights to delete the page '/" + page.getSitemapName() + "/" + page.getPathInSitemap() + "'");
        }
        
        return deletePage(page, deleteBelongingContents);
    }
    
    /**
     * Delete a page and its sub-pages.
     * The contents that belong only to the deleted page will be deleted if 'deleteBelongingContents' is set to true.
     * The newly created contents are deleted whatever the value if 'deleteBelongingContents'.
     * @param page the page to delete
     * @param deleteBelongingContents true to delete the contents that belong to the page and its sub-pages only
     * @return The id of deleted pages
     */
    public Map<String, Object> deletePage(ModifiablePage page, boolean deleteBelongingContents)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<String> contentToDelete = getDeleteablePageContentIds(page.getId(), !deleteBelongingContents);
        
        Sitemap sitemap = page.getSitemap();
        PagesContainer parent = page.getParent();
        String pagePathInSitemap = page.getPathInSitemap();
        
        List<String> childPagesIds = _getChildrenPageIds(page);
        
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_PAGE_ID, page.getId());
        eventParams.put(ObservationConstants.ARGS_PAGE_PARENT, parent);
        eventParams.put(ObservationConstants.ARGS_PAGE_PATH, pagePathInSitemap);
        eventParams.put(ObservationConstants.ARGS_SITEMAP, sitemap);
        eventParams.put(ObservationConstants.ARGS_PAGE_CONTENTS, getPageContents(page));
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_DELETING, _currentUserProvider.getUser(), eventParams));
        
        // FIXME API test if this is not modifiable
        page.getParent();
        page.remove();
        ((ModifiableAmetysObject) parent).saveChanges();
        
        _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_DELETED, _currentUserProvider.getUser(), eventParams));
        
        result.put("id", page.getId());
        result.put("childPages", childPagesIds);
        
        result.putAll(_contentDAO.deleteContents(contentToDelete, true));
        return result;
    }
    
    /**
     * Set pages as blank page
     * @param pageIds the id of pages to modify
     * @return the id of pages which succeeded or failed. 
     */
    @Callable
    public Map<String, Object> setBlank (List<String> pageIds)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<String> successes = new ArrayList<>();
        List<Map<String, Object>> failures = new ArrayList<>();
        
        for (String pageId : pageIds)
        {
            try
            {
                Page page = _resolver.resolveById(pageId);
                if (!(page instanceof ModifiablePage))
                {
                    throw new IllegalArgumentException("Can not set page as blank a non-modifiable page " + pageId);
                }
                
                ModifiablePage mPage = (ModifiablePage) page;
                
                if (page.getType().equals(PageType.CONTAINER))
                {
                    // Remove zones
                    for (ModifiableZone zone : mPage.getZones())
                    {
                        zone.remove();
                    }
                }
                
                mPage.setType(PageType.NODE);
                mPage.getSitemap().saveChanges();
                
                successes.add(pageId);
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_CHANGED, _currentUserProvider.getUser(), eventParams));
            }
            catch (Exception e)
            {
                getLogger().error("Cannot set the page '" + pageId + "' as blank page", e);
                
                Map<String, Object> failure = new HashMap<>();
                failure.put("id", pageId);
                failure.put("error", e.toString());
                failures.add(failure);
            }
        }

        result.put("success", successes);
        result.put("failure", failures);
        
        return result;
    }
    
    /**
     * Set a template to pages
     * @param pageIds the id of pages to update
     * @param templateName The template name
     * @return the id of pages which succeeded
     */
    @Callable
    public Map<String, Object> setTemplate (List<String> pageIds, String templateName)
    {
        return setTemplate(pageIds, templateName, true);
    }
    
    /**
     * Set a template to pages
     * @param pageIds the id of pages to update
     * @param templateName The template name
     * @param checkAvailableTemplate true if you want to check available template
     * @return the id of pages which succeeded
     */
    public Map<String, Object> setTemplate (List<String> pageIds, String templateName, boolean checkAvailableTemplate)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<String> successes = new ArrayList<>();
        
        String defaultZoneName = null;
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            if (!(page instanceof ModifiablePage))
            {
                throw new IllegalArgumentException("Can not set template a non-modifiable page " + pageId);
            }
            
            ModifiablePage mPage = (ModifiablePage) page;
            
            if (defaultZoneName == null)
            {
                String skinId = page.getSite().getSkinId();
                SkinTemplate tpl = _skinsManager.getSkin(skinId).getTemplate(templateName);
                if (tpl == null)
                {
                    throw new IllegalStateException("Template '" + templateName + "' does not exist on skin '" + skinId + "'");
                }
                
                defaultZoneName = tpl.getDefaultZoneId();
            }
            
            if (checkAvailableTemplate && !_templatesHandler.getAvailablesTemplates(mPage).contains(templateName))
            {
                throw new IllegalStateException("Template '" + templateName + "' is not available for page '" + pageId + "'");
            }
            
            if (page.getType().equals(PageType.CONTAINER))
            {
                _removeOldZones (mPage, templateName);
            }
            
            mPage.setTemplate(templateName);
            mPage.setType(PageType.CONTAINER);
            mPage.getSitemap().saveChanges();
            
            successes.add(pageId);
            
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_PAGE, page);
            _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_CHANGED, _currentUserProvider.getUser(), eventParams));
        }
        
        if (defaultZoneName != null)
        {
            result.put("zonename", defaultZoneName);
        }
        
        result.put("success", successes);
        
        return result;
    }
    
    /**
     * Get the script class name to execute to add or update this service 
     * @param serviceId the service id
     * @return the script class name. Can be empty
     */
    @Callable
    public String getServiceParametersAction (String serviceId)
    {
        try
        {
            Service service = _serviceExtensionPoint.getExtension(serviceId);
            return service.getParametersScript().getScriptClassname();
        }
        catch (IllegalArgumentException e)
        {
            throw new IllegalArgumentException("Service with id '" + serviceId + "' does not exist", e);
        }
    }
    
    private void _removeOldZones (ModifiablePage page, String templateName)
    {
        String skinId = page.getSite().getSkinId();
        
        SkinTemplate oldTemplate = _skinsManager.getSkin(skinId).getTemplate(templateName);
        
        Map<String, SkinTemplateZone> templateZones = oldTemplate.getZones();
        
        for (ModifiableZone zone : page.getZones())
        {
            if (!templateZones.containsKey(zone.getName()))
            {
                zone.remove();
            }
        }
    }
    
    /**
     * Get the tags from the pages
     * @param pageIds The ids of the pages
     * @return the tags of the pages
     */
    @Callable
    public Set<String> getTags (List<String> pageIds)
    {
        Set<String> tags = new HashSet<>();
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            tags.addAll(page.getTags());
        }
        
        return tags;
    }
    
    /**
     * Tag a list of pages
     * @param pageIds The ids of pages to tag
     * @param tagNames The tags
     * @param mode The mode for updating tags: 'REPLACE' to replace tags, 'INSERT' to add tags or 'REMOVE' to remove tags.
     * @param contextualParameters Contextual parameters. Must contain the site name
     * @return the result
     */
    @Callable
    public Map<String, Object> tag (List<String> pageIds, List<String> tagNames, String mode, Map<String, Object> contextualParameters)
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("nomodifiable-pages", new ArrayList<Map<String, Object>>());
        result.put("invalid-tags", new ArrayList<String>());
        result.put("allright-pages", new ArrayList<Map<String, Object>>());
        
        for (String pageId : pageIds)
        {
            Page page = _resolver.resolveById(pageId);
            
            Map<String, Object> page2json = new HashMap<>();
            page2json.put("id", page.getId());
            page2json.put("title", page.getTitle());
            
            if (page instanceof ModifiablePage)
            {
                ModifiablePage mPage = (ModifiablePage) page;
                
                TagMode tagMode = TagMode.valueOf(mode);
                
                Set<String> oldTags = mPage.getTags();
                if (TagMode.REPLACE.equals(tagMode))
                {
                    // First delete old tags
                    for (String tagName : oldTags)
                    {
                        mPage.untag(tagName);
                    }
                }
                    
                
                // Then set new tags
                for (String tagName : tagNames)
                {
                    if (_isTagValid(page, tagName))
                    {
                        if (TagMode.REMOVE.equals(tagMode))
                        {
                            mPage.untag(tagName);
                        }
                        else if (TagMode.REPLACE.equals(tagMode) || !oldTags.contains(tagName))
                        {
                            mPage.tag(tagName);
                        }
                    }
                    else
                    {
                        @SuppressWarnings("unchecked")
                        List<String> invalidTags = (List<String>) result.get("invalid-tags");
                        invalidTags.add(tagName);
                    }
                }
                
                mPage.saveChanges();
                
                page2json.put("tags", page.getTags());
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> allRightPages = (List<Map<String, Object>>) result.get("allright-pages");
                allRightPages.add(page2json);
                
                if (!oldTags.equals(page.getTags()))
                {
                    // Notify observers that the content has been tagged
                    Map<String, Object> eventParams = new HashMap<>();
                    eventParams.put(ObservationConstants.ARGS_PAGE, page);
                    eventParams.put("page.tags", page.getTags());
                    eventParams.put("page.old.tags", oldTags);
                    _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
                }
            }
            else
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> nomodifiablePages = (List<Map<String, Object>>) result.get("nomodifiable-pages");
                nomodifiablePages.add(page2json);
            }
        }
        
        return result;
    }
    
    /**
     * Tag a list of contents with the given tags
     * @param pageIds The ids of pages to tag
     * @param contentIds The ids of contents to tag
     * @param tagNames The tags
     * @param contextualParameters The contextual parameters
     * @return the result map
     */
    @Callable
    public Map<String, Object> tag (List<String> pageIds, List<String> contentIds, List<String> tagNames, Map<String, Object> contextualParameters)
    {
        return tag(pageIds, contentIds, tagNames, TagMode.REPLACE.toString(), contextualParameters);
    }
    
    /**
     * Tag a list of contents and/org pages
     * @param pageIds The ids of pages to tag
     * @param contentIds The ids of contents to tag
     * @param tagNames The tags
     * @param mode The mode for updating tags: 'REPLACE' to replace tags, 'INSERT' to add tags or 'REMOVE' to remove tags.
     * @param contextualParameters The contextual parameters
     * @return the result
     */
    @Callable
    public Map<String, Object> tag (List<String> pageIds, List<String> contentIds, List<String> tagNames, String mode, Map<String, Object> contextualParameters)
    {
        // Tag pages
        Map<String, Object> result = tag(pageIds, tagNames, mode, contextualParameters);
        
        // Tag contents
        result.putAll(_contentDAO.tag(contentIds, tagNames, mode, contextualParameters));
        
        // Invalid tags are ignored
        result.remove("invalid-tags");
        return result;
    }
    
    /**
     * Test if a tag is valid for a specific page
     * @param page The page
     * @param tagName The tag name
     * @return True if the tag is valid
     */
    public boolean _isTagValid (Page page, String tagName)
    {
        Map<String, Object> params = new HashMap<>();
        params.put("siteName", page.getSiteName());
        CMSTag tag = _tagProvider.getTag(tagName, params);
        
        return tag.getTarget().getName().equals("PAGE");
    }
    
    /**
     * Returns the ids of the pages matching the tag
     * @param sitename The site id
     * @param lang The language code
     * @param tag The tag id
     * @return Array of pages ids
     */
    public List<String> findPagedIdsByTag(String sitename, String lang, String tag)
    {
        return _getMemoryPageTagCache().get(PageTagCacheKey.of(sitename, lang, tag), __ -> _computePagesIds(sitename, lang, tag))
                    .stream()
                    .filter(_resolver::hasAmetysObjectForId) // Cache remember for tag in default, we have to check if page exists in current workspace
                    .collect(Collectors.toList());
    }
    
    private List<String> _computePagesIds(String sitename, String lang, String tag)
    {
        
        Session defaultSession = null;
        try
        {
            List<String> pagesIds = new ArrayList<>();
            
            // Force default workspace to execute query
            defaultSession = _repository.login(RepositoryConstants.DEFAULT_WORKSPACE);
            
            String xpath = PageQueryHelper.getPageXPathQuery(sitename, lang, null, new TagExpression(Operator.EQ, tag), null);
            AmetysObjectIterable<Page> pages = _ametysObjectResolver.query(xpath, defaultSession);
            Iterator<Page> it = pages.iterator();
    
            while (it.hasNext())
            {
                pagesIds.add(it.next().getId());
            }
            
            return pagesIds;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
        finally
        {
            if (defaultSession != null)
            {
                defaultSession.logout();
            }
        }
    }

    private Cache<PageTagCacheKey, List<String>> _getMemoryPageTagCache()
    {
        return _cacheManager.get(MEMORY_PAGESTAGCACHE);
    }
    
    /**
     * Set the visible of pages
     * @param pageIds The id of pages
     * @param visible <code>true</code> to set pages as visible, <code>false</code> otherwise
     * @return The result map
     */
    @Callable
    public Map<String, Object> setVisibility (List<String> pageIds, boolean visible)
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("nomodifiable-pages", new ArrayList<Map<String, Object>>());
        result.put("allright-pages", new ArrayList<Map<String, Object>>());
        
        for (String id : pageIds)
        {
            Page page = _resolver.resolveById(id);
         
            Map<String, Object> page2json = new HashMap<>();
            page2json.put("id", page.getId());
            page2json.put("title", page.getTitle());
            
            if (page instanceof ModifiablePage)
            {
                ModifiablePage mPage = (ModifiablePage) page;
                mPage.setVisible(visible);
                mPage.saveChanges();
                
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_PAGE, page);
                eventParams.put(ObservationConstants.ARGS_PAGE_ID, page.getId());
                _observationManager.notify(new Event(ObservationConstants.EVENT_PAGE_UPDATED, _currentUserProvider.getUser(), eventParams));
                
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> allRightPages = (List<Map<String, Object>>) result.get("allright-pages");
                allRightPages.add(page2json);
            }
            else
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> nomodifiablePages = (List<Map<String, Object>>) result.get("nomodifiable-pages");
                nomodifiablePages.add(page2json);
            }
        } 
        
        return result;
    }
    
    /**
     * Get the contents of a {@link Page} and its subpages which can be deleted.
     * A content is deleteable if user has right, the content is not locked and not referenced by other pages.
     * @param id The id of page
     * @return The list of deletable contents
     */
    @Callable
    public Map<String, Object> getDeleteablePageContents (String id)
    {
        Map<String, Object> results = new HashMap<>();
        
        results.put("deleteable-contents", new ArrayList<Map<String, Object>>());
        results.put("referenced-contents", new ArrayList<Map<String, Object>>());
        results.put("unauthorized-contents", new ArrayList<Map<String, Object>>());
        results.put("locked-contents", new ArrayList<Map<String, Object>>());
        
        Page page = _resolver.resolveById(id);
        List<Content> contents = getPageContents(page, true);
        
        for (Content content : contents)
        {
            Map<String, Object> contentParams = new HashMap<>();
            contentParams.put("id", content.getId());
            contentParams.put("title", content.getTitle(new Locale(page.getSitemapName())));
            contentParams.put("name", content.getName());
            
            if (_isReferenced(content))
            {
                // Content is referenced by at least another page
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> referencedContents = (List<Map<String, Object>>) results.get("referenced-contents");
                referencedContents.add(contentParams);
            }
            else if (!_contentDAO.canDelete(content))
            {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> unauthorizedContents = (List<Map<String, Object>>) results.get("unauthorized-contents");
                unauthorizedContents.add(contentParams);
            }
            else if (_isLocked(content))
            {
                // If the content is locked by other
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> lockedContents = (List<Map<String, Object>>) results.get("locked-contents");
                lockedContents.add(contentParams);
            }
            else
            {
                Map<String, Object> content2json = new HashMap<>();
                content2json.put("id", content.getId());
                content2json.put("name", content.getName());
                content2json.put("title", content.getTitle(new Locale(page.getSitemapName())));
                content2json.put("isNew", _isNew(content));
                content2json.put("isShared", content instanceof SharedContent);
                content2json.put("hasShared", _sharedContentManager.hasSharedContents(content));
                
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> allrightContents = (List<Map<String, Object>>) results.get("deleteable-contents");
                allrightContents.add(content2json);
            }
        }
        
        return results;
    }
    
    /**
     * Get the contents that belong to the {@link Page} and its sub-pages and that can be deleted.
     * A content is deleteable if user has right, the content is not locked and it's not referenced by other pages.
     * If 'onlyNewlyCreatedContents' is set to 'true', only newly created contents will be returned
     * @param pageId The id of page
     * @param onlyNewlyCreatedContents true to return only the newly created contents
     * @return The ids of deleteable contents
     */
    public List<String> getDeleteablePageContentIds (String pageId, boolean onlyNewlyCreatedContents)
    {
        List<String> contentsId = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        List<Content> contents = getPageContents(page, true);
        
        for (Content content : contents)
        {
            if (_contentDAO.canDelete(content) && !_isLocked(content) && !_isReferenced(content))
            {
                if (!onlyNewlyCreatedContents || _isNew(content))
                {
                    contentsId.add(content.getId());
                }
            }
        }
        
        return contentsId;
    }
        
    /**
     * Get the unreferenced contents of a {@link Page} or a {@link ZoneItem}
     * @param id The id of page or zone item
     * @return The list of unreferenced contents
     */
    @Callable
    public List<Map<String, Object>> getUnreferencedContents (String id)
    {
        List<Map<String, Object>> unreferencedContents = new ArrayList<>();
        
        Page page = _resolver.resolveById(id);
        List<Content> contents = getPageContents(page, true);
        
        for (Content content : contents)
        {
            if (!_isReferenced(content))
            {
                Map<String, Object> content2json = new HashMap<>();
                content2json.put("id", content.getId());
                content2json.put("name", content.getName());
                content2json.put("title", content.getTitle(new Locale(page.getSitemapName())));
                content2json.put("isNew", _isNew(content));
                content2json.put("isShared", content instanceof SharedContent);
                content2json.put("hasShared", _sharedContentManager.hasSharedContents(content));
                
                unreferencedContents.add(content2json);
            }
        }
        
        return unreferencedContents;
    }
    
    /**
     * Returns the page's attachments root node
     * @param id the page's id
     * @return The attachments' root node informations
     */
    @Callable
    public Map<String, Object> getAttachmentsRootNode (String id)
    {
        Map<String, Object> result = new HashMap<>();
        
        Page page = _resolver.resolveById(id);
        
        result.put("title", page.getTitle());
        result.put("contentId", page.getId());
        
        TraversableAmetysObject attachments = page.getRootAttachments();
        
        if (attachments != null)
        {
            result.put("id", attachments.getId());
            if (attachments instanceof ModifiableAmetysObject)
            {
                result.put("isModifiable", true);
            }
            if (attachments instanceof ModifiableResourceCollection)
            {
                result.put("canCreateChild", true);
            }
            
            boolean hasChildNodes = false;
            boolean hasResources = false;

            for (AmetysObject child : attachments.getChildren())
            {
                if (child instanceof Resource)
                {
                    hasResources = true;
                }
                else if (child instanceof ExplorerNode)
                {
                    hasChildNodes = true;
                }
            }

            if (hasChildNodes)
            {
                result.put("hasChildNodes", true);
            }

            if (hasResources)
            {
                result.put("hasResources", true);
            }
            
            return result;
        }
        
        throw new IllegalArgumentException("Page with id '" + id + "' does not support attachments.");
    }
    /**
     * Returns the page's parents ids
     * @param id the page's id
     * @return The attachments' root node informations
     */
    @Callable
    public Map<String, Object> getPageParents (String id)
    {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> pages = new ArrayList<>();
        Page page = _resolver.resolveById(id);
        pages.add(_page2Json(page));
        while (page.getParent() != null && page.getParent() instanceof Page)
        {
            page = page.getParent();
            pages.add(_page2Json(page));
        }
        result.put("parents", pages);
        return result;
    }
    
    /**
     * Get the contents of a page and its child pages
     * @param page The page
     * @return The list of contents
     */
    public List<Content> getPageContents (Page page)
    {
        return getPageContents(page, false);
    }
    
    /**
     * Get the contents of a page and its child pages
     * @param page The page
     * @param ignoreContentsOfNonRemovablePage true to ignore contents of non-removable pages (virtual pages)
     * @return The list of contents
     */
    public List<Content> getPageContents (Page page, boolean ignoreContentsOfNonRemovablePage)
    {
        List<Content> contents = new ArrayList<>();
        
        if ((!ignoreContentsOfNonRemovablePage || page instanceof RemovableAmetysObject) && page.getType() == Page.PageType.CONTAINER)
        {
            for (Zone zone : page.getZones())
            {
                try (AmetysObjectIterable< ? extends ZoneItem> zoneItems = zone.getZoneItems())
                {
                    for (ZoneItem zoneItem : zoneItems)
                    {
                        if (zoneItem.getType() == ZoneItem.ZoneType.CONTENT)
                        {
                            contents.add(zoneItem.getContent());
                        }
                    }
                }
            }
        }
        
        AmetysObjectIterable< ? extends Page> childrenPages = page.getChildrenPages();
        for (Page childPage : childrenPages)
        {
            contents.addAll(getPageContents(childPage, ignoreContentsOfNonRemovablePage));
        }
        
        return contents;
    }
    
    /**
     * Get the user rights on page container (page or sitemap)
     * @param pagesCt The pages container
     * @return The user's rights
     */
    protected Set<String> getUserRights (PagesContainer pagesCt)
    {
        UserIdentity user = _currentUserProvider.getUser();
        
        Set<String> userRights = _rightManager.getUserRights(user, pagesCt);
        
        // Do some specific stuff here, because the right 'Web_Rights_Page_Delete' is a right to delete child pages and not the page itself.
        // So the right should be checked on parent context.
        if (pagesCt instanceof Page)
        {
            PagesContainer parent = pagesCt.getParent();
            boolean canDelete = _rightManager.hasRight(user, "Web_Rights_Page_Delete", parent) == RightResult.RIGHT_ALLOW;
            if (!canDelete)
            {
                // No right on parent page, so remove the right if exists.
                userRights.remove("Web_Rights_Page_Delete");
            }
        }
        else
        {
            // There is no right of deletion on the sitemap
            userRights.remove("Web_Rights_Page_Delete");
        }
        
        return userRights;
    }
    
    private boolean _isReferenced (Content content)
    {
        return content instanceof WebContent && ((WebContent) content).getReferencingPages().size() > 1;
    }
    
    private boolean _isLocked (Content content)
    {
        if (content instanceof LockableAmetysObject)
        {
            LockableAmetysObject lockableContent = (LockableAmetysObject) content;
            if (lockableContent.isLocked())
            {
                boolean canUnlockAll = _rightManager.hasRight(_currentUserProvider.getUser(), "CMS_Rights_UnlockAll", "/cms") == RightResult.RIGHT_ALLOW;
                if (!LockHelper.isLockOwner(lockableContent, _currentUserProvider.getUser()) && !canUnlockAll)
                {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    private boolean _isNew (Content content)
    {
        boolean isNew = false;
        if (content instanceof WorkflowAwareContent)
        {
            WorkflowAwareContent waContent = (WorkflowAwareContent) content;
            long workflowId = waContent.getWorkflowId();
            
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
            isNew = workflow.getHistorySteps(workflowId).isEmpty();
        }
        return isNew;
    }

    private Map<String, Object> _page2Json (Page page)
    {
        Map<String, Object> page2json = new HashMap<>();
        page2json.put("id", page.getId());
        page2json.put("title", page.getTitle());
        page2json.put("siteName", page.getSiteName());
        page2json.put("path", page.getPathInSitemap());
        return page2json;
    }
    
    private Map<String, Object> _content2Json (Content content, Locale locale)
    {
        Map<String, Object> content2json = new HashMap<>();
        content2json.put("id", content.getId());
        content2json.put("title", content.getTitle(locale));
        content2json.put("name", content.getName());
        
        List<Map<String, Object>> pages = new ArrayList<>();
        if (content instanceof WebContent)
        {
            content2json.put("siteName", ((WebContent) content).getSiteName());
            Collection<Page> refPages = ((WebContent) content).getReferencingPages();
            for (Page refPage : refPages)
            {
                pages.add(_page2Json(refPage));
            }
            content2json.put("pages", pages);
        }
        
        return content2json;
    }
    
    private Map<String, Object> _publication2Json (Page page)
    {
        Map<String, Object> pub2json = new HashMap<>();
        @SuppressWarnings("unchecked")
        ElementType<ZonedDateTime> dateType = (ElementType<ZonedDateTime>) _pageDataTypeExtensionPoint.getExtension(ModelItemTypeConstants.DATETIME_TYPE_ID);
        
        ZonedDateTime startDate = page.getValue(DefaultPage.METADATA_PUBLICATION_START_DATE);
        if (startDate != null)
        {
            pub2json.put("startDate", dateType.valueToJSONForClient(startDate, DataContext.newInstance()));
        }

        ZonedDateTime endDate = page.getValue(DefaultPage.METADATA_PUBLICATION_END_DATE);
        if (endDate != null)
        {
            pub2json.put("endDate", dateType.valueToJSONForClient(endDate, DataContext.newInstance()));
        }
        
        return pub2json;
        
    }
    
    private AmetysObjectIterable<Content> _getIncomingContentReferences (String pageId)
    {
        String xpathQuery = "//element(*, ametys:content)[ametys-internal:consistency/@ametys-internal:link = 'page:" + pageId + "']";
        return _resolver.query(xpathQuery);
    }
    
    private AmetysObjectIterable<Page> _getIncomingPageReferences (String pageId)
    {
        String xpathQuery = "//element(*, ametys:page)[@ametys-internal:type = 'LINK' and @ametys-internal:url= '" + pageId + "']";
        return _resolver.query(xpathQuery);
    }
    
    private Map<String, Object> _zone2json (Zone zone, String zoneItemId)
    {
        Map<String, Object> jsonObject = new HashMap<>();
        jsonObject.put("name", zone.getName());
        jsonObject.put("isModifiable", zone instanceof ModifiableZone);
        
        List<Map<String, Object>> zoneitems = new ArrayList<>();
        for (ZoneItem zoneItem : zone.getZoneItems())
        {
            if (StringUtils.isBlank(zoneItemId) || zoneItemId.equals(zoneItem.getId()))
            {
                zoneitems.add(_zoneitem2json(zoneItem));
                
            }
        }
        
        jsonObject.put("zoneitems", zoneitems);
        
        return jsonObject;
    }
    
    private Map<String, Object> _zoneitem2json (ZoneItem zoneItem)
    {
        Map<String, Object> jsonObject = new HashMap<>();
        jsonObject.put("name", zoneItem.getName());
        jsonObject.put("id", zoneItem.getId());
        jsonObject.put("isModifiable", zoneItem instanceof ModifiableZoneItem);
        
        switch (zoneItem.getType())
        {
            case CONTENT:
                try
                {
                    
                    Content content = zoneItem.getContent();
                    List<String> unknownContentTypeIds = _contentHelper.getUnknownContentTypeIds(content);
                    if (unknownContentTypeIds.isEmpty())
                    {
                        jsonObject.put("viewName", zoneItem.getViewName());
                        jsonObject.put("content", _contentDAO.getContentProperties(content));
                    }
                    else
                    {
                        getLogger().error("Unable to get content property on zone item because following content types do not exist: " + StringUtils.join(unknownContentTypeIds, ", "));
                    }
                }
                catch (AmetysRepositoryException e)
                {
                    getLogger().error("Unable to get content property on zone item", e);
                }
                break;
                
            case SERVICE:
                jsonObject.put("service", zoneItem.getServiceId());
                break;
            default:
                break;
        }
        
        return jsonObject;
    }
    
    private void _updateContentsAfterCopy (Page createdPage) throws AmetysRepositoryException
    {
        for (Zone zone : createdPage.getZones())
        {
            try (AmetysObjectIterable< ? extends ZoneItem> zoneItems = zone.getZoneItems())
            {
                for (ZoneItem zoneItem : zoneItems)
                {
                    if (zoneItem.getType().equals(ZoneType.CONTENT))
                    {
                        Content content = zoneItem.getContent();
                        
                        // Convert content language if necessary
                        if (content instanceof ModifiableContent && content.getLanguage() != null && content.getLanguage() != createdPage.getSitemapName())
                        {
                            ((ModifiableContent) content).setLanguage(createdPage.getSitemapName());
                            ((ModifiableContent) content).saveChanges();
                        }
                        
                        // Create the first version
                        if (content instanceof VersionableAmetysObject)
                        {
                            ((VersionableAmetysObject) content).checkpoint();
                        }
                    }
                }
            }
        }
        
        // Browse child pages
        for (Page childPage : createdPage.getChildrenPages())
        {
            _updateContentsAfterCopy (childPage);
        }
    }
    
    private List<String> _getChildrenPageIds (Page page)
    {
        List<String> childIds = new ArrayList<>();
        
        for (Page childPage : page.getChildrenPages())
        {
            childIds.add(childPage.getId());
            childIds.addAll(_getChildrenPageIds(childPage));
        }
        
        return childIds;
    }

    /**
     * Check each parent and return true if one of them is invisible
     * @param page page to check
     * @return true if at least one parent is invisible
     */
    private boolean _isParentInvisible (Page page)
    {
        AmetysObject parent = page.getParent();
        while (parent != null && parent instanceof Page)
        {
            boolean invisible = !((Page) parent).isVisible();
            if (invisible)
            {
                return true;
            }
            parent = parent.getParent();
        }
        return false;
    }

    /* start of a group of methods for _isPreviewable */
    /**
     * Determine if this page is previewable
     * @param page The page to look at
     * @return true if the page can be previewed
     */
    private boolean _isPreviewable(Page page)
    {
        // Check for infinitive loop redirection
        ArrayList<String> pagesSequence = new ArrayList<>();
        pagesSequence.add(page.getId());
        if (_isInfiniteRedirection (page, pagesSequence))
        {
            getLogger().error("An infinite loop redirection was detected for page '" + page.getPathInSitemap() + "'");
            return false;
        }

        if (page.getType() == PageType.LINK && LinkType.PAGE.equals(page.getURLType()))
        {
            return _isPageExist(page.getURL()) && _isPreviewable((Page) _resolver.resolveById(page.getURL()));
        }

        if (page.getType() != PageType.NODE)
        {
            return true;
        }
        else
        {
            try (AmetysObjectIterable< ? extends Page> childrenPages = page.getChildrenPages())
            {
                for (Page subPage : childrenPages)
                {
                    if (_isPreviewable(subPage))
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private boolean _isPageExist (String id)
    {
        try
        {
            _resolver.resolveById(id);
            return true;
        }
        catch (UnknownAmetysObjectException e)
        {
            return false;
        }
    }

    private boolean _isInfiniteRedirection (Page page, List<String> pagesSequence)
    {
        Page redirectPage = _getPageRedirection (page);
        if (redirectPage == null)
        {
            return false;
        }

        if (pagesSequence.contains(redirectPage.getId()))
        {
            return true;
        }

        pagesSequence.add(redirectPage.getId());
        return _isInfiniteRedirection (redirectPage, pagesSequence);
    }

    private Page _getPageRedirection (Page page)
    {
        if (PageType.LINK.equals(page.getType()) && LinkType.PAGE.equals(page.getURLType()))
        {
            try
            {
                String pageId = page.getURL();
                return _resolver.resolveById(pageId);
            }
            catch (AmetysRepositoryException e)
            {
                return null;
            }
        }
        else if (PageType.NODE.equals(page.getType()))
        {
            AmetysObjectIterable<? extends Page> childPages = page.getChildrenPages();
            Iterator<? extends Page> it = childPages.iterator();
            if (it.hasNext())
            {
                return it.next();
            }
        }

        return null;
    }
    /* end of a group of methods for _isPreviewable */
    
    private static final class PageTagCacheKey extends AbstractCacheKey
    {
        private PageTagCacheKey(String sitename, String lang, String tag)
        {
            super(sitename, lang, tag);
        }
        
        private PageTagCacheKey(String sitename, String lang)
        {
            super(sitename, lang);
        }

        static PageTagCacheKey of(String sitename, String lang)
        {
            return new PageTagCacheKey(sitename, lang, null);
        }

        static PageTagCacheKey of(String sitename, String lang, String tag)
        {
            return new PageTagCacheKey(sitename, lang, tag);
        }
    }
}