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

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

import org.gcube.application.framework.core.session.ASLSession;
import org.gcube.applicationsupportlayer.social.SocialPortalBridge;
import org.gcube.common.core.scope.GCUBEScope;
import org.gcube.common.core.utils.logging.GCUBEClientLog;
import org.gcube.portlets.user.homelibrary.home.exceptions.HomeNotFoundException;
import org.gcube.portlets.user.homelibrary.home.exceptions.InternalErrorException;
import org.gcube.portlets.user.homelibrary.home.workspace.Workspace;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceFolder;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceItem;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceItemType;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceSharedFolder;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceSmartFolder;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.ItemNotFoundException;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.WorkspaceFolderNotFoundException;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.FolderBulkCreator;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.FolderItemType;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.items.ExternalUrl;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.items.ts.TimeSeries;
import org.gcube.portlets.user.homelibrary.home.workspace.search.SearchItem;
import org.gcube.portlets.user.homelibrary.home.workspace.sharing.WorkspaceMessage;
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.util.AllScope;
import org.gcube.portlets.user.workspace.server.util.Util;

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


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

	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 GCUBEClientLog workspaceLogger = new GCUBEClientLog("GWTWorkspaceServiceImpl");
	
	
	protected GWTWorkspaceBuilder getGWTWorkspaceBuilder()
	{
		return Util.getGWTWorkspaceBuilder(this.getThreadLocalRequest().getSession());
	}

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

	@Override
	public FolderModel getRootForTree() throws Exception {

		workspaceLogger.info("getRoot");
		
		workspaceLogger.trace("getting workspace");
		
		try {

			workspaceLogger.trace("getting workspace");
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);

			logger.info("getRoot");

			WorkspaceFolder root = workspace.getRoot();

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

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

			logger.trace("Root converted, returnig...");
			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("getRoot for scope " + scopeId);
			
			workspaceLogger.trace("on server getRoot for scope: " + scopeId);
			
			GCUBEScope gcubeScope = null;
			
			if(!scopeId.equals(AllScope.IDALLSCOPE)){
				gcubeScope = GCUBEScope.getScope(scopeId);
			}
			WorkspaceFolder root =  workspace.getRoot(gcubeScope);
//			WorkspaceFolder root = workspace.getRoot(); //TODO CHAGE METHOD
			
//			WorkspaceFolder root = workspace.getRoot(scopeId);

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

			logger.trace("Root loaded, gxt conversion");
			workspaceLogger.trace("Root loaded, gxt conversion");
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			logger.trace("Root converted, returnig...");
			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);

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

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
			
			logger.trace("Call search HL..");
			
			listFileGridModels = builder.buildGXTListFileGridModelItemForSearch(listSearchItems, null);
			logger.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{
		
		Workspace workspace;
		
		try {
			
			workspace = getWorkspace();
			
			List<FileModel> listFileModels = new ArrayList<FileModel>();
		
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get children");
	
			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);

			//GWT can't serialize all exceptions
			throw new Exception("Error during item loading, please contact the support.");
		}
	}

	@Override
	public List<FileGridModel> getFolderChildrenForFileGrid(FileModel folder) throws Exception {
		
		Workspace workspace;
		
		try {
			
			workspace = getWorkspace();
			
			List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
		
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get children for Grid");
			
			workspaceLogger.trace("get children for Grid");
	
			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));
			logger.info("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);

			//GWT can't serialize all exceptions
			throw new Exception("Error during item loading, please contact the support.");
		}
	}
	
	@Override
	public Boolean moveItem(String itemId, String destinationId) throws Exception {
		workspaceLogger.info("moveItem itemId: "+itemId+" destination: "+destinationId);

		try {
			Workspace workspace = getWorkspace();
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("moveItem item: "+itemId+" destination: "+destinationId);

			workspace.moveItem(itemId, destinationId);
			return Boolean.TRUE;

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

	}

	@Override
	public Boolean removeItem(String itemId) throws Exception {
		workspaceLogger.info("removeItem itemId: "+itemId);

		try {
			Workspace workspace = getWorkspace();
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("removeItem item: "+itemId);

			workspace.removeItem(itemId);
			return Boolean.TRUE;

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

	}

	@Override
	public Boolean renameItem(String itemId, String newName) throws Exception {

		workspaceLogger.info("renameItem itemId: "+itemId+" newName: "+newName);

		try {
			Workspace workspace = getWorkspace();
			

			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("renameItem itemId: "+itemId+" newName: "+newName);

			workspace.renameItem(itemId, newName);
			return true;

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

	}
	
	@Override
	public FolderModel createFolder(String nameFolder, String description, FileModel parent) throws Exception {
		
		workspaceLogger.info("create folder");

		try {
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("create folder: " + nameFolder);

			WorkspaceFolder wsFolder = workspace.createFolder(nameFolder, description, parent.getIdentifier());
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTFolderModelItem(wsFolder, parent);

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

	@Override
	public FileDetailsModel getDetailsFile(FileModel folder) throws Exception {
		
		workspaceLogger.info("load file details");

		try {
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("load file details: " + folder.getName());

			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);
//			workspaceLogger.trace("Error in server load file details" + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}
	
	
	@Override
	public ArrayList<SubTree> getChildrenSubTreeToRootByIdentifier(String itemIdentifier) throws Exception {
		
		ArrayList<SubTree>  listSubTree = new ArrayList<SubTree>();
		
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("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);
//			workspaceLogger.trace("Error in server find Item " + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
		
		return listSubTree;
	}
	
	@Override
	public List<FileGridModel> getSmartFolderResultsByCategory(String category) throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get smart folder by category: "+category);

//			listWorkspaceItems = workspace.getWorkspaceTree(workspace.getRoot()); //get item from workspace	

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
//			List<FileGridModel> listFileGridModel = new ArrayList<FileGridModel>();
//			ArrayList<FolderItemType> listFolderItemType = builder.getListWorkspaceType(category);
			
			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);

//			workspaceLogger.trace("listFileGridModel " + listFileGridModel.size());	
//			return builder.filterListByCategory(listFileGridModel, category);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server get smart folder by category", e);
//			workspaceLogger.trace("Error in server get smart folder by category " + e);
			//GWT can't serialize all exceptions
			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("create smart folder by name: "+name);
			
			workspaceLogger.trace("name " + name);
			workspaceLogger.trace("query " + query);
			
			/*WorkspaceFolder wsFolder  = workspace.createSmartFolder(name, query); //create Smart Folder from workspace	
			
			workspaceLogger.trace("create : " +wsFolder.getName()  + " id "+ wsFolder.getId());

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGXTSmartFolderModel(wsFolder,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 {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("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);
//			workspaceLogger.trace("Error in get smart folder by id " + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public List<SmartFolderModel> getAllSmartFolders() throws Exception{
		
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get all smart folder");
//			workspaceLogger.trace("get all smart folder");
			
//			List<WorkspaceFolder> listWorkspaceFolder = new ArrayList<WorkspaceFolder>();
//			listWorkspaceFolder = workspace.getAllSmartFolders(); //create Smart Folder from workspace	
			
			List<WorkspaceSmartFolder> listWorkspaceFolder = new ArrayList<WorkspaceSmartFolder>();
			
			listWorkspaceFolder = workspace.getAllSmartFolders(); //create Smart Folder from workspace	
			
			workspaceLogger.trace("listWorkspaceFolder size" + listWorkspaceFolder.size());
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
		
			return builder.buildGXTListSmartFolderModel(listWorkspaceFolder);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server get all smart folder: ", e);
//			workspaceLogger.trace("Error in server get all smart folder:" + e.getMessage());
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}

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

		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get smart folder by id: "+folderId);
			
//			WorkspaceFolder wsFolder  = workspace.getSmartFolder(folderId); //get Smart Folder from workspace	
			
			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(), null);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in get server smart folder by id", e);
//			workspaceLogger.trace("Error in server get smart folder by id " + e);
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}

	@Override
	public GWTWorkspaceItem getImageById(String identifier, boolean isInteralImage, boolean fullDetails) throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get image by id: "+identifier);
			
			WorkspaceItem item = workspace.getItem(identifier); //get item from workspace	
			
			workspaceLogger.trace("item name " + item.getName());
		
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			return builder.buildGWTWorkspaceImage(item, isInteralImage, fullDetails);
			
//			workspaceLogger.trace(" children "+wsFolder.getChildren().size());
//			return builder.buildGWTWorkspaceItemsForGrid(wsFolder.getChildren(), null);
		
		} catch (Exception e) {
			workspaceLogger.error("Error in server get image by id", e);
//			workspaceLogger.trace("Error in server get image by id " + e);
			
			throw new Exception(e.getMessage());
		}
	}
	
	@Override
	public GWTWorkspaceItem getTimeSeriesById(String identifier) throws Exception {
		
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("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 {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("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 property, String value) throws Exception {
		
		String urlPortlet = "";
		String appId = "";
		
		try{
			ASLSession session = Util.getAslSession(this.getThreadLocalRequest().getSession());
			
			Properties prop = new Properties();

			InputStream in = (InputStream) GWTWorkspaceServiceImpl.class.getResourceAsStream("portletClassName.properties");
			
			// load a properties file
			prop.load(in);
			
			// get the property value - the application Id
			appId = prop.getProperty(property);
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.trace("get URL From property file return AppId: "+appId);
		 
			//print it out
			System.out.println("get URL From property file return AppId: "+appId);
			
			//set property in ASL session
			setValueInSession(property,value);


			SocialPortalBridge spb = new SocialPortalBridge(session,appId);
			
			urlPortlet = spb.getApplicationProfile().getUrl();


		} 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 = Util.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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.trace("get all scope");
			
//			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
//			 workspace.getAllScope();
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			
//			return builder.buildGXTListScopeModel(HomeLibrary.getHomeManagerFactory().listScopes()); //TODO passare list items
			
			return builder.buildGXTListScopeModel(workspace.getHome().listScopes()); //TODO passare list items
			
		} 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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.trace("get all contacts");
		
//			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
//			 workspace.getAllScope();

			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			if(isTestMode()){
				
				logger.warn("WORKSPACE PORTLET IS IN TEST MODE - RETURN TEST USERS");
				List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
//				//TEST USERS
				listContactsModel.add(new InfoContactModel("Federico.Test", "Federico.Test", "Federico de Faveri"));
				listContactsModel.add(new InfoContactModel("Antonio.Test", "Antonio.Test", "Antonio Gioia"));
				listContactsModel.add(new InfoContactModel("Fabio.Test", "Fabio.Test", "Fabio Sinibaldi"));
				listContactsModel.add(new InfoContactModel(Util.TEST_USER, Util.TEST_USER, Util.TEST_USER));
				listContactsModel.add(new InfoContactModel("massimiliano.assante", "massimiliano.assante", "Massimiliano Assante"));
				listContactsModel.add(new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa"));
				return listContactsModel;
				
			}

			return builder.buildGXTListContactsModel(workspace.getHome().getHomeManager().getUsers()); //TODO passare list items
			
		} catch (Exception e) {
			workspaceLogger.error("Error in server get all contacts ", e);
			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("send To");
			
//			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
//			 workspace.getAllScope();
//			
			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);
//			workspaceLogger.trace("Error in server get sendTo " + e.getMessage());
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
		
	}

	@Override
	public List<MessageModel> getAllMessagesSent() throws Exception {
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("getAllMessagesSent");
			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("getAllMessagesReceived");
			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("get Message by Id");
			
//			WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace	
//			 workspace.getAllScope();
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
//			return builder.buildGXTListMessageModel(); 
			
			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);
//			workspaceLogger.trace("Error in server get Message by Id " + e.getMessage());
			//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();
				
				GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
				
				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());
			}
		
		
	}

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

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

	try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("save attachments by messageIdentifier");
			
			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);
//			workspaceLogger.trace("Error in server save attachments by messageIdentifier " + e.getMessage());
			//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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
//			logger.info("markMessageAsRead");
			
			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);
//			workspaceLogger.trace("Error in server markMessageAsRead by messageIdentifier " + e.getMessage());
			//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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
//			logger.info("deleteMessage by messageIdentifier");
			
			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);
//			workspaceLogger.trace("Error in server deleteMessage by messageIdentifier " + e.getMessage());
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
	}


	public List<MessageModel> getNewMessagesReceived() throws Exception {

		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			
//			workspaceLogger.trace("in server getNewMessagesReceived ");
			
			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);
//			workspaceLogger.trace("Error in server getNewMessagesReceived by messageIdentifier " + e.getMessage());
			//GWT can't serialize all exceptions
			throw new Exception(e.getMessage());
		}
		
	}
	
	
	@Override
	public List<MessageModel> searchInSentMessagesByText(String text) throws Exception {
		try {
			
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("searchInSentMessagesByText");
//			workspaceLogger.trace("searchInSentMessagesByText ");

			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("searchInSentMessagesByText");
//			workspaceLogger.trace("searchInSentMessagesByText ");

			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 {
		
		try {

			Workspace workspace = getWorkspace();

			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("copyItem by id: " + itemId);

			WorkspaceItem item = workspace.copy(itemId, destinationFolderId);  
															
			if(item!=null)
				return true;
			
			return false;

		} catch (Exception e) {
			workspaceLogger.error("Error in server copyItem  by id", e);
//			workspaceLogger.trace("Error in server copyItem by id " + e);

			throw new Exception(e.getMessage());
		}
	}

	@Override
	public boolean deleteBulk(String bulkId) throws Exception {
		
		try {
			Workspace workspace = getWorkspace();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("delete bulk " + bulkId);
			
//			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();
			
			GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
			logger.info("getWebDavUrl " + itemId);
			
			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 {
		
		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());
			}
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
			
			List<String> listLogin = builder.getListLoginByInfoContactModel(listContacts);
			
			WorkspaceSharedFolder sharedFolder = null;
			
			if(listLogin.size()>0){
				
				if(!isNewFolder)
					sharedFolder = workspace.shareFolder(listLogin, folder.getIdentifier());
				else
					sharedFolder = workspace.createSharedFolder(folder.getName(), "description", listLogin, folder.getParentFileModel().getIdentifier());
			}
			
			boolean created = sharedFolder==null?false:true;

			
			if(created){
				NotificationsProducer np = getNotificationProducer();
				np.notifyFolderSharing(listContacts, sharedFolder);
			}
				
			return created;

		} catch (Exception e) {
			workspaceLogger.error("Error in shareFolder ", e);
			e.printStackTrace();
			throw new Exception(e.getMessage());
		}
	}

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

			WorkspaceItem wsItem = workspace.getItem(folderSharedId);
			
			if(wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
				
				WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;

				GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

				List<String> listUser = wsFolder.getUsers();
				
				workspaceLogger.trace("getListUserSharedByFolderSharedId return "+ listUser.size() + " user");
				
				return builder.buildGxtInfoContactFromPortalLogin(listUser);
				
			}
			else{
				workspaceLogger.trace("the item with id: "+folderSharedId+ " is not  "+WorkspaceItemType.SHARED_FOLDER);
				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 boolean unSharedFolderByFolderSharedId(String folderSharedId) throws Exception{
		
		boolean unShared = false;
		
		workspaceLogger.trace("unSharedFolderByFolderSharedId "+ folderSharedId);
		try {
			Workspace workspace = getWorkspace();

			WorkspaceItem wsItem = workspace.getItem(folderSharedId);
			
			if(wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
				
				WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;

				WorkspaceFolder unSharedFolder = wsFolder.unShare();
				
				unShared = unSharedFolder==null?false:true;	
				
				System.out.println("unShared is "+unShared);
				
				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"));
					}
					
					np.notifyFolderUnSharing(contacts, wsFolder);
				}

			}
			else
				workspaceLogger.trace("the item with id: "+folderSharedId+ "is not  "+WorkspaceItemType.SHARED_FOLDER);
			
		} catch (Exception e) {
			workspaceLogger.error("Error in unSharedFolderByFolderSharedId ", e);
			e.printStackTrace();
			throw new Exception(e.getMessage());
		}
		
		return unShared;
	}

	@Override
	public List<FileModel> getListParentsByItemIdentifier(String itemIdentifier) 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);
			
			GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();

			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 unSharedFolderByFolderSharedId ", e);
			e.printStackTrace();
			throw new Exception(e.getMessage());
		}

		return listParents;
	}
}