package org.gcube.portlets.user.workspace.server;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;
import org.gcube.application.framework.core.session.ASLSession;
import org.gcube.common.homelibrary.home.Home;
import org.gcube.common.homelibrary.home.HomeLibrary;
import org.gcube.common.homelibrary.home.exceptions.HomeNotFoundException;
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
import org.gcube.common.homelibrary.home.workspace.Workspace;
import org.gcube.common.homelibrary.home.workspace.WorkspaceFolder;
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
import org.gcube.common.homelibrary.home.workspace.WorkspaceItemType;
import org.gcube.common.homelibrary.home.workspace.WorkspaceSharedFolder;
import org.gcube.common.homelibrary.home.workspace.WorkspaceSmartFolder;
import org.gcube.common.homelibrary.home.workspace.accessmanager.ACLType;
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntry;
import org.gcube.common.homelibrary.home.workspace.exceptions.InsufficientPrivilegesException;
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemAlreadyExistException;
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemNotFoundException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WorkspaceFolderNotFoundException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WrongDestinationException;
import org.gcube.common.homelibrary.home.workspace.folder.FolderItem;
import org.gcube.common.homelibrary.home.workspace.folder.FolderItemType;
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalUrl;
import org.gcube.common.homelibrary.home.workspace.folder.items.ts.TimeSeries;
import org.gcube.common.homelibrary.home.workspace.search.SearchItem;
import org.gcube.common.homelibrary.home.workspace.sharing.WorkspaceMessage;
import org.gcube.common.scope.api.ScopeProvider;
import org.gcube.portlets.user.workspace.client.ConstantsExplorer;
import org.gcube.portlets.user.workspace.client.interfaces.GXTCategoryItemInterface;
import org.gcube.portlets.user.workspace.client.model.BulkCreatorModel;
import org.gcube.portlets.user.workspace.client.model.FileDetailsModel;
import org.gcube.portlets.user.workspace.client.model.FileGridModel;
import org.gcube.portlets.user.workspace.client.model.FileModel;
import org.gcube.portlets.user.workspace.client.model.FolderModel;
import org.gcube.portlets.user.workspace.client.model.InfoContactModel;
import org.gcube.portlets.user.workspace.client.model.MessageModel;
import org.gcube.portlets.user.workspace.client.model.ScopeModel;
import org.gcube.portlets.user.workspace.client.model.SmartFolderModel;
import org.gcube.portlets.user.workspace.client.model.SubTree;
import org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService;
import org.gcube.portlets.user.workspace.client.workspace.GWTWorkspaceItem;
import org.gcube.portlets.user.workspace.server.notifications.NotificationsProducer;
import org.gcube.portlets.user.workspace.server.notifications.NotificationsUtil;
import org.gcube.portlets.user.workspace.server.resolver.UriResolverReaderParameter;
import org.gcube.portlets.user.workspace.server.shortener.UrlShortener;
import org.gcube.portlets.user.workspace.server.util.HttpRequestUtil;
import org.gcube.portlets.user.workspace.server.util.StringUtil;
import org.gcube.portlets.user.workspace.server.util.UserUtil;
import org.gcube.portlets.user.workspace.server.util.WsUtil;
import org.gcube.portlets.user.workspace.server.util.scope.ScopeUtilFilter;
import org.gcube.portlets.user.workspace.shared.SessionExpiredException;
import org.gcube.portlets.user.workspace.shared.WorkspaceACL;
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingEntryType;
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingField;
import org.gcube.portlets.user.workspaceapplicationhandler.ApplicationReaderFromGenericResource;
import org.gcube.vomanagement.usermanagement.GroupManager;
import org.gcube.vomanagement.usermanagement.UserManager;
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayGroupManager;
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayUserManager;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;


/**
 * @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
 *
 */
public class GWTWorkspaceServiceImpl extends RemoteServiceServlet implements GWTWorkspaceService{


	/**
	 * 
	 */
	protected static final String IDENTIFIER_IS_NULL = "Identifier is null";
	protected static final String RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST = " retrieving item. Either the item doesn't exist anymore or you do not have the permission to access it";
	private static final long serialVersionUID = 2828885661214875589L;

	public static final String LAST_OPEN_FOLDER_ATTRIBUTE = "WORKSPACE.LAST_OPEN_FOLDER";
	public static final String SELECTION_STATE_ATTRIBUTE = "WORKSPACE.SELECTION_STATE";

//	protected GCUBELog workspaceLogger = new GCUBELog(GWTWorkspaceServiceImpl.class);
	
	protected Logger workspaceLogger = Logger.getLogger(GWTWorkspaceServiceImpl.class);
	
	
	protected GWTWorkspaceBuilder getGWTWorkspaceBuilder()
	{
		return WsUtil.getGWTWorkspaceBuilder(this.getThreadLocalRequest().getSession());
	}

	protected Workspace getWorkspace() throws InternalErrorException, HomeNotFoundException, WorkspaceFolderNotFoundException
	{
		return WsUtil.getWorkspace(this.getThreadLocalRequest().getSession());
	}
	
	protected NotificationsProducer getNotificationProducer(){
		
		return WsUtil.getNotificationProducer(WsUtil.getAslSession(this.getThreadLocalRequest().getSession()));
	}
	
	protected ScopeUtilFilter getScopeUtilFilter(){
		
		return WsUtil.getScopeUtilFilter(this.getThreadLocalRequest().getSession());
	}
	
	protected boolean isTestMode(){
		return WsUtil.withoutPortal;
	}
	
	protected UrlShortener getUrlShortener() {
		return WsUtil.getUrlShortener(this.getThreadLocalRequest().getSession());
	}

	protected UriResolverReaderParameter getUriResolver() {
		return WsUtil.getUriResolver(this.getThreadLocalRequest().getSession());
	}
	
	@Override
	public FolderModel getRootForTree() throws Exception {

		workspaceLogger.trace("getRoot");
		
		try {

			workspaceLogger.trace("getting workspace");
			Workspace workspace = getWorkspace();
			

			WorkspaceFolder root = workspace.getRoot();

			if (root == null) {
				workspaceLogger.error("The root is null");
				throw new Exception("The root is null");
			}

			workspaceLogger.trace("Root loaded, gxt conversion");
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			FolderModel gwtroot =builder.buildWorkspaceFileModelRoot(root);

			workspaceLogger.trace("Root converted, returnig...");
			return gwtroot;
		} catch (Exception e) {
			workspaceLogger.error("Error in server during root retrieving", e);
//			workspaceLogger.trace("Error in server During root retrieving " + e);
			
			//GWT can't serialize all exceptions
			throw new Exception("Error during workspace loading, please contact the support. Exception:" +e);
		}
	}
	
	@Override
	public FolderModel getRootForTree(String scopeId) throws Exception {

		workspaceLogger.info("getRoot for scope " + scopeId);
		workspaceLogger.trace("getting workspace");
		
		try {

			Workspace workspace = getWorkspace();

			workspaceLogger.trace("on server getRoot for scope: " + scopeId);
			
//			GCUBEScope gcubeScope = null;
//			
//			if(scopeId.compareTo(ScopeUtilFilter.IDALLSCOPE)!=0){
//				gcubeScope = GCUBEScope.getScope(scopeId);
//			}
			
			WorkspaceFolder root =  workspace.getRoot();

			if (root == null) {
				workspaceLogger.error("The root is null");
				throw new Exception("The root is null");
			}

			workspaceLogger.trace("Root loaded, gxt conversion");
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			workspaceLogger.trace("Root converted, returnig...");
			return builder.buildWorkspaceFileModelRoot(root);

		} catch (Exception e) {
			workspaceLogger.error("Error in server during root retrieving", e);
//			workspaceLogger.trace("Error in server During root retrieving " + e);
			
			//GWT can't serialize all exceptions
			throw new Exception("Error during workspace loading, please contact the support. Exception:" +e);
		}
	}
	

	@Override
	public List<FileGridModel> getItemsBySearchName(String text) throws Exception {

		workspaceLogger.trace("getting search");
		
		try {

			Workspace workspace = getWorkspace();

			List<SearchItem> listSearchItems = workspace.searchByName(text);

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
			
			workspaceLogger.trace("Call search HL..");
			
			listFileGridModels = builder.buildGXTListFileGridModelItemForSearch(listSearchItems);
			workspaceLogger.trace("Search converted, completed...");
			
			return listFileGridModels;
		} catch (Exception e) {
			workspaceLogger.error("Error in server During search retrieving", e);
//			workspaceLogger.trace("Error in server During search retrieving " + e);
			
			//GWT can't serialize all exceptions
			throw new Exception("Error during searching, please contact the support.");
		}
	}
	
	@Override
	public List<FileModel> getFolderChildren(FolderModel folder) throws Exception, SessionExpiredException{
		
		Workspace workspace;

		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {
			
			if(folder == null)
				throw new Exception("Folder is null");	

			workspaceLogger.trace("get folder children for: "+folder.getIdentifier());
			workspace = getWorkspace();
			
			List<FileModel> listFileModels = new ArrayList<FileModel>();

			WorkspaceItem wsItem = workspace.getItem(folder.getIdentifier());
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			listFileModels = builder.buildGXTListFileModelItem(wsItem, folder);
			
			return listFileModels;
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server During item retrieving", e);
//			workspaceLogger.trace("Error in server During item retrieving " + e);
			String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
			//GWT can't serialize all exceptions
			throw new Exception(error);
		}
	}

