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

import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Value;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.cms.repository.Content;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.DefaultAmetysObject;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * Class representing a cart, backed by a JCR node.<br>
 */
public class Cart extends DefaultAmetysObject<CartFactory>
{
    private static final String TITLE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":label";
    private static final String DESCRIPTION = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":description";
    private static final String AUTHOR = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":author";
    private static final String VISIBILITY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":visibility";
    
    private static final String PROFILE_READ_ACCESS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":read-access";
    private static final String PROFILE_WRITE_ACCESS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":write-access";
    private static final String GROUPS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":groups";
    private static final String USERS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":users";
    
    private static final String CONTENT_CART_ELEMENTS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":contents";    
    private static final String RESOURCE_CART_ELEMENTS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":resources";
    private static final String QUERIES_CART_ELEMENTS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":queries";
    
    private static final String QUERY_ID_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":id";
    private static final String QUERY_DESCRIPTION_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":description";
    private static final String QUERY_AUTHOR_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":author";
    private static final String QUERY_TITLE_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":title";
    private static final String QUERY_DATE_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":date";
    
    private static Logger _logger = LoggerFactory.getLogger(Cart.class.getName());
    
    /**
     * Visibility of a Cart
     */
    public enum Visibility
    {
        /** Private visibility. */
        PRIVATE,
        /** Shared visibility. */
        SHARED,
        /** Public visibility. */
        PUBLIC;
        
        @Override
        public String toString()
        {
            return name().toLowerCase();
        }
    }
    
    /**
     * Rights profiles
     */
    public enum CartProfile
    {
        /** Read access */
        READ_ACCESS,
        /** Write access */
        WRITE_ACCESS;
        
        @Override
        public String toString()
        {
            return name().toLowerCase();
        }
        
        /**
         * Cart profile title getter.
         * @return The title of the profile
         */
        public I18nizableText getTitle()
        {
            switch (this)
            {
                case READ_ACCESS: 
                    return new I18nizableText("plugin.cart", "PLUGINS_CART_RIGHT_PROFILE_READ_TITLE");
                case WRITE_ACCESS: 
                    return new I18nizableText("plugin.cart", "PLUGINS_CART_RIGHT_PROFILE_WRITE_TITLE");
                default: 
                    return null;
            }
        }

        /**
         * Cart profile description getter.
         * @return The description of the profile
         */
        public I18nizableText getDescription()
        {
            switch (this)
            {
                case READ_ACCESS: 
                    return new I18nizableText("plugin.cart", "PLUGINS_CART_RIGHT_PROFILE_READ_DESCRIPTION");
                case WRITE_ACCESS: 
                    return new I18nizableText("plugin.cart", "PLUGINS_CART_RIGHT_PROFILE_WRITE_DESCRIPTION");
                default: 
                    return null;
            }
        }
    }
    
    /**
     * Types of CartElement
     */
    public enum CartElementType
    {
        /** Type: content. */
        CONTENT,
        /** Type: resource. */
        RESOURCE,
        /** Type: cartQuery. */
        CARTQUERY
    }
    
    /**
     * Creates an {@link Cart}.
     * @param node the node backing this {@link AmetysObject}
     * @param parentPath the parentPath in the Ametys hierarchy
     * @param factory the DefaultAmetysObjectFactory which created the AmetysObject
     */
    public Cart(Node node, String parentPath, CartFactory factory)
    {
        super(node, parentPath, factory);
    }        
    
    /**
     * Set the title of this cart.
     * @param title the description
     */
    public void setTitle (String title)
    {
        try
        {
            getNode().setProperty(TITLE, title != null ? title : StringUtils.EMPTY);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while setting title property.", e);
        }
    }
    
    /**
     * Set the description of this cart.
     * @param description the description
     */
    public void setDescription (String description)
    {
        try
        {
            getNode().setProperty(DESCRIPTION, description != null ? description : StringUtils.EMPTY);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while setting description property.", e);
        }
    }
    
    /**
     * Set the author of this cart.
     * @param author the author
     */
    public void setAuthor(UserIdentity author)
    {
        try
        {
            Node authorNode = _getOrCreateNode(getNode(), AUTHOR, "ametys:user");
            authorNode.setProperty("ametys:login", author.getLogin());
            authorNode.setProperty("ametys:population", author.getPopulationId());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error setting the author property.", e);
        }
    }
    
    /**
     * Set the cart visibility
     * @param visibility the visibility
     */
    public void setVisibility (Visibility visibility)
    {
        try
        {
            getNode().setProperty(VISIBILITY, visibility.name());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while setting title property.", e);
        }
    }
    
