1521 lines
50 KiB
Java
1521 lines
50 KiB
Java
package org.gcube.portlets.user.workspace.server;
|
|
|
|
import java.io.BufferedInputStream;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
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 javax.servlet.ServletContext;
|
|
|
|
import org.gcube.application.framework.core.session.ASLSession;
|
|
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 org.gcube.portlets.user.workspace.shared.FieldVerifier;
|
|
|
|
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.isTestMode(Util.getAslSession(this.getThreadLocalRequest().getSession()));
|
|
}
|
|
|
|
@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 void readFromApplicationProfile(String name, String value) throws Exception {
|
|
|
|
try{
|
|
ASLSession session = Util.getAslSession(this.getThreadLocalRequest().getSession());
|
|
|
|
Properties prop = new Properties();
|
|
|
|
try {
|
|
|
|
InputStream in = (InputStream) FieldVerifier.class.getResourceAsStream("portletClassName.properties");
|
|
|
|
// load a properties file from class path, inside static method
|
|
prop.load(in);
|
|
|
|
// get the property value and print it out
|
|
System.out.println(prop.getProperty("idreport"));
|
|
System.out.println(prop.getProperty("idtemplate"));
|
|
|
|
|
|
} catch (IOException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
|
|
|
|
// SocialPortalBridge spb = new SocialPortalBridge(session,)
|
|
//
|
|
// 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 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.info("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.info("get all contacts");
|
|
|
|
// WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace
|
|
// workspace.getAllScope();
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
if(isTestMode()){
|
|
|
|
System.out.println("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"));
|
|
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;
|
|
}
|
|
}
|