2280 lines
74 KiB
Java
2280 lines
74 KiB
Java
package org.gcube.portlets.user.workspace.server;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import org.apache.log4j.Logger;
|
|
import org.gcube.application.framework.core.session.ASLSession;
|
|
import org.gcube.common.homelibrary.home.Home;
|
|
import org.gcube.common.homelibrary.home.HomeLibrary;
|
|
import org.gcube.common.homelibrary.home.exceptions.HomeNotFoundException;
|
|
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
|
|
import org.gcube.common.homelibrary.home.workspace.Workspace;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceFolder;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceItemType;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceSharedFolder;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceSmartFolder;
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntry;
|
|
import org.gcube.common.homelibrary.home.workspace.exceptions.InsufficientPrivilegesException;
|
|
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemAlreadyExistException;
|
|
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemNotFoundException;
|
|
import org.gcube.common.homelibrary.home.workspace.exceptions.WorkspaceFolderNotFoundException;
|
|
import org.gcube.common.homelibrary.home.workspace.exceptions.WrongDestinationException;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.FolderBulkCreator;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.FolderItem;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.FolderItemType;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalUrl;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ts.TimeSeries;
|
|
import org.gcube.common.homelibrary.home.workspace.search.SearchItem;
|
|
import org.gcube.common.homelibrary.home.workspace.sharing.WorkspaceMessage;
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.portlets.user.workspace.client.ConstantsExplorer;
|
|
import org.gcube.portlets.user.workspace.client.interfaces.GXTCategoryItemInterface;
|
|
import org.gcube.portlets.user.workspace.client.model.BulkCreatorModel;
|
|
import org.gcube.portlets.user.workspace.client.model.FileDetailsModel;
|
|
import org.gcube.portlets.user.workspace.client.model.FileGridModel;
|
|
import org.gcube.portlets.user.workspace.client.model.FileModel;
|
|
import org.gcube.portlets.user.workspace.client.model.FolderModel;
|
|
import org.gcube.portlets.user.workspace.client.model.InfoContactModel;
|
|
import org.gcube.portlets.user.workspace.client.model.MessageModel;
|
|
import org.gcube.portlets.user.workspace.client.model.ScopeModel;
|
|
import org.gcube.portlets.user.workspace.client.model.SmartFolderModel;
|
|
import org.gcube.portlets.user.workspace.client.model.SubTree;
|
|
import org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService;
|
|
import org.gcube.portlets.user.workspace.client.workspace.GWTWorkspaceItem;
|
|
import org.gcube.portlets.user.workspace.server.notifications.NotificationsProducer;
|
|
import org.gcube.portlets.user.workspace.server.notifications.NotificationsUtil;
|
|
import org.gcube.portlets.user.workspace.server.resolver.UriResolverReaderParameter;
|
|
import org.gcube.portlets.user.workspace.server.shortener.UrlShortener;
|
|
import org.gcube.portlets.user.workspace.server.util.HttpRequestUtil;
|
|
import org.gcube.portlets.user.workspace.server.util.StringUtil;
|
|
import org.gcube.portlets.user.workspace.server.util.UserUtil;
|
|
import org.gcube.portlets.user.workspace.server.util.WsUtil;
|
|
import org.gcube.portlets.user.workspace.server.util.scope.ScopeUtilFilter;
|
|
import org.gcube.portlets.user.workspace.shared.SessionExpiredException;
|
|
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingEntryType;
|
|
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingField;
|
|
import org.gcube.portlets.user.workspaceapplicationhandler.ApplicationReaderFromGenericResource;
|
|
import org.gcube.vomanagement.usermanagement.GroupManager;
|
|
import org.gcube.vomanagement.usermanagement.UserManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayGroupManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.liferay.LiferayUserManager;
|
|
|
|
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
|
|
|
|
|
|
/**
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
*/
|
|
public class GWTWorkspaceServiceImpl extends RemoteServiceServlet implements GWTWorkspaceService{
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
protected static final String IDENTIFIER_IS_NULL = "Identifier is null";
|
|
protected static final String RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST = " retrieving item. Either the item doesn't exist anymore or you do not have the permission to access it";
|
|
private static final long serialVersionUID = 2828885661214875589L;
|
|
|
|
public static final String LAST_OPEN_FOLDER_ATTRIBUTE = "WORKSPACE.LAST_OPEN_FOLDER";
|
|
public static final String SELECTION_STATE_ATTRIBUTE = "WORKSPACE.SELECTION_STATE";
|
|
|
|
// protected GCUBELog workspaceLogger = new GCUBELog(GWTWorkspaceServiceImpl.class);
|
|
|
|
protected Logger workspaceLogger = Logger.getLogger(GWTWorkspaceServiceImpl.class);
|
|
|
|
|
|
protected GWTWorkspaceBuilder getGWTWorkspaceBuilder()
|
|
{
|
|
return WsUtil.getGWTWorkspaceBuilder(this.getThreadLocalRequest().getSession());
|
|
}
|
|
|
|
protected Workspace getWorkspace() throws InternalErrorException, HomeNotFoundException, WorkspaceFolderNotFoundException
|
|
{
|
|
return WsUtil.getWorkspace(this.getThreadLocalRequest().getSession());
|
|
}
|
|
|
|
protected NotificationsProducer getNotificationProducer(){
|
|
|
|
return WsUtil.getNotificationProducer(WsUtil.getAslSession(this.getThreadLocalRequest().getSession()));
|
|
}
|
|
|
|
protected ScopeUtilFilter getScopeUtilFilter(){
|
|
|
|
return WsUtil.getScopeUtilFilter(this.getThreadLocalRequest().getSession());
|
|
}
|
|
|
|
protected boolean isTestMode(){
|
|
return WsUtil.withoutPortal;
|
|
}
|
|
|
|
protected UrlShortener getUrlShortener() {
|
|
return WsUtil.getUrlShortener(this.getThreadLocalRequest().getSession());
|
|
}
|
|
|
|
protected UriResolverReaderParameter getUriResolver() {
|
|
return WsUtil.getUriResolver(this.getThreadLocalRequest().getSession());
|
|
}
|
|
|
|
@Override
|
|
public FolderModel getRootForTree() throws Exception {
|
|
|
|
workspaceLogger.trace("getRoot");
|
|
|
|
try {
|
|
|
|
workspaceLogger.trace("getting workspace");
|
|
Workspace workspace = getWorkspace();
|
|
|
|
|
|
WorkspaceFolder root = workspace.getRoot();
|
|
|
|
if (root == null) {
|
|
workspaceLogger.error("The root is null");
|
|
throw new Exception("The root is null");
|
|
}
|
|
|
|
workspaceLogger.trace("Root loaded, gxt conversion");
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
FolderModel gwtroot =builder.buildWorkspaceFileModelRoot(root);
|
|
|
|
workspaceLogger.trace("Root converted, returnig...");
|
|
return gwtroot;
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server during root retrieving", e);
|
|
// workspaceLogger.trace("Error in server During root retrieving " + e);
|
|
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception("Error during workspace loading, please contact the support. Exception:" +e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public FolderModel getRootForTree(String scopeId) throws Exception {
|
|
|
|
workspaceLogger.info("getRoot for scope " + scopeId);
|
|
workspaceLogger.trace("getting workspace");
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("on server getRoot for scope: " + scopeId);
|
|
|
|
// GCUBEScope gcubeScope = null;
|
|
//
|
|
// if(scopeId.compareTo(ScopeUtilFilter.IDALLSCOPE)!=0){
|
|
// gcubeScope = GCUBEScope.getScope(scopeId);
|
|
// }
|
|
|
|
WorkspaceFolder root = workspace.getRoot();
|
|
|
|
if (root == null) {
|
|
workspaceLogger.error("The root is null");
|
|
throw new Exception("The root is null");
|
|
}
|
|
|
|
workspaceLogger.trace("Root loaded, gxt conversion");
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
workspaceLogger.trace("Root converted, returnig...");
|
|
return builder.buildWorkspaceFileModelRoot(root);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server during root retrieving", e);
|
|
// workspaceLogger.trace("Error in server During root retrieving " + e);
|
|
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception("Error during workspace loading, please contact the support. Exception:" +e);
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public List<FileGridModel> getItemsBySearchName(String text) throws Exception {
|
|
|
|
workspaceLogger.trace("getting search");
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
List<SearchItem> listSearchItems = workspace.searchByName(text);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
|
|
|
|
workspaceLogger.trace("Call search HL..");
|
|
|
|
listFileGridModels = builder.buildGXTListFileGridModelItemForSearch(listSearchItems, null);
|
|
workspaceLogger.trace("Search converted, completed...");
|
|
|
|
return listFileGridModels;
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server During search retrieving", e);
|
|
// workspaceLogger.trace("Error in server During search retrieving " + e);
|
|
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception("Error during searching, please contact the support.");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<FileModel> getFolderChildren(FolderModel folder) throws Exception, SessionExpiredException{
|
|
|
|
Workspace workspace;
|
|
|
|
if(isSessionExpired())
|
|
throw new SessionExpiredException();
|
|
|
|
try {
|
|
|
|
if(folder == null)
|
|
throw new Exception("Folder is null");
|
|
|
|
workspaceLogger.trace("get folder children for: "+folder.getIdentifier());
|
|
workspace = getWorkspace();
|
|
|
|
List<FileModel> listFileModels = new ArrayList<FileModel>();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(folder.getIdentifier());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
listFileModels = builder.buildGXTListFileModelItem(wsItem, folder);
|
|
|
|
return listFileModels;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server During item retrieving", e);
|
|
// workspaceLogger.trace("Error in server During item retrieving " + e);
|
|
String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<FileGridModel> getFolderChildrenForFileGrid(FileModel folder) throws Exception, SessionExpiredException {
|
|
|
|
if(isSessionExpired())
|
|
throw new SessionExpiredException();
|
|
|
|
try {
|
|
|
|
if(folder == null)
|
|
throw new Exception("Folder is null");
|
|
|
|
workspaceLogger.trace("get children for Grid for folder: "+folder.getIdentifier());
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
|
|
|
|
WorkspaceFolder wsFolder = (WorkspaceFolder) workspace.getItem(folder.getIdentifier());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
|
|
Long startTime = System.currentTimeMillis();
|
|
|
|
List<WorkspaceItem> listItems = (List<WorkspaceItem>) wsFolder.getChildren();
|
|
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
workspaceLogger.debug("##HL FILLING: grid getChildren() returning "+listItems.size()+" elements in " + time);
|
|
|
|
listFileGridModels = builder.buildGXTListFileGridModelItem(listItems, folder);
|
|
|
|
|
|
return listFileGridModels;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server During items retrieving", e);
|
|
// workspaceLogger.trace("Error in server During items retrieving " + e);
|
|
// e.printStackTrace();
|
|
String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<FileGridModel> getFolderChildrenForFileGridById(String folderId) throws Exception, SessionExpiredException {
|
|
|
|
|
|
if(isSessionExpired())
|
|
throw new SessionExpiredException();
|
|
|
|
try {
|
|
|
|
if(folderId == null)
|
|
throw new Exception("Folder id is null");
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get children for Grid by id: "+folderId);
|
|
List<FileGridModel> listFileGridModels = new ArrayList<FileGridModel>();
|
|
|
|
|
|
if(folderId==null || folderId.isEmpty()){
|
|
workspaceLogger.trace("id is null or empty, return");
|
|
return listFileGridModels;
|
|
}
|
|
|
|
workspaceLogger.trace("get children for Grid by id: "+folderId);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
//BUILD PARENT
|
|
WorkspaceItem wsItem = workspace.getItem(folderId);
|
|
|
|
WorkspaceFolder parent;
|
|
|
|
if(wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER) || wsItem.getType().equals(WorkspaceItemType.FOLDER)){
|
|
workspaceLogger.trace("item id: "+folderId +" is of type: "+wsItem.getType());
|
|
parent = (WorkspaceFolder) wsItem;
|
|
|
|
}else{
|
|
workspaceLogger.trace("item id: "+folderId +" is not a folder but of type: "+wsItem.getType()+", get parent");
|
|
parent = wsItem.getParent();
|
|
}
|
|
|
|
if(parent==null)
|
|
return listFileGridModels;
|
|
|
|
|
|
FileGridModel wsParent = builder.buildGXTFileGridModelItem(parent, null);
|
|
|
|
//PARENT BUILDED IS SHARED?
|
|
if(parent.isShared()){
|
|
wsParent.setShared(true);
|
|
wsParent.setShareable(false);
|
|
}
|
|
|
|
Long startTime = System.currentTimeMillis();
|
|
|
|
//GET CHILDREN
|
|
List<WorkspaceItem> listItems = (List<WorkspaceItem>) parent.getChildren();
|
|
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
workspaceLogger.debug("grid getChildren() returning "+listItems.size()+" elements in " + time);
|
|
|
|
|
|
listFileGridModels = builder.buildGXTListFileGridModelItem(listItems, wsParent);
|
|
|
|
return listFileGridModels;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server During items retrieving", e);
|
|
// workspaceLogger.trace("Error in server During items retrieving " + e);
|
|
|
|
String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
|
|
// e.printStackTrace();
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public FileGridModel getItemForFileGrid(String itemId) throws Exception {
|
|
|
|
try {
|
|
|
|
if(itemId == null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get child for Grid by id: "+itemId);
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
Long startTime = System.currentTimeMillis();
|
|
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
workspaceLogger.debug("get child for Grid by id returning element in " + time);
|
|
|
|
|
|
//BUILD PARENT
|
|
WorkspaceFolder folder = wsItem.getParent(); //get parent
|
|
FileGridModel wsFolder = builder.buildGXTFileGridModelItem(folder, null);
|
|
|
|
//BUILD ITEM
|
|
return builder.buildGXTFileGridModelItem(wsItem, wsFolder);
|
|
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server during item retrieving, getItemForFileGrid", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR + RETRIEVING_ITEM_EITHER_ITEM_DOESN_T_EXIST;
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Boolean moveItem(String itemId, String destinationId) throws Exception {
|
|
workspaceLogger.trace("moveItem itemId: "+itemId+" destination: "+destinationId);
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
if(itemId == null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
workspaceLogger.trace("moveItem item: "+itemId+" destination: "+destinationId);
|
|
|
|
WorkspaceItem sourceItem = workspace.getItem(itemId); //GET SOURCE ITEM BEFORE OF MOVE
|
|
|
|
if(sourceItem==null)
|
|
return Boolean.FALSE;
|
|
|
|
String sourceSharedId = null;
|
|
boolean sourceItemIsShared = sourceItem.isShared();
|
|
|
|
if(sourceItemIsShared)
|
|
sourceSharedId = sourceItem.getIdSharedFolder(); //GET SHARED ID BEFORE OF MOVE
|
|
|
|
|
|
//System.out.println("moveItem item: "+itemId+" sourceItem name "+sourceItem.getName() + " shared: "+sourceItemIsShared+ " destination: "+destinationId);
|
|
|
|
workspace.moveItem(itemId, destinationId); //move item
|
|
|
|
WorkspaceItem folderDestinationItem = workspace.getItem(destinationId); //retrieve folder destination
|
|
|
|
//System.out.println("sourceItem.isShared() "+sourceItemIsShared );
|
|
//System.out.println("folderDestinationItem item: "+destinationId+" folderDestinationItem name "+folderDestinationItem.getName() + " folderDestinationItem shared: "+folderDestinationItem.isShared());
|
|
|
|
if(folderDestinationItem!=null){
|
|
|
|
try{
|
|
checkNotifyAddItemToShare(sourceItem, sourceSharedId, folderDestinationItem);
|
|
|
|
checkNotifyMoveItemFromShare(sourceItemIsShared, sourceItem, sourceSharedId, folderDestinationItem);
|
|
|
|
}catch (Exception e) {
|
|
workspaceLogger.error("An error occurred in checkNotify ", e);
|
|
}
|
|
}
|
|
|
|
return Boolean.TRUE;
|
|
|
|
}catch (InsufficientPrivilegesException e) {
|
|
workspaceLogger.error("Error in server Item move", e);
|
|
String error = "An error occurred on moving item. "+e.getMessage();
|
|
throw new Exception(error);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server Item move", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR + " moving item. "+e.getMessage();
|
|
throw new Exception(error);
|
|
}
|
|
|
|
}
|
|
|
|
private void checkNotifyAddItemToShare(final WorkspaceItem sourceItem, final String sourceSharedId, final WorkspaceItem folderDestinationItem) {
|
|
|
|
workspaceLogger.trace("checkNotifyAddItemToShare");
|
|
|
|
if(folderDestinationItem!=null){
|
|
|
|
try{
|
|
//if folder destination is shared folder
|
|
if(folderDestinationItem.isShared()){ //Notify Added Item To Sharing?
|
|
|
|
workspaceLogger.trace("checkNotifyAddItemToShare source item: "+sourceItem.getName()+" sourceSharedId: "+sourceSharedId + " folder destination: "+folderDestinationItem.getName());
|
|
|
|
//share condition is true if source shared folder is null or not equal to destination shared folder
|
|
boolean shareChangeCondition = (sourceSharedId==null) || (sourceSharedId.compareTo(folderDestinationItem.getIdSharedFolder())!=0);
|
|
|
|
//System.out.println("shareChangeCondition add item: "+ shareChangeCondition);
|
|
|
|
workspaceLogger.trace("shareChangeCondition add item: "+shareChangeCondition);
|
|
|
|
//if shareChangeCondition is true.. notifies added item to sharing
|
|
if(shareChangeCondition){
|
|
|
|
List<InfoContactModel> listContacts = getListUserSharedByFolderSharedId(folderDestinationItem.getIdSharedFolder());
|
|
|
|
//DEBUG
|
|
printContacts(listContacts);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem destinationSharedFolder = workspace.getItem(folderDestinationItem.getIdSharedFolder());
|
|
|
|
NotificationsProducer np = getNotificationProducer();
|
|
|
|
np.notifyAddedItemToSharing(listContacts, sourceItem, (WorkspaceFolder) destinationSharedFolder);
|
|
|
|
workspaceLogger.trace("The notifies was sent correctly");
|
|
// np.notifyAddedItemToSharing(listContacts, (WorkspaceFolder) folderDestinationItem);
|
|
}
|
|
}
|
|
else
|
|
workspaceLogger.trace("folder destination is not shared");
|
|
|
|
}catch (Exception e) {
|
|
workspaceLogger.error("An error occurred in verifyNotifyAddItemToShare ",e);
|
|
}
|
|
}else
|
|
workspaceLogger.warn("The notifies is failure in verifyNotifyAddItemToShare because folder destination item is null");
|
|
}
|
|
|
|
|
|
private void checkNotifyMoveItemFromShare(final boolean sourceItemIsShared, final WorkspaceItem sourceItem, final String sourceSharedId, final WorkspaceItem folderDestinationItem) {
|
|
|
|
workspaceLogger.trace("checkNotifyMoveItemFromShare:");
|
|
|
|
try{
|
|
|
|
if(folderDestinationItem!=null){
|
|
|
|
String idSharedFolder = folderDestinationItem.getIdSharedFolder()!=null?folderDestinationItem.getIdSharedFolder():"";
|
|
|
|
//share condition is true if source shared folder is not equal to destination shared folder
|
|
boolean shareChangeCondition = sourceSharedId==null?false:(sourceSharedId.compareTo(idSharedFolder)!=0);
|
|
|
|
workspaceLogger.trace("checkNotifyMoveItemFromShare source item: "+sourceItem.getName()+" sourceSharedId: "+sourceSharedId + " folder destination: "+folderDestinationItem.getName() +" sourceItemIsShared: "+sourceItemIsShared);
|
|
|
|
// System.out.println("shareChangeCondition remove item: "+ shareChangeCondition);
|
|
|
|
workspaceLogger.trace("shareChangeCondition remove item: "+ shareChangeCondition);
|
|
|
|
//Notify Removed Item To Sharing?
|
|
//if source Item is shared and folder destination is not shared or shareChangeCondition is true.. notifies removed item to sharing
|
|
if(sourceItemIsShared && (!folderDestinationItem.isShared() || shareChangeCondition)){
|
|
|
|
//get contacts
|
|
List<InfoContactModel> listContacts = getListUserSharedByFolderSharedId(sourceSharedId);
|
|
|
|
//DEBUG
|
|
printContacts(listContacts);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem sourceSharedFolder = workspace.getItem(sourceSharedId);
|
|
|
|
//System.out.println(" name sourceSharedFolder: "+ sourceSharedFolder.getName());
|
|
|
|
NotificationsProducer np = getNotificationProducer();
|
|
|
|
np.notifyMovedItemToSharing(listContacts, sourceItem, (WorkspaceFolder) sourceSharedFolder);
|
|
|
|
workspaceLogger.trace("The notifies was sent correctly");
|
|
|
|
}
|
|
|
|
}else
|
|
workspaceLogger.warn("The notifies is failure in checkNotifyMoveItemFromShare because folder destination item is null");
|
|
|
|
}catch (Exception e) {
|
|
workspaceLogger.error("An error occurred in checkNotifyMoveItemFromShare ",e);
|
|
}
|
|
|
|
}
|
|
|
|
//DEBUG
|
|
private void printContacts(List<InfoContactModel> listContacts){
|
|
|
|
boolean testMode = isTestMode();
|
|
if(testMode)
|
|
System.out.println("Contacts: ");
|
|
else
|
|
workspaceLogger.trace("Contacts:");
|
|
|
|
for (InfoContactModel infoContactModel : listContacts) {
|
|
if(testMode)
|
|
System.out.println("User: "+infoContactModel);
|
|
else
|
|
workspaceLogger.trace("User: "+infoContactModel);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Boolean removeItem(String itemId) throws Exception {
|
|
|
|
try {
|
|
|
|
if(itemId == null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("removeItem item for id: "+itemId);
|
|
|
|
//NOTIFICATION
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
//SAVING ATTRIBUTE FOR NOTIFICATION
|
|
boolean sourceItemIsShared = wsItem.isShared();
|
|
String itemName = wsItem.getName();
|
|
String sourceFolderSharedId = null;
|
|
|
|
if(sourceItemIsShared){
|
|
sourceFolderSharedId = wsItem.getIdSharedFolder();
|
|
}
|
|
|
|
//REMOVE ITEM
|
|
workspace.removeItem(itemId);
|
|
|
|
//IF SOURCE SHARED FOLDER IS NOT NULL
|
|
if(sourceFolderSharedId!=null)
|
|
NotificationsUtil.checkSendNotifyRemoveItemToShare(this.getThreadLocalRequest().getSession(), sourceItemIsShared, itemName, itemId, sourceFolderSharedId);
|
|
|
|
|
|
return Boolean.TRUE;
|
|
|
|
} catch (InsufficientPrivilegesException e) {
|
|
workspaceLogger.error("Error in server Item remove", e);
|
|
String error = "An error occurred on deleting item. "+e.getMessage();
|
|
throw new Exception(error);
|
|
|
|
}catch (ItemNotFoundException e) {
|
|
String error = "An error occurred on deleting item. "+ConstantsExplorer.ERROR_ITEM_DOES_NOT_EXIST;
|
|
workspaceLogger.error(error, e);
|
|
throw new Exception(error);
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server Item remove", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR +" deleting item. "+e.getMessage();
|
|
throw new Exception(error);
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public Boolean renameItem(String itemId, String newName, String previousName) throws Exception {
|
|
|
|
try {
|
|
|
|
if(itemId == null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("rename item itemId: "+itemId+" old name "+ previousName +", new name: "+newName);
|
|
|
|
workspace.renameItem(itemId, newName);
|
|
|
|
//NOTIFIER
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
if(wsItem.isShared()){
|
|
|
|
try{
|
|
List<InfoContactModel> listSharedContact = new ArrayList<InfoContactModel>();
|
|
NotificationsProducer notification = getNotificationProducer();
|
|
listSharedContact = getListUserSharedByFolderSharedId(wsItem.getIdSharedFolder());
|
|
if(NotificationsUtil.isASharedFolder(wsItem)){
|
|
notification.notifyFolderRenamed(listSharedContact, wsItem, previousName, newName, wsItem.getIdSharedFolder());
|
|
}else{
|
|
WorkspaceFolder sharedFolder = (WorkspaceFolder) workspace.getItem(wsItem.getIdSharedFolder());
|
|
notification.notifyItemRenamed(listSharedContact, previousName, wsItem, sharedFolder);
|
|
}
|
|
}catch (Exception e) {
|
|
workspaceLogger.error("An error occurred in checkNotify ", e);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
|
|
} catch (ItemAlreadyExistException e) {
|
|
String error = "An error occurred on renaming item, " +e.getMessage();
|
|
workspaceLogger.error(error, e);
|
|
throw new Exception(error);
|
|
}catch (ItemNotFoundException e2) {
|
|
String error = "An error occurred on renaming item. "+ConstantsExplorer.ERROR_ITEM_DOES_NOT_EXIST;
|
|
workspaceLogger.error(error, e2);
|
|
throw new Exception(error);
|
|
} catch (Exception e) {
|
|
String error = ConstantsExplorer.SERVER_ERROR + " renaming item. "+ConstantsExplorer.TRY_AGAIN;
|
|
workspaceLogger.error(error, e);
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public FolderModel createFolder(String nameFolder, String description, FileModel parent) throws Exception {
|
|
|
|
workspaceLogger.trace("create folder: "+nameFolder +" parent is null"+parent==null);
|
|
|
|
try {
|
|
|
|
if(nameFolder == null)
|
|
throw new Exception("Folder name is null");
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceFolder wsFolder = workspace.createFolder(nameFolder, description, parent.getIdentifier());
|
|
|
|
WorkspaceItem folderDestinationItem = workspace.getItem(parent.getIdentifier());
|
|
|
|
checkNotifyAddItemToShare(wsFolder, null, folderDestinationItem);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGXTFolderModelItem(wsFolder, parent);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server create folder", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public FileDetailsModel getDetailsFile(FileModel folder) throws Exception {
|
|
|
|
try {
|
|
|
|
if(folder == null)
|
|
throw new Exception("Folder is null");
|
|
|
|
workspaceLogger.trace("load file details: " + folder.getName());
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(folder.getIdentifier());
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGWTWorkspaceFileDetails(wsItem, folder);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in load server file details", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public ArrayList<SubTree> getChildrenSubTreeToRootByIdentifier(String itemIdentifier) throws Exception {
|
|
|
|
ArrayList<SubTree> listSubTree = new ArrayList<SubTree>();
|
|
|
|
try {
|
|
|
|
if(itemIdentifier == null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("search itemId: "+itemIdentifier);
|
|
|
|
WorkspaceItem item = workspace.getItem(itemIdentifier); //get item from workspace
|
|
getListsChildrenByParents(listSubTree, item);
|
|
Collections.reverse(listSubTree); //reverse order of array
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server find Item", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
return listSubTree;
|
|
}
|
|
|
|
@Override
|
|
public List<FileGridModel> getSmartFolderResultsByCategory(String category) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get smart folder by category: "+category);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<SearchItem> listWorkspaceItems = new ArrayList<SearchItem>();
|
|
|
|
//Category IMAGES
|
|
if(category.equals(GXTCategoryItemInterface.SMF_IMAGES.toString())){
|
|
|
|
listWorkspaceItems = workspace.getFolderItems(FolderItemType.IMAGE_DOCUMENT, FolderItemType.EXTERNAL_IMAGE);
|
|
|
|
//Category BIODIVERSITY
|
|
}else if(category.equals(GXTCategoryItemInterface.SMF_BIODIVERSITY.toString())){
|
|
|
|
listWorkspaceItems = workspace.getFolderItems(FolderItemType.AQUAMAPS_ITEM);
|
|
|
|
//Category DOCUMENTS
|
|
}else if(category.equals(GXTCategoryItemInterface.SMF_DOCUMENTS.toString())){
|
|
|
|
listWorkspaceItems = workspace.getFolderItems(
|
|
FolderItemType.EXTERNAL_FILE,
|
|
FolderItemType.EXTERNAL_PDF_FILE,
|
|
FolderItemType.QUERY,
|
|
FolderItemType.PDF_DOCUMENT,
|
|
FolderItemType.METADATA,
|
|
FolderItemType.WORKFLOW_REPORT,
|
|
FolderItemType.WORKFLOW_TEMPLATE,
|
|
// FolderItemType.URL_DOCUMENT,
|
|
FolderItemType.DOCUMENT
|
|
);
|
|
|
|
//Category LINKS
|
|
}else if(category.equals(GXTCategoryItemInterface.SMF_LINKS.toString())){
|
|
|
|
listWorkspaceItems = workspace.getFolderItems(FolderItemType.EXTERNAL_URL, FolderItemType.URL_DOCUMENT, FolderItemType.EXTERNAL_RESOURCE_LINK);
|
|
|
|
//Category REPORTS
|
|
}else if(category.equals(GXTCategoryItemInterface.SMF_REPORTS.toString())){
|
|
|
|
listWorkspaceItems = workspace.getFolderItems(FolderItemType.REPORT_TEMPLATE, FolderItemType.REPORT);
|
|
|
|
//Category TIME SERIES
|
|
}else if(category.equals(GXTCategoryItemInterface.SMF_TIMESERIES.toString())){
|
|
|
|
listWorkspaceItems = workspace.getFolderItems(FolderItemType.TIME_SERIES);
|
|
}
|
|
else
|
|
new Exception("Smart folder category unknown");
|
|
|
|
|
|
return builder.filterListFileGridModelItemByCategory(listWorkspaceItems, category);
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get smart folder by category", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
private void getListsChildrenByParents(ArrayList<SubTree> listSubTree, WorkspaceItem item) throws Exception{
|
|
|
|
if(item==null || item.getParent()==null){
|
|
// listParents.add(item);
|
|
return;
|
|
}
|
|
|
|
FolderModel parentModel = new FolderModel(item.getParent().getId(), item.getParent().getName(), null, true, item.getParent().isShared()); //Create parent model
|
|
|
|
List<FileModel> childrenList = getFolderChildren(parentModel); //create children list
|
|
|
|
SubTree subTree = new SubTree(parentModel, childrenList);
|
|
|
|
listSubTree.add(subTree);
|
|
|
|
getListsChildrenByParents(listSubTree, item.getParent());
|
|
}
|
|
|
|
@Override
|
|
public SmartFolderModel createSmartFolder(String name, String description, String query) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("create smart folder by name: "+name);
|
|
workspaceLogger.trace("description " + description);
|
|
workspaceLogger.trace("query " + query);
|
|
|
|
WorkspaceSmartFolder wsSmartFolder = workspace.createSmartFolder(name, description, query); //create Smart Folder from workspace
|
|
|
|
workspaceLogger.trace("create : " +wsSmartFolder.getName() + " id "+ wsSmartFolder.getId());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGXTSmartFolderModel(wsSmartFolder,query);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server create smart folder by name: ", e);
|
|
// workspaceLogger.trace("Error in server create smart folder by id " + e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public Boolean removeSmartFolder(String itemId, String name) throws Exception {
|
|
|
|
if(itemId==null)
|
|
return null;
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("remove smart folder by id: "+itemId);
|
|
|
|
workspace.removeItem(itemId); //remove Smart Folder from workspace
|
|
|
|
return true;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in remove smart folder by id: ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<SmartFolderModel> getAllSmartFolders() throws Exception{
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get all smart folder");
|
|
|
|
List<WorkspaceSmartFolder> listWorkspaceFolder = new ArrayList<WorkspaceSmartFolder>();
|
|
|
|
listWorkspaceFolder = workspace.getAllSmartFolders(); //create Smart Folder from workspace
|
|
|
|
workspaceLogger.trace("list smart folders size" + listWorkspaceFolder.size());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGXTListSmartFolderModel(listWorkspaceFolder);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get all smart folder: ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<FileGridModel> getSmartFolderResultsById(String folderId) throws Exception {
|
|
|
|
if(folderId == null)
|
|
return null;
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get smart folder by id: "+folderId);
|
|
|
|
WorkspaceSmartFolder wsSmartFolder = workspace.getSmartFolder(folderId); //get Smart Folder from workspace
|
|
|
|
workspaceLogger.trace("wsFolder " + wsSmartFolder.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
workspaceLogger.trace(" children size "+wsSmartFolder.getSearchItems().size());
|
|
|
|
return builder.buildGXTListFileGridModelItemForSearch((List<SearchItem>) wsSmartFolder.getSearchItems(), null);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in get server smart folder by id", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public GWTWorkspaceItem getImageById(String identifier, boolean isInteralImage, boolean fullDetails) throws Exception {
|
|
|
|
if(identifier==null)
|
|
return null;
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get image by id: "+identifier);
|
|
|
|
WorkspaceItem item = workspace.getItem(identifier); //get item from workspace
|
|
|
|
//ACCOUNTING READ
|
|
item.markAsRead(true);
|
|
|
|
workspaceLogger.trace("item name " + item.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGWTWorkspaceImage(item, isInteralImage, fullDetails);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get image by id", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public GWTWorkspaceItem getTimeSeriesById(String identifier) throws Exception {
|
|
|
|
if(identifier==null)
|
|
return null;
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get timeseries by id: "+identifier);
|
|
|
|
WorkspaceItem item = workspace.getItem(identifier); //get item from workspace
|
|
|
|
workspaceLogger.trace("item name " + item.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGWTTimeSeries((TimeSeries)item, null);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get timeseries by id", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public GWTWorkspaceItem getUrlById(String identifier, boolean isInternalUrl, boolean fullDetails) throws Exception {
|
|
|
|
try {
|
|
|
|
if(identifier==null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get url by id: "+identifier);
|
|
|
|
WorkspaceItem item = workspace.getItem(identifier); //get item from workspace
|
|
|
|
workspaceLogger.trace("item name " + item.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
// return builder.buildGXTImage(item, isInteralImage, fullDetails);
|
|
|
|
return builder.buildGWTWorspaceUrl(item, isInternalUrl, fullDetails);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get image by id ", e);
|
|
// workspaceLogger.trace("Error in server get image by id " + e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public FileModel createExternalUrl(FileModel parentFileModel, String name, String description, String url) throws Exception {
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
if(parentFileModel==null)
|
|
throw new Exception("Parent item is null");
|
|
|
|
workspaceLogger.trace("create url in parent id: "+parentFileModel.getIdentifier());
|
|
|
|
//DEBUG
|
|
// workspaceLogger.trace("Name " + name);
|
|
// workspaceLogger.trace("description " + description);
|
|
// workspaceLogger.trace("url " + url);
|
|
// workspaceLogger.trace("parentFileModel " + parentFileModel.getIdentifier() + " " + parentFileModel.getName());
|
|
// if(description == null)
|
|
// description = "";
|
|
|
|
ExternalUrl ext = workspace.createExternalUrl(name, description, url, parentFileModel.getIdentifier());
|
|
|
|
WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace
|
|
workspaceLogger.trace("parent name " + parent.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGXTFileModelItem(ext, parentFileModel);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server create url in parent id ", e);
|
|
// workspaceLogger.trace("Error in server create url in parent id " + e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String getURLFromApplicationProfile(String oid) throws Exception {
|
|
|
|
String urlPortlet = "";
|
|
|
|
ApplicationReaderFromGenericResource app = new ApplicationReaderFromGenericResource();
|
|
|
|
try{
|
|
|
|
if(oid==null)
|
|
throw new Exception(IDENTIFIER_IS_NULL);
|
|
|
|
ASLSession session = WsUtil.getAslSession(this.getThreadLocalRequest().getSession());
|
|
|
|
if(WsUtil.isVRE(session)){
|
|
|
|
ScopeProvider.instance.set(session.getScope());
|
|
|
|
// GET WORKSPACE
|
|
Workspace workspace = HomeLibrary.getUserWorkspace(session.getUsername());
|
|
|
|
// GET ITEM FROM WORKSPACE
|
|
WorkspaceItem item = workspace.getItem(oid);
|
|
|
|
// ITEM IS A WorkspaceItemType.FOLDER_ITEM?
|
|
if (item.getType().equals(WorkspaceItemType.FOLDER_ITEM)) {
|
|
FolderItem folderItem = (FolderItem) item;
|
|
|
|
if(folderItem.getFolderItemType().equals(FolderItemType.REPORT)){
|
|
setValueInSession("idreport", oid);
|
|
|
|
}else if(folderItem.getFolderItemType().equals(FolderItemType.REPORT_TEMPLATE)){
|
|
setValueInSession("idtemplate", oid);
|
|
|
|
}
|
|
|
|
return "";
|
|
}
|
|
}
|
|
else
|
|
urlPortlet = app.getURLFromApplicationProfile(oid, WsUtil.getAslSession(this.getThreadLocalRequest().getSession()),this.getThreadLocalRequest().getSession());
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("getURLFromApplicationProfile", e);
|
|
throw new Exception("Sorry, an error occurred in retrieve application profile, try again");
|
|
}
|
|
|
|
return urlPortlet;
|
|
}
|
|
|
|
@Override
|
|
public void setValueInSession(String name, String value) throws Exception {
|
|
|
|
try{
|
|
|
|
ASLSession session = WsUtil.getAslSession(this.getThreadLocalRequest().getSession());
|
|
session.setAttribute(name, value);
|
|
workspaceLogger.trace("set value in session with name: "+name+", value: "+value);
|
|
// workspaceLogger.debug("WS Session Id = " + session.getExternalSessionID());
|
|
// System.out.println("set value in session with name: "+name+", value: "+value);
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("setValueInSession", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<ScopeModel> getAllScope() throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get all scope");
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
ScopeUtilFilter scopeUtilFilter = getScopeUtilFilter();
|
|
|
|
Home home = workspace.getHome();
|
|
if(home!=null){
|
|
List<String> listIdFilterdScope = scopeUtilFilter.convertListScopeToPortlet(home.listScopes());
|
|
return builder.buildGXTListScopeModel(listIdFilterdScope, scopeUtilFilter.getHashScopesFiltered());
|
|
}else{
|
|
workspaceLogger.error("workspace.getHome() is null");
|
|
throw new Exception("Sorry, an error occurred on getting all scope. Please try later");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get all scope ", e);
|
|
e.printStackTrace();
|
|
// workspaceLogger.trace("Error in server get all scope " + e.getMessage());
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<InfoContactModel> getAllContacts() throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get all contacts");
|
|
|
|
// WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace
|
|
// workspace.getAllScope();
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
if(isTestMode()){
|
|
|
|
workspaceLogger.warn("WORKSPACE PORTLET IS IN TEST MODE - RETURN TEST USERS");
|
|
List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
|
|
// //TEST USERS
|
|
listContactsModel.add(new InfoContactModel("federico.defaveri", "federico.defaveri", "Federico de Faveri"));
|
|
listContactsModel.add(new InfoContactModel("antonio.gioia", "antonio.gioia", "Antonio Gioia"));
|
|
listContactsModel.add(new InfoContactModel("fabio.sinibaldi", "fabio.sinibaldi", "Fabio Sinibaldi"));
|
|
listContactsModel.add(new InfoContactModel("pasquale.pagano", "pasquale.pagano", "Pasquale Pagano"));
|
|
listContactsModel.add(new InfoContactModel(WsUtil.TEST_USER, WsUtil.TEST_USER, WsUtil.TEST_USER_FULL_NAME));
|
|
listContactsModel.add(new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa"));
|
|
listContactsModel.add(new InfoContactModel("massimiliano.assante", "massimiliano.assante", "Massimiliano Assante"));
|
|
return listContactsModel;
|
|
|
|
}
|
|
|
|
UserManager userManag = new LiferayUserManager();
|
|
GroupManager gm = new LiferayGroupManager();
|
|
String groupId = gm.getRootVO().getGroupId();
|
|
workspaceLogger.trace("user manager getting list users by group: "+groupId);
|
|
return builder.buildGXTListContactsModel(userManag.listUsersByGroup(groupId));
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get all contacts ", e);
|
|
// return new ArrayList<InfoContactModel>();
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
// @Override
|
|
// public boolean sendTo(List<InfoContactModel> listContacts, List<FileModel> listAttachments, String subject, String text) throws Exception {
|
|
//
|
|
// try {
|
|
//
|
|
// Workspace workspace = getWorkspace();
|
|
//
|
|
// GCUBEClientLog logger = new GCUBEClientLog(GWTWorkspaceServiceImpl.class);
|
|
// logger.info("sendTo");
|
|
//
|
|
//// WorkspaceItem parent = workspace.getItem(parentFileModel.getIdentifier()); //get item from workspace
|
|
//// workspace.getAllScope();
|
|
//
|
|
// workspaceLogger.trace("######### SEND TO: ");
|
|
// workspaceLogger.trace("subject " + subject);
|
|
// workspaceLogger.trace("text " + text);
|
|
//
|
|
//
|
|
// GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
//
|
|
// return true;
|
|
//
|
|
// } catch (Exception e) {
|
|
// workspaceLogger.error("Error in server sendTo ", e);
|
|
// workspaceLogger.trace("Error in server get sendTo " + e.getMessage());
|
|
// //GWT can't serialize all exceptions
|
|
// throw new Exception(e.getMessage());
|
|
// }
|
|
// }
|
|
|
|
@Override
|
|
public boolean sendToById(List<String> listContactsId, List<String> listAttachmentsId, String subject, String body) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("######### SEND TO: ");
|
|
workspaceLogger.trace("subject " + subject);
|
|
workspaceLogger.trace("body " + body);
|
|
|
|
for(String contactId : listContactsId)
|
|
workspaceLogger.trace("contactId " + contactId);
|
|
|
|
for(String id : listAttachmentsId)
|
|
workspaceLogger.trace("attachId " + id);
|
|
|
|
workspace.getWorkspaceMessageManager().sendMessageToPortalLogins(subject, body, listAttachmentsId, listContactsId);
|
|
|
|
return true;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server sendTo ", e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public List<MessageModel> getAllMessagesSent() throws Exception {
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get All Messages Sent ");
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().getSentMessages();
|
|
|
|
return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_SENT);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server getAllMessagesSent ", e);
|
|
// workspaceLogger.trace("Error in server get getAllMessagesSent " + e.getMessage());
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<MessageModel> getAllMessagesReceived() throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get All Messages Received ");
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().getReceivedMessages();
|
|
|
|
return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_RECEIVED);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server getAllMessagesReceived ", e);
|
|
// workspaceLogger.trace("Error in server get getAllMessagesReceived " + e.getMessage());
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public MessageModel getMessageById(String messageIdentifier, String messageType) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("get Message by Id: "+messageIdentifier);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
WorkspaceMessage message = null;
|
|
if(messageType.equals(GXTCategoryItemInterface.MS_RECEIVED))
|
|
message = workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier);
|
|
else
|
|
message = workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier);
|
|
|
|
|
|
List<WorkspaceItem> listWorkspaceItems = getListWorkspaceItemById(workspace,message.getAttachmentsIds());
|
|
|
|
return builder.buildGXTMessageModel(message, listWorkspaceItems, messageType);
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server get Message by Id ", e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
private List<WorkspaceItem> getListWorkspaceItemById(Workspace workspace, List<String> listItemsId) throws ItemNotFoundException, InternalErrorException{
|
|
|
|
List<WorkspaceItem> listWorkspaceItem = new ArrayList<WorkspaceItem>();
|
|
|
|
for(String itemId: listItemsId){
|
|
|
|
WorkspaceItem item = workspace.getItem(itemId);
|
|
|
|
workspaceLogger.trace("Attach name: " +item.getName());
|
|
workspaceLogger.trace("Attach id: " +item.getId());
|
|
|
|
listWorkspaceItem.add(workspace.getItem(itemId)); //get item from workspace
|
|
}
|
|
|
|
return listWorkspaceItem;
|
|
|
|
|
|
}
|
|
|
|
@Override
|
|
public List<BulkCreatorModel> getListFolderBulkCreator() throws Exception {
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
List<FolderBulkCreator> listFBC = workspace.getFolderBulkCreatorManager().getActiveFolderBulkCreators();
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGXTListBulkCreatorModel(listFBC);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in getNewFolderBulkCreator ", e);
|
|
// workspaceLogger.trace("Error in getNewFolderBulkCreator " + e.getMessage());
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
|
|
}
|
|
|
|
@Override
|
|
public boolean sentToByMessageModel(MessageModel message) throws Exception {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean saveAttachments(String messageIdentifier, String messageType) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace(" save attachments by messageIdentifier " + messageIdentifier);
|
|
if(messageType.equals(GXTCategoryItemInterface.MS_SENT))
|
|
workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).saveAttachments(workspace.getRoot().getId());
|
|
else
|
|
workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).saveAttachments(workspace.getRoot().getId());
|
|
|
|
return true;
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server save attachments by messageIdentifier ", e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean saveAttach(String attachId) throws Exception {
|
|
// TODO NOT USED
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean markMessage(String messageIdentifier, String messageType, boolean boolMark, String markType) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace(" markMessageAsRead by messageIdentifier " + messageIdentifier + " boolMark " + boolMark + " messageType " +messageType);
|
|
|
|
if(messageType.equals(GXTCategoryItemInterface.MS_RECEIVED)){
|
|
|
|
// workspaceLogger.trace("#######################################Message identifier: "+messageIdentifier);
|
|
// workspaceLogger.trace("#######################################Message messageType: "+messageType);
|
|
|
|
if(markType.equals("READ")){
|
|
workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).setStatus(boolMark);
|
|
}else if(markType.equals("OPEN")){
|
|
workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).open();
|
|
}else if(markType.equals("BOTH")){
|
|
workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).setStatus(boolMark);
|
|
workspace.getWorkspaceMessageManager().getReceivedMessage(messageIdentifier).open();
|
|
}
|
|
}
|
|
|
|
else{
|
|
|
|
// workspaceLogger.trace("#######################################Message sent identifier: "+messageIdentifier);
|
|
// workspaceLogger.trace("#######################################Message sent messageType: "+messageType);
|
|
|
|
if(markType.equals("READ")){
|
|
workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).setStatus(boolMark);
|
|
}else if(markType.equals("OPEN")){
|
|
workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).open();
|
|
}else if(markType.equals("BOTH")){
|
|
workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).setStatus(boolMark);
|
|
workspace.getWorkspaceMessageManager().getSentMessage(messageIdentifier).open();
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server markMessageAsRead by messageIdentifier ", e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean deleteMessage(String messageIdentifier, String messageType) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("deleteMessage by messageIdentifier " + messageIdentifier);
|
|
|
|
if(messageType.equals(GXTCategoryItemInterface.MS_RECEIVED))
|
|
workspace.getWorkspaceMessageManager().deleteReceivedMessage(messageIdentifier);
|
|
else
|
|
workspace.getWorkspaceMessageManager().deleteSentMessage(messageIdentifier);
|
|
|
|
return true;
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server deleteMessage by messageIdentifier ", e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
public List<MessageModel> getNewMessagesReceived() throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
int count = workspace.getWorkspaceMessageManager().getMessagesNotOpened();
|
|
|
|
List<MessageModel> listMessageModels = new ArrayList<MessageModel>();
|
|
|
|
for(int i=0; i<count; i++)
|
|
listMessageModels.add(new MessageModel());
|
|
|
|
return listMessageModels;
|
|
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server getNewMessagesReceived by messageIdentifier ", e);
|
|
//GWT can't serialize all exceptions
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
@Override
|
|
public List<MessageModel> searchInSentMessagesByText(String text) throws Exception {
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("searchInSentMessagesByText "+text);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().searchOutMessages(text);
|
|
|
|
return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_SENT);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server searchInSentMessagesByText ", e);
|
|
// workspaceLogger.trace("Error in server searchInSentMessagesByText " + e.getMessage());
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public List<MessageModel> searchInReceivedMessagesByText(String text) throws Exception {
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("searchInSentMessagesByText: "+text);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<WorkspaceMessage> listMessages = workspace.getWorkspaceMessageManager().searchInMessages(text);
|
|
|
|
return builder.buildGXTListMessageModelForGrid(listMessages, GXTCategoryItemInterface.MS_RECEIVED);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server searchInSentMessagesByText ", e);
|
|
// workspaceLogger.trace("Error in server searchInSentMessagesByText " + e.getMessage());
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public boolean copyItem(String itemId, String destinationFolderId) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem sourceItem = workspace.getItem(itemId); //GET SOURCE ITEM BEFORE COPY
|
|
String sourceSharedId = sourceItem.getIdSharedFolder();
|
|
|
|
workspaceLogger.trace("copyItem by id: " + itemId);
|
|
|
|
WorkspaceItem item = workspace.copy(itemId, destinationFolderId); //copy item
|
|
|
|
WorkspaceItem folderDestinationItem = workspace.getItem(destinationFolderId);
|
|
|
|
checkNotifyAddItemToShare(sourceItem, sourceSharedId, folderDestinationItem);
|
|
|
|
if(item!=null)
|
|
return true;
|
|
|
|
return false;
|
|
}catch (InsufficientPrivilegesException e) {
|
|
String error = "An error occurred on copying item, " +e.getMessage() + ". "+ConstantsExplorer.TRY_AGAIN;
|
|
throw new Exception(error);
|
|
|
|
}catch (ItemAlreadyExistException e) {
|
|
String error = "An error occurred on copying item, " +e.getMessage();
|
|
throw new Exception(error);
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in server copyItem by id", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR +" copying item " + ConstantsExplorer.TRY_AGAIN;
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean deleteBulk(String bulkId) throws Exception {
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("delete bulk " + bulkId);
|
|
|
|
workspace.getFolderBulkCreatorManager().getActiveFolderBulkCreator(bulkId).remove();
|
|
|
|
return true;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in getNewFolderBulkCreator ", e);
|
|
// workspaceLogger.trace("Error in getNewFolderBulkCreator " + e.getMessage());
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public String getUrlWebDav(String itemId) throws Exception {
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("getWebDavUrl" + itemId);
|
|
|
|
return workspace.getUrlWebDav();
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in getNewFolderBulkCreator ", e);
|
|
// workspaceLogger.trace("Error in getNewFolderBulkCreator " + e.getMessage());
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean shareFolder(FileModel folder, List<InfoContactModel> listContacts, boolean isNewFolder) throws Exception {
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
workspaceLogger.trace("shareFolder "+ folder.getIdentifier()
|
|
+ " name: "+ folder.getName()
|
|
// + " parent name: " + folder.getParentFileModel().getName()
|
|
+ " listContacts size: " + listContacts.size());
|
|
|
|
// //DEBUG
|
|
//System.out.println("shareFolder "+ folder.getIdentifier() + " name: "+ folder.getName() + " parent name: " + folder.getParentFileModel().getName() + " listContacts size: " + listContacts.size());
|
|
|
|
// for (InfoContactModel infoContactModel : listContacts) {
|
|
// System.out.println("share with "+ infoContactModel.getLogin());
|
|
// }
|
|
|
|
printContacts(listContacts);
|
|
|
|
List<String> listLogin = UserUtil.getListLoginByInfoContactModel(listContacts);
|
|
|
|
WorkspaceSharedFolder sharedFolder = null;
|
|
|
|
List<InfoContactModel> listSharedContact = null;
|
|
|
|
boolean sourceFolderIsShared = folder.isShared();
|
|
|
|
if(sourceFolderIsShared){ //if source folder is already share... retrieve old list of sharing to notify
|
|
listSharedContact = getListUserSharedByFolderSharedId(folder.getIdentifier());
|
|
}
|
|
|
|
if(listLogin.size()>0){
|
|
|
|
if(!isNewFolder){
|
|
sharedFolder = workspace.shareFolder(listLogin, folder.getIdentifier());
|
|
sharedFolder.setDescription(folder.getDescription()); //SET NEW DESCRIPTION
|
|
}
|
|
else
|
|
sharedFolder = workspace.createSharedFolder(folder.getName(), folder.getDescription(), listLogin, folder.getParentFileModel().getIdentifier());
|
|
}
|
|
|
|
boolean created = sharedFolder==null?false:true;
|
|
|
|
|
|
if(created){
|
|
NotificationsProducer np = getNotificationProducer();
|
|
if(!sourceFolderIsShared) //if source folder is not already shared
|
|
np.notifyFolderSharing(listContacts, sharedFolder);
|
|
else{
|
|
System.out.println("SHARED CONTACS: ");
|
|
printContacts(listSharedContact);
|
|
System.out.println("NEW CONTACS: ");
|
|
printContacts(listContacts);
|
|
np.notifyAddedUsersToSharing(listSharedContact, listContacts, sharedFolder);
|
|
}
|
|
}
|
|
|
|
return created;
|
|
|
|
} catch (InsufficientPrivilegesException e) {
|
|
workspaceLogger.error("Error in shareFolder ", e);
|
|
String error = "An error occurred on creating shared folder. "+ e.getMessage();
|
|
throw new Exception(error);
|
|
|
|
} catch (ItemAlreadyExistException e) {
|
|
workspaceLogger.error("Error in shareFolder ", e);
|
|
String error = "An error occurred on creating shared folder. "+ e.getMessage();
|
|
throw new Exception(error);
|
|
|
|
} catch (WrongDestinationException e) {
|
|
workspaceLogger.error("Error in shareFolder ", e);
|
|
String error = "An error occurred on creating shared folder. "+ e.getMessage();
|
|
throw new Exception(error);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in shareFolder ", e);
|
|
e.printStackTrace();
|
|
String error = ConstantsExplorer.SERVER_ERROR+" creating shared folder.";
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<InfoContactModel> getListUserSharedByFolderSharedId(String folderSharedId) throws Exception{
|
|
|
|
workspaceLogger.trace("getListUserSharedByFolderSharedId "+ folderSharedId);
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(folderSharedId);
|
|
|
|
if(NotificationsUtil.isASharedFolder(wsItem)){
|
|
|
|
WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<String> listPortalLogin = wsFolder.getUsers();
|
|
|
|
workspaceLogger.trace("getListUserSharedByFolderSharedId return "+ listPortalLogin.size() + " user");
|
|
|
|
if(isTestMode())
|
|
return builder.buildGxtInfoContactFromPortalLoginTestMode(listPortalLogin);
|
|
|
|
return builder.buildGxtInfoContactsFromPortalLogins(listPortalLogin);
|
|
|
|
}
|
|
else{
|
|
workspaceLogger.trace("the item with id: "+folderSharedId+ " is not "+WorkspaceItemType.SHARED_FOLDER);
|
|
|
|
//DEBUG
|
|
//System.out.println("the item with id: "+folderSharedId+ " is not "+WorkspaceItemType.SHARED_FOLDER);
|
|
}
|
|
return new ArrayList<InfoContactModel>();
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in getListUserSharedByItemId ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public List<InfoContactModel> getListUserSharedBySharedItem(String sharedItemId) throws Exception{
|
|
|
|
workspaceLogger.trace("getListUserSharedBySharedItem "+ sharedItemId);
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(sharedItemId);
|
|
|
|
if(wsItem!=null && wsItem.isShared()){
|
|
|
|
WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) workspace.getItem(wsItem.getIdSharedFolder());
|
|
|
|
if(wsFolder!=null){
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<String> listPortalLogin = wsFolder.getUsers();
|
|
|
|
workspaceLogger.trace("getListUserSharedByFolderSharedId return "+ listPortalLogin.size() + " user");
|
|
|
|
if(isTestMode())
|
|
return builder.buildGxtInfoContactFromPortalLoginTestMode(listPortalLogin);
|
|
|
|
|
|
return builder.buildGxtInfoContactsFromPortalLogins(listPortalLogin);
|
|
}
|
|
|
|
}
|
|
return new ArrayList<InfoContactModel>();
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in getListUserSharedByItemId ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean unSharedFolderByFolderSharedId(String folderSharedId) throws Exception{
|
|
|
|
boolean unShared = false;
|
|
|
|
workspaceLogger.trace("unSharedFolderByFolderSharedId "+ folderSharedId);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(folderSharedId);
|
|
|
|
workspaceLogger.trace("workspace return an item with name "+wsItem.getName());
|
|
|
|
if(wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
|
|
|
|
WorkspaceSharedFolder wsFolder = (WorkspaceSharedFolder) wsItem;
|
|
|
|
WorkspaceFolder unSharedFolder = wsFolder.unShare();
|
|
|
|
unShared = unSharedFolder==null?false:true;
|
|
|
|
// System.out.println("unShared is "+unShared);
|
|
|
|
workspaceLogger.trace("unShared is "+ unShared);
|
|
|
|
|
|
/* INTERNAL POLICY, UN SHARE NOT SHOULD PRODUCE NOTIFICATIONS
|
|
if(unShared){
|
|
NotificationsProducer np = getNotificationProducer();
|
|
|
|
List<InfoContactModel> contacts = getListUserSharedByFolderSharedId(folderSharedId);
|
|
|
|
// if(isTestMode()){
|
|
// contacts = new ArrayList<InfoContactModel>();
|
|
// contacts.add(new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa"));
|
|
// }
|
|
workspaceLogger.trace("UNSHARE WITH: ");
|
|
printContacts(contacts);
|
|
|
|
np.notifyFolderUnSharing(contacts, unSharedFolder);
|
|
}
|
|
|
|
*/
|
|
|
|
}
|
|
else
|
|
workspaceLogger.trace("the item with id: "+folderSharedId+ "is not "+WorkspaceItemType.SHARED_FOLDER);
|
|
|
|
} catch (InternalErrorException e) {
|
|
workspaceLogger.error("Error in unSharedFolderByFolderSharedId ", e);
|
|
String error = "An error occerred on unsharing folder. "+ e.getMessage();
|
|
throw new Exception(error);
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in unSharedFolderByFolderSharedId ", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR+" un share folder. Refresh folder and " +ConstantsExplorer.TRY_AGAIN;
|
|
e.printStackTrace();
|
|
throw new Exception(error);
|
|
}
|
|
|
|
return unShared;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param itemIdentifier
|
|
* @param includeItemAsParent - if parameter is true and item passed in input is a folder, the folder is included in path returned as last parent
|
|
* @return
|
|
* @throws Exception
|
|
*/
|
|
@Override
|
|
public List<FileModel> getListParentsByItemIdentifier(String itemIdentifier, boolean includeItemAsParent) throws Exception {
|
|
List<FileModel> listParents = new ArrayList<FileModel>();
|
|
workspaceLogger.trace("get List Parents By Item Identifier "+ itemIdentifier);
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemIdentifier);
|
|
|
|
workspaceLogger.trace("workspace retrieve item name: "+wsItem.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
if(includeItemAsParent==true && wsItem.getType().equals(WorkspaceItemType.FOLDER)){
|
|
listParents.add(builder.buildGXTFolderModelItem((WorkspaceFolder) wsItem, null));
|
|
}
|
|
|
|
while(wsItem!=null && wsItem.getParent()!=null){
|
|
|
|
WorkspaceFolder wsFolder = wsItem.getParent();
|
|
listParents.add(builder.buildGXTFolderModelItem(wsFolder, null));
|
|
wsItem = wsFolder;
|
|
}
|
|
|
|
Collections.reverse(listParents);
|
|
|
|
//SET PARENTS
|
|
for(int i=0; i<listParents.size()-1; i++){
|
|
|
|
FileModel parent = listParents.get(i);
|
|
FileModel fileModel = listParents.get(i+1);
|
|
|
|
fileModel.setParentFileModel(parent);
|
|
}
|
|
|
|
workspaceLogger.trace("list parents return size: "+listParents.size());
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in get List Parents By Item Identifier ", e);
|
|
e.printStackTrace();
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
return listParents;
|
|
}
|
|
|
|
@Override
|
|
public InfoContactModel getOwnerByItemId(String itemId) throws Exception {
|
|
|
|
workspaceLogger.trace("get Owner By ItemId "+ itemId);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
return builder.buildGXTInfoContactModel(wsItem.getOwner());
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in getOwnerByItemId ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String itemExistsInWorkpaceFolder(String parentId, String itemName) throws Exception {
|
|
|
|
workspaceLogger.trace("get itemExistsInWorkpace by parentId: "+parentId);
|
|
System.out.println("get itemExistsInWorkpace by parentId: "+parentId);
|
|
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(parentId); //GET PARENT
|
|
|
|
if(wsItem.getType().equals(WorkspaceItemType.FOLDER) || wsItem.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
|
|
|
|
WorkspaceItem itemFound = workspace.find(itemName, parentId);
|
|
|
|
if(itemFound==null)
|
|
return null;
|
|
|
|
return itemFound.getId();
|
|
}
|
|
else
|
|
throw new Exception("Invalid Folder parent");
|
|
|
|
|
|
} catch (InternalErrorException e) {
|
|
|
|
return null;
|
|
|
|
} catch (ItemNotFoundException e) {
|
|
|
|
return null;
|
|
|
|
} catch (Exception e) {
|
|
String error = "an error occurred on search item in folder ";
|
|
workspaceLogger.error(error, e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Date getItemCreationDateById(String itemId) throws Exception {
|
|
workspaceLogger.trace("get Item Creation Date By ItemId "+ itemId);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
Calendar cl = wsItem.getCreationTime();
|
|
|
|
if(cl!=null)
|
|
return cl.getTime();
|
|
|
|
return null;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("get Item Creation Date By ItemId ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Long loadSizeByItemId(String itemId) throws Exception {
|
|
|
|
workspaceLogger.trace("get Size By ItemId "+ itemId);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
Long size = new Long(-1);
|
|
|
|
if(wsItem instanceof FolderItem){
|
|
|
|
FolderItem folderItem = (FolderItem) wsItem;
|
|
|
|
size = new Long(folderItem.getLength());
|
|
}
|
|
|
|
return size;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("get Size By ItemId ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public Date loadLastModificationDateById(String itemId) throws Exception {
|
|
|
|
workspaceLogger.trace("get last modification date ItemId "+ itemId);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
wsItem.getLastModificationTime().getTime();
|
|
|
|
Date lastModification =null;
|
|
|
|
if(wsItem.getLastModificationTime()!=null){
|
|
|
|
lastModification = wsItem.getLastModificationTime().getTime();
|
|
}
|
|
|
|
return lastModification;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("get last modification date ItemId ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public FileModel getParentByItemId(String identifier) throws Exception {
|
|
|
|
workspaceLogger.trace("get Parent By Item Identifier "+ identifier);
|
|
try {
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(identifier);
|
|
|
|
workspaceLogger.trace("workspace retrieve item name: "+wsItem.getName());
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
while(wsItem!=null && wsItem.getParent()!=null){
|
|
|
|
WorkspaceFolder wsFolder = wsItem.getParent();
|
|
workspaceLogger.trace("parent was found "+wsFolder.getName()+ " retuning");
|
|
return builder.buildGXTFolderModelItem(wsFolder, null);
|
|
}
|
|
workspaceLogger.trace("parent not found - retuning");
|
|
return null;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error in get Parent By Item Identifier", e);
|
|
e.printStackTrace();
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<GxtAccountingField> getAccountingReaders(String identifier) throws Exception {
|
|
|
|
workspaceLogger.trace("get accounting readers "+ identifier);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(identifier);
|
|
|
|
// List<AccountingEntry> accoutings = wsItem.getAccounting();
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<GxtAccountingField> listReaders = builder.buildGXTAccountingItemFromReaders(wsItem.getReaders());
|
|
|
|
workspaceLogger.trace("get accounting readers - returning size "+listReaders.size());
|
|
return listReaders;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error get accounting readers ", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR+" getting account. "+ConstantsExplorer.TRY_AGAIN;
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<GxtAccountingField> getAccountingHistory(String identifier) throws Exception {
|
|
|
|
workspaceLogger.trace("get accounting history "+ identifier);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(identifier);
|
|
|
|
List<AccountingEntry> accoutings = wsItem.getAccounting();
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
List<GxtAccountingField> listReaders = builder.buildGXTAccountingItem(accoutings, GxtAccountingEntryType.ALL);
|
|
|
|
workspaceLogger.trace("get accounting readers - returning size "+listReaders.size());
|
|
return listReaders;
|
|
|
|
} catch (Exception e) {
|
|
workspaceLogger.error("Error get accounting readers ", e);
|
|
String error = ConstantsExplorer.SERVER_ERROR+" getting account. "+ConstantsExplorer.TRY_AGAIN;
|
|
throw new Exception(error);
|
|
}
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService#getShortUrl(java.lang.String)
|
|
*/
|
|
@Override
|
|
public String getShortUrl(String longUrl) throws Exception {
|
|
|
|
workspaceLogger.trace("get short url for "+ longUrl);
|
|
|
|
UrlShortener shortener = getUrlShortener();
|
|
try{
|
|
|
|
if(shortener!=null && shortener.isAvailable())
|
|
return shortener.shorten(longUrl);
|
|
|
|
return longUrl;
|
|
|
|
}catch (Exception e) {
|
|
workspaceLogger.error("Error get short url for ", e);
|
|
return longUrl;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param itemId
|
|
* @param shortenUrl
|
|
* @return
|
|
*/
|
|
@Override
|
|
public String getPublicLinkForFolderItemId(String itemId, boolean shortenUrl) throws Exception{
|
|
|
|
workspaceLogger.trace("get Public Link For ItemId: "+ itemId);
|
|
|
|
GWTWorkspaceBuilder builder = getGWTWorkspaceBuilder();
|
|
|
|
try{
|
|
|
|
Workspace workspace = getWorkspace();
|
|
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
if(wsItem.getType().equals(WorkspaceItemType.FOLDER_ITEM)){
|
|
|
|
FolderItem folderItem = (FolderItem) wsItem;
|
|
String smpUri = builder.getPubliLinkForFolderItem(folderItem);
|
|
|
|
if(smpUri==null || smpUri.isEmpty())
|
|
throw new Exception("Sorry, public link on "+wsItem.getName() +" is not available");
|
|
|
|
UriResolverReaderParameter uriResolver = getUriResolver();
|
|
|
|
String uriRequest = "";
|
|
|
|
if(uriResolver!=null && uriResolver.isAvailable()){
|
|
|
|
String itemName = StringUtil.removeSpecialCharacters(folderItem.getName());
|
|
|
|
itemName = StringUtil.replaceAllWhiteSpace(itemName, "_");
|
|
uriRequest = uriResolver.resolveAsUriRequest(smpUri, itemName, folderItem.getMimeType(), true);
|
|
|
|
|
|
//VALIDATE CONNECTION
|
|
if(!HttpRequestUtil.urlExists(uriRequest))
|
|
throw new Exception("Sorry, The Public Link for selected file is unavailable");
|
|
|
|
if(shortenUrl)
|
|
uriRequest = getShortUrl(uriRequest);
|
|
|
|
return uriRequest;
|
|
|
|
}
|
|
else
|
|
throw new Exception("Sorry, The Uri resolver service is temporarily unavailable. Please try again later");
|
|
|
|
}else{
|
|
workspaceLogger.warn("ItemId: "+ itemId +" is not a folder item, sent exception Public Link unavailable");
|
|
throw new Exception("Sorry, The Public Link for selected file is unavailable");
|
|
}
|
|
|
|
}catch (Exception e) {
|
|
workspaceLogger.error("Error getPublicLinkForFolderItemId for item: "+itemId);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see org.gcube.portlets.user.workspace.client.rpc.GWTWorkspaceService#isSessionExpired()
|
|
*/
|
|
@Override
|
|
public boolean isSessionExpired() throws Exception {
|
|
workspaceLogger.trace("workspace session validating...");
|
|
//READING USERNAME FROM ASL SESSION
|
|
String userUsername = WsUtil.getAslSession(this.getThreadLocalRequest().getSession()).getUsername();
|
|
boolean isTestUser = userUsername.compareTo(WsUtil.TEST_USER)==0;
|
|
|
|
// //TODO COMMENT THIS FOR DEVELOPMENT
|
|
// workspaceLogger.trace("is "+WsUtil.TEST_USER+" user: "+isTestUser + " is test mode: "+isTestMode());
|
|
//
|
|
// if(isTestUser && !isTestMode()){
|
|
// workspaceLogger.error("workspace session is expired! username is: "+WsUtil.TEST_USER);
|
|
// return true; //is TEST_USER, session is expired
|
|
// }
|
|
|
|
|
|
//TODO UNCOMMENT THIS FOR RELEASE
|
|
workspaceLogger.trace("is "+WsUtil.TEST_USER+" user: "+isTestUser);
|
|
|
|
if(isTestUser){
|
|
workspaceLogger.error("workspace session is expired! username is: "+WsUtil.TEST_USER);
|
|
return true; //is TEST_USER, session is expired
|
|
}
|
|
|
|
|
|
workspaceLogger.trace("workspace session is valid! current username is: "+userUsername);
|
|
|
|
return false;
|
|
|
|
}
|
|
}
|