	@Override
	public List<FileGridModel> getFolderChildrenForFileGrid(FileModel folder) throws Exception, SessionExpiredException {
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {
			
			if(folder == null)
				throw new Exception("Folder is null");	
			
			workspaceLogger.trace("get children for Grid for folder: "+folder.getIdentifier());
			
			Workspace workspace = getWorkspace();
			
			List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();

			WorkspaceFolder wsFolder = (WorkspaceFolder) workspace.getItem(folder.getIdentifier());

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			
			Long startTime =  System.currentTimeMillis();
			
			List<WorkspaceItem> listItems = (List<WorkspaceItem>) wsFolder.getChildren();
			
			Long endTime = System.currentTimeMillis() - startTime;
			String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
			workspaceLogger.debug("##HL FILLING: grid getChildren() returning "+listItems.size()+" elements in " + time);

			listFileGridModels = builder.buildGXTListFileGridModelItem(listItems, folder);
			
			
			return listFileGridModels;
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server During items retrieving", e);
//			workspaceLogger.trace("Error in server During items retrieving " + e);
//			e.printStackTrace();
			String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
			//GWT can't serialize all exceptions
			throw new Exception(error);
		}
	}
	
	@Override
	public List<FileGridModel> getFolderChildrenForFileGridById(String folderId) throws Exception, SessionExpiredException {
		

		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {

			if(folderId == null)
				throw new Exception("Folder id is null");	
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get children for Grid by id: "+folderId);
			List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
			
			
			if(folderId==null || folderId.isEmpty()){
				workspaceLogger.trace("id is null or empty, return");
				return listFileGridModels;
			}
		
			workspaceLogger.trace("get children for Grid by id: "+folderId);
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			//BUILD PARENT
			WorkspaceItem wsItem = workspace.getItem(folderId);
			
			WorkspaceFolder parent;

			if(wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER) || wsItem.getType().equals(WorkspaceItemType.FOLDER)){
				workspaceLogger.trace("item id: "+folderId +" is of type: "+wsItem.getType());
				parent = (WorkspaceFolder) wsItem;
				
			}else{
				workspaceLogger.trace("item id: "+folderId +" is not a folder but of type: "+wsItem.getType()+", get parent");
				parent = wsItem.getParent();
			}
			
			if(parent==null)
				return listFileGridModels;
			

			FileGridModel wsParent = builder.buildGXTFileGridModelItem(parent, null);
			
			//PARENT BUILDED IS SHARED?
			if(parent.isShared()){
				wsParent.setShared(true);
				wsParent.setShareable(false);
			}
			
			Long startTime =  System.currentTimeMillis();
			
			//GET CHILDREN
			List<WorkspaceItem> listItems = (List<WorkspaceItem>) parent.getChildren();
			
			Long endTime = System.currentTimeMillis() - startTime;
			String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
			workspaceLogger.debug("grid getChildren() returning "+listItems.size()+" elements in " + time);
			
			
			listFileGridModels = builder.buildGXTListFileGridModelItem(listItems, wsParent);
			
			return listFileGridModels;
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server During items retrieving", e);
//			workspaceLogger.trace("Error in server During items retrieving " + e);
			
			String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
//			e.printStackTrace();
			//GWT can't serialize all exceptions
			throw new Exception(error);
		}
	}
	
	
	@Override
	public FileGridModel getItemForFileGrid(String itemId) throws Exception {

		try {
			
			if(itemId == null)
				throw new Exception(IDENTIFIER_IS_NULL);	
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get child for Grid by id: "+itemId);
			
			WorkspaceItem wsItem =  workspace.getItem(itemId);
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			Long startTime =  System.currentTimeMillis();
		
			Long endTime = System.currentTimeMillis() - startTime;
			String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
			workspaceLogger.debug("get child for Grid by id returning element in " + time);

			
			//BUILD PARENT
			WorkspaceFolder folder = wsItem.getParent(); //get parent
			FileGridModel wsFolder = builder.buildGXTFileGridModelItem(folder, null);
			
			//BUILD ITEM 
			return builder.buildGXTFileGridModelItem(wsItem, wsFolder);

			
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server during item retrieving, getItemForFileGrid", e);
			String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
			throw new Exception(error);
		}
	}
	
	@Override
	public Boolean moveItem(String itemId, String destinationId) throws Exception {
		workspaceLogger.trace("moveItem itemId: "+itemId+" destination: "+destinationId);

		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {
			Workspace workspace = getWorkspace();
		
			if(itemId == null)
				throw new Exception(IDENTIFIER_IS_NULL);	
			
			workspaceLogger.trace("moveItem item: "+itemId+" destination: "+destinationId);

			WorkspaceItem sourceItem = workspace.getItem(itemId);  //GET SOURCE ITEM BEFORE OF MOVE
			
			if(sourceItem==null)
				return Boolean.FALSE;
			
			String sourceSharedId = null;
			boolean sourceItemIsShared = sourceItem.isShared();
			
			if(sourceItemIsShared)
				sourceSharedId = sourceItem.getIdSharedFolder(); //GET SHARED ID BEFORE OF MOVE

			
			//System.out.println("moveItem item: "+itemId+" sourceItem name "+sourceItem.getName() + " shared: "+sourceItemIsShared+ " destination: "+destinationId);

			workspace.moveItem(itemId, destinationId); //move item
			
			WorkspaceItem folderDestinationItem = workspace.getItem(destinationId); //retrieve folder destination
			
			//System.out.println("sourceItem.isShared() "+sourceItemIsShared );
			//System.out.println("folderDestinationItem item: "+destinationId+" folderDestinationItem name "+folderDestinationItem.getName() + " folderDestinationItem shared: "+folderDestinationItem.isShared());

			if(folderDestinationItem!=null){ 
				
				try{
					checkNotifyAddItemToShare(sourceItem, sourceSharedId, folderDestinationItem);
					
					checkNotifyMoveItemFromShare(sourceItemIsShared, sourceItem, sourceSharedId, folderDestinationItem);
				
				}catch (Exception e) {
					workspaceLogger.error("An error occurred in checkNotify ", e);
				}
			}
			
			return Boolean.TRUE;

		}catch (InsufficientPrivilegesException e) {
			workspaceLogger.error("Error in server Item move", e);
			String error = "An error occurred on moving item. "+e.getMessage();
			throw new Exception(error);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server Item move", e);
			String error = ConstantsExplorer.SERVER_ERROR + " moving item. "+e.getMessage();
			throw new Exception(error);
		}

	}
	
	
	
	@Override
	public Boolean moveItems(List<String> ids, String destinationId) throws Exception {
		workspaceLogger.trace("moveItems "+ids.size()+ ", destination: "+destinationId);

		if(isSessionExpired())
			throw new SessionExpiredException();
		
		boolean error = false;
		
		try {
			Workspace workspace = getWorkspace();
			
			for (String itemId : ids) {
				
				if(itemId == null)
					throw new Exception(IDENTIFIER_IS_NULL);	
				
				workspaceLogger.trace("moveItem item: "+itemId+" destination: "+destinationId);

				WorkspaceItem sourceItem = workspace.getItem(itemId);  //GET SOURCE ITEM BEFORE OF MOVE
				
				if(sourceItem==null){
					error = true;
					break;
				}
				
				String sourceSharedId = null;
				boolean sourceItemIsShared = sourceItem.isShared();
				
				if(sourceItemIsShared)
					sourceSharedId = sourceItem.getIdSharedFolder(); //GET SHARED ID BEFORE OF MOVE

				
				//System.out.println("moveItem item: "+itemId+" sourceItem name "+sourceItem.getName() + " shared: "+sourceItemIsShared+ " destination: "+destinationId);

				workspace.moveItem(itemId, destinationId); //move item
				
				WorkspaceItem folderDestinationItem = workspace.getItem(destinationId); //retrieve folder destination
				
				//System.out.println("sourceItem.isShared() "+sourceItemIsShared );
				//System.out.println("folderDestinationItem item: "+destinationId+" folderDestinationItem name "+folderDestinationItem.getName() + " folderDestinationItem shared: "+folderDestinationItem.isShared());

				if(folderDestinationItem!=null){ 
					
					try{
						checkNotifyAddItemToShare(sourceItem, sourceSharedId, folderDestinationItem);
						
						checkNotifyMoveItemFromShare(sourceItemIsShared, sourceItem, sourceSharedId, folderDestinationItem);
					
					}catch (Exception e) {
						workspaceLogger.error("An error occurred in checkNotify ", e);
					}
				}
			}
			
			if(error)
				return Boolean.FALSE;
			
			return Boolean.TRUE;

		}catch (InsufficientPrivilegesException e) {
			workspaceLogger.error("Error in server Item move", e);
			String error1 = "An error occurred on moving item. "+e.getMessage();
			throw new Exception(error1);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server Item move", e);
			String error2 = ConstantsExplorer.SERVER_ERROR + " moving item. "+e.getMessage();
			throw new Exception(error2);
		}

	}
	
	private void checkNotifyAddItemToShare(final WorkspaceItem sourceItem, final String sourceSharedId, final WorkspaceItem folderDestinationItem) {
		
		workspaceLogger.trace("checkNotifyAddItemToShare");
		
		if(folderDestinationItem!=null){ 
				
			try{
				//if folder destination is shared folder
				if(folderDestinationItem.isShared()){ 	//Notify Added Item To Sharing?
					
					workspaceLogger.trace("checkNotifyAddItemToShare source item: "+sourceItem.getName()+" sourceSharedId: "+sourceSharedId + " folder destination: "+folderDestinationItem.getName());
					
					//share condition is true if source shared folder is null or not equal to destination shared folder
					boolean shareChangeCondition = (sourceSharedId==null) || (sourceSharedId.compareTo(folderDestinationItem.getIdSharedFolder())!=0);
				
					//System.out.println("shareChangeCondition add item: "+  shareChangeCondition);
				
					workspaceLogger.trace("shareChangeCondition add item: "+shareChangeCondition);
					
					//if shareChangeCondition is true.. notifies added item to sharing
					if(shareChangeCondition){  

						List<InfoContactModel> listContacts = getListUserSharedByFolderSharedId(folderDestinationItem.getIdSharedFolder());

						//DEBUG
						printContacts(listContacts);
						
						Workspace workspace = getWorkspace();
						
						WorkspaceItem destinationSharedFolder = workspace.getItem(folderDestinationItem.getIdSharedFolder());
						
						NotificationsProducer np = getNotificationProducer();
						
						np.notifyAddedItemToSharing(listContacts, sourceItem, (WorkspaceFolder) destinationSharedFolder);	
						
						workspaceLogger.trace("The notifies sent correctly");
//							np.notifyAddedItemToSharing(listContacts, (WorkspaceFolder) folderDestinationItem);	
					}	
				}
				else
					workspaceLogger.trace("folder destination is not shared");
			
			}catch (Exception e) {
				workspaceLogger.error("An error occurred in  verifyNotifyAddItemToShare ",e);
			}
		}else
			workspaceLogger.warn("The notifies is failure in verifyNotifyAddItemToShare because folder destination item is null");	
	}
	

	private void checkNotifyMoveItemFromShare(final boolean sourceItemIsShared, final WorkspaceItem sourceItem, final String sourceSharedId, final WorkspaceItem folderDestinationItem) {
		
		workspaceLogger.trace("checkNotifyMoveItemFromShare:");
		
		try{
			
			if(folderDestinationItem!=null){ 
				
				String idSharedFolder = folderDestinationItem.getIdSharedFolder()!=null?folderDestinationItem.getIdSharedFolder():"";
				
				//share condition is true if source shared folder is not equal to destination shared folder
				boolean shareChangeCondition = sourceSharedId==null?false:(sourceSharedId.compareTo(idSharedFolder)!=0);
				
				workspaceLogger.trace("checkNotifyMoveItemFromShare source item: "+sourceItem.getName()+" sourceSharedId: "+sourceSharedId + " folder destination: "+folderDestinationItem.getName() +" sourceItemIsShared: "+sourceItemIsShared);
				
//				System.out.println("shareChangeCondition remove item: "+  shareChangeCondition);
				
				workspaceLogger.trace("shareChangeCondition remove item: "+  shareChangeCondition);
				
				//Notify Removed Item To Sharing?
				//if source Item is shared and folder destination is not shared or shareChangeCondition is true.. notifies removed item to sharing
				if(sourceItemIsShared && (!folderDestinationItem.isShared() || shareChangeCondition)){
						
						//get contacts
						List<InfoContactModel> listContacts = getListUserSharedByFolderSharedId(sourceSharedId);
						
						//DEBUG
						printContacts(listContacts);
						
						Workspace workspace = getWorkspace();
						
						WorkspaceItem sourceSharedFolder = workspace.getItem(sourceSharedId);
						
						//System.out.println(" name sourceSharedFolder:  "+ sourceSharedFolder.getName());
						
						NotificationsProducer np = getNotificationProducer();
						
						np.notifyMovedItemToSharing(listContacts, sourceItem, (WorkspaceFolder) sourceSharedFolder);
						
						workspaceLogger.trace("The notifies was sent correctly");
						
				}

			}else
				workspaceLogger.warn("The notifies is failure in checkNotifyMoveItemFromShare because folder destination item is null");
			
		}catch (Exception e) {
			workspaceLogger.error("An error occurred in checkNotifyMoveItemFromShare ",e);
		}

	}
	
	//DEBUG
	private void printContacts(List<InfoContactModel> listContacts){
		
		boolean testMode = isTestMode();
		if(testMode)
			System.out.println("Contacts: ");
		else
			workspaceLogger.trace("Contacts:");
		
		for (InfoContactModel infoContactModel : listContacts) {
			if(testMode)
				System.out.println("User: "+infoContactModel);
			else
				workspaceLogger.trace("User: "+infoContactModel);
		}
	}

	@Override
	public Boolean removeItem(String itemId) throws Exception {
		
		try {
			
			if(itemId == null)
				throw new Exception(IDENTIFIER_IS_NULL);	
			
			Workspace workspace = getWorkspace();

			workspaceLogger.trace("removeItem item for id: "+itemId);

			//NOTIFICATION
			WorkspaceItem wsItem = workspace.getItem(itemId);
			
			//SAVING ATTRIBUTE FOR NOTIFICATION
			boolean sourceItemIsShared = wsItem.isShared();
			String itemName = wsItem.getName();
			String sourceFolderSharedId = null;

			if(sourceItemIsShared){
				sourceFolderSharedId = wsItem.getIdSharedFolder();
			}
			
			//REMOVE ITEM
			workspace.removeItem(itemId);
			
			//IF SOURCE SHARED FOLDER IS NOT NULL
			if(sourceFolderSharedId!=null)
				NotificationsUtil.checkSendNotifyRemoveItemToShare(this.getThreadLocalRequest().getSession(), sourceItemIsShared, itemName, itemId, sourceFolderSharedId);
			
			
			return Boolean.TRUE;
			
		} catch (InsufficientPrivilegesException e) {
			workspaceLogger.error("Error in server Item remove", e);
			String error = "An error occurred on deleting item. "+e.getMessage();
			throw new Exception(error);

		}catch (ItemNotFoundException e) {
			String error = "An error occurred on deleting item. "+ConstantsExplorer.ERROR_ITEM_DOES_NOT_EXIST;
			workspaceLogger.error(error, e);
			throw new Exception(error);
		} catch (Exception e) {
			workspaceLogger.error("Error in server Item remove", e);
			String error = ConstantsExplorer.SERVER_ERROR +" deleting item. "+e.getMessage();
			throw new Exception(error);
		}

	}

	@Override
	public Boolean renameItem(String itemId, String newName, String previousName) throws Exception {
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {
			
			if(itemId == null)
				throw new Exception(IDENTIFIER_IS_NULL);	
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("rename item itemId: "+itemId+" old name "+ previousName +", new name: "+newName);

			workspace.renameItem(itemId, newName);

			//NOTIFIER
			WorkspaceItem wsItem = workspace.getItem(itemId);
			
			if(wsItem.isShared()){
				
				try{
					List<InfoContactModel> listSharedContact = new ArrayList<InfoContactModel>();
					NotificationsProducer notification = getNotificationProducer();
					listSharedContact = getListUserSharedByFolderSharedId(wsItem.getIdSharedFolder());
					if(NotificationsUtil.isASharedFolder(wsItem)){
						notification.notifyFolderRenamed(listSharedContact, wsItem, previousName, newName, wsItem.getIdSharedFolder());
					}else{
						WorkspaceFolder sharedFolder = (WorkspaceFolder) workspace.getItem(wsItem.getIdSharedFolder());
						notification.notifyItemRenamed(listSharedContact, previousName, wsItem, sharedFolder);
					}
				}catch (Exception e) {
					workspaceLogger.error("An error occurred in checkNotify ", e);
					return true;
				}
			}

			return true;

		} catch (ItemAlreadyExistException e) {
			String error = "An error occurred on renaming item, "  +e.getMessage();
			workspaceLogger.error(error, e);
			throw new Exception(error);
		}catch (ItemNotFoundException e2) {
			String error = "An error occurred on renaming item. "+ConstantsExplorer.ERROR_ITEM_DOES_NOT_EXIST;
			workspaceLogger.error(error, e2);
			throw new Exception(error);
		} catch (Exception e) {
			String error = ConstantsExplorer.SERVER_ERROR + " renaming item. "+ConstantsExplorer.TRY_AGAIN;
			workspaceLogger.error(error, e);
			throw new Exception(error);
		}
	}
	
	@Override
	public FolderModel createFolder(String nameFolder, String description, FileModel parent) throws Exception {
		
		workspaceLogger.trace("create folder: "+nameFolder +" parent is null"+parent==null);

		try {
			
			if(nameFolder == null)
				throw new Exception("Folder name is null");	
			
			Workspace workspace = getWorkspace();

			WorkspaceFolder wsFolder = workspace.createFolder(nameFolder, description, parent.getIdentifier());

			WorkspaceItem folderDestinationItem = workspace.getItem(parent.getIdentifier());
			
			checkNotifyAddItemToShare(wsFolder, null, folderDestinationItem);
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTFolderModelItem(wsFolder, parent);

		} catch (Exception e) {
			workspaceLogger.error("Error in server create folder", e);
			throw new Exception(e.getMessage());
		}
		
	}

	@Override
	public FileDetailsModel getDetailsFile(FileModel folder) throws Exception {
		
		try {
			
			if(folder == null)
				throw new Exception("Folder is null");	
			
			workspaceLogger.trace("load file details: " + folder.getName());
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(folder.getIdentifier());
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGWTWorkspaceFileDetails(wsItem, folder);

		} catch (Exception e) {
			workspaceLogger.error("Error in load server file details", e);
			throw new Exception(e.getMessage());
		}
	}
	
	
	@Override
	public ArrayList<SubTree> getChildrenSubTreeToRootByIdentifier(String itemIdentifier) throws Exception {
		
		ArrayList<SubTree>  listSubTree = new ArrayList<SubTree>();
		
		try {
			
			if(itemIdentifier == null)
				throw new Exception(IDENTIFIER_IS_NULL);	
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("search itemId: "+itemIdentifier);
			
			WorkspaceItem item = workspace.getItem(itemIdentifier); //get item from workspace	
			getListsChildrenByParents(listSubTree, item);
			Collections.reverse(listSubTree); //reverse order of array
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server find Item", e);
			throw new Exception(e.getMessage());
		}
		
		return listSubTree;
	}
	
	@Override
	public List<FileGridModel> getSmartFolderResultsByCategory(String category) throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get smart folder by category: "+category);

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<SearchItem> listWorkspaceItems = new ArrayList<SearchItem>();
			
			//Category IMAGES
			if(category.equals(GXTCategoryItemInterface.SMF_IMAGES.toString())){
					
				listWorkspaceItems = workspace.getFolderItems(FolderItemType.IMAGE_DOCUMENT, FolderItemType.EXTERNAL_IMAGE);
				
			//Category BIODIVERSITY
			}else if(category.equals(GXTCategoryItemInterface.SMF_BIODIVERSITY.toString())){
					
				listWorkspaceItems = workspace.getFolderItems(FolderItemType.AQUAMAPS_ITEM);

			//Category DOCUMENTS
			}else if(category.equals(GXTCategoryItemInterface.SMF_DOCUMENTS.toString())){
					
				listWorkspaceItems = workspace.getFolderItems(
						FolderItemType.EXTERNAL_FILE, 
						FolderItemType.EXTERNAL_PDF_FILE,
						FolderItemType.QUERY,
						FolderItemType.PDF_DOCUMENT,
						FolderItemType.METADATA,
						FolderItemType.WORKFLOW_REPORT,
						FolderItemType.WORKFLOW_TEMPLATE,
//						FolderItemType.URL_DOCUMENT,
						FolderItemType.DOCUMENT
						);
					
					//Category LINKS
			}else if(category.equals(GXTCategoryItemInterface.SMF_LINKS.toString())){
				
				listWorkspaceItems = workspace.getFolderItems(FolderItemType.EXTERNAL_URL, FolderItemType.URL_DOCUMENT, FolderItemType.EXTERNAL_RESOURCE_LINK);
								
					//Category REPORTS
			}else if(category.equals(GXTCategoryItemInterface.SMF_REPORTS.toString())){
			
				listWorkspaceItems = workspace.getFolderItems(FolderItemType.REPORT_TEMPLATE, FolderItemType.REPORT);
	
					//Category TIME SERIES
			}else if(category.equals(GXTCategoryItemInterface.SMF_TIMESERIES.toString())){
					
				listWorkspaceItems = workspace.getFolderItems(FolderItemType.TIME_SERIES);
			}
			else
				new Exception("Smart folder category unknown");

			
			return builder.filterListFileGridModelItemByCategory(listWorkspaceItems, category);

		
		} catch (Exception e) {
			workspaceLogger.error("Error in server get smart folder by category", e);
			throw new Exception(e.getMessage());
		}
		
	}

	private void getListsChildrenByParents(ArrayList<SubTree> listSubTree, WorkspaceItem item) throws Exception{
  	
	  	if(item==null || item.getParent()==null){
	//  		listParents.add(item);
	  		return;
	  	}
	  	
	  	FolderModel parentModel = new FolderModel(item.getParent().getId(), item.getParent().getName(), null, true, item.getParent().isShared()); //Create parent model
	  	
		List<FileModel> childrenList = getFolderChildren(parentModel); //create children list
		
		SubTree subTree = new SubTree(parentModel, childrenList);
	  	
		listSubTree.add(subTree);
  	
		getListsChildrenByParents(listSubTree, item.getParent());
  }

	@Override
	public SmartFolderModel createSmartFolder(String name, String description, String query) throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();

			workspaceLogger.trace("create smart folder by name: "+name);	
			workspaceLogger.trace("description " + description);
			workspaceLogger.trace("query " + query);

			WorkspaceSmartFolder wsSmartFolder  = workspace.createSmartFolder(name, description, query); //create Smart Folder from workspace	
			
			workspaceLogger.trace("create : " +wsSmartFolder.getName()  + " id "+ wsSmartFolder.getId());

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTSmartFolderModel(wsSmartFolder,query);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server create smart folder by name: ", e);
//			workspaceLogger.trace("Error in server create smart folder by id " + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}
	
	
	@Override
	public Boolean removeSmartFolder(String itemId, String name) throws Exception {
		
		if(itemId==null)
			return null;
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("remove smart folder by id: "+itemId);
			
			workspace.removeItem(itemId); //remove Smart Folder from workspace	
			
			return true;
		
		} catch (Exception e) {
			workspaceLogger.error("Error in remove smart folder by id: ", e);
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public List<SmartFolderModel> getAllSmartFolders() throws Exception{
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get all smart folder");
			
			List<WorkspaceSmartFolder> listWorkspaceFolder = new ArrayList<WorkspaceSmartFolder>();
			
			listWorkspaceFolder = workspace.getAllSmartFolders(); //create Smart Folder from workspace	
			
			workspaceLogger.trace("list smart folders size" + listWorkspaceFolder.size());
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
		
			return builder.buildGXTListSmartFolderModel(listWorkspaceFolder);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server get all smart folder: ", e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public List<FileGridModel> getSmartFolderResultsById(String folderId) throws Exception {

		if(folderId == null)
			return null;
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get smart folder by id: "+folderId);
			
			WorkspaceSmartFolder wsSmartFolder  = workspace.getSmartFolder(folderId); //get Smart Folder from workspace	
			
			workspaceLogger.trace("wsFolder " + wsSmartFolder.getName());
		
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			workspaceLogger.trace(" children size "+wsSmartFolder.getSearchItems().size());
			
			return builder.buildGXTListFileGridModelItemForSearch((List<SearchItem>) wsSmartFolder.getSearchItems());
		
		} catch (Exception e) {
			workspaceLogger.error("Error in get server smart folder by id", e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public GWTWorkspaceItem getImageById(String identifier, boolean isInteralImage, boolean fullDetails) throws Exception {
		
		if(identifier==null)
			return null;
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get image by id: "+identifier);
			
			WorkspaceItem item = workspace.getItem(identifier); //get item from workspace	
			
			//ACCOUNTING READ
			item.markAsRead(true);
			
			workspaceLogger.trace("item name " + item.getName());
		
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGWTWorkspaceImage(item, isInteralImage, fullDetails);

		} catch (Exception e) {
			workspaceLogger.error("Error in server get image by id", e);
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public GWTWorkspaceItem getTimeSeriesById(String identifier) throws Exception {
		
		if(identifier==null)
			return null;
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get timeseries by id: "+identifier);
			
			WorkspaceItem item = workspace.getItem(identifier); //get item from workspace	
			
			workspaceLogger.trace("item name " + item.getName());
		
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGWTTimeSeries((TimeSeries)item, null);
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server get timeseries by id", e);
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public GWTWorkspaceItem getUrlById(String identifier, boolean isInternalUrl, boolean fullDetails) throws Exception {
		
		try {
			
			if(identifier==null)
				throw new Exception(IDENTIFIER_IS_NULL);
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get url by id: "+identifier);
			
			WorkspaceItem item = workspace.getItem(identifier); //get item from workspace	
			
			workspaceLogger.trace("item name " + item.getName());
		
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
//			return builder.buildGXTImage(item, isInteralImage, fullDetails);
			
			return builder.buildGWTWorspaceUrl(item, isInternalUrl, fullDetails);
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server get image by id ", e);
//			workspaceLogger.trace("Error in server get image by id  " + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public FileModel createExternalUrl(FileModel parentFileModel, String name, String description, String url) throws Exception {
		
	try {
			Workspace workspace = getWorkspace();
			
			if(parentFileModel==null)
				throw new Exception("Parent item is null");
			
			workspaceLogger.trace("create url in parent id: "+parentFileModel.getIdentifier());
			
			//DEBUG
//			workspaceLogger.trace("Name " + name);
//			workspaceLogger.trace("description " + description);
//			workspaceLogger.trace("url " + url);
//			workspaceLogger.trace("parentFileModel " + parentFileModel.getIdentifier() + " " + parentFileModel.getName());	
//			if(description == null) 
//				description = "";
			
			ExternalUrl ext = workspace.createExternalUrl(name, description, url, parentFileModel.getIdentifier());

			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
			workspaceLogger.trace("parent name " + parent.getName());

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTFileModelItem(ext, parentFileModel);
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server create url in parent id ", e);
//			workspaceLogger.trace("Error in server create url in parent id " + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public String getURLFromApplicationProfile(String oid) throws Exception {
		
		String urlPortlet = "";

		ApplicationReaderFromGenericResource app = new ApplicationReaderFromGenericResource();
		
		try{
			
			if(oid==null)
				throw new Exception(IDENTIFIER_IS_NULL);

			ASLSession session = WsUtil.getAslSession(this.getThreadLocalRequest().getSession());
			
			if(WsUtil.isVRE(session)){
				
				ScopeProvider.instance.set(session.getScope());
				
				// GET WORKSPACE
				Workspace workspace = HomeLibrary.getUserWorkspace(session.getUsername());

				// GET ITEM FROM WORKSPACE
				WorkspaceItem item = workspace.getItem(oid);
				
				// ITEM IS A WorkspaceItemType.FOLDER_ITEM?
				if (item.getType().equals(WorkspaceItemType.FOLDER_ITEM)) {
					FolderItem folderItem = (FolderItem) item;
					
					if(folderItem.getFolderItemType().equals(FolderItemType.REPORT)){
						setValueInSession("idreport", oid);
						
					}else if(folderItem.getFolderItemType().equals(FolderItemType.REPORT_TEMPLATE)){
						setValueInSession("idtemplate", oid);
						
					}
				
					return "";
				}
			}
			else
				urlPortlet = app.getURLFromApplicationProfile(oid, WsUtil.getAslSession(this.getThreadLocalRequest().getSession()),this.getThreadLocalRequest().getSession());
	
		} catch (Exception e) {
			workspaceLogger.error("getURLFromApplicationProfile", e);
			throw new Exception("Sorry, an error occurred in retrieve application profile, try again");
		}
		
		return urlPortlet;
	}
	
	@Override
	public void setValueInSession(String name, String value) throws Exception {
		
		try{

			ASLSession session = WsUtil.getAslSession(this.getThreadLocalRequest().getSession());
			session.setAttribute(name, value);
			workspaceLogger.trace("set value in session with name: "+name+", value: "+value);
//			workspaceLogger.debug("WS Session Id = " + session.getExternalSessionID());
//			System.out.println("set value in session with name: "+name+", value: "+value);
			

		} catch (Exception e) {
			workspaceLogger.error("setValueInSession", e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public List<ScopeModel> getAllScope() throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get all scope");

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			ScopeUtilFilter scopeUtilFilter = getScopeUtilFilter();

			Home home = workspace.getHome();
			if(home!=null){
				List<String> listIdFilterdScope = scopeUtilFilter.convertListScopeToPortlet(home.listScopes());
				return builder.buildGXTListScopeModel(listIdFilterdScope, scopeUtilFilter.getHashScopesFiltered());
			}else{
				workspaceLogger.error("workspace.getHome() is null");
				throw new Exception("Sorry, an error occurred on getting all scope. Please try later");
			}
				
		} catch (Exception e) {
			workspaceLogger.error("Error in server get all scope ", e);
			e.printStackTrace();
//			workspaceLogger.trace("Error in server get all scope " + e.getMessage());
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public List<InfoContactModel> getAllContacts() throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get all contacts");
		
//			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
//			 workspace.getAllScope();

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			if(isTestMode()){
				
				workspaceLogger.warn("WORKSPACE PORTLET IS IN TEST MODE - RETURN TEST USERS");
				List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
//				//TEST USERS
				listContactsModel.add(new InfoContactModel("federico.defaveri", "federico.defaveri", "Federico de Faveri"));
				listContactsModel.add(new InfoContactModel("antonio.gioia", "antonio.gioia", "Antonio Gioia"));
				listContactsModel.add(new InfoContactModel("fabio.sinibaldi", "fabio.sinibaldi", "Fabio Sinibaldi"));
				listContactsModel.add(new InfoContactModel("pasquale.pagano", "pasquale.pagano", "Pasquale Pagano"));
				listContactsModel.add(new InfoContactModel(WsUtil.TEST_USER, WsUtil.TEST_USER, WsUtil.TEST_USER_FULL_NAME));
				listContactsModel.add(new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa"));
				listContactsModel.add(new InfoContactModel("massimiliano.assante", "massimiliano.assante", "Massimiliano Assante"));
				return listContactsModel;
				
			}

			UserManager userManag = new LiferayUserManager();
			GroupManager gm = new LiferayGroupManager();
			String groupId = gm.getRootVO().getGroupId();
			workspaceLogger.trace("user manager getting list users by group: "+groupId);
			return builder.buildGXTListContactsModel(userManag.listUsersByGroup(groupId));
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server get all contacts ", e);
//			return new ArrayList<InfoContactModel>();
			throw new Exception(e.getMessage());
		}
	}

//	@Override
//	public boolean sendTo(List<InfoContactModel> listContacts, List<FileModel> listAttachments, String subject, String text) throws Exception {
//		
//		try {
//			
//			Workspace workspace = getWorkspace();
//			
//			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
//			logger.info("sendTo");
//			
////			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
////			 workspace.getAllScope();
//			
//			workspaceLogger.trace("######### SEND TO: ");
//			workspaceLogger.trace("subject " + subject);
//			workspaceLogger.trace("text " + text);
//			
//			
//			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
//			
//			return true; 
//			
//		} catch (Exception e) {
//			workspaceLogger.error("Error in server sendTo ", e);
//			workspaceLogger.trace("Error in server get sendTo " + e.getMessage());
//			//GWT can't serialize all exceptions
//			throw new Exception(e.getMessage());
//		}
//	}

	@Override
	public boolean sendToById(List<String> listContactsId, List<String> listAttachmentsId, String subject, String body)  throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();

			workspaceLogger.trace("######### SEND TO: ");
			workspaceLogger.trace("subject " + subject);
			workspaceLogger.trace("body " + body);
			
			for(String contactId : listContactsId)
			workspaceLogger.trace("contactId " + contactId);
			
			for(String id : listAttachmentsId)
				workspaceLogger.trace("attachId " + id);

			workspace.getWorkspaceMessageManager().sendMessageToPortalLogins(subject, body, listAttachmentsId, listContactsId);
			
			return true; 
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server sendTo ", e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
		
	}

	@Override
	public List<MessageModel> getAllMessagesSent() throws Exception {
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get All Messages Sent ");

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().getSentMessages();
			
			return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_SENT); 
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server getAllMessagesSent ", e);
//			workspaceLogger.trace("Error in server get getAllMessagesSent " + e.getMessage());
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public List<MessageModel> getAllMessagesReceived() throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();

			workspaceLogger.trace("get All Messages Received ");

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().getReceivedMessages();
			
			return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_RECEIVED); 
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server getAllMessagesReceived ", e);
//			workspaceLogger.trace("Error in server get getAllMessagesReceived " + e.getMessage());
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public MessageModel getMessageById(String messageIdentifier, String messageType) throws Exception {
	
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("get Message by Id: "+messageIdentifier);
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			WorkspaceMessage message = null;
			if(messageType.equals(GXTCategoryItemInterface.MS_RECEIVED))
				 message = workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier);
			else
				 message = workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier);
			
			
			List<WorkspaceItem> listWorkspaceItems = getListWorkspaceItemById(workspace,message.getAttachmentsIds());
			
			return builder.buildGXTMessageModel(message, listWorkspaceItems, messageType);
			
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server get Message by Id ", e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}
	
	
	private List<WorkspaceItem> getListWorkspaceItemById(Workspace workspace, List<String> listItemsId) throws ItemNotFoundException, InternalErrorException{
		
		List<WorkspaceItem> listWorkspaceItem = new ArrayList<WorkspaceItem>();
		
		for(String itemId: listItemsId){
			
			WorkspaceItem item = workspace.getItem(itemId);
			
			workspaceLogger.trace("Attach name: " +item.getName());
			workspaceLogger.trace("Attach id: " +item.getId());
			
			listWorkspaceItem.add(workspace.getItem(itemId)); //get item from workspace	
		}
		
		return listWorkspaceItem;
		
		
	}
	
	@Override
	public List<BulkCreatorModel> getListFolderBulkCreator() throws Exception {

	/*	try {
				Workspace workspace = getWorkspace();
				
				List<FolderBulkCreator> listFBC = workspace.getFolderBulkCreatorManager().getActiveFolderBulkCreators();
				
				GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
				
				return builder.buildGXTListBulkCreatorModel(listFBC);

			} catch (Exception e) {
				workspaceLogger.error("Error in getNewFolderBulkCreator ", e);
//				workspaceLogger.trace("Error in getNewFolderBulkCreator " + e.getMessage());
				//GWT can't serialize all exceptions
				throw new Exception(e.getMessage());
			}
		
		*/
		return null;
	}

	@Override
	public boolean sentToByMessageModel(MessageModel message) throws Exception {
		return false;
	}

	@Override
	public boolean saveAttachments(String messageIdentifier, String messageType) throws Exception {

		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace(" save attachments by messageIdentifier " + messageIdentifier);
			if(messageType.equals(GXTCategoryItemInterface.MS_SENT))
				workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).saveAttachments(workspace.getRoot().getId());
			else
				workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).saveAttachments(workspace.getRoot().getId());
			
			return true;
			
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server save attachments by messageIdentifier ", e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public boolean saveAttach(String attachId) throws Exception {
		// TODO NOT USED
		return false;
	}

	@Override
	public boolean markMessage(String messageIdentifier, String messageType, boolean boolMark, String markType) throws Exception {
		
		try {

			Workspace workspace = getWorkspace();

			workspaceLogger.trace(" markMessageAsRead by messageIdentifier " + messageIdentifier + " boolMark " + boolMark + " messageType " +messageType);
			
			if(messageType.equals(GXTCategoryItemInterface.MS_RECEIVED)){
				
//				workspaceLogger.trace("#######################################Message identifier: "+messageIdentifier);
//				workspaceLogger.trace("#######################################Message messageType: "+messageType);
				
				if(markType.equals("READ")){
					workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).setStatus(boolMark);
				}else if(markType.equals("OPEN")){
					workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).open();
				}else if(markType.equals("BOTH")){
					workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).setStatus(boolMark);
					workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).open();
				}
			}
			
			else{
				
//				workspaceLogger.trace("#######################################Message sent identifier: "+messageIdentifier);
//				workspaceLogger.trace("#######################################Message sent messageType: "+messageType);
				
				if(markType.equals("READ")){
					workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).setStatus(boolMark);
				}else if(markType.equals("OPEN")){
					workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).open();
				}else if(markType.equals("BOTH")){
					workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).setStatus(boolMark);
					workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).open();
				}
			}
				
			
			return true;
			
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server markMessageAsRead by messageIdentifier ", e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public boolean deleteMessage(String messageIdentifier, String messageType) throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("deleteMessage by messageIdentifier " + messageIdentifier);
			
			if(messageType.equals(GXTCategoryItemInterface.MS_RECEIVED))
				workspace.getWorkspaceMessageManager().deleteReceivedMessage(messageIdentifier);
			else
				workspace.getWorkspaceMessageManager().deleteSentMessage(messageIdentifier);
			
			return true;
			
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server deleteMessage by messageIdentifier ", e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}


	public List<MessageModel> getNewMessagesReceived() throws Exception {

		try {
			
			Workspace workspace = getWorkspace();

			int count = workspace.getWorkspaceMessageManager().getMessagesNotOpened();
			
			List<MessageModel> listMessageModels = new ArrayList<MessageModel>();
			
			for(int i=0; i<count; i++)
				listMessageModels.add(new MessageModel());
			
			return listMessageModels;
			
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server getNewMessagesReceived by messageIdentifier ", e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
		
	}
	
	
	@Override
	public List<MessageModel> searchInSentMessagesByText(String text) throws Exception {
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("searchInSentMessagesByText "+text);
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().searchOutMessages(text);
			
			return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_SENT); 
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server searchInSentMessagesByText ", e);
//			workspaceLogger.trace("Error in server searchInSentMessagesByText " + e.getMessage());
			throw new Exception(e.getMessage());
		}
	}
	
	
	@Override
	public List<MessageModel> searchInReceivedMessagesByText(String text) throws Exception {
		try {
			
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("searchInSentMessagesByText: "+text);

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().searchInMessages(text);
			
			return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_RECEIVED); 
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server searchInSentMessagesByText ", e);
//			workspaceLogger.trace("Error in server searchInSentMessagesByText " + e.getMessage());
			throw new Exception(e.getMessage());
		}
	}

	

	@Override
	public boolean copyItem(String itemId, String destinationFolderId) throws Exception {
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {

			Workspace workspace = getWorkspace();
			
			WorkspaceItem sourceItem = workspace.getItem(itemId); //GET SOURCE ITEM BEFORE COPY
			String sourceSharedId = sourceItem.getIdSharedFolder();
	
			workspaceLogger.trace("copyItem by id: " + itemId);

			WorkspaceItem item = workspace.copy(itemId, destinationFolderId);  //copy item
			
			WorkspaceItem folderDestinationItem = workspace.getItem(destinationFolderId);
			
			checkNotifyAddItemToShare(sourceItem, sourceSharedId, folderDestinationItem);
															
			if(item!=null)
				return true;
			
			return false;
		}catch (InsufficientPrivilegesException e) {
			String error = "An error occurred on copying item, "  +e.getMessage() + ". "+ConstantsExplorer.TRY_AGAIN;
			throw new Exception(error);

		}catch (ItemAlreadyExistException e) {
			String error = "An error occurred on copying item, "  +e.getMessage();
			throw new Exception(error);
		} catch (Exception e) {
			workspaceLogger.error("Error in server copyItem  by id", e);
			String error  = ConstantsExplorer.SERVER_ERROR +" copying item "  + ConstantsExplorer.TRY_AGAIN;
			throw new Exception(error);
		}
	}
	
	
	@Override
	public boolean copyItems(List<String> idsItem, String destinationFolderId) throws Exception {
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {

			Workspace workspace = getWorkspace();
			boolean error = false;
			
			for (String itemId : idsItem) {

				WorkspaceItem sourceItem = workspace.getItem(itemId); //GET SOURCE ITEM BEFORE COPY
				String sourceSharedId = sourceItem.getIdSharedFolder();
		
				workspaceLogger.trace("copyItem by id: " + itemId);
	
				WorkspaceItem item = workspace.copy(itemId, destinationFolderId);  //copy item
				
				WorkspaceItem folderDestinationItem = workspace.getItem(destinationFolderId);
				
				checkNotifyAddItemToShare(sourceItem, sourceSharedId, folderDestinationItem);
						
				if(item==null){
					error = true;
					break;
				}
			}
			
			if(error)
				return false; //Copied is false
			
			return true; //copied is true

		}catch (InsufficientPrivilegesException e) {
			String error = "An error occurred on copying item, "  +e.getMessage() + ". "+ConstantsExplorer.TRY_AGAIN;
			throw new Exception(error);

		}catch (ItemAlreadyExistException e) {
			String error = "An error occurred on copying item, "  +e.getMessage();
			throw new Exception(error);
		} catch (Exception e) {
			workspaceLogger.error("Error in server copyItem  by id", e);
			String error  = ConstantsExplorer.SERVER_ERROR +" copying item "  + ConstantsExplorer.TRY_AGAIN;
			throw new Exception(error);
		}
	}

	@Override
	public boolean deleteBulk(String bulkId) throws Exception {
		
		try {
			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("delete bulk " + bulkId);

			workspace.getFolderBulkCreatorManager().getActiveFolderBulkCreator(bulkId).remove();
			
			return true;

		} catch (Exception e) {
			workspaceLogger.error("Error in getNewFolderBulkCreator ", e);
//			workspaceLogger.trace("Error in getNewFolderBulkCreator " + e.getMessage());
			throw new Exception(e.getMessage());
		}
		
	}

	@Override
	public String getUrlWebDav(String itemId) throws Exception {
		
		try {
			Workspace workspace = getWorkspace();

			workspaceLogger.trace("getWebDavUrl" + itemId);

			return workspace.getUrlWebDav();

		} catch (Exception e) {
			workspaceLogger.error("Error in getNewFolderBulkCreator ", e);
//			workspaceLogger.trace("Error in getNewFolderBulkCreator " + e.getMessage());
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public boolean shareFolder(FileModel folder, List<InfoContactModel> listContacts, boolean isNewFolder) throws Exception {
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		try {

			Workspace workspace = getWorkspace();
			
			workspaceLogger.trace("shareFolder "+ folder.getIdentifier() 
					+ " name: "+ folder.getName() 
//					+ " parent name: " + folder.getParentFileModel().getName()
					+ " listContacts size: " + listContacts.size());
			
//			//DEBUG
			//System.out.println("shareFolder "+ folder.getIdentifier() + " name: "+ folder.getName() + " parent name: " + folder.getParentFileModel().getName() + " listContacts size: " + listContacts.size());
			
//			for (InfoContactModel infoContactModel : listContacts) {
//				System.out.println("share with "+ infoContactModel.getLogin());
//			}
			
			printContacts(listContacts);

			List<String> listLogin = UserUtil.getListLoginByInfoContactModel(listContacts);
			
			WorkspaceSharedFolder sharedFolder = null;
			
			List<InfoContactModel> listSharedContact = null;
			
			boolean sourceFolderIsShared = folder.isShared();
			
			if(sourceFolderIsShared){ //if source folder is already share... retrieve old list of sharing to notify
				listSharedContact = getListUserSharedByFolderSharedId(folder.getIdentifier());
			}

			if(listLogin.size()>0){
				
				if(!isNewFolder){
					sharedFolder = workspace.shareFolder(listLogin, folder.getIdentifier());
					sharedFolder.setDescription(folder.getDescription()); //SET NEW DESCRIPTION
				}
				else
					sharedFolder = workspace.createSharedFolder(folder.getName(), folder.getDescription(), listLogin, folder.getParentFileModel().getIdentifier());
			}
			
			boolean created = sharedFolder==null?false:true;

			
			if(created){
				NotificationsProducer np = getNotificationProducer();
				if(!sourceFolderIsShared) //if source folder is not already shared
					np.notifyFolderSharing(listContacts, sharedFolder);
				else{
					System.out.println("SHARED CONTACS: ");
					printContacts(listSharedContact);
					System.out.println("NEW CONTACS: ");
					printContacts(listContacts);
					np.notifyAddedUsersToSharing(listSharedContact, listContacts, sharedFolder);
				}
			}
				
			return created;

		} catch (InsufficientPrivilegesException e) {
			workspaceLogger.error("Error in shareFolder ", e);
			String error = "An error occurred on creating shared folder. "+ e.getMessage();
			throw new Exception(error);
			
		} catch (ItemAlreadyExistException e) {
			workspaceLogger.error("Error in shareFolder ", e);
			String error = "An error occurred on creating shared folder. "+ e.getMessage();
			throw new Exception(error);
			
		} catch (WrongDestinationException e) {
			workspaceLogger.error("Error in shareFolder ", e);
			String error = "An error occurred on creating shared folder. "+ e.getMessage();
			throw new Exception(error);

		} catch (Exception e) {
			workspaceLogger.error("Error in shareFolder ", e);
			e.printStackTrace();
			String error = ConstantsExplorer.SERVER_ERROR+" creating shared folder.";
			throw new Exception(error);
		}
	}

	@Override
	public List<InfoContactModel> getListUserSharedByFolderSharedId(String folderSharedId) throws Exception{
		
		workspaceLogger.trace("getListUserSharedByFolderSharedId "+ folderSharedId);

		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(folderSharedId);
			
			if(NotificationsUtil.isASharedFolder(wsItem)){
				
				WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;

				GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

				List<String> listPortalLogin = wsFolder.getUsers();

				workspaceLogger.trace("getListUserSharedByFolderSharedId return "+ listPortalLogin.size() + " user");

				if(isTestMode())
					return builder.buildGxtInfoContactFromPortalLoginTestMode(listPortalLogin);
				
				return builder.buildGxtInfoContactsFromPortalLogins(listPortalLogin);
				
			}
			else{
				workspaceLogger.trace("the item with id: "+folderSharedId+ " is not  "+WorkspaceItemType.SHARED_FOLDER);
				
				//DEBUG
				//System.out.println("the item with id: "+folderSharedId+ " is not  "+WorkspaceItemType.SHARED_FOLDER);
			}
			return new ArrayList<InfoContactModel>();
		
		} catch (Exception e) {
			workspaceLogger.error("Error in getListUserSharedByItemId ", e);
			throw new Exception(e.getMessage());
		}
	}
	
	
	@Override
	public List<InfoContactModel> getListUserSharedBySharedItem(String sharedItemId) throws Exception{
		
		workspaceLogger.trace("getListUserSharedBySharedItem "+ sharedItemId);

		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(sharedItemId);
			
			if(wsItem!=null && wsItem.isShared()){
				
				WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) workspace.getItem(wsItem.getIdSharedFolder());

				if(wsFolder!=null){
	
					GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
	
					List<String> listPortalLogin = wsFolder.getUsers();
	
					workspaceLogger.trace("getListUserSharedByFolderSharedId return "+ listPortalLogin.size() + " user");
	
					if(isTestMode())
						return builder.buildGxtInfoContactFromPortalLoginTestMode(listPortalLogin);
					
					
					return builder.buildGxtInfoContactsFromPortalLogins(listPortalLogin);
				}
		
			}
			return new ArrayList<InfoContactModel>();
		
		} catch (Exception e) {
			workspaceLogger.error("Error in getListUserSharedByItemId ", e);
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public boolean unSharedFolderByFolderSharedId(String folderSharedId) throws Exception{
		
		boolean unShared = false;
		
		if(isSessionExpired())
			throw new SessionExpiredException();
		
		workspaceLogger.trace("unSharedFolderByFolderSharedId "+ folderSharedId);
		try {
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(folderSharedId);
			
			workspaceLogger.trace("workspace return an item with name "+wsItem.getName());
			
			if(wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
				
				WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;

//				WorkspaceFolder unSharedFolder = wsFolder.unShare();
//				unShared = unSharedFolder==null?false:true;	
				
				//TEMPORARY SOLUTION
				wsFolder.unShare();
				unShared = true;
//				System.out.println("unShared is "+unShared);
				
				workspaceLogger.trace("unShared is "+ unShared);
				
				
				/* INTERNAL POLICY, UN SHARE NOT SHOULD PRODUCE NOTIFICATIONS
				if(unShared){
					NotificationsProducer np = getNotificationProducer();
					
					List<InfoContactModel> contacts = getListUserSharedByFolderSharedId(folderSharedId);
								
//					if(isTestMode()){
//						contacts = new ArrayList<InfoContactModel>();
//						contacts.add(new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa"));
//					}
					workspaceLogger.trace("UNSHARE WITH: ");
					printContacts(contacts);
					
					np.notifyFolderUnSharing(contacts, unSharedFolder);
				}
				
				*/

			}
			else
				workspaceLogger.trace("the item with id: "+folderSharedId+ "is not  "+WorkspaceItemType.SHARED_FOLDER);
			
		} catch (InternalErrorException e) {
			workspaceLogger.error("Error in unSharedFolderByFolderSharedId ", e);
			String error = "An error occerred on unsharing folder. "+ e.getMessage();
			throw new Exception(error);
			
		} catch (Exception e) {
			workspaceLogger.error("Error in unSharedFolderByFolderSharedId ", e);
			String error = ConstantsExplorer.SERVER_ERROR+" un share folder. Refresh folder and " +ConstantsExplorer.TRY_AGAIN;
			e.printStackTrace();
			throw new Exception(error);
		}
		
		return unShared;
	}

	/**
	 * 
	 * @param itemIdentifier
	 * @param includeItemAsParent -  if parameter is true and item passed in input is a folder, the folder is included in path returned as last parent
	 * @return
	 * @throws Exception
	 */
	@Override
	public List<FileModel> getListParentsByItemIdentifier(String itemIdentifier, boolean includeItemAsParent) throws Exception {
		List<FileModel> listParents = new ArrayList<FileModel>();
		workspaceLogger.trace("get List Parents By Item Identifier "+ itemIdentifier);
		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(itemIdentifier);
			
			workspaceLogger.trace("workspace retrieve item name: "+wsItem.getName());
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			if(includeItemAsParent==true && wsItem.getType().equals(WorkspaceItemType.FOLDER)){
				listParents.add(builder.buildGXTFolderModelItem((WorkspaceFolder) wsItem, null));
			}
			
			while(wsItem!=null && wsItem.getParent()!=null){
				
				WorkspaceFolder wsFolder = wsItem.getParent();
				listParents.add(builder.buildGXTFolderModelItem(wsFolder, null));
				wsItem = wsFolder;
			}
			
			Collections.reverse(listParents);

			//SET PARENTS
			for(int i=0; i<listParents.size()-1; i++){
				
				FileModel parent = listParents.get(i);
				FileModel fileModel = listParents.get(i+1);
				
				fileModel.setParentFileModel(parent);
			}

			workspaceLogger.trace("list parents return size: "+listParents.size());
			
		} catch (Exception e) {
			workspaceLogger.error("Error in get List Parents By Item Identifier ", e);
			e.printStackTrace();
			throw new Exception(e.getMessage());
		}

		return listParents;
	}

	@Override
	public InfoContactModel getOwnerByItemId(String itemId) throws Exception {
		
		workspaceLogger.trace("get Owner By ItemId "+ itemId);
		try {
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(itemId);

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTInfoContactModel(wsItem.getOwner());
			
		} catch (Exception e) {
			workspaceLogger.error("Error in getOwnerByItemId ", e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public String itemExistsInWorkpaceFolder(String parentId, String itemName) throws Exception {
		
		workspaceLogger.trace("get itemExistsInWorkpace by parentId: "+parentId);
		System.out.println("get itemExistsInWorkpace by parentId: "+parentId);
		
		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(parentId); //GET PARENT
			
			if(wsItem.getType().equals(WorkspaceItemType.FOLDER) || wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
				
				WorkspaceItem itemFound = workspace.find(itemName, parentId);
				
				if(itemFound==null)
					return null;
				
				return itemFound.getId();
			}
			else
				throw new Exception("Invalid Folder parent");

			
		} catch (InternalErrorException e) {

			return null;
			
		} catch (ItemNotFoundException e) {

			return null;
			
		} catch (Exception e) {
			String error = "an error occurred on search item in folder ";
			workspaceLogger.error(error, e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public Date getItemCreationDateById(String itemId) throws Exception {
		workspaceLogger.trace("get Item Creation Date By ItemId "+ itemId);
		try {
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(itemId);

			Calendar cl = wsItem.getCreationTime();
			
			if(cl!=null)
				return  cl.getTime();
			
			return null;
			
		} catch (Exception e) {
			workspaceLogger.error("get Item Creation Date By ItemId ", e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public Long loadSizeByItemId(String itemId) throws Exception {
		
		workspaceLogger.trace("get Size By ItemId "+ itemId);
		try {
			
			Workspace workspace = getWorkspace();
			
			WorkspaceItem wsItem = workspace.getItem(itemId);
			
			Long size = new Long(-1);
			
			if(wsItem instanceof FolderItem){
				
				FolderItem folderItem = (FolderItem) wsItem;
				
				size = new Long(folderItem.getLength());
			}
			
			return size;
			
		} catch (Exception e) {
			workspaceLogger.error("get Size By ItemId ", e);
			throw new Exception(e.getMessage());
		}
	}
	
	
	@Override
	public Date loadLastModificationDateById(String itemId) throws Exception {
		
		workspaceLogger.trace("get last modification date ItemId "+ itemId);
		try {
			
			Workspace workspace = getWorkspace();
			
			WorkspaceItem wsItem = workspace.getItem(itemId);
			
			wsItem.getLastModificationTime().getTime();
			
			Date lastModification =null;
			
			if(wsItem.getLastModificationTime()!=null){
				
				lastModification = wsItem.getLastModificationTime().getTime();
			}
			
			return lastModification;
			
		} catch (Exception e) {
			workspaceLogger.error("get last modification date ItemId ", e);
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public FileModel getParentByItemId(String identifier) throws Exception {
		
		workspaceLogger.trace("get Parent By Item Identifier "+ identifier);
		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(identifier);
			
			workspaceLogger.trace("workspace retrieve item name: "+wsItem.getName());
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			while(wsItem!=null && wsItem.getParent()!=null){
				
				WorkspaceFolder wsFolder = wsItem.getParent();
				workspaceLogger.trace("parent was found "+wsFolder.getName()+ " retuning");
				return builder.buildGXTFolderModelItem(wsFolder, null);
			}
			workspaceLogger.trace("parent not found - retuning");
			return null;

		} catch (Exception e) {
			workspaceLogger.error("Error in get Parent By Item Identifier", e);
			e.printStackTrace();
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public List<GxtAccountingField> getAccountingReaders(String identifier) throws Exception {
		
		workspaceLogger.trace("get accounting readers "+ identifier);
		try {
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(identifier);
			
//			List<AccountingEntry> accoutings = wsItem.getAccounting();

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<GxtAccountingField> listReaders = builder.buildGXTAccountingItemFromReaders(wsItem.getReaders());

			workspaceLogger.trace("get accounting readers - returning size "+listReaders.size());
			return listReaders;

		} catch (Exception e) {
			workspaceLogger.error("Error get accounting readers ", e);
			String error = ConstantsExplorer.SERVER_ERROR+" getting account. "+ConstantsExplorer.TRY_AGAIN;
			throw new Exception(error);
		}
	}
	
	@Override
	public List<GxtAccountingField> getAccountingHistory(String identifier) throws Exception {
		
		workspaceLogger.trace("get accounting history "+ identifier);
		try {
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(identifier);
			
			List<AccountingEntry> accoutings = wsItem.getAccounting();

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			List<GxtAccountingField> listReaders = builder.buildGXTAccountingItem(accoutings, GxtAccountingEntryType.ALL);

			workspaceLogger.trace("get accounting readers - returning size "+listReaders.size());
			return listReaders;

		} catch (Exception e) {
			workspaceLogger.error("Error get accounting readers ", e);
			String error = ConstantsExplorer.SERVER_ERROR+" getting account. "+ConstantsExplorer.TRY_AGAIN;
			throw new Exception(error);
		}
	}

	/* (non-Javadoc)
	 * @see org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService#getShortUrl(java.lang.String)
	 */
	@Override
	public String getShortUrl(String longUrl) throws Exception {
	
		workspaceLogger.trace("get short url for "+ longUrl);
		
		UrlShortener shortener = getUrlShortener();
		try{
			
			if(shortener!=null && shortener.isAvailable())
				return shortener.shorten(longUrl);
			
			return longUrl;
			
		}catch (Exception e) {
			workspaceLogger.error("Error get short url for ", e);
			return longUrl;
		}
	}
	
	/**
	 * 
	 * @param itemId
	 * @param shortenUrl
	 * @return
	 */
	@Override
	public String getPublicLinkForFolderItemId(String itemId, boolean shortenUrl) throws Exception{

		workspaceLogger.trace("get Public Link For ItemId: "+ itemId);
		
		GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
		
		try{
			
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(itemId);
			
			if(wsItem.getType().equals(WorkspaceItemType.FOLDER_ITEM)){
	
				FolderItem folderItem = (FolderItem) wsItem;
				String smpUri = builder.getPubliLinkForFolderItem(folderItem);
				
				if(smpUri==null || smpUri.isEmpty())
					throw new Exception("Sorry, public link on "+wsItem.getName() +" is not available");
				
				UriResolverReaderParameter uriResolver = getUriResolver();

				String uriRequest = "";
				
				if(uriResolver!=null && uriResolver.isAvailable()){
					
					String itemName = StringUtil.removeSpecialCharacters(folderItem.getName());
					
					itemName = StringUtil.replaceAllWhiteSpace(itemName, "_");
					uriRequest =  uriResolver.resolveAsUriRequest(smpUri, itemName, folderItem.getMimeType(), true);

					
					//VALIDATE CONNECTION
					if(!HttpRequestUtil.urlExists(uriRequest))
						throw new Exception("Sorry, The Public Link for selected file is unavailable");
						
					if(shortenUrl)	
						uriRequest = getShortUrl(uriRequest);
					
					return uriRequest;

				}
				else
					throw new Exception("Sorry, The Uri resolver service is temporarily unavailable. Please try again later");
				
			}else{
				workspaceLogger.warn("ItemId: "+ itemId +" is not a folder item, sent exception Public Link  unavailable");
				throw new Exception("Sorry, The Public Link for selected file is unavailable");
			}

		}catch (Exception e) {
			workspaceLogger.error("Error getPublicLinkForFolderItemId for item: "+itemId, e);
			throw new Exception(e.getMessage());
		}
		
	}

	/* (non-Javadoc)
	 * @see org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService#isSessionExpired()
	 */
	@Override
	public boolean isSessionExpired() throws Exception {
		return WsUtil.isSessionExpired(this.getThreadLocalRequest().getSession());
	}

	/* (non-Javadoc)
	 * @see org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService#deleteListItemsForIds(java.util.List)
	 */
	@Override
	public void deleteListItemsForIds(List<String> ids) throws Exception {
		
		try {
			
			if(ids == null)
				throw new Exception("List identifiers is null");	
			
			Workspace workspace = getWorkspace();

			workspaceLogger.trace("removeItem item for list size: "+ids.size());

			for (String itemId : ids) {

				//NOTIFICATION
				WorkspaceItem wsItem = workspace.getItem(itemId);
				
				//SAVING ATTRIBUTE FOR NOTIFICATION
				boolean sourceItemIsShared = wsItem.isShared();
				String itemName = wsItem.getName();
				String sourceFolderSharedId = null;
	
				if(sourceItemIsShared){
					sourceFolderSharedId = wsItem.getIdSharedFolder();
				}
				
				//REMOVE ITEM
				workspace.removeItem(itemId);
				
				//IF SOURCE SHARED FOLDER IS NOT NULL
				if(sourceFolderSharedId!=null)
					NotificationsUtil.checkSendNotifyRemoveItemToShare(this.getThreadLocalRequest().getSession(), sourceItemIsShared, itemName, itemId, sourceFolderSharedId);

			}

			
		} catch (InsufficientPrivilegesException e) {
			workspaceLogger.error("Error in server Item remove", e);
			String error = "An error occurred on deleting item. "+e.getMessage();
			throw new Exception(error);

		}catch (ItemNotFoundException e) {
			String error = "An error occurred on deleting item. "+ConstantsExplorer.ERROR_ITEM_DOES_NOT_EXIST;
			workspaceLogger.error(error, e);
			throw new Exception(error);
		} catch (Exception e) {
			workspaceLogger.error("Error in server Item remove", e);
			String error = ConstantsExplorer.SERVER_ERROR +" deleting item. "+e.getMessage();
			throw new Exception(error);
		}
		
	}
	
	/**
	 * 
	 * @param folderId
	 * @param listUserIds
	 * @param aclType
	 * @throws Exception
	 */
	@Override
	public void setACLs(String folderId, List<String> listLogins, String aclType) throws Exception{
		try {
//			AccessManager am = HomeLibrary.getHomeManagerFactory().getAccessManager();
			
			if(folderId == null)
				throw new Exception("Folder id is null");	
				
			if(listLogins==null || listLogins.size()==0)
				throw new Exception("List Logins is null or empty");
				
			Workspace workspace = getWorkspace();
			WorkspaceItem wsItem = workspace.getItem(folderId);
			
			if(wsItem.isShared() && (wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER))){
				WorkspaceSharedFolder ite = (WorkspaceSharedFolder) workspace.getItemByPath(wsItem.getPath());
				ite.setACL(listLogins, ACLType.valueOf(aclType));
			}else
				throw new Exception("Source item is not shared or shared folder");
		} catch (Exception e) {
			workspaceLogger.error("Error in set ACLs", e);
			String error = ConstantsExplorer.SERVER_ERROR +" setting permissions. "+e.getMessage();
			throw new Exception(error);
		}
	}
	
	/**
	 * 
	 * @return
	 * @throws Exception
	 */
	@Override
	public List<WorkspaceACL> getACLs() throws Exception{
		try {
			List<WorkspaceACL> acls = new ArrayList<WorkspaceACL>();
			
			for (ACLType acl : ACLType.values()) {
				
				switch (acl) {
				case ADMINISTRATOR:
					acls.add(new WorkspaceACL(acl.toString(), acl.toString()));
					break;
				case READ_ONLY:
					acls.add(new WorkspaceACL(acl.toString(), "Read Only"));
					break;
				case WRITE_OWNER:
					acls.add(new WorkspaceACL(acl.toString(), "Write Owner"));
					break;
					
				case WRITE_ALL:
					acls.add(new WorkspaceACL(acl.toString(), "Write All"));
					break;

				default:
					acls.add(new WorkspaceACL(acl.toString(), acl.toString()));
					break;
				}
			}
			
			if(acls.size()==0)
				throw new Exception("No ACLs rules found!");
			
			return acls;
		} catch (Exception e) {
			workspaceLogger.error("Error in server get ACLs", e);
			String error = ConstantsExplorer.SERVER_ERROR +" get ACL rules. "+e.getMessage();
			throw new Exception(error);
		}
	}
}