Synnefo

/*

 * Copyright 2007, 2008, 2009, 2010  Electronic Business Systems Ltd.

 *

 * This file is part of GSS.

 *

 * GSS is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * GSS is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with GSS.  If not, see <http://www.gnu.org/licenses/>.

 */

package gr.ebs.gss.server.ejb;

import static gr.ebs.gss.server.configuration.GSSConfigurationFactory.getConfiguration;

import gr.ebs.gss.client.exceptions.DuplicateNameException;

import gr.ebs.gss.client.exceptions.GSSIOException;

import gr.ebs.gss.client.exceptions.InsufficientPermissionsException;

import gr.ebs.gss.client.exceptions.InvitationUsedException;

import gr.ebs.gss.client.exceptions.ObjectNotFoundException;

import gr.ebs.gss.client.exceptions.QuotaExceededException;

import gr.ebs.gss.server.domain.AuditInfo;

import gr.ebs.gss.server.domain.FileBody;

import gr.ebs.gss.server.domain.FileHeader;

import gr.ebs.gss.server.domain.FileTag;

import gr.ebs.gss.server.domain.FileUploadStatus;

import gr.ebs.gss.server.domain.Folder;

import gr.ebs.gss.server.domain.Group;

import gr.ebs.gss.server.domain.Invitation;

import gr.ebs.gss.server.domain.Nonce;

import gr.ebs.gss.server.domain.Permission;

import gr.ebs.gss.server.domain.User;

import gr.ebs.gss.server.domain.UserClass;

import gr.ebs.gss.server.domain.dto.FileBodyDTO;

import gr.ebs.gss.server.domain.dto.FileHeaderDTO;

import gr.ebs.gss.server.domain.dto.FolderDTO;

import gr.ebs.gss.server.domain.dto.GroupDTO;

import gr.ebs.gss.server.domain.dto.PermissionDTO;

import gr.ebs.gss.server.domain.dto.StatsDTO;

import gr.ebs.gss.server.domain.dto.UserDTO;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.UnsupportedEncodingException;

import java.net.MalformedURLException;

import java.util.ArrayList;

import java.util.Date;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Random;

import java.util.Set;

import java.util.StringTokenizer;

import javax.ejb.EJB;

import javax.ejb.EJBException;

import javax.ejb.EJBTransactionRolledbackException;

import javax.ejb.Stateless;

import javax.ejb.TransactionAttribute;

import javax.ejb.TransactionAttributeType;

import javax.jms.Connection;

import javax.jms.ConnectionFactory;

import javax.jms.JMSException;

import javax.jms.MapMessage;

import javax.jms.MessageProducer;

import javax.jms.Queue;

import javax.jms.QueueConnectionFactory;

import javax.jms.Session;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import javax.persistence.PersistenceException;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.solr.client.solrj.SolrQuery;

import org.apache.solr.client.solrj.SolrServerException;

import org.apache.solr.client.solrj.impl.CommonsHttpSolrServer;

import org.apache.solr.client.solrj.request.ContentStreamUpdateRequest;

import org.apache.solr.client.solrj.response.QueryResponse;

import org.apache.solr.common.SolrDocument;

import org.apache.solr.common.SolrDocumentList;

import org.apache.solr.common.SolrException;

import org.apache.solr.common.SolrInputDocument;

import org.hibernate.exception.ConstraintViolationException;

import com.novell.ldap.LDAPAttribute;

import com.novell.ldap.LDAPAttributeSet;

import com.novell.ldap.LDAPConnection;

import com.novell.ldap.LDAPEntry;

import com.novell.ldap.LDAPException;

/**

 * The concrete implementation of the ExternalAPI interface.

 *

 * @author past

 */

@Stateless

public class ExternalAPIBean implements ExternalAPI, ExternalAPIRemote {

        /**

         * The default MIME type for files without an explicit one.

         */

        private static final String DEFAULT_MIME_TYPE = "application/octet-stream";

        /**

         * The size of the buffer that is used to temporarily store chunks of

         * uploaded files, while storing them to the file repository.

         */

        private static final int UPLOAD_BUFFER_SIZE = 1024 * 4;

        /**

         * The logger.

         */

        private static Log logger = LogFactory.getLog(ExternalAPIBean.class);

        /**

         * Injected reference to the GSSDAO data access facade.

         */

        @EJB

        private GSSDAO dao;

        /**

         * A cached random number generator for creating unique filenames.

         */

        private static Random random = new Random();

        /**

         * Mark the folder and all of its parent folders as modified from the specified user.

         */

        private void touchParentFolders(Folder folder, User user, Date date) {

                Folder f = folder;

                while (f != null) {

                        AuditInfo ai = f.getAuditInfo();

                        ai.setModifiedBy(user);

                        ai.setModificationDate(date);

                        f.setAuditInfo(ai);

                        f = f.getParent();

                }

        }

        @Override