    /**
     * Get the title of the cart
     * @return The title
     */
    public String getTitle()
    {        
        try
        {
            if (getNode().hasProperty(TITLE))
            {
                return getNode().getProperty(TITLE).getValue().getString();
            }
            else
            {
                return StringUtils.EMPTY;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting title property.", e);
        }
    }
    
    
    /**
     * Get the description of the cart
     * @return The description
     */
    public String getDescription()
    {
        try
        {
            if (getNode().hasProperty(DESCRIPTION))
            {
                return getNode().getProperty(DESCRIPTION).getValue().getString();
            }
            else
            {
                return StringUtils.EMPTY;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting description property.", e);
        }
    }
    
    
    /**
     * Get the author of the cart
     * @return The author
     */
    public UserIdentity getAuthor ()
    {
        try
        {
            Node authorNode = getNode().getNode(AUTHOR);
            return new UserIdentity(authorNode.getProperty("ametys:login").getString(), authorNode.getProperty("ametys:population").getString());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting author property.", e);
        }
    }
    
    
    /**
     * Get the visibility of the cart
     * @return The visibility
     */
    public Visibility getVisibility()
    {
        try
        {
            return Visibility.valueOf(getNode().getProperty(VISIBILITY).getValue().getString());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting visibility property.", e);
        }
    }
    
    /**
     * Get the granted users
     * @param profile the cart's profile
     * @return the granted users
     */
    public Set<UserIdentity> getGrantedUsers(CartProfile profile)
    {
        try
        {
            String profileNodeName = null;
                    
            switch (profile)
            {
                case READ_ACCESS:
                    profileNodeName = PROFILE_READ_ACCESS;
                    break;
                case WRITE_ACCESS:
                    profileNodeName = PROFILE_WRITE_ACCESS;
                    break;
                default:
                    throw new AmetysRepositoryException("Unexisting Cart profile : " + profile);
            }
            
            Node profileNode = _getOrCreateNode(getNode(), profileNodeName, "nt:unstructured");
            Set<UserIdentity> grantedUsers = new HashSet<>();
            
            grantedUsers.add(this.getAuthor());
            
            if (profileNode.hasNode(USERS))
            {
                NodeIterator it = profileNode.getNodes(USERS);
                while (it.hasNext())
                {
                    Node next = (Node) it.next();
                    grantedUsers.add(new UserIdentity(next.getProperty("ametys:login").getString(), next.getProperty("ametys:population").getString()));
                }
            }
            
            return grantedUsers;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting grantedUsers property.", e);
        }
    }
    
    /**
     * Get the granted groups
     * @param profile the cart's profile
     * @return the logins of granted groups
     */
    public Set<GroupIdentity> getGrantedGroups(CartProfile profile)
    {
        try
        {
            String profileNodeName = null;
                    
            switch (profile)
            {
                case READ_ACCESS:
                    profileNodeName = PROFILE_READ_ACCESS;
                    break;
                case WRITE_ACCESS:
                    profileNodeName = PROFILE_WRITE_ACCESS;
                    break;
                default:
                    throw new AmetysRepositoryException("Unexisting Cart profile : " + profile);
            }
            
            Node profileNode = _getOrCreateNode(getNode(), profileNodeName, "nt:unstructured");
            Set<GroupIdentity> grantedGroups = new HashSet<>();
            
            if (profileNode.hasNode(GROUPS))
            {
                NodeIterator it = profileNode.getNodes(GROUPS);
                while (it.hasNext())
                {
                    Node next = (Node) it.next();
                    grantedGroups.add(new GroupIdentity(next.getProperty("ametys:groupId").getString(), next.getProperty("ametys:groupDirectory").getString()));
                }
            }
            
            return grantedGroups;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting grantedGroups property.", e);
        }
    }
    
    /**
     * Determines if an user has READ access to this cart.
     * @param user The user
     * @return <code>true</code> if the user has read access, <code>false</code> otherwise
     */
    public boolean canRead(UserIdentity user)
    {
        Visibility visibility = getVisibility();
        
        switch (visibility)
        {
            case PRIVATE:
                return getAuthor().equals(user);
                
            case SHARED:
                return getGrantedUsers(CartProfile.READ_ACCESS).contains(user) || CollectionUtils.containsAny(getGrantedGroups(CartProfile.READ_ACCESS), _getFactory()._getGroupsManager().getUserGroups(user)) || canWrite(user);

            case PUBLIC:
            default:
                return true;
        }
    }
    
    /**
     * Determines if an user has WRITE access to this cart.
     * @param user The user
     * @return <code>true</code> if the user has write access, <code>false</code> otherwise
     */
    public boolean canWrite(UserIdentity user)
    {
        Visibility visibility = getVisibility();
        
        switch (visibility)
        {
            case PRIVATE:
                return getAuthor().equals(user);
                
            case SHARED:
                return getGrantedUsers(CartProfile.WRITE_ACCESS).contains(user) || CollectionUtils.containsAny(getGrantedGroups(CartProfile.WRITE_ACCESS), _getFactory()._getGroupsManager().getUserGroups(user));

            case PUBLIC:
            default:
                return true;
        }
    }
    
    /**
     * Set the granted users
     * @param profile the cart's profile
     * @param users the granted users
     */
    public void setGrantedUsers (CartProfile profile, Set<UserIdentity> users)
    {
        try
        {
            String profileNodeName = null;
            
            switch (profile)
            {
                case READ_ACCESS:
                    profileNodeName = PROFILE_READ_ACCESS;
                    break;
                case WRITE_ACCESS:
                    profileNodeName = PROFILE_WRITE_ACCESS;
                    break;
                default:
                    throw new AmetysRepositoryException("Unexisting Cart profile : " + profile);
            }
            
            Node profileNode = _getOrCreateNode(getNode(), profileNodeName, "nt:unstructured");
            
            NodeIterator it = profileNode.getNodes(USERS);
            while (it.hasNext())
            {
                Node next = (Node) it.next();
                next.remove();
            }
            
            UserIdentity author = this.getAuthor();
            users.remove(author);
            
            for (UserIdentity userIdentity : users)
            {
                Node userNode = profileNode.addNode(USERS, "ametys:user");
                userNode.setProperty("ametys:login", userIdentity.getLogin());
                userNode.setProperty("ametys:population", userIdentity.getPopulationId());
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while setting users property.", e);
        }
    }
    
    /**
     * Set the granted groups
     * @param profile the cart's profile
     * @param groups the granted groups
     */
    public void setGrantedGroups(CartProfile profile, Set<GroupIdentity> groups)
    {
        try
        {
            String profileNodeName = null;
            
            switch (profile)
            {
                case READ_ACCESS:
                    profileNodeName = PROFILE_READ_ACCESS;
                    break;
                case WRITE_ACCESS:
                    profileNodeName = PROFILE_WRITE_ACCESS;
                    break;
                default:
                    throw new AmetysRepositoryException("Unexisting Cart profile : " + profile);
            }
            
            Node profileNode = _getOrCreateNode(getNode(), profileNodeName, "nt:unstructured");
            
            NodeIterator it = profileNode.getNodes(GROUPS);
            while (it.hasNext())
            {
                Node next = (Node) it.next();
                next.remove();
            }
            
            for (GroupIdentity groupIdentity : groups)
            {
                Node groupNode = profileNode.addNode(GROUPS, "ametys:group");
                groupNode.setProperty("ametys:groupId", groupIdentity.getId());
                groupNode.setProperty("ametys:groupDirectory", groupIdentity.getDirectoryId());
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while setting groups property.", e);
        }
    }
    
    /**
     * Add a content to the cart
     * @param contentId The content id
     */
    public void addContent (String contentId)
    {
        try
        {
            Set<String> contentIds = new HashSet<>();
            
            if (getNode().hasProperty(CONTENT_CART_ELEMENTS))
            {
                Value[] values = getNode().getProperty(CONTENT_CART_ELEMENTS).getValues();
                for (Value value : values)
                {
                    contentIds.add(value.getString());
                }
            }
            
            contentIds.add(contentId);
            
            getNode().setProperty(CONTENT_CART_ELEMENTS, contentIds.toArray(new String[contentIds.size()]));
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while adding content cart element.", e);
        }
    }
    
    /**
     * Add a resource to the cart
     * @param resourceId The resource id
     */
    public void addResource (String resourceId)
    {
        try
        {
            Set<String> resourceIds = new HashSet<>();
            
            if (getNode().hasProperty(RESOURCE_CART_ELEMENTS))
            {
                Value[] values = getNode().getProperty(RESOURCE_CART_ELEMENTS).getValues();
                for (Value value : values)
                {
                    resourceIds.add(value.getString());
                }
            }
            
            resourceIds.add(resourceId);
            
            getNode().setProperty(RESOURCE_CART_ELEMENTS, resourceIds.toArray(new String[resourceIds.size()]));
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while adding resource cart element.", e);
        }
    }
    
    /**
     * Add a query to the cart
     * @param author The author of the query
     * @param title The title of the query 
     * @param description The query as string
     */
    public void addQuery (UserIdentity author, String title, String description)
    {
        try
        {
            Node queriesNode = _getOrCreateQueriesNode ();
            
            Node queryNode = queriesNode.addNode("query");       
            queryNode.setProperty(QUERY_ID_PROPERTY, org.ametys.core.util.StringUtils.generateKey());
            queryNode.setProperty(QUERY_TITLE_PROPERTY, title);
            queryNode.setProperty(QUERY_DESCRIPTION_PROPERTY, description);
            
            try
            {
                Node authorNode = _getOrCreateNode(queryNode, QUERY_AUTHOR_PROPERTY, "ametys:user");
                authorNode.setProperty("ametys:login", author.getLogin());
                authorNode.setProperty("ametys:population", author.getPopulationId());
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException("Error setting the author property.", e);
            }
            
            queryNode.setProperty(QUERY_DATE_PROPERTY, Calendar.getInstance());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while adding query cart element.", e);
        }
    }
    
    private Node _getOrCreateQueriesNode () throws RepositoryException
    {
        if (getNode().hasNode(QUERIES_CART_ELEMENTS))
        {
            return getNode().getNode(QUERIES_CART_ELEMENTS);
        }
        
        return getNode().addNode(QUERIES_CART_ELEMENTS);
    }
    
    /**
     * Delete an element
     * @param elmtId The id of element to remove
     * @param elmtType The type of element to remove
     */
    public void removeElement (String elmtId, CartElementType elmtType)
    {
        switch (elmtType)
        {
            case CONTENT:
                _removeContent(elmtId);
                break;
                
            case RESOURCE:
                _removeResource(elmtId);
                break;
                
            case CARTQUERY:
                _removeQuery(elmtId);
                break;
                
            default:
                break;
        }
    }
    
    /**
     * Remove a resource from the cart
     * @param resourceIdToRemove The id of the resource to remove
     */
    protected void _removeResource(String resourceIdToRemove)
    {
        try
        {
            Set<String> resourceIds = new HashSet<>();
            
            if (getNode().hasProperty(RESOURCE_CART_ELEMENTS))
            {
                Value[] values = getNode().getProperty(RESOURCE_CART_ELEMENTS).getValues();
                for (Value value : values)
                {                    
                    String resourceId = value.getString();
                    if (!resourceId.equals(resourceIdToRemove))
                    {
                        resourceIds.add(value.getString());                        
                    }                    
                }
            }
            
            getNode().setProperty(RESOURCE_CART_ELEMENTS, resourceIds.toArray(new String[resourceIds.size()]));
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while removing resource cart element.", e);
        }
    }
    
    /**
     * Remove a content from the cart
     * @param contentIdToRemove The id of the content to remove
     */
    protected void _removeContent(String contentIdToRemove)
    {
        try
        {
            Set<String> contentIds = new HashSet<>();
            
            if (getNode().hasProperty(CONTENT_CART_ELEMENTS))
            {
                Value[] values = getNode().getProperty(CONTENT_CART_ELEMENTS).getValues();
                for (Value value : values)
                {                    
                    String contentId = value.getString();
                    if (!contentId.equals(contentIdToRemove))
                    {
                        contentIds.add(value.getString());                        
                    }                    
                }
            }
            
            getNode().setProperty(CONTENT_CART_ELEMENTS, contentIds.toArray(new String[contentIds.size()]));
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while removing content cart element.", e);
        }
    }
    
    /**
     * Remove a query from the cart
     * @param queryIdToRemove The id of the query to remove
     */
    protected void _removeQuery(String queryIdToRemove)
    {
        try
        {                       
            if (getNode().hasNode(QUERIES_CART_ELEMENTS))
            {
                Node queries = getNode().getNode(QUERIES_CART_ELEMENTS);                
                for (NodeIterator it = queries.getNodes(); it.hasNext();)
                {
                    Node query = it.nextNode();
                    String queryId = query.getProperty(QUERY_ID_PROPERTY).getString();
                    if (queryId.equals(queryIdToRemove))
                    {
                        query.remove();                       
                        break;
                    }
                }                
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while removing query cart element.", e);
        }
    }
    
    
    
    /**
     * Get the elements of the cart
     * @return The elements of the cart
     */
    public List<CartElement> getElements ()
    {
        List<CartElement> elmts = new ArrayList<>();
        
        try
        {
            elmts.addAll(getContentCartElements());
            elmts.addAll(getResourceCartElements());
            elmts.addAll(getQueryCartElements());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error while getting cart elements", e);
        }
        
        return elmts;
    }
    
    /**
     * Get the contents of the cart
     * @return The elements of the cart
     * @throws RepositoryException if an exception occurs while exploring the repository
     */
    public List<ContentElement> getContentCartElements () throws RepositoryException
    {
        List<String> unexistingElmts = new ArrayList<>();
        
        List<ContentElement> elmts = new ArrayList<>();
        
        if (getNode().hasProperty(CONTENT_CART_ELEMENTS))
        {
            Value[] values = getNode().getProperty(CONTENT_CART_ELEMENTS).getValues();
            
            for (Value value : values)
            {
                String contentId = value.getString();
                
                try
                {
                    Content content = _getFactory().getResolver().resolveById(contentId);
                    elmts.add(new ContentElement(content, _getFactory()._getContentTypesHelper(), _getFactory()._getContentTypeEP()));
                }
                catch (UnknownAmetysObjectException e)
                {
                    _logger.error("The content of id '{}' does not exist anymore. It will be deleting from cart '{}'.", contentId, getId());
                    unexistingElmts.add(contentId);
                }
            }
        }
        
        // Delete unexisting contents
        for (String contentId : unexistingElmts)
        {
            _removeContent(contentId);
        }
        
        return elmts;
    }
    
    /**
     * Get the resources of the cart
     * @return The elements of the cart
     * @throws RepositoryException if an exception occurs while exploring the repository
     */
    public List<ResourceElement> getResourceCartElements () throws RepositoryException
    {
        List<String> unexistingElmts = new ArrayList<>();
        List<ResourceElement> elmts = new ArrayList<>();
        
        if (getNode().hasProperty(RESOURCE_CART_ELEMENTS))
        {
            Value[] values = getNode().getProperty(RESOURCE_CART_ELEMENTS).getValues();
            
            for (Value value : values)
            {
                String resourceId = value.getString();
                
                try
                {
                    Resource resource = _getFactory().getResolver().resolveById(resourceId);
                    elmts.add(new ResourceElement(resource));
                }
                catch (UnknownAmetysObjectException e)
                {
                    _logger.error("The resource of id '{}' does not exist anymore. It will be deleting from cart '{}'.", resourceId, getId());
                    unexistingElmts.add(resourceId);
                }
            }
        }
        
        // Delete unexisting resources
        for (String resourceId : unexistingElmts)
        {
            _removeResource(resourceId);
        }
        
        return elmts;
    }
    
    /**
     * Get the queries of the cart
     * @return The elements of the cart
     * @throws RepositoryException if an exception occurs while exploring the repository
     */
    public List<QueryElement> getQueryCartElements () throws RepositoryException
    {
        List<QueryElement> elmts = new ArrayList<>();
        
        if (getNode().hasNode(QUERIES_CART_ELEMENTS))
        {
            Node queries = getNode().getNode(QUERIES_CART_ELEMENTS);            
            
            for (NodeIterator it = queries.getNodes(); it.hasNext();)
            {
                Node queryNode = it.nextNode();
                String id = queryNode.getProperty(QUERY_ID_PROPERTY).getString();
                String authorLogin = queryNode.getNode(QUERY_AUTHOR_PROPERTY).getProperty("ametys:login").getString();
                String authorPopulation = queryNode.getNode(QUERY_AUTHOR_PROPERTY).getProperty("ametys:population").getString();
                UserIdentity author = new UserIdentity(authorLogin, authorPopulation);
                String query = queryNode.getProperty(QUERY_DESCRIPTION_PROPERTY).getString();
                String title = queryNode.getProperty(QUERY_TITLE_PROPERTY).getString();
                Calendar creationDate = queryNode.getProperty(QUERY_DATE_PROPERTY).getDate();
                       
                QueryElement q = new QueryElement(id, query, author, creationDate, title);
                elmts.add(q); 
            }
        }
        
        return elmts;
    }

    private Node _getOrCreateNode(Node parent, String name, String type) throws RepositoryException
    {
        Node node = null;
        
        if (parent.hasNode(name))
        {
            node = parent.getNode(name);
        }
        else if (type != null)
        {
            node = parent.addNode(name, type);
        }
        else
        {
            node = parent.addNode(name);
        }
        
        return node;
    }
}