        public FolderDTO getRootFolder(Long userId) throws ObjectNotFoundException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                Folder folder = dao.getRootFolder(userId);

                return folder.getDTO();

        }

        @Override

        public FolderDTO getFolder(final Long userId, final Long folderId) throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                final User user = dao.getEntityById(User.class, userId);

                final Folder folder = dao.getEntityById(Folder.class, folderId);

                // Check permissions

                if (!folder.hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the permissions to read this folder");

                return folder.getDTO();

        }

        @Override

        public User getUser(Long userId) throws ObjectNotFoundException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                return dao.getEntityById(User.class, userId);

        }

        @Override

        public UserDTO getUserDTO(final Long userId) throws ObjectNotFoundException {

                return getUser(userId).getDTO();

        }

        @Override

        public GroupDTO getGroup(final Long groupId) throws ObjectNotFoundException {

                if (groupId == null)

                        throw new ObjectNotFoundException("No group specified");

                final Group group = dao.getEntityById(Group.class, groupId);

                return group.getDTO();

        }

        @Override

        public GroupDTO getGroup(Long userId, String name) throws ObjectNotFoundException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (name == null)

                        throw new ObjectNotFoundException("No group specified");

                User user = dao.getEntityById(User.class, userId);

                List<Group> groups = user.getGroupsSpecified();

                for (Group group: groups)

                        if (group.getName().equals(name))

                                return group.getDTO();

                throw new ObjectNotFoundException("Group " + name + " not found");

        }

        @Override

        public List<GroupDTO> getGroups(final Long userId) throws ObjectNotFoundException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                final List<Group> groups = dao.getGroups(userId);

                final List<GroupDTO> result = new ArrayList<GroupDTO>();

                for (final Group g : groups)

                        result.add(g.getDTO());

                return result;

        }

        @Override

        public List<FileHeaderDTO> getFiles(Long userId, Long folderId, boolean ignoreDeleted)

                        throws ObjectNotFoundException, InsufficientPermissionsException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                User user = dao.getEntityById(User.class, userId);

                Folder folder = dao.getEntityById(Folder.class, folderId);

                if (!folder.hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the permissions to read this folder");

                // Do the actual work.

                List<FileHeaderDTO> result = new ArrayList<FileHeaderDTO>();

                List<FileHeader> files = dao.getFiles(folderId, userId, ignoreDeleted);

                for (FileHeader f : files)

                        result.add(f.getDTO());

                return result;

        }

        @Override

        public List<UserDTO> getUsers(final Long userId, final Long groupId) throws ObjectNotFoundException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (groupId == null)

                        throw new ObjectNotFoundException("No group specified");

                // Do the actual work.

                final List<User> users = dao.getUsers(groupId);

                final List<UserDTO> result = new ArrayList<UserDTO>();

                for (final User u : users)

                        result.add(u.getDTO());

                return result;

        }

        @Override

        public FolderDTO createFolder(Long userId, Long parentId, String name)

                        throws DuplicateNameException, ObjectNotFoundException, InsufficientPermissionsException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (StringUtils.isEmpty(name))

                        throw new ObjectNotFoundException("New folder name is empty");

                if (parentId == null)

                        throw new ObjectNotFoundException("No parent specified");

                if (dao.existsFolderOrFile(parentId, name))

                        throw new DuplicateNameException("A folder or file with the name '" +

                                                name + "' already exists at this level");

                User creator = dao.getEntityById(User.class, userId);

                Folder parent = null;

                try {

                        parent = dao.getEntityById(Folder.class, parentId);

                } catch (ObjectNotFoundException onfe) {

                        // Supply a more accurate problem description.

                        throw new ObjectNotFoundException("Parent folder not found");

                }

                if (!parent.hasWritePermission(creator))

                        throw new InsufficientPermissionsException("You don't have the permissions" +

                                        " to write to this folder");

                // Do the actual work.

                return createFolder(name, parent, creator);

        }

        /**

         * Create a new folder with the provided name, parent and owner.

         *

         * @param name

         * @param parent

         * @param creator

         * @return the new folder

         */

        private FolderDTO createFolder(String name, Folder parent, User creator) {

                Folder folder = new Folder();

                folder.setName(name);

                if (parent != null) {

                        parent.addSubfolder(folder);

                        folder.setOwner(parent.getOwner());

                } else

                        folder.setOwner(creator);

                Date now = new Date();

                AuditInfo auditInfo = new AuditInfo();

                auditInfo.setCreatedBy(creator);

                auditInfo.setCreationDate(now);

                auditInfo.setModifiedBy(creator);

                auditInfo.setModificationDate(now);

                folder.setAuditInfo(auditInfo);

                touchParentFolders(folder, auditInfo.getModifiedBy(), auditInfo.getModificationDate());

                if (parent != null)

                        for (Permission p : parent.getPermissions()) {

                                Permission permission = new Permission();

                                permission.setGroup(p.getGroup());

                                permission.setUser(p.getUser());

                                permission.setRead(p.getRead());

                                permission.setWrite(p.getWrite());

                                permission.setModifyACL(p.getModifyACL());

                                folder.addPermission(permission);

                        }

                else {

                        Permission permission = new Permission();

                        permission.setUser(creator);

                        permission.setRead(true);

                        permission.setWrite(true);

                        permission.setModifyACL(true);

                        folder.addPermission(permission);

                }

                if(parent != null)

                        folder.setReadForAll(parent.isReadForAll());

                dao.create(folder);

                return folder.getDTO();

        }

        @Override

        public void deleteFolder(final Long userId, final Long folderId) throws InsufficientPermissionsException, ObjectNotFoundException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                // Do the actual work.

                final Folder folder = dao.getEntityById(Folder.class, folderId);

                final Folder parent = folder.getParent();

                if (parent == null)

                        throw new ObjectNotFoundException("Deleting the root folder is not allowed");

                final User user = dao.getEntityById(User.class, userId);

                if (!folder.hasDeletePermission(user)) {

                        logger.info("User " + user.getId() + " cannot delete folder " + folder.getName() + "(" + folder.getId() + ")");

                        throw new InsufficientPermissionsException("User " + user.getId() + " cannot delete folder " + folder.getName() + "(" + folder.getId() + ")");

                }

                removeSubfolderFiles(folder);

                parent.removeSubfolder(folder);

                dao.delete(folder);

                touchParentFolders(parent, user, new Date());

        }

        /**

         * Traverses the folder and deletes all actual files (file system)

         * regardless of permissions

         *

         * @param folder

         */

        private void removeSubfolderFiles(Folder folder) {

                //remove files for all subfolders

                for (Folder subfolder:folder.getSubfolders())

                        removeSubfolderFiles(subfolder);

                //remove this folder's file bodies (actual files)

                for (FileHeader file:folder.getFiles()) {

                        for (FileBody body:file.getBodies())

                                deleteActualFile(body.getStoredFilePath());

                        indexFile(file.getId(), true);

                }

        }

        @Override

        @SuppressWarnings("unchecked")

        public List<FolderDTO> getSubfolders(Long userId, Long folderId)

                        throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                User user = dao.getEntityById(User.class, userId);

                Folder folder = dao.getEntityById(Folder.class, folderId);

                if (!folder.hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the permissions to read this folder");

                List<FolderDTO> result = new ArrayList<FolderDTO>();

                if (folder.hasReadPermission(user))

                        for (Folder f : folder.getSubfolders())

                                if (f.hasReadPermission(user) && !f.isDeleted())

                                        result.add(f.getDTO());

                return result;

        }

        @Override

        public FolderDTO updateFolder(Long userId, Long folderId, String folderName,

                                Boolean readForAll,

                                Set<PermissionDTO> permissions)

                        throws InsufficientPermissionsException, ObjectNotFoundException,

                        DuplicateNameException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                Folder folder = dao.getEntityById(Folder.class, folderId);

                User user = dao.getEntityById(User.class, userId);

                if (folderName != null && !folder.hasWritePermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                if(permissions != null && !permissions.isEmpty() && !folder.hasModifyACLPermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                // Check permissions for making file public.

                if (readForAll != null && !user.equals(folder.getOwner()))

                                throw new InsufficientPermissionsException("Only the owner can make a folder public or not public");

                Folder parent = folder.getParent();

                if (folderName != null) {

                        if (parent != null)

                                if (!folder.getName().equals(folderName) && dao.existsFolderOrFile(parent.getId(), folderName))

                                        throw new DuplicateNameException("A folder or file with the name '" + folderName + "' already exists at this level");

                        // Do the actual modification.

                        folder.setName(folderName);

                }

                if (permissions != null)

                        setFolderPermissions(user, folder, permissions);

                if (readForAll != null)

                        setFolderReadForAll(user, folder, readForAll);

                folder.getAuditInfo().setModificationDate(new Date());

                folder.getAuditInfo().setModifiedBy(user);

                dao.update(folder);

                touchParentFolders(folder, user, new Date());

                return folder.getDTO();

        }

        @Override

        public void createGroup(final Long userId, final String name) throws ObjectNotFoundException, DuplicateNameException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (StringUtils.isEmpty(name))

                        throw new ObjectNotFoundException("New group name is empty");

                if (name.indexOf('/')>=0)

                        throw new IllegalArgumentException("Character '/' is not allowed in group name");

                if (dao.existsGroup(userId, name))

                        throw new DuplicateNameException("A group with the name '" + name + "' already exists");

                // TODO: Check permissions

                final User owner = dao.getEntityById(User.class, userId);

                // Do the actual work.

                owner.createGroup(name);

        }

        @Override

        public void deleteGroup(final Long userId, final Long groupId) throws ObjectNotFoundException, InsufficientPermissionsException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (groupId == null)

                        throw new ObjectNotFoundException("No group specified");

                // Do the actual work.

                final User owner = dao.getEntityById(User.class, userId);

                final Group group = dao.getEntityById(Group.class, groupId);

                final Date now = new Date();

                // Only delete the group if actually owned by the user.

                if (group.getOwner().equals(owner)) {

                        List<Folder> folders = dao.getFoldersPermittedForGroup(userId, groupId);

                        for (Folder f : folders){

                                f.getPermissions().removeAll(group.getPermissions());

                                touchFolder(f, owner, now);

                                for(FileHeader file : f.getFiles()){

                                        file.getPermissions().removeAll(group.getPermissions());

                                        touchFile(file, owner, now);

                                }

                        }

                        List<FileHeader> files = dao.getFilesPermittedForGroup(userId, groupId);

                        for(FileHeader h : files){

                                h.getPermissions().removeAll(group.getPermissions());

                                touchFile(h, owner, now);

                        }

                        owner.removeSpecifiedGroup(group);

                        dao.delete(group);

                }

                else throw new InsufficientPermissionsException("You are not the owner of this group");

        }

        @Override

        public FileHeaderDTO createFile(Long userId, Long folderId, String name, String mimeType, InputStream stream)

                        throws DuplicateNameException, ObjectNotFoundException, GSSIOException,

                        InsufficientPermissionsException, QuotaExceededException {

                File file = null;

                try {

                        file = uploadFile(stream, userId);

                } catch ( IOException ioe) {

                        // Supply a more accurate problem description.

                        throw new GSSIOException("Problem creating file",ioe);

                }

                return createFile(userId, folderId, name, mimeType, file.length(), file.getAbsolutePath());

        }

        /* (non-Javadoc)

         * @see gr.ebs.gss.server.ejb.ExternalAPIRemote#indexFile(java.lang.Long, boolean)

         */

        @Override

        public void indexFile(Long fileId, boolean delete) {

                Connection qConn = null;

                Session session = null;

                MessageProducer sender = null;

                try {

                        Context jndiCtx = new InitialContext();

                        ConnectionFactory factory = (QueueConnectionFactory) jndiCtx.lookup("java:/JmsXA");

                        Queue queue = (Queue) jndiCtx.lookup("queue/gss-indexingQueue");

                        qConn = factory.createConnection();

                        session = qConn.createSession(false, Session.AUTO_ACKNOWLEDGE);

                        sender = session.createProducer(queue);

                        MapMessage map = session.createMapMessage();

                        map.setObject("id", fileId);

                        map.setBoolean("delete", delete);

                        sender.send(map);

                }

                catch (NamingException e) {

                        logger.error("Index was not updated: ", e);

                }

                catch (JMSException e) {

                        logger.error("Index was not updated: ", e);

                }

                finally {

                        try {

                                if (sender != null)

                                        sender.close();

                                if (session != null)

                                        session.close();

                                if (qConn != null)

                                        qConn.close();

                        }

                        catch (JMSException e) {

                                logger.warn(e);

                        }

                }

        }

        /**

         * A helper method that generates a unique file path for a stored file. The

         * files are stored using random hash names that are distributed evenly in

         * a 2-level tree of subdirectories named after the first two hex characters

         * in the name. For example, file ab1234cd5769f will be stored in the path

         * /file-repository-root/a/b/ab1234cd5769f. The directories will be created

         * if they don't already exist.

         *

         * @return a unique new file path

         */

        private String generateRepositoryFilePath() {

                String filename = Long.toHexString(random.nextLong());

                String fileRepositoryPath = getConfiguration().getString("fileRepositoryPath","/tmp");

                File root = new File(fileRepositoryPath);

                if (!root.exists())

                        root.mkdirs();

                File firstFolder = new File(root + File.separator + filename.substring(0, 1));

                if (!firstFolder.exists())

                        firstFolder.mkdir();

                File secondFolder = new File(firstFolder + File.separator + filename.substring(1, 2));

                if (!secondFolder.exists())

                        secondFolder.mkdir();

                return secondFolder + File.separator + filename;

        }

        @Override

        public void deleteFile(final Long userId, final Long fileId) throws ObjectNotFoundException, InsufficientPermissionsException {

                // Validate.

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                // Do the actual work.

                final FileHeader file = dao.getEntityById(FileHeader.class, fileId);

                final Folder parent = file.getFolder();

                if (parent == null)

                        throw new ObjectNotFoundException("The specified file has no parent folder");

                final User user = dao.getEntityById(User.class, userId);

                if (!file.hasDeletePermission(user))

                        throw new InsufficientPermissionsException("User " + user.getId() + " cannot delete file " + file.getName() + "(" + file.getId() + ")");

                for (final FileBody body : file.getBodies())

                        deleteActualFile(body.getStoredFilePath());

                dao.delete(file);

                touchParentFolders(parent, user, new Date());

                indexFile(fileId, true);

        }

        @Override

        public void deleteActualFile(String path) {

                if (path == null)

                        return;

                File file = new File(path);

                if (!file.delete())

                        logger.error("Could not delete file " + path);

        }

        @Override

        public void createTag(final Long userId, final Long fileHeaderId, final String tag) throws ObjectNotFoundException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileHeaderId == null)

                        throw new ObjectNotFoundException("No file specified");

                if (StringUtils.isEmpty(tag))

                        throw new ObjectNotFoundException("Tag is empty");

                final User user = dao.getEntityById(User.class, userId);

                final FileHeader fh = dao.getEntityById(FileHeader.class, fileHeaderId);

                final Folder parent = fh.getFolder();

                if (parent == null)

                        throw new ObjectNotFoundException("The specified file has no parent folder");

                user.addTag(fh, tag);

                touchParentFolders(parent, user, new Date());

        }

        @Override

        public Set<String> getUserTags(final Long userId) throws ObjectNotFoundException {

                return dao.getUserTags(userId);

        }

        @Override

        public void updateFile(Long userId, Long fileId, String name,

                                String tagSet, Date modificationDate, Boolean versioned,

                                Boolean readForAll,        Set<PermissionDTO> permissions)

                        throws DuplicateNameException, ObjectNotFoundException,        InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                FileHeader file = dao.getEntityById(FileHeader.class, fileId);

                final Folder parent = file.getFolder();

                if (parent == null)

                        throw new ObjectNotFoundException("The specified file has no parent folder");

                User user = dao.getEntityById(User.class, userId);

                // Check permissions for modifying the file metadata.

                if ((name != null || tagSet != null || modificationDate != null || versioned != null) && !file.hasWritePermission(user))

                        throw new InsufficientPermissionsException("User " + user.getId() +        " cannot update file " + file.getName() + "(" +        file.getId() + ")");

                // Check permissions for making file public.

                if (readForAll != null && !user.equals(file.getOwner()))

                                throw new InsufficientPermissionsException("Only the owner can make a file public or not public");

                // Check permissions for modifying the ACL.

                if(permissions != null && !permissions.isEmpty() &&        !file.hasModifyACLPermission(user))

                        throw new InsufficientPermissionsException("User " + user.getId() +        " cannot update the permissions on file " +        file.getName() + "(" + file.getId() + ")");

                if (name != null) {

                        // Do plain check for file already exists.

                        // Extreme concurrency case should be caught by constraint violation later.

                        if (dao.existsFolderOrFile(parent.getId(), name)) throw new DuplicateNameException("A file or folder with the name '" + name + "' already exists");

                        file.setName(name);

                }

                if (modificationDate != null)

                        file.getAuditInfo().setModificationDate(modificationDate);

                else

                        file.getAuditInfo().setModificationDate(new Date());

                file.getAuditInfo().setModifiedBy(user);

                List<FileTag> tags = file.getFileTags();

                if (tagSet != null) {

                        Iterator<FileTag> i = tags.iterator();

                        while (i.hasNext()) {

                                FileTag tag = i.next();

                                i.remove();

                                tag.setFile(null);

                                user.removeTag(tag);

                                dao.delete(tag);

                        }

                        dao.flush();

                        StringTokenizer st = new StringTokenizer(tagSet, ",");

                        while (st.hasMoreTokens())

                                new FileTag(user, file, st.nextToken().trim());

                }

                if (versioned != null && !file.isVersioned() == versioned) {

                        if (file.isVersioned())

                                removeOldVersions(userId, fileId);

                        file.setVersioned(versioned);

                }

                if (readForAll != null && user.equals(file.getOwner()))

                        file.setReadForAll(readForAll);

                if (permissions != null && !permissions.isEmpty())

                        setFilePermissions(file, permissions);

                /*

                 * Force constraint violation to manifest itself here.

                 * This should cover extreme concurrency cases that the simple check

                 * above hasn't caught.

                 */

                try {

                        dao.flush();

                }

                catch (EJBTransactionRolledbackException e) {

                        Throwable cause = e.getCause();

                        if (cause instanceof PersistenceException && cause.getCause() instanceof ConstraintViolationException)

                                throw new DuplicateNameException("A file or folder with the name '" + name + "' already exists");

                        throw e;

                }

                touchParentFolders(parent, user, new Date());

                // Re-index the file if it was modified.

                if (name != null || tagSet != null)

                        indexFile(fileId, false);

        }

        @Override

        public InputStream getFileContents(Long userId, Long fileId)

                        throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                FileHeader header = dao.getEntityById(FileHeader.class, fileId);

                User user = dao.getEntityById(User.class, userId);

                if (!header.hasReadPermission(user)) {

                        logger.info("User " + user.getId() + " cannot read file " + header.getName() + "(" + fileId + ")");

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                }

                File f = new File(header.getCurrentBody().getStoredFilePath());

                try {

                        return new FileInputStream(f);

                } catch (FileNotFoundException e) {

                        logger.error("Could not locate the contents of file " + f.getAbsolutePath());

                        throw new ObjectNotFoundException("The file contents could not be located");

                }

        }

        /* (non-Javadoc)

         * @see gr.ebs.gss.server.ejb.ExternalAPI#getFileContents(java.lang.Long, java.lang.Long, java.lang.Long)

         */

        @Override

        public InputStream getFileContents(Long userId, Long fileId, Long bodyId) throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                if (bodyId == null)

                        throw new ObjectNotFoundException("No file specified");

                final FileHeader header = dao.getEntityById(FileHeader.class, fileId);

                final FileBody body = dao.getEntityById(FileBody.class, bodyId);

                final User user = dao.getEntityById(User.class, userId);

                if (!header.hasReadPermission(user)) {

                        logger.info("User " + user.getId() + " cannot read file " + header.getName() + "(" + fileId + ")");

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                }

                File f = new File(body.getStoredFilePath());

                try {

                        return new FileInputStream(f);

                } catch (FileNotFoundException e) {

                        logger.error("Could not locate the contents of file " + f.getAbsolutePath());

                        throw new ObjectNotFoundException("The file contents could not be located");

                }

        }

        @Override

        public FileHeaderDTO getFile(Long userId, Long fileId) throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                final User user = dao.getEntityById(User.class, userId);

                final FileHeader file = dao.getEntityById(FileHeader.class, fileId);

                if (!file.hasReadPermission(user) && !file.getFolder().hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                return file.getDTO();

        }

        @Override

        public FileBodyDTO getFileBody(Long userId, Long fileId, Long bodyId) throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                User user = dao.getEntityById(User.class, userId);

                FileHeader file = dao.getEntityById(FileHeader.class, fileId);

                if (!file.hasReadPermission(user) && !file.getFolder().hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                FileBody body = dao.getEntityById(FileBody.class, bodyId);

                return body.getDTO();

        }

        @Override

        public Object getResourceAtPath(Long ownerId, String path, boolean ignoreDeleted)

                        throws ObjectNotFoundException {

                if (ownerId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (StringUtils.isEmpty(path))

                        throw new ObjectNotFoundException("No path specified");

                User owner = dao.getEntityById(User.class, ownerId);

                List<String> pathElements = new ArrayList<String>();

                StringTokenizer st = new StringTokenizer(path, "/");

                while (st.hasMoreTokens())

                        pathElements.add(st.nextToken());

                if (pathElements.size() < 1)

                        return getRootFolder(owner.getId());

                // Store the last element, since it requires special handling.

                String lastElement = pathElements.remove(pathElements.size() - 1);

                FolderDTO cursor = getRootFolder(owner.getId());

                // Traverse and verify the specified folder path.

                for (String pathElement : pathElements) {

                        cursor = getFolder(cursor.getId(), pathElement);

                        if (cursor.isDeleted())

                                throw new ObjectNotFoundException("Folder " + cursor.getPath() + " not found");

                }

                // Use the lastElement to retrieve the actual resource.

                Object resource = null;

                try {

                        FileHeaderDTO file = getFile(cursor.getId(), lastElement);

                        if (ignoreDeleted && file.isDeleted())

                                throw new ObjectNotFoundException("Resource not found");

                        resource = file;

                } catch (ObjectNotFoundException e) {

                        // Perhaps the requested resource is not a file, so

                        // check for folders as well.

                        FolderDTO folder = getFolder(cursor.getId(), lastElement);

                        if (ignoreDeleted && folder.isDeleted())

                                throw new ObjectNotFoundException("Resource not found");

                        resource = folder;

                }

                return resource;

        }

        /**

         * Retrieve a file for the specified user that has the specified name and

         * its parent folder has id equal to folderId.

         *

         * @param folderId the ID of the parent folder

         * @param name the name of the requested file

         * @return the file found

         * @throws ObjectNotFoundException if the specified folder or file was not

         *             found, with the exception message mentioning the precise

         *             problem

         */

        private FileHeaderDTO getFile(Long folderId, String name) throws ObjectNotFoundException {

                if (folderId == null)

                        throw new ObjectNotFoundException("No parent folder specified");

                if (StringUtils.isEmpty(name))

                        throw new ObjectNotFoundException("No file specified");

                FileHeader file = dao.getFile(folderId, name);

                return file.getDTO();

        }

        /**

         * Retrieve a folder for the specified user that has the specified name and

         * its parent folder has id equal to parentId.

         *

         * @param parentId the ID of the parent folder

         * @param name the name of the requested folder

         * @return the folder found

         * @throws ObjectNotFoundException if the specified folder or parent was not

         *             found, with the exception message mentioning the precise

         *             problem

         */

        private FolderDTO getFolder(Long parentId, String name) throws ObjectNotFoundException {

                if (parentId == null)

                        throw new ObjectNotFoundException("No parent folder specified");

                if (StringUtils.isEmpty(name))

                        throw new ObjectNotFoundException("No folder specified");

                Folder folder = dao.getFolder(parentId, name);

                return folder.getDTO();

        }

        private FileHeaderDTO updateFileContents(Long userId, Long fileId, String mimeType, InputStream resourceInputStream) throws ObjectNotFoundException, GSSIOException, InsufficientPermissionsException, QuotaExceededException {

                File file = null;

                try {

                        file = uploadFile(resourceInputStream, userId);

                } catch ( IOException ioe) {

                        // Supply a more accurate problem description.

                        throw new GSSIOException("Problem creating file",ioe);

                }

                return updateFileContents(userId, fileId, mimeType, file.length(), file.getAbsolutePath());

        }

        @Override

        public void copyFile(Long userId, Long fileId, String dest) throws ObjectNotFoundException, DuplicateNameException, GSSIOException, InsufficientPermissionsException, QuotaExceededException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                if (StringUtils.isEmpty(dest))

                        throw new ObjectNotFoundException("No destination specified");

                Object destination = getResourceAtPath(userId, getParentPath(dest), true);

                if (!(destination instanceof FolderDTO))

                        throw new ObjectNotFoundException("Destination parent folder not found");

                FolderDTO parent = (FolderDTO) destination;

                copyFile(userId, fileId, parent.getId(), getLastElement(dest));

        }

        @Override

        public void copyFileToPath(Long userId, Long ownerId, Long fileId, String dest) throws ObjectNotFoundException, DuplicateNameException, GSSIOException, InsufficientPermissionsException, QuotaExceededException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (ownerId == null)

                        throw new ObjectNotFoundException("No owner specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                if (StringUtils.isEmpty(dest))

                        throw new ObjectNotFoundException("No destination specified");

                Object destination = getResourceAtPath(ownerId, getParentPath(dest), true);

                if (!(destination instanceof FolderDTO))

                        throw new ObjectNotFoundException("Destination parent folder not found");

                FolderDTO parent = (FolderDTO) destination;

                copyFile(userId, fileId, parent.getId(), getLastElement(dest));

        }

        @Override

        public void copyFile(Long userId, Long fileId, Long destId, String destName) throws ObjectNotFoundException, DuplicateNameException, GSSIOException, InsufficientPermissionsException, QuotaExceededException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (fileId == null)

                        throw new ObjectNotFoundException("No file specified");

                if (destId == null)

                        throw new ObjectNotFoundException("No destination specified");

                if (StringUtils.isEmpty(destName))

                        throw new ObjectNotFoundException("No destination file name specified");

                FileHeader file = dao.getEntityById(FileHeader.class, fileId);

                Folder destination = dao.getEntityById(Folder.class, destId);

                User user = dao.getEntityById(User.class, userId);

                if (!file.hasReadPermission(user) || !destination.hasWritePermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                boolean versioned = file.isVersioned();

                int versionsNumber = file.getBodies().size();

                FileBody oldestBody = file.getBodies().get(0);

                assert oldestBody != null;

                File contents = new File(oldestBody.getStoredFilePath());

                try {

                        createFile(user.getId(), destination.getId(), destName, oldestBody.getMimeType(), new FileInputStream(contents));

                        FileHeader copiedFile = dao.getFile(destination.getId(), destName);

                        copiedFile.setVersioned(versioned);

                        dao.flush();

                        if (versionsNumber > 1)

                                for (int i = 1; i < versionsNumber; i++) {

                                        FileBody body = file.getBodies().get(i);

                                        assert body != null;

                                        contents = new File(body.getStoredFilePath());

                                        updateFileContents(user.getId(), copiedFile.getId(), body.getMimeType(), new FileInputStream(contents));

                                }

                        List<FileTag> tags = file.getFileTags();

                        for (FileTag tag : tags)

                                createTag(userId, copiedFile.getId(), tag.getTag());

                } catch (FileNotFoundException e) {

                        throw new ObjectNotFoundException("File contents not found for file " + contents.getAbsolutePath());

                }

        }

        @Override

        public void copyFolder(Long userId, Long folderId, String dest) throws ObjectNotFoundException, DuplicateNameException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                if (StringUtils.isEmpty(dest))

                        throw new ObjectNotFoundException("No destination specified");

                Object destination = getResourceAtPath(userId, getParentPath(dest), true);

                if (!(destination instanceof FolderDTO))

                        throw new ObjectNotFoundException("Destination folder not found");

                FolderDTO parent = (FolderDTO) destination;

                copyFolder(userId, folderId, parent.getId(), getLastElement(dest));

        }

        @Override

        public void copyFolder(Long userId, Long folderId, Long destId, String destName) throws ObjectNotFoundException, DuplicateNameException, InsufficientPermissionsException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                if (destId == null)

                        throw new ObjectNotFoundException("No destination specified");

                if (StringUtils.isEmpty(destName))

                        throw new ObjectNotFoundException("No destination folder name specified");

                Folder folder = dao.getEntityById(Folder.class, folderId);

                Folder destination = dao.getEntityById(Folder.class, destId);

                User user = dao.getEntityById(User.class, userId);

                if (!destination.hasWritePermission(user) || !folder.hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                createFolder(user.getId(), destination.getId(), destName);

        }

        @Override

        public void copyFolderStructureToPath(Long userId, Long ownerId, Long folderId, String dest) throws ObjectNotFoundException, DuplicateNameException, InsufficientPermissionsException, GSSIOException, QuotaExceededException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (ownerId == null)

                        throw new ObjectNotFoundException("No owner specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                if (StringUtils.isEmpty(dest))

                        throw new ObjectNotFoundException("No destination specified");

                Object destination = getResourceAtPath(ownerId, getParentPath(dest), true);

                if (!(destination instanceof FolderDTO))

                        throw new ObjectNotFoundException("Destination folder not found");

                FolderDTO parent = (FolderDTO) destination;

                copyFolderStructure(userId, folderId, parent.getId(), getLastElement(dest));

        }

        @Override

        public void copyFolderStructure(Long userId, Long folderId, Long destId, String destName) throws ObjectNotFoundException, DuplicateNameException, InsufficientPermissionsException, GSSIOException, QuotaExceededException {

                if (userId == null)

                        throw new ObjectNotFoundException("No user specified");

                if (folderId == null)

                        throw new ObjectNotFoundException("No folder specified");

                if (destId == null)

                        throw new ObjectNotFoundException("No destination specified");

                if (StringUtils.isEmpty(destName))

                        throw new ObjectNotFoundException("No destination folder name specified");

                Folder folder = dao.getEntityById(Folder.class, folderId);

                Folder destination = dao.getEntityById(Folder.class, destId);

                final User user = dao.getEntityById(User.class, userId);

                // XXX: quick fix need to copy only visible items to user (Source

                // for bugs)

                if (!folder.getOwner().getId().equals(userId) && !folder.hasReadPermission(user))

                        return;

                if(folder.isDeleted())//do not copy trashed folder and contents

                        return;

                if (!destination.hasWritePermission(user) || !folder.hasReadPermission(user))

                        throw new InsufficientPermissionsException("You don't have the necessary permissions");

                createFolder(user.getId(), destination.getId(), destName);

                Folder createdFolder = dao.getFolder(destination.getId(), destName);

                List<FileHeader> files = folder.getFiles();

                if (files != null)

                        for (FileHeader file : files)

                                if(!file.isDeleted())

                                        copyFile(userId, file.getId(), createdFolder.getId(), file.getName());

                List<Folder> subFolders = folder.getSubfolders();

                if (subFolders != null)

                        for (Folder sub : subFolders)

                                if(!sub.getId().equals(createdFolder.getId()))

                                        copyFolderStructure(userId, sub.getId(), createdFolder.getId(), sub.getName());

        }

        /**

         * For a provided path, remove the last element and return the rest, that is

         * the path of the parent folder.

         *

         * @param path the specified path

         * @return the path of the parent folder

         * @throws ObjectNotFoundException if the provided string contains no path

         *             delimiters

         */

        private String getParentPath(String path) throws ObjectNotFoundException {

                int lastDelimiter = path.lastIndexOf('/');

                if (lastDelimiter == 0)

                        return "/";

                if (lastDelimiter == -1)

                        // No path found.

                        throw new ObjectNotFoundException("There is no parent in the path: " + path);

                else if (lastDelimiter < path.length() - 1)

                        // Return the part before the delimiter.

                        return path.substring(0, lastDelimiter);

                else {

                        // Remove the trailing delimiter and then recurse.

                        String strippedTrail = path.substring(0, lastDelimiter);

                        return getParentPath(strippedTrail);

                }

        }

        /**

         * Get the last element in a path that denotes the file or folder name.

         *

         * @param path the provided path

         * @return the last element in the path

         */

        private String getLastElement(String path) {

                int lastDelimiter = path.lastIndexOf('/');

                if (lastDelimiter == -1)

                        // No path found.

                        return path;

                else if (lastDelimiter < path.length() - 1)

                        // Return the part after the delimiter.

                        return path.substring(lastDelimiter + 1);

                else {

                        // Remove the trailing delimiter and then recurse.

                        String strippedTrail = path.substring(0, lastDelimiter);

                        return getLastElement(strippedTrail);

                }

        }

        @Override

        public void moveFileToTrash(Long userId, Long fileId) throws ObjectNotFoundException, InsufficientPermissionsException {

                if (userId == null)