2013-02-06 15:40:17 +01:00
|
|
|
package org.gcube.portlets.user.workspace.client;
|
|
|
|
|
|
|
|
import java.util.ArrayList;
|
2018-11-28 16:50:18 +01:00
|
|
|
import java.util.Arrays;
|
2013-02-06 15:40:17 +01:00
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.HashMap;
|
2013-02-13 18:39:33 +01:00
|
|
|
import java.util.List;
|
2018-03-28 18:35:12 +02:00
|
|
|
import java.util.Map;
|
2016-07-14 12:22:11 +02:00
|
|
|
|
2018-06-13 14:55:53 +02:00
|
|
|
import org.gcube.common.workspacetaskexecutor.shared.FilterOperator;
|
2016-11-25 15:23:28 +01:00
|
|
|
import org.gcube.portal.clientcontext.client.GCubeClientContext;
|
2015-10-06 12:16:22 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.ConstantsExplorer.WS_UPLOAD_TYPE;
|
2013-06-14 15:04:43 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.ConstantsExplorer.WsPortletInitOperation;
|
2013-05-23 19:03:43 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.AccountingHistoryEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AccountingHistoryEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AccountingReadersEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AccountingReadersEventHandler;
|
2014-07-08 18:41:53 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.AddAdministratorEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AddAdministratorEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.AddFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AddFolderEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AddSmartFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.AddSmartFolderEventHandler;
|
2018-03-28 18:35:12 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.CheckItemLockedBySyncEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.CheckItemLockedBySyncEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.CompletedFileUploadEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.CompletedFileUploadEventHandler;
|
2018-11-28 16:50:18 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.CopyItemsEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.CopyItemsEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.CreateSharedFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.CreateSharedFolderEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.CreateUrlEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.CreateUrlEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.DeleteItemEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.DeleteItemEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.DeleteSmartFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.DeleteSmartFolderEventHandler;
|
2018-11-28 16:50:18 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.DragOnTreeMoveItemEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.DragOnTreeMoveItemEventHandler;
|
2015-01-28 12:42:48 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.EditUserPermissionEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.EditUserPermissionEventHandler;
|
2018-06-07 16:54:36 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.ExecuteDataMinerTaskEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.ExecuteDataMinerTaskEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.ExpandFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.ExpandFolderEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FileDownloadEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FileDownloadEvent.DownloadType;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FileDownloadEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FileUploadEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FileUploadEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FilterScopeEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.FilterScopeEventHandler;
|
2016-09-14 12:17:14 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetFolderLinkEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetFolderLinkEventHandler;
|
2013-03-25 12:35:05 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetInfoEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetInfoEventHandler;
|
2013-07-09 14:48:34 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetPublicLinkEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetPublicLinkEventHandler;
|
2013-06-07 14:07:37 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetShareLinkEvent;
|
2013-06-07 14:47:28 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.GetSharedLinkEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.ImagePreviewEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.ImagePreviewEventHandler;
|
2018-11-28 16:50:18 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.LoadFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.MoveItemsEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.MoveItemsEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.OpenContextMenuTreeEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.OpenContextMenuTreeEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.OpenReportsEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.OpenReportsEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.OpenUrlEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.OpenUrlEventHandler;
|
2016-06-27 16:27:48 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.PublishOnDataCatalogueEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.PublishOnDataCatalogueEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.RefreshFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.RefreshItemEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.RenameItemEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.RenameItemEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.RenderForm;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.RenderFormEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SelectedItemEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SelectedItemEventHandler;
|
2013-09-04 15:30:17 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.SessionExpiredEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SessionExpiredEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.SmartFolderSelectedEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SmartFolderSelectedEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SubTreeLoadedEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SubTreeLoadedEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SwitchViewEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SwitchViewEventHandler;
|
2018-03-01 11:34:08 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.SyncWithThreddsCatalogueEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.SyncWithThreddsCatalogueEventHandler;
|
2014-01-13 17:11:09 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.TrashEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.TrashEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.UnShareFolderEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.UnShareFolderEventHandler;
|
2014-10-30 18:11:56 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.UpdateWorkspaceSizeEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.UpdateWorkspaceSizeEventHandler;
|
2014-03-18 12:50:53 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.UpdatedVREPermissionEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.UpdatedVREPermissionEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.VRESettingPermissionEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.VRESettingPermissionEventHandler;
|
2017-02-20 14:57:07 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.VersioningHistoryShowEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.VersioningHistoryShowEventHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.event.WebDavUrlEvent;
|
|
|
|
import org.gcube.portlets.user.workspace.client.event.WebDavUrlEventHandler;
|
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.EventsTypeEnum;
|
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.GXTFolderItemTypeEnum;
|
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.GuiEventInterface;
|
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.SubscriberInterface;
|
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.TreeAppControllerInterface;
|
|
|
|
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.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.rpc.GWTWorkspaceServiceAsync;
|
2013-06-25 15:33:03 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.util.RequestBuilderWorkspaceValidateItem;
|
|
|
|
import org.gcube.portlets.user.workspace.client.util.WindowOpenParameter;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.ExplorerPanel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.sharing.DialogShareFolder;
|
2016-05-05 11:49:36 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.sharing.UserStore;
|
2014-03-17 14:43:06 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.sharing.permissions.DialogPermission;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.tree.AsyncTreePanel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogAddFolderAndSmart;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogAddFolderAndSmart.AddType;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogAddUrl;
|
2013-03-25 12:35:05 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogGetInfo;
|
2016-09-14 12:17:14 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogGetLink;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogGetLink.Link_Type;
|
2013-06-07 14:07:37 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogShareLink;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogText;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.DialogWebDavUrl;
|
2017-05-26 17:34:51 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.ImagesPreviewController;
|
2013-06-25 15:33:03 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.InfoDisplayMessage;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.MessageBoxAlert;
|
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.MessageBoxConfirm;
|
2015-09-21 13:00:26 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.NewBrowserWindow;
|
2013-06-07 14:07:37 +02:00
|
|
|
import org.gcube.portlets.user.workspace.client.view.windows.accounting.WindowAccountingInfo;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.GWTWorkspaceItem;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.GWTExternalImage;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.GWTExternalUrl;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.gcube.GWTImageDocument;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.gcube.GWTUrlDocument;
|
2019-04-30 12:06:04 +02:00
|
|
|
import org.gcube.portlets.user.workspace.shared.SHUBOperationNotAllowedException;
|
2014-01-14 14:41:03 +01:00
|
|
|
import org.gcube.portlets.user.workspace.shared.SessionExpiredException;
|
2014-10-28 17:12:40 +01:00
|
|
|
import org.gcube.portlets.user.workspace.shared.UserBean;
|
2018-11-28 16:50:18 +01:00
|
|
|
import org.gcube.portlets.user.workspace.shared.WorkspaceOperationResult;
|
2013-05-23 19:03:43 +02:00
|
|
|
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingField;
|
2016-07-14 12:22:11 +02:00
|
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.client.events.CloseCreationFormEvent;
|
2017-05-15 18:15:34 +02:00
|
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.client.ui.form.CreateDatasetForm;
|
2015-01-28 18:27:23 +01:00
|
|
|
import org.gcube.portlets.widgets.workspacesharingwidget.client.ConstantsSharing.LOAD_CONTACTS_AS;
|
|
|
|
import org.gcube.portlets.widgets.workspacesharingwidget.client.MultiDragConstants;
|
2019-02-22 12:18:03 +01:00
|
|
|
import org.gcube.portlets.widgets.workspacesharingwidget.client.ShowPermissionsDialog;
|
2014-09-23 16:15:36 +02:00
|
|
|
import org.gcube.portlets.widgets.workspacesharingwidget.client.SimpleMultiDragWorkspaceContact;
|
2019-02-22 12:18:03 +01:00
|
|
|
import org.gcube.portlets.widgets.workspacesharingwidget.client.rpc.WorkspaceSharingServiceAsync;
|
|
|
|
import org.gcube.portlets.widgets.workspacesharingwidget.shared.InfoContactModel;
|
2015-10-05 18:33:14 +02:00
|
|
|
import org.gcube.portlets.widgets.workspaceuploader.client.WorkspaceUploadNotification.WorskpaceUploadNotificationListener;
|
2015-10-06 10:46:17 +02:00
|
|
|
import org.gcube.portlets.widgets.workspaceuploader.client.uploader.DialogUpload.UPLOAD_TYPE;
|
|
|
|
import org.gcube.portlets.widgets.workspaceuploader.client.uploader.MultipleDilaogUpload;
|
2018-11-28 16:50:18 +01:00
|
|
|
import org.gcube.portlets.widgets.wsexplorer.client.WorkspaceExplorerConstants;
|
|
|
|
import org.gcube.portlets.widgets.wsexplorer.client.notification.WorkspaceExplorerSelectNotification.WorskpaceExplorerSelectNotificationListener;
|
|
|
|
import org.gcube.portlets.widgets.wsexplorer.client.select.WorkspaceExplorerSelectDialog;
|
|
|
|
import org.gcube.portlets.widgets.wsexplorer.client.view.grid.ItemsTable.DISPLAY_FIELD;
|
|
|
|
import org.gcube.portlets.widgets.wsexplorer.shared.Item;
|
2018-06-07 16:54:36 +02:00
|
|
|
import org.gcube.portlets.widgets.wstaskexecutor.client.WsTaskExecutorWidget;
|
2018-06-13 14:55:53 +02:00
|
|
|
import org.gcube.portlets.widgets.wstaskexecutor.shared.SelectableOperator;
|
2018-06-07 16:54:36 +02:00
|
|
|
import org.gcube.portlets.widgets.wstaskexecutor.shared.WSItem;
|
2018-03-20 11:25:43 +01:00
|
|
|
import org.gcube.portlets.widgets.wsthreddssync.client.SyncCompletedNotification.SyncCompletedNotificationListner;
|
2018-03-02 17:06:41 +01:00
|
|
|
import org.gcube.portlets.widgets.wsthreddssync.client.WsThreddsWidget;
|
|
|
|
import org.gcube.portlets.widgets.wsthreddssync.shared.WsFolder;
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
import com.extjs.gxt.ui.client.Registry;
|
|
|
|
import com.extjs.gxt.ui.client.event.BaseEvent;
|
|
|
|
import com.extjs.gxt.ui.client.event.Events;
|
|
|
|
import com.extjs.gxt.ui.client.event.Listener;
|
|
|
|
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
|
|
|
|
import com.extjs.gxt.ui.client.widget.Dialog;
|
2013-02-12 17:17:15 +01:00
|
|
|
import com.extjs.gxt.ui.client.widget.Info;
|
2014-07-08 18:41:53 +02:00
|
|
|
import com.extjs.gxt.ui.client.widget.MessageBox;
|
2016-06-27 16:27:48 +02:00
|
|
|
import com.github.gwtbootstrap.client.ui.Modal;
|
2016-07-14 12:22:11 +02:00
|
|
|
import com.github.gwtbootstrap.client.ui.event.HideEvent;
|
|
|
|
import com.github.gwtbootstrap.client.ui.event.HideHandler;
|
2013-02-06 15:40:17 +01:00
|
|
|
import com.google.gwt.core.client.GWT;
|
|
|
|
import com.google.gwt.event.shared.EventHandler;
|
|
|
|
import com.google.gwt.event.shared.HandlerManager;
|
2013-06-25 15:33:03 +02:00
|
|
|
import com.google.gwt.http.client.RequestBuilder;
|
2013-03-25 11:14:26 +01:00
|
|
|
import com.google.gwt.user.client.Timer;
|
2016-06-27 16:27:48 +02:00
|
|
|
import com.google.gwt.user.client.Window;
|
2013-02-06 15:40:17 +01:00
|
|
|
import com.google.gwt.user.client.rpc.AsyncCallback;
|
|
|
|
import com.google.gwt.user.client.ui.HasWidgets;
|
|
|
|
|
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* The Class AppControllerExplorer.
|
2013-02-06 15:40:17 +01:00
|
|
|
*
|
2019-02-22 14:40:20 +01:00
|
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa{@literal @}isti.cnr.it May 15, 2017
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public class AppControllerExplorer implements EventHandler, TreeAppControllerInterface {
|
2013-05-27 12:21:16 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
public static final GWTWorkspaceServiceAsync rpcWorkspaceService = (GWTWorkspaceServiceAsync) GWT
|
|
|
|
.create(GWTWorkspaceService.class);
|
2013-02-06 15:40:17 +01:00
|
|
|
private ExplorerPanel explorerPanel;
|
|
|
|
private final static HandlerManager eventBus = new HandlerManager(null);
|
2014-01-21 14:55:19 +01:00
|
|
|
private HashMap<EventsTypeEnum, ArrayList<SubscriberInterface>> subscribers = null;
|
2013-02-06 15:40:17 +01:00
|
|
|
private boolean selectRootItem;
|
2014-02-12 12:49:07 +01:00
|
|
|
public static String myLogin;
|
2014-10-28 17:12:40 +01:00
|
|
|
public static String myLoginFirstName;
|
2019-02-22 12:18:03 +01:00
|
|
|
// PRE-LOAD LIST OF USER FORM LIFERAY
|
2016-05-05 11:49:36 +02:00
|
|
|
private UserStore userStore = new UserStore();
|
2014-09-03 15:52:14 +02:00
|
|
|
private static AppControllerExplorer singleton;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
private Map<String, String> msgFolderSynched = new HashMap<String, String>();
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2018-03-05 15:45:25 +01:00
|
|
|
private WsThreddsWidget wsThreddsWidget = new WsThreddsWidget();
|
2018-06-07 16:54:36 +02:00
|
|
|
private WsTaskExecutorWidget taskExecutor = new WsTaskExecutorWidget();
|
2018-03-05 15:45:25 +01:00
|
|
|
|
2019-04-30 12:06:04 +02:00
|
|
|
public static final int delayTime = 3000;
|
2019-02-22 10:57:16 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Instantiates a new app controller explorer.
|
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
public AppControllerExplorer() {
|
|
|
|
Registry.register(ConstantsExplorer.RPC_WORKSPACE_SERVICE, rpcWorkspaceService);
|
2016-02-19 15:59:23 +01:00
|
|
|
subscribers = new HashMap<EventsTypeEnum, ArrayList<SubscriberInterface>>();
|
2013-02-06 15:40:17 +01:00
|
|
|
bind();
|
2014-09-03 15:52:14 +02:00
|
|
|
singleton = this;
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Gets the single instance of AppControllerExplorer.
|
|
|
|
*
|
|
|
|
* @return single instance of AppControllerExplorer
|
|
|
|
*/
|
2014-09-03 15:52:14 +02:00
|
|
|
public static AppControllerExplorer getInstance() {
|
|
|
|
return singleton;
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Gets the event bus.
|
|
|
|
*
|
|
|
|
* @return the event bus
|
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
public static HandlerManager getEventBus() {
|
|
|
|
return eventBus;
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Gets the rpc workspace service.
|
|
|
|
*
|
|
|
|
* @return the rpc workspace service
|
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
public GWTWorkspaceServiceAsync getRpcWorkspaceService() {
|
2013-12-20 11:38:09 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
return rpcWorkspaceService;
|
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Bind.
|
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
private void bind() {
|
2015-01-28 12:42:48 +01:00
|
|
|
|
2018-03-28 18:35:12 +02:00
|
|
|
eventBus.addHandler(CheckItemLockedBySyncEvent.TYPE, new CheckItemLockedBySyncEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onCheckItemLockedBySync(final CheckItemLockedBySyncEvent checkItemLockedBySyncEvent) {
|
|
|
|
|
|
|
|
GWT.log("Fired CheckItemLocked...");
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (checkItemLockedBySyncEvent.getItem() != null) {
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.isItemUnderSync(checkItemLockedBySyncEvent.getItem().getIdentifier(),
|
|
|
|
new AsyncCallback<Boolean>() {
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// TODO Auto-generated method stub
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean result) {
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("CheckItemLocked for folder: "
|
|
|
|
+ checkItemLockedBySyncEvent.getItem().getName() + " returned locked: "
|
|
|
|
+ result);
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
String msgDisplayed = msgFolderSynched
|
|
|
|
.get(checkItemLockedBySyncEvent.getItem().getIdentifier());
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (msgDisplayed == null && result) {
|
|
|
|
String msg = "The folder: " + checkItemLockedBySyncEvent.getItem().getName()
|
|
|
|
+ ", " + ConstantsExplorer.MSG_FOLDER_LOCKED_BY_SYNC;
|
|
|
|
MessageBox.info("Warning: folder under synchornization", msg, null);
|
|
|
|
msgFolderSynched.put(checkItemLockedBySyncEvent.getItem().getIdentifier(), msg);
|
|
|
|
}
|
2018-03-28 18:35:12 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2018-03-28 18:35:12 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2016-06-27 16:27:48 +02:00
|
|
|
eventBus.addHandler(PublishOnDataCatalogueEvent.TYPE, new PublishOnDataCatalogueEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onPublish(PublishOnDataCatalogueEvent publishEvent) {
|
|
|
|
|
|
|
|
// get the folder id
|
|
|
|
final String folderId = publishEvent.getFolderId();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folderId != null && !folderId.isEmpty()) {
|
2016-06-27 16:27:48 +02:00
|
|
|
|
|
|
|
final Modal modal = new Modal(true, true);
|
|
|
|
|
2017-02-16 17:04:14 +01:00
|
|
|
modal.setTitle("Publish Item");
|
2016-09-23 12:47:14 +02:00
|
|
|
modal.addStyleName("insert-metadata-modal-style");
|
2016-11-30 16:39:36 +01:00
|
|
|
modal.addStyleName("modal-top-custom");
|
2019-02-22 12:18:03 +01:00
|
|
|
// ((Element)modal.getElement().getChildNodes().getItem(1)).addClassName("modal-body-custom");
|
2016-09-23 12:47:14 +02:00
|
|
|
modal.add(new CreateDatasetForm(folderId, eventBus));
|
|
|
|
modal.setCloseVisible(true);
|
|
|
|
modal.show();
|
2016-08-29 15:39:13 +02:00
|
|
|
|
2016-09-23 12:47:14 +02:00
|
|
|
// hide any popup panel opened
|
|
|
|
modal.addHideHandler(new HideHandler() {
|
2016-06-27 16:27:48 +02:00
|
|
|
|
|
|
|
@Override
|
2016-09-23 12:47:14 +02:00
|
|
|
public void onHide(HideEvent hideEvent) {
|
|
|
|
eventBus.fireEvent(new CloseCreationFormEvent());
|
2016-06-27 16:27:48 +02:00
|
|
|
}
|
|
|
|
});
|
2016-09-23 12:47:14 +02:00
|
|
|
|
2016-06-27 16:27:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2018-03-01 11:34:08 +01:00
|
|
|
eventBus.addHandler(SyncWithThreddsCatalogueEvent.TYPE, new SyncWithThreddsCatalogueEventHandler() {
|
2017-09-27 18:38:30 +02:00
|
|
|
|
|
|
|
@Override
|
2018-03-01 11:34:08 +01:00
|
|
|
public void onSync(SyncWithThreddsCatalogueEvent publishEvent) {
|
2017-09-27 18:38:30 +02:00
|
|
|
|
|
|
|
final FileModel folder = publishEvent.getFolderToPublish();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folder != null) {
|
2018-03-02 15:29:27 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
WsFolder wsFolder = new WsFolder(folder.getIdentifier(), folder.getName());
|
|
|
|
try {
|
|
|
|
wsThreddsWidget.showSyncFolderInfo(wsFolder);
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
wsThreddsWidget.addSyncCompletedListner(new SyncCompletedNotificationListner() {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSyncError(WsFolder folder) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getListParentsByItemIdentifier(folder.getFolderId(), false,
|
|
|
|
new AsyncCallback<List<FileModel>>() {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// TODO Auto-generated method
|
|
|
|
// stub
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(List<FileModel> result) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (result.size() > 0) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
eventBus.fireEvent(new RefreshFolderEvent(
|
|
|
|
result.get(result.size() - 1), true, false, false));
|
|
|
|
}
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2018-03-20 11:25:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSyncCompleted(WsFolder folder) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folder != null) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getListParentsByItemIdentifier(folder.getFolderId(), false,
|
|
|
|
new AsyncCallback<List<FileModel>>() {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// TODO Auto-generated
|
|
|
|
// method stub
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(List<FileModel> result) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (result.size() > 0) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
eventBus.fireEvent(new RefreshFolderEvent(
|
|
|
|
result.get(result.size() - 1), true, false, false));
|
|
|
|
}
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2018-03-20 11:25:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onUnSyncPerformed(WsFolder folder) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folder != null) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getListParentsByItemIdentifier(folder.getFolderId(), false,
|
|
|
|
new AsyncCallback<List<FileModel>>() {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// TODO Auto-generated
|
|
|
|
// method stub
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(List<FileModel> result) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (result.size() > 0) {
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
eventBus.fireEvent(new RefreshFolderEvent(
|
|
|
|
result.get(result.size() - 1), true, false, false));
|
|
|
|
}
|
2018-03-20 11:25:43 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2018-03-20 11:25:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
});
|
2018-03-02 15:29:27 +01:00
|
|
|
} catch (Exception e) {
|
|
|
|
Window.alert(e.getMessage());
|
|
|
|
}
|
2017-09-27 18:38:30 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2017-02-20 14:57:07 +01:00
|
|
|
eventBus.addHandler(VersioningHistoryShowEvent.TYPE, new VersioningHistoryShowEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
2019-01-09 11:47:58 +01:00
|
|
|
public void onFileVersioning(VersioningHistoryShowEvent versioningHistoryEvent) {
|
2017-02-20 14:57:07 +01:00
|
|
|
|
2019-01-09 11:47:58 +01:00
|
|
|
FileModel file = versioningHistoryEvent.getTargetFileModel();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (file == null)
|
2017-02-20 14:57:07 +01:00
|
|
|
return;
|
|
|
|
|
2019-01-09 11:47:58 +01:00
|
|
|
notifySubscriber(versioningHistoryEvent);
|
2017-02-20 14:57:07 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2018-06-07 16:54:36 +02:00
|
|
|
eventBus.addHandler(ExecuteDataMinerTaskEvent.TYPE, new ExecuteDataMinerTaskEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onExecuteDMTask(ExecuteDataMinerTaskEvent executeDataMinerTaskEvent) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (executeDataMinerTaskEvent.getTargetFileModel() != null) {
|
|
|
|
WSItem wsItem = new WSItem(executeDataMinerTaskEvent.getTargetFileModel().getIdentifier(),
|
|
|
|
executeDataMinerTaskEvent.getTargetFileModel().getName());
|
2018-06-13 14:55:53 +02:00
|
|
|
wsItem.setFolder(executeDataMinerTaskEvent.getTargetFileModel().isDirectory());
|
2018-06-07 16:54:36 +02:00
|
|
|
try {
|
2018-06-13 14:55:53 +02:00
|
|
|
|
|
|
|
String[] filterForParameterTypes = new String[1];
|
|
|
|
filterForParameterTypes[0] = "FILE";
|
2019-02-22 12:18:03 +01:00
|
|
|
FilterOperator filterOperator = wsItem.isFolder() ? FilterOperator.LOGICAL_NOT
|
|
|
|
: FilterOperator.LOGICAL_OR;
|
|
|
|
SelectableOperator selectableOperator = new SelectableOperator(filterForParameterTypes,
|
|
|
|
filterOperator);
|
2018-06-13 14:55:53 +02:00
|
|
|
|
|
|
|
taskExecutor.showTaskConfigurations(wsItem, selectableOperator);
|
2019-02-22 12:18:03 +01:00
|
|
|
} catch (Exception e) {
|
2018-06-07 16:54:36 +02:00
|
|
|
Window.alert(e.getMessage());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2014-10-30 18:11:56 +01:00
|
|
|
eventBus.addHandler(UpdateWorkspaceSizeEvent.TYPE, new UpdateWorkspaceSizeEventHandler() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-10-30 18:11:56 +01:00
|
|
|
@Override
|
|
|
|
public void onUpdateWorkspaceSize(UpdateWorkspaceSizeEvent updateWorkspaceSizeEvent) {
|
|
|
|
doUpdateWorkspaceSize(updateWorkspaceSizeEvent);
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(RenderForm.TYPE, new RenderFormEventHandler() {
|
|
|
|
@Override
|
|
|
|
public void onRenderForm(RenderForm event) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2016-09-14 12:17:14 +02:00
|
|
|
eventBus.addHandler(GetFolderLinkEvent.TYPE, new GetFolderLinkEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onGetFolderLink(GetFolderLinkEvent getFolderLinkEvent) {
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("getFolderLinkEvent.getSourceFile() " + getFolderLinkEvent.getSourceFile());
|
2016-09-14 12:17:14 +02:00
|
|
|
// TODO Auto-generated method stub
|
2019-02-22 12:18:03 +01:00
|
|
|
if (getFolderLinkEvent.getSourceFile() != null) {
|
|
|
|
GWT.log("getFolderLinkEvent.getSourceFile() " + getFolderLinkEvent.getSourceFile());
|
|
|
|
DialogGetLink dialog = new DialogGetLink("Copy to clipboard Folder Link: Ctrl+C",
|
|
|
|
getFolderLinkEvent.getSourceFile(), null, Link_Type.FOLDER_LINK,
|
|
|
|
getFolderLinkEvent.isSetPublic());
|
2016-09-14 12:17:14 +02:00
|
|
|
dialog.show();
|
2016-09-15 18:07:32 +02:00
|
|
|
|
2016-09-14 12:17:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
eventBus.addHandler(UnShareFolderEvent.TYPE, new UnShareFolderEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onUnShareFolder(UnShareFolderEvent unShareFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
final FileModel source = unShareFolderEvent.getTargetFileModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
String folderId = null;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (source != null)
|
2013-02-06 15:40:17 +01:00
|
|
|
folderId = source.getIdentifier();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folderId != null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
String msg = "Unsharing the folder, the files will be removed from your workspace. Continue?";
|
|
|
|
MessageBoxConfirm mbc = new MessageBoxConfirm("Confirm Unshare?", msg);
|
|
|
|
|
|
|
|
final String folderIdentification = folderId;
|
|
|
|
|
|
|
|
mbc.getMessageBoxConfirm().addCallback(new Listener<MessageBoxEvent>() {
|
|
|
|
|
2013-12-20 17:05:40 +01:00
|
|
|
public void handleEvent(MessageBoxEvent be) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// IF NOT CANCELLED
|
2013-12-20 17:05:40 +01:00
|
|
|
String clickedButton = be.getButtonClicked().getItemId();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (clickedButton.equals(Dialog.YES)) {
|
2019-05-13 12:32:27 +02:00
|
|
|
GWT.log("Calling unSharedFolderByFolderSharedId for id: "+folderIdentification);
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().mask(ConstantsExplorer.UNSHARING,
|
|
|
|
ConstantsExplorer.LOADINGSTYLE);
|
|
|
|
WorkspaceSharingServiceAsync.INSTANCE.unSharedFolderByFolderSharedId(
|
|
|
|
folderIdentification, new AsyncCallback<Boolean>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2019-02-22 10:57:16 +01:00
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
|
|
|
}
|
2019-02-22 10:57:16 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean result) {
|
2019-04-30 12:06:04 +02:00
|
|
|
GWT.log("Waiting " + delayTime);
|
2019-02-22 12:18:03 +01:00
|
|
|
if (result) { // REFRESH PARENT
|
|
|
|
// FOLDER
|
|
|
|
Timer t = new Timer() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2019-04-30 12:06:04 +02:00
|
|
|
GWT.log("Runing refresh after wait: " + delayTime);
|
2019-02-22 12:18:03 +01:00
|
|
|
eventBus.fireEvent(new RefreshFolderEvent(
|
|
|
|
source.getParentFileModel(), true, true, false));
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-04-30 12:06:04 +02:00
|
|
|
t.schedule(delayTime);
|
2019-02-22 12:18:03 +01:00
|
|
|
} else
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
}
|
|
|
|
|
|
|
|
});
|
2013-12-20 17:05:40 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2014-01-13 17:11:09 +01:00
|
|
|
eventBus.addHandler(TrashEvent.TYPE, new TrashEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2014-01-13 17:11:09 +01:00
|
|
|
@Override
|
|
|
|
public void onTrashEvent(TrashEvent trashEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2014-01-13 17:11:09 +01:00
|
|
|
notifySubscriber(trashEvent);
|
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
eventBus.addHandler(AddAdministratorEvent.TYPE, new AddAdministratorEventHandler() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
@Override
|
|
|
|
public void onAddAdministrator(AddAdministratorEvent addAdministratorEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
final FileModel file = addAdministratorEvent.getSelectedFolder();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (file == null || file.getIdentifier() == null)
|
2014-07-08 18:41:53 +02:00
|
|
|
return;
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// ADMINISTRATOR/S CAN EDIT OTHER ADMINISTRATOR/S
|
2017-03-03 12:06:49 +01:00
|
|
|
showAddAdministratorsDialog(file);
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// COMMENTED 03-03-2017 ONLY OWNER CAN EDIT ADMINISTRATOR/S
|
|
|
|
/*
|
|
|
|
* rpcWorkspaceService.getOwnerByItemId(file.getIdentifier(),
|
|
|
|
* new AsyncCallback<InfoContactModel>() {
|
|
|
|
*
|
|
|
|
* @Override public void onFailure(Throwable caught) {
|
|
|
|
*
|
|
|
|
* if(caught instanceof SessionExpiredException){
|
|
|
|
* GWT.log("Session expired"); eventBus.fireEvent(new
|
|
|
|
* SessionExpiredEvent()); return; }
|
|
|
|
*
|
|
|
|
* new MessageBoxAlert("Error",
|
|
|
|
* "Sorry, an error occurred on recovering the contacts, try again later"
|
|
|
|
* , null); explorerPanel.unmask(); }
|
|
|
|
*
|
|
|
|
* @Override public void onSuccess(InfoContactModel
|
|
|
|
* infoContactModel) {
|
|
|
|
*
|
|
|
|
* //IF IS OWNER
|
|
|
|
* if(AppControllerExplorer.myLogin.compareToIgnoreCase(
|
|
|
|
* infoContactModel.getLogin())==0)
|
|
|
|
* showAddAdministratorsDialog(file); else new
|
|
|
|
* MessageBoxAlert("Permission denied",
|
|
|
|
* "You have no permissions to manage administrators. You are not manager of \""
|
|
|
|
* +file.getName()+"\"", null);
|
|
|
|
*
|
|
|
|
* } });
|
|
|
|
*/
|
2014-07-08 18:41:53 +02:00
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-01-28 12:42:48 +01:00
|
|
|
eventBus.addHandler(EditUserPermissionEvent.TYPE, new EditUserPermissionEventHandler() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-01-28 12:42:48 +01:00
|
|
|
@Override
|
|
|
|
public void onEditUserPermission(EditUserPermissionEvent editUserPermissionEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-01-28 12:42:48 +01:00
|
|
|
final FileModel file = editUserPermissionEvent.getSourceFolder();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (file == null || file.getIdentifier() == null)
|
2015-01-28 12:42:48 +01:00
|
|
|
return;
|
2019-02-22 12:18:03 +01:00
|
|
|
WorkspaceSharingServiceAsync.INSTANCE.getOwnerByItemId(file.getIdentifier(),
|
|
|
|
new AsyncCallback<InfoContactModel>() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2015-01-28 12:42:48 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
2015-01-28 12:42:48 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error",
|
|
|
|
"Sorry, an error occurred on recovering the contacts, try again later", null);
|
|
|
|
explorerPanel.unmask();
|
|
|
|
}
|
2017-03-03 18:40:27 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(InfoContactModel infoContactModel) {
|
|
|
|
|
|
|
|
ediPermissions(file);
|
|
|
|
|
|
|
|
// GWT.log("Comparing owner login
|
|
|
|
// "+infoContactModel +" with "
|
|
|
|
// +AppControllerExplorer.myLogin);
|
|
|
|
// //IF IS OWNER
|
|
|
|
// if(AppControllerExplorer.myLogin.compareToIgnoreCase(infoContactModel.getLogin())==0)
|
|
|
|
// ediPermissions(file);
|
|
|
|
// else
|
|
|
|
// new MessageBoxAlert("Permission denied", "You
|
|
|
|
// have no authority to manage user permissions.
|
|
|
|
// You are not manager of
|
|
|
|
// \""+file.getName()+"\"", null);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2015-01-28 12:42:48 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-01-28 12:42:48 +01:00
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2013-03-25 12:35:05 +01:00
|
|
|
eventBus.addHandler(GetInfoEvent.TYPE, new GetInfoEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-03-25 12:35:05 +01:00
|
|
|
@Override
|
|
|
|
public void onGetInfo(GetInfoEvent getInfoEvent) {
|
|
|
|
new DialogGetInfo(getInfoEvent.getSourceFile());
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(CreateSharedFolderEvent.TYPE, new CreateSharedFolderEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onCreateSharedFolder(CreateSharedFolderEvent createSharedFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
final FileModel sourceFileModel = createSharedFolderEvent.getFileSourceModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// IF ITEM IS SHAREABLE
|
|
|
|
if (sourceFileModel.isShareable()) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// DEBUG
|
|
|
|
System.out.println(
|
|
|
|
"create shared folderEvent - sourceFileModel id " + sourceFileModel.getIdentifier());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
final FileModel parentFileModel = createSharedFolderEvent.getParentFileModel();
|
2013-02-12 16:02:00 +01:00
|
|
|
final boolean isNewFolder = createSharedFolderEvent.isNewFolder();
|
|
|
|
DialogShareFolder dialogSharedFolder = null;
|
|
|
|
String parentDirectoryName = null;
|
|
|
|
FileModel parent = null;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// COMMENTED 26/02/2014
|
|
|
|
// if(parentFileModel==null){ //PARENT IS ROOT
|
|
|
|
// parent = explorerPanel.getAsycTreePanel().getRootItem();
|
|
|
|
// sourceFileModel.setParentFileModel(parent);
|
|
|
|
// }
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (sourceFileModel.isDirectory()) {
|
|
|
|
// explorerPanel.getAsycTreePanel().setExpandTreeLevel(sourceFileModel.getIdentifier(),
|
|
|
|
// true);
|
2013-02-12 16:02:00 +01:00
|
|
|
parentDirectoryName = sourceFileModel.getName();
|
|
|
|
parent = sourceFileModel;
|
2019-02-22 12:18:03 +01:00
|
|
|
} else {
|
2013-02-12 16:02:00 +01:00
|
|
|
parentDirectoryName = parentFileModel.getName();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (isNewFolder)
|
2016-05-16 10:50:15 +02:00
|
|
|
dialogSharedFolder = new DialogShareFolder(parentDirectoryName, eventBus, userStore);
|
2013-02-12 16:02:00 +01:00
|
|
|
else
|
2019-02-22 12:18:03 +01:00
|
|
|
dialogSharedFolder = new DialogShareFolder(parentDirectoryName, sourceFileModel, eventBus,
|
|
|
|
userStore);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
final DialogShareFolder finalDialog = dialogSharedFolder;
|
|
|
|
final FileModel parentModel = parent;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
finalDialog.getButtonById(Dialog.OK).addListener(Events.Select, new Listener<BaseEvent>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
@Override
|
|
|
|
public void handleEvent(BaseEvent be) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (finalDialog.isValidForm(true)) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
FileModel fileModel = null;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (isNewFolder) {
|
|
|
|
// create a lowest object to send to server
|
|
|
|
fileModel = new FileModel("tempId", finalDialog.getName(), parentModel, true,
|
|
|
|
false); // create new shared folder
|
|
|
|
|
|
|
|
} else {
|
|
|
|
fileModel = finalDialog.getParentFolder(); // add
|
|
|
|
// user
|
|
|
|
// for
|
|
|
|
// share
|
|
|
|
|
|
|
|
// create a lowest object to send to server
|
|
|
|
fileModel = new FileModel(fileModel.getIdentifier(), fileModel.getName(),
|
|
|
|
fileModel.getParentFileModel(), fileModel.isDirectory(),
|
|
|
|
fileModel.isShared());
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-27 19:17:22 +01:00
|
|
|
fileModel.setDescription(finalDialog.getDescription());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// DEBUG
|
2014-02-11 16:41:56 +01:00
|
|
|
/*
|
2019-02-22 12:18:03 +01:00
|
|
|
* System.out.println("FileModel id "+fileModel.
|
|
|
|
* getIdentifier() +
|
|
|
|
* " name: "+fileModel.getName() + " parent " +
|
|
|
|
* fileModel.getParentFileModel());
|
|
|
|
* for(InfoContactModel
|
|
|
|
* contact:finalDialog.getSharedListUsers() ){
|
|
|
|
* System.out.println("Share with Contact "
|
|
|
|
* +contact) ;
|
|
|
|
*
|
|
|
|
* }
|
|
|
|
*/
|
|
|
|
|
|
|
|
System.out.println("ACL is " + finalDialog.getSelectedACL());
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2013-02-12 17:17:15 +01:00
|
|
|
Info.display("Info", "An operation of sharing was submitted");
|
2014-02-25 17:24:31 +01:00
|
|
|
explorerPanel.mask("Setting permissions", ConstantsExplorer.LOADINGSTYLE);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
WorkspaceSharingServiceAsync.INSTANCE.shareFolder(fileModel.getIdentifier(),
|
|
|
|
fileModel.getName(), fileModel.getDescription(),
|
|
|
|
fileModel.getParentFileModel() != null
|
|
|
|
? fileModel.getParentFileModel().getIdentifier() : null,
|
|
|
|
finalDialog.getSharedListUsers(), isNewFolder, finalDialog.getSelectedACL(),
|
|
|
|
new AsyncCallback<Boolean>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
2019-02-22 10:57:16 +01:00
|
|
|
explorerPanel.unmask();
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
|
|
|
}
|
2019-02-22 10:57:16 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean result) {
|
|
|
|
if (result) {
|
|
|
|
|
2019-02-22 12:24:33 +01:00
|
|
|
// REFRESH PARENT FOLDER
|
2019-02-22 12:18:03 +01:00
|
|
|
|
2019-02-22 12:24:33 +01:00
|
|
|
Timer t = new Timer() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2019-04-30 12:06:04 +02:00
|
|
|
GWT.log("Runing refresh after wait: " + delayTime); // TODO
|
2019-02-22 12:24:33 +01:00
|
|
|
FileModel parentToRefresh = null;
|
|
|
|
|
|
|
|
if (isNewFolder)
|
|
|
|
parentToRefresh = parentModel;
|
|
|
|
else
|
|
|
|
parentToRefresh = parentFileModel;
|
|
|
|
|
|
|
|
GWT.log("share completed throwing refresh folder : "
|
|
|
|
+ parentToRefresh.getName() + " get id: "
|
|
|
|
+ parentToRefresh.getIdentifier());
|
|
|
|
|
|
|
|
// UPDATED ID
|
|
|
|
RefreshFolderEvent refEvent = new RefreshFolderEvent(
|
|
|
|
parentToRefresh, true, true, false);
|
|
|
|
refEvent.setForceReloadBreadCrumb(true);
|
|
|
|
eventBus.fireEvent(refEvent);
|
|
|
|
explorerPanel.unmask();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-04-30 12:06:04 +02:00
|
|
|
t.schedule(delayTime);
|
2019-02-22 12:18:03 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
explorerPanel.unmask();
|
|
|
|
}
|
|
|
|
});
|
2013-02-12 16:02:00 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else {// ITEM IS NOT SHAREABLE
|
|
|
|
new InfoDisplayMessage("Info",
|
|
|
|
"The selected item is not shareable because an ancestor item is already shared");
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-12 16:02:00 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// ********EVENTS TO NOTIFY SUBSCRIBERS
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(SubTreeLoadedEvent.TYPE, new SubTreeLoadedEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onSubTreeLoaded(SubTreeLoadedEvent event) {
|
|
|
|
doSubTreeLoaded(event);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2019-02-22 12:18:03 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
private void doSubTreeLoaded(SubTreeLoadedEvent event) {
|
|
|
|
notifySubscriber(event);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// ********EVENTS TO NOTIFY SUBSCRIBERS
|
2013-09-04 15:30:17 +02:00
|
|
|
eventBus.addHandler(SessionExpiredEvent.TYPE, new SessionExpiredEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-09-04 15:30:17 +02:00
|
|
|
@Override
|
|
|
|
public void onSessionExpired(SessionExpiredEvent sessionExpiredEvent) {
|
|
|
|
notifySubscriber(sessionExpiredEvent);
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(WebDavUrlEvent.TYPE, new WebDavUrlEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onClickWebDavUrl(WebDavUrlEvent webDavUrlEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
String itemIdentifier = webDavUrlEvent.getItemIdentifier();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (itemIdentifier == null)
|
2013-02-06 15:40:17 +01:00
|
|
|
itemIdentifier = explorerPanel.getAsycTreePanel().getRootItem().getIdentifier();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
rpcWorkspaceService.getUrlWebDav(itemIdentifier, new AsyncCallback<String>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error",
|
|
|
|
ConstantsExplorer.SERVER_ERROR + " viewing WebDAV url" + ConstantsExplorer.TRY_AGAIN,
|
|
|
|
null);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSuccess(String url) {
|
2019-02-22 12:18:03 +01:00
|
|
|
// new MessageBoxInfo(ConstantsExplorer.URL_WEBDAV,
|
|
|
|
// url);
|
|
|
|
DialogWebDavUrl diag = new DialogWebDavUrl(
|
|
|
|
ConstantsExplorer.URL_WEBDAV + ": " + ConstantsExplorer.TITLEACCESSWEBDAV, "", url);
|
2013-02-06 15:40:17 +01:00
|
|
|
diag.selectTxt();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-06-07 14:47:28 +02:00
|
|
|
eventBus.addHandler(GetShareLinkEvent.TYPE, new GetSharedLinkEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-06-07 14:07:37 +02:00
|
|
|
@Override
|
|
|
|
public void onGetLink(GetShareLinkEvent getLinkEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (getLinkEvent.getSourceFile() != null) {
|
2013-06-07 14:07:37 +02:00
|
|
|
|
|
|
|
String currentUrl = portalURL();
|
|
|
|
int lastChar = currentUrl.lastIndexOf("?");
|
2019-02-22 12:18:03 +01:00
|
|
|
currentUrl = lastChar > -1 ? currentUrl.substring(0, lastChar) : currentUrl; // IF
|
|
|
|
// EXISTS
|
|
|
|
// -
|
|
|
|
// REMOVE
|
|
|
|
// STRING
|
|
|
|
// AFTER
|
|
|
|
// ?
|
|
|
|
// (?
|
|
|
|
// INLCUSE)
|
|
|
|
|
|
|
|
// int last = currentUrl.lastIndexOf("/");
|
|
|
|
// String shareLinkUrl = currentUrl.substring(0,last+1) +
|
|
|
|
// "?"
|
|
|
|
// +ConstantsExplorer.GET_ITEMID_PARAMETER+"="+getLinkEvent.getSourceFile().getIdentifier();
|
|
|
|
String shareLinkUrl = currentUrl + "?" + ConstantsExplorer.GET_ITEMID_PARAMETER + "="
|
|
|
|
+ getLinkEvent.getSourceFile().getIdentifier();
|
|
|
|
shareLinkUrl += "&" + ConstantsExplorer.GET_OPERATION_PARAMETER + "="
|
|
|
|
+ WsPortletInitOperation.gotofolder;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-06-07 14:07:37 +02:00
|
|
|
DialogShareLink dialog = new DialogShareLink("Copy to clipboard Share Link: Ctrl+C", shareLinkUrl);
|
|
|
|
dialog.show();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-07-09 14:48:34 +02:00
|
|
|
eventBus.addHandler(GetPublicLinkEvent.TYPE, new GetPublicLinkEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-07-09 14:48:34 +02:00
|
|
|
@Override
|
|
|
|
public void onGetPublicLink(GetPublicLinkEvent getPublicLinkEvent) {
|
|
|
|
// TODO Auto-generated method stub
|
2019-02-22 12:18:03 +01:00
|
|
|
if (getPublicLinkEvent.getSourceFile() != null) {
|
|
|
|
DialogGetLink dialog = new DialogGetLink("Copy to clipboard Public Link: Ctrl+C",
|
|
|
|
getPublicLinkEvent.getSourceFile(), getPublicLinkEvent.getVersion(), Link_Type.PUBLIC_LINK,
|
|
|
|
false);
|
2013-07-09 14:48:34 +02:00
|
|
|
dialog.show();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(RefreshFolderEvent.TYPE, new RefreshItemEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
2013-09-12 15:54:06 +02:00
|
|
|
public void onRefreshItem(RefreshFolderEvent refreshItemEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("RefreshFolderEvent: " + refreshItemEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (refreshItemEvent.getFolderTarget() != null
|
|
|
|
&& refreshItemEvent.getFolderTarget().getIdentifier() != null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (!refreshItemEvent.isCalledTreeSide()) { // Called Tree
|
|
|
|
// side
|
|
|
|
explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(
|
|
|
|
refreshItemEvent.getFolderTarget().getIdentifier(), refreshItemEvent.isExpandFolder());
|
2014-01-15 12:49:40 +01:00
|
|
|
notifySubscriber(refreshItemEvent);
|
2019-02-22 12:18:03 +01:00
|
|
|
} else { // Validating folder existence - called portlet
|
|
|
|
// side
|
|
|
|
// FileModel target =
|
|
|
|
// explorerPanel.getAsycTreePanel().getFileModelByIdentifier(refreshItemEvent.getFolderTarget().getIdentifier());
|
|
|
|
// if(target!=null)
|
|
|
|
explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(
|
|
|
|
refreshItemEvent.getFolderTarget().getIdentifier(), refreshItemEvent.isExpandFolder());
|
2014-01-15 12:49:40 +01:00
|
|
|
}
|
2019-02-22 12:18:03 +01:00
|
|
|
} else
|
2013-03-25 11:14:26 +01:00
|
|
|
GWT.log("warn: escape refresh because item is null");
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// Called from context menu on grid
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(OpenContextMenuTreeEvent.TYPE, new OpenContextMenuTreeEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onOpenContextMenuTree(OpenContextMenuTreeEvent openContextMenuTreeEvent) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().getContextMenuTree().openContextMenuOnItem(
|
|
|
|
openContextMenuTreeEvent.getSelectedItems(), openContextMenuTreeEvent.getClientX(),
|
|
|
|
openContextMenuTreeEvent.getClientY());
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// eventBus.addHandler(CopyItemsEvent.TYPE, new CopyItemsEventHandler()
|
|
|
|
// {
|
|
|
|
//
|
|
|
|
// @Override
|
|
|
|
// public void onCopyItems(CopyItemsEvent copytemEvent) {
|
|
|
|
// notifySubscriber(copytemEvent);
|
|
|
|
// }
|
|
|
|
// });
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
eventBus.addHandler(CopyItemsEvent.TYPE, new CopyItemsEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
2018-11-28 16:50:18 +01:00
|
|
|
public void onCopyItems(final CopyItemsEvent copytemEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (copytemEvent.getIds() != null && copytemEvent.getIds().size() > 0) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
explorerPanel.mask("Copying...", ConstantsExplorer.LOADINGSTYLE);
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.copyItems(copytemEvent.getIds(), copytemEvent.getDestinationFolderId(),
|
|
|
|
new AsyncCallback<WorkspaceOperationResult>() {
|
2014-01-24 16:01:15 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2014-01-24 16:01:15 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.unmask();
|
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error", caught.getMessage() + ".", null);
|
|
|
|
explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(
|
|
|
|
copytemEvent.getDestinationFolderId(), false);
|
|
|
|
notifySubscriber(copytemEvent);
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(WorkspaceOperationResult result) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.unmask();
|
|
|
|
GWT.log("Copy terminated without error? " + result);
|
|
|
|
FileModel folderDestionationInTree = explorerPanel.getAsycTreePanel()
|
|
|
|
.getFileModelByIdentifier(copytemEvent.getDestinationFolderId());
|
|
|
|
GWT.log("Destination Folder: " + copytemEvent.getDestinationFolderId()
|
|
|
|
+ " is in Tree: " + folderDestionationInTree);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (result.getError() != null)
|
|
|
|
new MessageBoxAlert("Error", result.getError(), null);
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folderDestionationInTree != null)
|
|
|
|
eventBus.fireEvent(
|
|
|
|
new RefreshFolderEvent(folderDestionationInTree, true, false, false));
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
notifySubscriber(copytemEvent);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2018-11-28 16:50:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
eventBus.addHandler(MoveItemsEvent.TYPE, new MoveItemsEventHandler() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
@Override
|
|
|
|
public void onMoveItems(MoveItemsEvent moveItemEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("MoveItemEvent is fired on : " + moveItemEvent.getIds().size() + "items, DestinationId: "
|
|
|
|
+ moveItemEvent.getDestionationFolderId());
|
2018-11-28 16:50:18 +01:00
|
|
|
doMoveItems(moveItemEvent);
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
private void doMoveItems(final MoveItemsEvent moveItemsEvent) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (moveItemsEvent.getIds() == null || moveItemsEvent.getIds().size() == 0)
|
2018-11-28 16:50:18 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
WorkspaceExplorerConstants.SELECT = "Move";
|
2019-02-22 12:18:03 +01:00
|
|
|
DISPLAY_FIELD[] displayFields = new DISPLAY_FIELD[] { DISPLAY_FIELD.ICON, DISPLAY_FIELD.NAME,
|
|
|
|
DISPLAY_FIELD.OWNER };
|
|
|
|
final WorkspaceExplorerSelectDialog navigator = new WorkspaceExplorerSelectDialog("Move to...", true,
|
|
|
|
moveItemsEvent.getSourceParentFolder().getIdentifier(), "", displayFields);
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
WorskpaceExplorerSelectNotificationListener listener = new WorskpaceExplorerSelectNotificationListener() {
|
2018-11-28 16:50:18 +01:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSelectedItem(Item item) {
|
|
|
|
navigator.hide();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (item == null)
|
|
|
|
new MessageBoxAlert("Error", "No folder selected", null);
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("destionation folder is: " + item);
|
2018-11-28 16:50:18 +01:00
|
|
|
final String destinationFolderId = item.getId();
|
2019-02-22 12:18:03 +01:00
|
|
|
moveItemsEvent.setDestionationFolderId(destinationFolderId); // do
|
|
|
|
// not
|
|
|
|
// remove
|
|
|
|
// this
|
|
|
|
// set
|
2018-11-28 16:50:18 +01:00
|
|
|
|
|
|
|
explorerPanel.mask("Moving...", ConstantsExplorer.LOADINGSTYLE);
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.moveItems(moveItemsEvent.getIds(), destinationFolderId,
|
|
|
|
new AsyncCallback<WorkspaceOperationResult>() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.unmask();
|
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error", caught.getMessage() + ".", null);
|
|
|
|
explorerPanel.getAsycTreePanel()
|
|
|
|
.reloadTreeLevelAndExpandFolder(destinationFolderId, false);
|
|
|
|
String sourceParentId = moveItemsEvent.getSourceParentFolder() != null
|
|
|
|
? moveItemsEvent.getSourceParentFolder().getIdentifier() : null;
|
|
|
|
explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(sourceParentId,
|
|
|
|
true);
|
|
|
|
notifySubscriber(moveItemsEvent); // WE
|
|
|
|
// MISSING
|
|
|
|
// THE
|
|
|
|
// PARENT
|
|
|
|
// OF
|
|
|
|
// destinationFolderId
|
|
|
|
}
|
2014-01-24 16:01:15 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(WorkspaceOperationResult result) {
|
|
|
|
explorerPanel.unmask();
|
|
|
|
GWT.log("Move terminated without error? " + result);
|
|
|
|
|
|
|
|
// NO ERROR
|
|
|
|
if (result.getError() == null) {
|
|
|
|
// REFRESHING SOURCE PARENT FOLDER
|
|
|
|
eventBus.fireEvent(new RefreshFolderEvent(
|
|
|
|
moveItemsEvent.getSourceParentFolder(), true, false, false));
|
|
|
|
} else {
|
|
|
|
// WITH ERROR
|
|
|
|
new MessageBoxAlert("Error", result.getError(), null);
|
|
|
|
}
|
2014-01-24 16:01:15 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// GETTING DESTINATION FOLDER
|
|
|
|
FileModel folderDestionationInTree = explorerPanel.getAsycTreePanel()
|
|
|
|
.getFileModelByIdentifier(destinationFolderId);
|
|
|
|
GWT.log("Destination Folder: " + destinationFolderId + " is in Tree: "
|
|
|
|
+ folderDestionationInTree);
|
|
|
|
|
|
|
|
// IF DESTINATION FOLDER IS IN THE TREE,
|
|
|
|
// REFRESH IT
|
|
|
|
if (folderDestionationInTree != null)
|
|
|
|
eventBus.fireEvent(new RefreshFolderEvent(folderDestionationInTree, true,
|
|
|
|
false, false));
|
|
|
|
|
|
|
|
// if(folderDestionationInTree!=null)
|
|
|
|
// moveItemsEvent.setTreeRefreshable(true);
|
|
|
|
// else
|
|
|
|
// moveItemsEvent.setTreeRefreshable(false);
|
|
|
|
|
|
|
|
moveItemsEvent.setTreeRefreshable(false); // forcing
|
|
|
|
// grid
|
|
|
|
// refresh
|
|
|
|
notifySubscriber(moveItemsEvent);
|
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
}
|
2014-01-24 16:01:15 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
@Override
|
|
|
|
public void onFailed(Throwable throwable) {
|
|
|
|
GWT.log("onFailed..");
|
|
|
|
navigator.hide();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
@Override
|
|
|
|
public void onAborted() {
|
|
|
|
GWT.log("onAborted..");
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onNotValidSelection() {
|
|
|
|
GWT.log("onNotValidSelection..");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
navigator.addWorkspaceExplorerSelectNotificationListener(listener);
|
|
|
|
navigator.show();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// break;
|
|
|
|
|
|
|
|
// case COPY:
|
|
|
|
//
|
|
|
|
// rpcWorkspaceService.copyItems(pasteItemEvent.getIds(),
|
|
|
|
// pasteItemEvent.getFolderDestinationId(), new
|
|
|
|
// AsyncCallback<Boolean>() {
|
|
|
|
//
|
|
|
|
// @Override
|
|
|
|
// public void onFailure(Throwable caught) {
|
|
|
|
//
|
|
|
|
// if(caught instanceof SessionExpiredException){
|
|
|
|
// GWT.log("Session expired");
|
|
|
|
// eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
// return;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
//
|
|
|
|
// eventBus.fireEvent(new
|
|
|
|
// RefreshFolderEvent(explorerPanel.getAsycTreePanel().getFileModelByIdentifier(pasteItemEvent.getFolderDestinationId()),
|
|
|
|
// false, true, false));
|
|
|
|
//
|
|
|
|
// notifySubscriber(pasteItemEvent);
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// @Override
|
|
|
|
// public void onSuccess(Boolean result) {
|
|
|
|
//
|
|
|
|
// FileModel fileInTree =
|
|
|
|
// explorerPanel.getAsycTreePanel().getFileModelByIdentifier(pasteItemEvent.getFolderDestinationId());
|
|
|
|
// if(result)
|
|
|
|
// eventBus.fireEvent(new RefreshFolderEvent(fileInTree, false,
|
|
|
|
// false, false));
|
|
|
|
//
|
|
|
|
// if(fileInTree!=null)
|
|
|
|
// pasteItemEvent.setTreeRefreshable(true);
|
|
|
|
// else
|
|
|
|
// pasteItemEvent.setTreeRefreshable(false);
|
|
|
|
//
|
|
|
|
// notifySubscriber(pasteItemEvent);
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// });
|
|
|
|
|
|
|
|
// break;
|
|
|
|
|
|
|
|
// default:
|
|
|
|
//
|
|
|
|
// }
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(SwitchViewEvent.TYPE, new SwitchViewEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onSwitchView(SwitchViewEvent switchViewEvent) {
|
|
|
|
notifySubscriber(switchViewEvent);
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(FilterScopeEvent.TYPE, new FilterScopeEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onClickScopeFilter(FilterScopeEvent filterScopeEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().setSearch(false); // SET IS
|
|
|
|
// SEARCH
|
|
|
|
// FALSE
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
doChangeScope(filterScopeEvent.getScopeId());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doChangeScope(String scopeId) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().loadRootItem(selectRootItem); // RELOAD
|
|
|
|
// ROOT
|
|
|
|
// BY
|
|
|
|
// SCOPE
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
eventBus.addHandler(AccountingHistoryEvent.TYPE, new AccountingHistoryEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
@Override
|
|
|
|
public void onAccountingHistoryShow(AccountingHistoryEvent accountingHistoryEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-05-24 18:18:14 +02:00
|
|
|
FileModel fileItem = accountingHistoryEvent.getTargetFileModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileItem != null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
String title = ConstantsExplorer.ACCOUNTING_HISTORY_OF + fileItem.getName();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
final WindowAccountingInfo winInfo = new WindowAccountingInfo(fileItem, title);
|
2013-05-24 18:18:14 +02:00
|
|
|
winInfo.show();
|
|
|
|
winInfo.maskAccountingInfo(true);
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getAccountingHistory(fileItem.getIdentifier(),
|
|
|
|
new AsyncCallback<List<GxtAccountingField>>() {
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
winInfo.maskAccountingInfo(false);
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(List<GxtAccountingField> result) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
winInfo.updateInfoContainer(result);
|
|
|
|
winInfo.maskAccountingInfo(false);
|
|
|
|
}
|
|
|
|
});
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
eventBus.addHandler(AccountingReadersEvent.TYPE, new AccountingReadersEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
@Override
|
|
|
|
public void onAccountingReadersShow(AccountingReadersEvent accountingReadersEvent) {
|
|
|
|
|
2013-05-24 18:18:14 +02:00
|
|
|
FileModel fileItem = accountingReadersEvent.getTargetFileModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileItem != null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
String title = ConstantsExplorer.ACCOUNTING_READERS_OF + fileItem.getName();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
final WindowAccountingInfo winInfo = new WindowAccountingInfo(fileItem, title);
|
2013-05-24 18:18:14 +02:00
|
|
|
winInfo.show();
|
|
|
|
winInfo.maskAccountingInfo(true);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getAccountingReaders(fileItem.getIdentifier(),
|
|
|
|
new AsyncCallback<List<GxtAccountingField>>() {
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
winInfo.maskAccountingInfo(false);
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(List<GxtAccountingField> result) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
winInfo.updateInfoContainer(result);
|
|
|
|
winInfo.maskAccountingInfo(false);
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
eventBus.addHandler(FileDownloadEvent.TYPE, new FileDownloadEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onFileDownloadEvent(FileDownloadEvent fileDownloadEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileDownloadEvent.getItemIdentifier() != null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2017-02-21 18:24:44 +01:00
|
|
|
// Add currentContextId parameter
|
|
|
|
String currentContextId = GCubeClientContext.getCurrentContextId();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileDownloadEvent.getDownloadType().equals(DownloadType.SHOW)) {
|
|
|
|
if (fileDownloadEvent.getItemName() != null) {
|
2013-06-25 15:33:03 +02:00
|
|
|
|
|
|
|
try {
|
2017-02-21 18:24:44 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// String currentUserId =
|
|
|
|
// GCubeClientContext.getCurrentUserId();
|
|
|
|
String queryString = "id=" + fileDownloadEvent.getItemIdentifier()
|
|
|
|
+ "&viewContent=true&" + ConstantsExplorer.CURRENT_CONTEXT_ID + "="
|
|
|
|
+ currentContextId;
|
|
|
|
if (fileDownloadEvent.getVersionId() != null)
|
|
|
|
queryString += "&" + ConstantsExplorer.FILE_VERSION_ID + "="
|
|
|
|
+ fileDownloadEvent.getVersionId();
|
|
|
|
new RequestBuilderWorkspaceValidateItem(RequestBuilder.GET,
|
|
|
|
ConstantsExplorer.DOWNLOAD_WORKSPACE_SERVICE, queryString, "_blank",
|
|
|
|
downloadHandlerCallback);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-06-25 15:33:03 +02:00
|
|
|
} catch (Exception e) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error", e.getMessage(), null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-06-25 15:33:03 +02:00
|
|
|
}
|
2019-02-22 12:18:03 +01:00
|
|
|
// com.google.gwt.user.client.Window.open(ConstantsExplorer.DOWNLOAD_WORKSPACE_SERVICE+"?id="+fileDownloadEvent.getItemIdentifier()+"&viewContent=true",
|
|
|
|
// fileDownloadEvent.getItemName(), "");
|
|
|
|
} else {
|
|
|
|
|
|
|
|
// Task #12601 - Migrated to StorageHub
|
|
|
|
/*
|
|
|
|
* if (fileDownloadEvent.isFolder()) {
|
|
|
|
* FolderDownloadDialog dlg = new
|
|
|
|
* FolderDownloadDialog(fileDownloadEvent, myLogin);
|
|
|
|
* dlg.setPopupPosition(Window.getClientWidth() -
|
|
|
|
* (FolderDownloadDialog.WIDTH + 50),
|
|
|
|
* Window.getClientHeight() -
|
|
|
|
* (FolderDownloadDialog.HEIGHT + 120)); dlg.show(); }
|
|
|
|
*
|
|
|
|
* else { try { //String currentUserId =
|
|
|
|
* GCubeClientContext.getCurrentUserId(); String
|
|
|
|
* queryString =
|
|
|
|
* "id="+fileDownloadEvent.getItemIdentifier()+"&"+
|
|
|
|
* ConstantsExplorer.CURRENT_CONTEXT_ID+"="+
|
|
|
|
* currentContextId;
|
|
|
|
* if(fileDownloadEvent.getVersionId()!=null)
|
|
|
|
* queryString+="&"+ConstantsExplorer.FILE_VERSION_ID+
|
|
|
|
* "="+fileDownloadEvent.getVersionId(); new
|
|
|
|
* RequestBuilderWorkspaceValidateItem(RequestBuilder.
|
|
|
|
* GET,ConstantsExplorer.DOWNLOAD_WORKSPACE_SERVICE,
|
|
|
|
* queryString, "_self", downloadHandlerCallback); }
|
|
|
|
* catch (Exception e) {
|
|
|
|
* explorerPanel.getAsycTreePanel().unmask(); new
|
|
|
|
* MessageBoxAlert("Error", e.getMessage(), null);
|
|
|
|
* explorerPanel.getAsycTreePanel().
|
|
|
|
* removeAllAndRecoveryRoot(); } }
|
|
|
|
*/
|
2018-11-28 16:50:18 +01:00
|
|
|
|
|
|
|
try {
|
2019-02-22 12:18:03 +01:00
|
|
|
// String currentUserId =
|
|
|
|
// GCubeClientContext.getCurrentUserId();
|
|
|
|
String queryString = "id=" + fileDownloadEvent.getItemIdentifier() + "&"
|
|
|
|
+ ConstantsExplorer.CURRENT_CONTEXT_ID + "=" + currentContextId;
|
|
|
|
if (fileDownloadEvent.getVersionId() != null)
|
|
|
|
queryString += "&" + ConstantsExplorer.FILE_VERSION_ID + "="
|
|
|
|
+ fileDownloadEvent.getVersionId();
|
|
|
|
new RequestBuilderWorkspaceValidateItem(RequestBuilder.GET,
|
|
|
|
ConstantsExplorer.DOWNLOAD_WORKSPACE_SERVICE, queryString, "_self",
|
|
|
|
downloadHandlerCallback);
|
2018-11-28 16:50:18 +01:00
|
|
|
} catch (Exception e) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error", e.getMessage(), null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2013-06-25 15:33:03 +02:00
|
|
|
}
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2013-05-24 18:18:14 +02:00
|
|
|
notifySubscriber(fileDownloadEvent);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(FileUploadEvent.TYPE, new FileUploadEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onFileUploadEvent(FileUploadEvent fileUploadEvent) {
|
|
|
|
doFileUploadEvent(fileUploadEvent);
|
|
|
|
}
|
|
|
|
|
2015-10-06 12:16:22 +02:00
|
|
|
private void doFileUploadEvent(final FileUploadEvent fileUploadEvent) {
|
2015-10-05 18:33:14 +02:00
|
|
|
GWT.log("FileUploadEvent...");
|
2013-03-25 19:01:50 +01:00
|
|
|
FileModel folder = fileUploadEvent.getTargetFolderModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (folder == null)
|
2013-03-25 15:31:28 +01:00
|
|
|
folder = explorerPanel.getAsycTreePanel().getRootItem();
|
|
|
|
|
2015-10-05 18:33:14 +02:00
|
|
|
String caption = "Upload ";
|
|
|
|
UPLOAD_TYPE upType = UPLOAD_TYPE.File;
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileUploadEvent.getUploadType().compareTo(WS_UPLOAD_TYPE.Archive) == 0) {
|
|
|
|
caption += "Archive";
|
2015-10-05 18:33:14 +02:00
|
|
|
upType = UPLOAD_TYPE.Archive;
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (fileUploadEvent.getUploadType().compareTo(WS_UPLOAD_TYPE.File) == 0) {
|
|
|
|
caption += "File/s";
|
2015-10-05 18:33:14 +02:00
|
|
|
upType = UPLOAD_TYPE.File;
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
caption += " in: " + folder.getName();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-10-06 10:46:17 +02:00
|
|
|
MultipleDilaogUpload uploadStream = new MultipleDilaogUpload(caption, folder.getIdentifier(), upType);
|
2015-10-05 18:33:14 +02:00
|
|
|
WorskpaceUploadNotificationListener listener = new WorskpaceUploadNotificationListener() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-10-05 18:33:14 +02:00
|
|
|
@Override
|
2018-07-05 16:57:41 +02:00
|
|
|
public void onUploadCompleted(String parentId, String itemId) {
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("Upload completed: [parentID: " + parentId + ", itemId: " + itemId + ", uploadType: "
|
|
|
|
+ fileUploadEvent.getUploadType() + "]");
|
|
|
|
eventBus.fireEvent(
|
|
|
|
new CompletedFileUploadEvent(parentId, itemId, fileUploadEvent.getUploadType(), false));
|
2015-10-05 18:33:14 +02:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-10-05 18:33:14 +02:00
|
|
|
@Override
|
|
|
|
public void onUploadAborted(String parentId, String itemId) {
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("Upload Aborted: [parentID: " + parentId + ", itemId: " + itemId + "]");
|
2015-10-05 18:33:14 +02:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-10-05 18:33:14 +02:00
|
|
|
@Override
|
|
|
|
public void onError(String parentId, String itemId, Throwable throwable) {
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("Upload Error: [parentID: " + parentId + ", itemId: " + itemId + "]");
|
2015-10-05 18:33:14 +02:00
|
|
|
}
|
2015-10-16 11:52:03 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onOverwriteCompleted(String parentId, String itemId) {
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("Upload Override Completed: [parentID: " + parentId + ", itemId: " + itemId + "]");
|
|
|
|
eventBus.fireEvent(
|
|
|
|
new CompletedFileUploadEvent(parentId, itemId, fileUploadEvent.getUploadType(), true));
|
2015-10-16 11:52:03 +02:00
|
|
|
}
|
2015-10-05 18:33:14 +02:00
|
|
|
};
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-10-05 18:33:14 +02:00
|
|
|
uploadStream.addWorkspaceUploadNotificationListener(listener);
|
|
|
|
uploadStream.center();
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(CompletedFileUploadEvent.TYPE, new CompletedFileUploadEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onCompletedFileUploadEvent(CompletedFileUploadEvent completedFileUploadEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
doCompletedFileUploadEvent(completedFileUploadEvent);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doCompletedFileUploadEvent(CompletedFileUploadEvent completedFileUploadEvent) {
|
2015-10-06 12:07:37 +02:00
|
|
|
|
2015-10-05 18:33:14 +02:00
|
|
|
boolean isLevelExpanded = treeLevelIsExpanded(completedFileUploadEvent.getParentId());
|
2019-02-22 12:18:03 +01:00
|
|
|
// REFRESH TREE ONLY IF FOLDER PARENT EXISTS IN TREE
|
|
|
|
FileModel parent = explorerPanel.getAsycTreePanel()
|
|
|
|
.getFileModelByIdentifier(completedFileUploadEvent.getParentId());
|
|
|
|
GWT.log("doCompletedFileUploadEvent..." + parent);
|
|
|
|
if (parent != null && completedFileUploadEvent.getItemIdentifier() != null) {
|
|
|
|
explorerPanel.getAsycTreePanel()
|
|
|
|
.reloadTreeLevelAndExpandFolder(completedFileUploadEvent.getParentId(), isLevelExpanded);
|
|
|
|
// explorerPanel.getAsycTreePanel().addItemIdAndExpandFolder(parent,
|
|
|
|
// completedFileUploadEvent.getItemIdentifier(),
|
|
|
|
// isLevelExpanded);
|
2013-03-25 19:01:50 +01:00
|
|
|
}
|
2014-10-30 18:11:56 +01:00
|
|
|
doUpdateWorkspaceSize(new UpdateWorkspaceSizeEvent());
|
2013-02-06 15:40:17 +01:00
|
|
|
notifySubscriber(completedFileUploadEvent);
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(DeleteSmartFolderEvent.TYPE, new DeleteSmartFolderEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onDeleteItem(DeleteSmartFolderEvent deleteSmartFolderEvent) {
|
|
|
|
doDeleteSmartFolder(deleteSmartFolderEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doDeleteSmartFolder(DeleteSmartFolderEvent deleteSmartFolderEvent) {
|
|
|
|
final String smartIdentifier = deleteSmartFolderEvent.getSmartIdentifier();
|
|
|
|
final String smartName = deleteSmartFolderEvent.getSmartName();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
MessageBoxConfirm mbc = new MessageBoxConfirm(ConstantsExplorer.MESSAGE_DELETE,
|
|
|
|
ConstantsExplorer.MESSAGE_CONFIRM_DELETE_SMART_FOLDER + " " + smartName + "?");
|
2013-02-06 15:40:17 +01:00
|
|
|
mbc.getMessageBoxConfirm().addCallback(new Listener<MessageBoxEvent>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
public void handleEvent(MessageBoxEvent be) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// eventBus.fireEvent(new DeleteItemEvent(sel));
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// IF NOT CANCELLED
|
2014-01-21 14:55:19 +01:00
|
|
|
String clickedButton = be.getButtonClicked().getItemId();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (clickedButton.equals(Dialog.YES)) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.removeSmartFolder(smartIdentifier, smartName,
|
|
|
|
new AsyncCallback<Boolean>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean result) {
|
2018-07-05 16:52:58 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
// explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error",
|
|
|
|
ConstantsExplorer.SERVER_ERROR + " deleting smart folder.", null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(AddSmartFolderEvent.TYPE, new AddSmartFolderEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onSaveSmartFolder(AddSmartFolderEvent saveSmartFolderEvent) {
|
|
|
|
doSaveSmartFolder(saveSmartFolderEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doSaveSmartFolder(final AddSmartFolderEvent saveSmartFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
final String query = saveSmartFolderEvent.getSearchText();
|
2015-10-12 15:30:59 +02:00
|
|
|
final String parentId = saveSmartFolderEvent.getParentId();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
final DialogAddFolderAndSmart dialogAddSmartFolder = new DialogAddFolderAndSmart("",
|
|
|
|
AddType.SMARTFOLDER);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
dialogAddSmartFolder.getButtonById(Dialog.OK).addListener(Events.Select, new Listener<BaseEvent>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void handleEvent(BaseEvent be) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (dialogAddSmartFolder.isValidForm())
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.createSmartFolder(dialogAddSmartFolder.getName(),
|
|
|
|
dialogAddSmartFolder.getDescription(), query, parentId,
|
|
|
|
new AsyncCallback<SmartFolderModel>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
new MessageBoxAlert("Error",
|
|
|
|
ConstantsExplorer.SERVER_ERROR + " saving smart folder.", null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(SmartFolderModel smart) {
|
2018-07-05 16:52:58 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(SmartFolderSelectedEvent.TYPE, new SmartFolderSelectedEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onSmartFolderSelected(SmartFolderSelectedEvent smartFolderSelectedEvent) {
|
|
|
|
searching(true);
|
2019-02-22 12:18:03 +01:00
|
|
|
// System.out.println("Click smart folder : " +
|
|
|
|
// smartFolderSelectedEvent.getSmartFolderName());
|
2013-02-06 15:40:17 +01:00
|
|
|
doSmartFolderSelected(smartFolderSelectedEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
private void doSmartFolderSelected(SmartFolderSelectedEvent smartFolderSelectedEvent) {
|
|
|
|
|
|
|
|
notifySubscriber(smartFolderSelectedEvent);
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(RenameItemEvent.TYPE, new RenameItemEventHandler() {
|
|
|
|
@Override
|
|
|
|
public void onRenameItem(RenameItemEvent event) {
|
|
|
|
doRenameItem(event);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
private void doRenameItem(final RenameItemEvent event) {
|
|
|
|
|
|
|
|
final FileModel target = event.getFileTarget();
|
2019-02-22 12:18:03 +01:00
|
|
|
final DialogText dgt = new DialogText(ConstantsExplorer.MESSAGE_RENAME,
|
|
|
|
ConstantsExplorer.MESSAGE_ITEM_NAME, event.getFileTarget().getName(), target.isDirectory());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
dgt.getButtonById(Dialog.OK).addListener(Events.Select, new Listener<BaseEvent>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void handleEvent(BaseEvent be) {
|
|
|
|
|
|
|
|
final String newName = dgt.getTxtValue();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (dgt.isValidForm()) {
|
2015-07-31 11:23:46 +02:00
|
|
|
dgt.mask("Renaming...");
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("Renaming on id: " + target.getIdentifier());
|
|
|
|
rpcWorkspaceService.renameItem(target.getIdentifier(), newName, target.getName(),
|
|
|
|
new AsyncCallback<Boolean>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
dgt.unmask();
|
|
|
|
dgt.hide();
|
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
2019-04-30 12:06:04 +02:00
|
|
|
|
|
|
|
if(caught instanceof SHUBOperationNotAllowedException) {
|
|
|
|
MessageBox.info("Operation not allowed...", caught.getMessage(), null).show();
|
|
|
|
}else {
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
}
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean result) {
|
|
|
|
dgt.unmask();
|
|
|
|
dgt.hide();
|
|
|
|
explorerPanel.getAsycTreePanel().renameItem(target.getIdentifier(), newName,
|
|
|
|
null);
|
|
|
|
event.setNewName(newName);
|
|
|
|
notifySubscriber(event);
|
|
|
|
}
|
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(DeleteItemEvent.TYPE, new DeleteItemEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onDeleteItem(DeleteItemEvent event) {
|
|
|
|
doDeleteItem(event);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
private void doDeleteItem(final DeleteItemEvent event) {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2013-03-25 11:14:26 +01:00
|
|
|
String title = "";
|
|
|
|
String msg = "";
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (event.getFileTarget().isShared()) {
|
2014-01-21 14:55:19 +01:00
|
|
|
title = ConstantsExplorer.MESSAGE_DELETE;
|
|
|
|
msg = "This item is shared. Deleting this item will affect other users. Continue?";
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
else {
|
2014-01-21 14:55:19 +01:00
|
|
|
title = ConstantsExplorer.MESSAGE_DELETE;
|
2019-02-22 12:18:03 +01:00
|
|
|
msg = ConstantsExplorer.MESSAGE_CONFIRM_DELETE_ITEM + " " + event.getFileTarget().getName() + "?";
|
2014-01-21 14:55:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
MessageBoxConfirm mbc = new MessageBoxConfirm(title, msg);
|
|
|
|
mbc.getMessageBoxConfirm().addCallback(new Listener<MessageBoxEvent>() {
|
|
|
|
|
|
|
|
public void handleEvent(MessageBoxEvent be) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// IF NOT CANCELLED
|
2014-01-21 14:55:19 +01:00
|
|
|
String clickedButton = be.getButtonClicked().getItemId();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (clickedButton.equals(Dialog.YES)) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-02-25 17:24:31 +01:00
|
|
|
explorerPanel.getAsycTreePanel().mask("Deleting", ConstantsExplorer.LOADINGSTYLE);
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.deleteItem(event.getFileTarget().getIdentifier(),
|
|
|
|
new AsyncCallback<Boolean>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
2019-04-30 12:06:04 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
2019-04-30 12:06:04 +02:00
|
|
|
|
|
|
|
if(caught instanceof SHUBOperationNotAllowedException) {
|
|
|
|
MessageBox.info("Operation not allowed...", caught.getMessage(), null).show();
|
|
|
|
}else {
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean result) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
// Timer is used as work around to
|
|
|
|
// chrome and safari browser
|
|
|
|
Timer t = new Timer() {
|
|
|
|
public void run() {
|
|
|
|
|
|
|
|
FileModel fileModel = event.getFileTarget();
|
|
|
|
if (explorerPanel.getAsycTreePanel()
|
|
|
|
.deleteItem(fileModel.getIdentifier())) {
|
|
|
|
explorerPanel.getAsycTreePanel().selectItem(
|
|
|
|
fileModel.getParentFileModel().getIdentifier()); // Select
|
|
|
|
// parent
|
|
|
|
// of
|
|
|
|
// item
|
|
|
|
// deleted
|
|
|
|
}
|
|
|
|
|
|
|
|
notifySubscriber(event);
|
|
|
|
// doUpdateWorkspaceSize(new
|
|
|
|
// UpdateWorkspaceSizeEvent());
|
|
|
|
// eventBus.fireEvent(new
|
|
|
|
// UpdateWorkspaceSizeEvent());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Schedule the timer to run after
|
|
|
|
// 250 ms.
|
|
|
|
t.schedule(250);
|
2013-03-25 11:14:26 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
}
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(SelectedItemEvent.TYPE, new SelectedItemEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onSelectedItem(SelectedItemEvent selectedItemEvent) {
|
|
|
|
doSelectedItem(selectedItemEvent);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
private void doSelectedItem(SelectedItemEvent event) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2016-02-19 15:59:23 +01:00
|
|
|
notifySubscriber(event);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(ExpandFolderEvent.TYPE, new ExpandFolderEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onExpandFolder(ExpandFolderEvent expandFolderEvent) {
|
|
|
|
doExpandFolder(expandFolderEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
private void doExpandFolder(ExpandFolderEvent expandFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
notifySubscriber(expandFolderEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(AddFolderEvent.TYPE, new AddFolderEventHandler() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onAddItem(AddFolderEvent event) {
|
2016-02-19 15:59:23 +01:00
|
|
|
doAddItem(event);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doAddItem(final AddFolderEvent event) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
final FileModel sourceFileModel = event.getFileSourceModel();
|
2019-02-22 12:18:03 +01:00
|
|
|
final FileModel parentFileModel = event.getParentFileModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
String directory = null;
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (sourceFileModel.isDirectory()) {
|
2013-02-06 15:40:17 +01:00
|
|
|
explorerPanel.getAsycTreePanel().setExpandTreeLevel(sourceFileModel.getIdentifier(), true);
|
|
|
|
directory = sourceFileModel.getName();
|
2019-02-22 12:18:03 +01:00
|
|
|
} else
|
2013-02-06 15:40:17 +01:00
|
|
|
directory = parentFileModel.getName();
|
|
|
|
|
|
|
|
final DialogAddFolderAndSmart dialogAddFolder = new DialogAddFolderAndSmart(directory, AddType.FOLDER);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
dialogAddFolder.getButtonById(Dialog.OK).addListener(Events.Select, new Listener<BaseEvent>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void handleEvent(BaseEvent be) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (dialogAddFolder.isValidForm()) {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (sourceFileModel.isDirectory()) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.createFolder(dialogAddFolder.getName(),
|
|
|
|
dialogAddFolder.getDescription(), sourceFileModel,
|
|
|
|
new AsyncCallback<FolderModel>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(FolderModel child) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel()
|
|
|
|
.addItem(sourceFileModel.getIdentifier(), child, false);
|
|
|
|
event.setNewFolder(child);
|
|
|
|
notifySubscriber(event);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.createFolder(dialogAddFolder.getName(),
|
|
|
|
dialogAddFolder.getDescription(), parentFileModel,
|
|
|
|
new AsyncCallback<FolderModel>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(FolderModel child) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel()
|
|
|
|
.addItem(parentFileModel.getIdentifier(), child, false);
|
|
|
|
event.setNewFolder(child);
|
|
|
|
notifySubscriber(event);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
eventBus.addHandler(DragOnTreeMoveItemEvent.TYPE, new DragOnTreeMoveItemEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
2018-11-28 16:50:18 +01:00
|
|
|
public void onMoveItem(final DragOnTreeMoveItemEvent event) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().mask(ConstantsExplorer.MOVING, ConstantsExplorer.LOADINGSTYLE);
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.moveItems(Arrays.asList(event.getFileSourceModel().getIdentifier()),
|
|
|
|
event.getTargetParentFileModel().getIdentifier(),
|
|
|
|
new AsyncCallback<WorkspaceOperationResult>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
if (caught instanceof SessionExpiredException) {
|
|
|
|
GWT.log("Session expired");
|
|
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
|
|
return;
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error", caught.getMessage() + ".", null);
|
2019-05-13 12:32:27 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// System.out.println(caught.getMessage());
|
2019-05-13 12:32:27 +02:00
|
|
|
// explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(
|
|
|
|
// event.getTargetParentFileModel().getIdentifier(), false);
|
|
|
|
// explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(
|
|
|
|
// event.getFileSourceModel().getParentFileModel().getIdentifier(), true);
|
|
|
|
|
|
|
|
//FXING THE ISSUE #16665
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(WorkspaceOperationResult result) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
if (result != null) {
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-05-13 12:32:27 +02:00
|
|
|
if (result.getError() != null) {
|
2019-02-22 12:18:03 +01:00
|
|
|
new MessageBoxAlert("Error", result.getError(), null);
|
2019-05-13 12:32:27 +02:00
|
|
|
//FXING THE ISSUE #16665
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
|
|
|
}
|
2018-11-28 16:50:18 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().reloadTreeLevelAndExpandFolder(
|
|
|
|
event.getTargetParentFileModel().getIdentifier(), true);
|
|
|
|
notifySubscriber(event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(ImagePreviewEvent.TYPE, new ImagePreviewEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onClickPreview(ImagePreviewEvent imagePreviewEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (imagePreviewEvent.getClientX() > 0 && imagePreviewEvent.getClientY() > 0)
|
2017-05-24 12:01:16 +02:00
|
|
|
doClickPreview(imagePreviewEvent, imagePreviewEvent.getClientX(), imagePreviewEvent.getClientY());
|
2013-02-06 15:40:17 +01:00
|
|
|
else
|
|
|
|
doClickPreview(imagePreviewEvent, 50, 50);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// ADDED 24/07/2013
|
|
|
|
if (imagePreviewEvent.getSourceFileModel() != null) { // FILE
|
|
|
|
// CAN
|
|
|
|
// NOT
|
|
|
|
// LOADED
|
|
|
|
// IN
|
|
|
|
// TREE
|
|
|
|
notifySubscriber(new FileDownloadEvent(imagePreviewEvent.getSourceFileModel().getIdentifier(),
|
|
|
|
imagePreviewEvent.getSourceFileModel().getName(), FileDownloadEvent.DownloadType.SHOW,
|
|
|
|
false, null));
|
2013-07-24 16:44:26 +02:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doClickPreview(ImagePreviewEvent imagePreviewEvent, final int positionX, final int positionY) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
final FileModel fileModel = imagePreviewEvent.getSourceFileModel();
|
|
|
|
boolean fullDetails = false;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getImageById(fileModel.getIdentifier(),
|
|
|
|
fileModel.getGXTFolderItemType().equals(GXTFolderItemTypeEnum.IMAGE_DOCUMENT), fullDetails,
|
|
|
|
new AsyncCallback<GWTWorkspaceItem>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error",
|
|
|
|
ConstantsExplorer.SERVER_ERROR + " getting the image preview", null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(GWTWorkspaceItem item) {
|
|
|
|
GWT.log("Image loaded: " + item.getName() + " label: " + item.getLabel() + " type: "
|
|
|
|
+ fileModel.getGXTFolderItemType());
|
|
|
|
if (fileModel.getGXTFolderItemType().equals(GXTFolderItemTypeEnum.IMAGE_DOCUMENT))
|
|
|
|
new ImagesPreviewController(fileModel.getName(), fileModel.getParentFileModel(),
|
|
|
|
(GWTImageDocument) item, positionX, positionY);
|
|
|
|
else
|
|
|
|
new ImagesPreviewController(fileModel.getName(), fileModel.getParentFileModel(),
|
|
|
|
(GWTExternalImage) item, positionX, positionY);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(OpenUrlEvent.TYPE, new OpenUrlEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onClickUrl(OpenUrlEvent openUrlEvent) {
|
|
|
|
doClickUrl(openUrlEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2016-02-19 15:59:23 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(CreateUrlEvent.TYPE, new CreateUrlEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onClickCreateUrl(CreateUrlEvent createUrlEvent) {
|
|
|
|
doClickCreateUrl(createUrlEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doClickCreateUrl(final CreateUrlEvent createUrlEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
final FileModel parent = createUrlEvent.getParentFileModel();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
final DialogAddUrl dgu = new DialogAddUrl(parent.getName());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
dgu.getButtonById(Dialog.OK).addListener(Events.Select, new Listener<BaseEvent>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void handleEvent(BaseEvent be) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (dgu.isValidForm()) {
|
|
|
|
explorerPanel.getAsycTreePanel().mask(ConstantsExplorer.VALIDATINGOPERATION,
|
|
|
|
ConstantsExplorer.LOADINGSTYLE);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("parent: " + parent);
|
|
|
|
rpcWorkspaceService.createExternalUrl(parent.getIdentifier(), dgu.getName(),
|
|
|
|
dgu.getDescription(), dgu.getUrl(), new AsyncCallback<FileModel>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error",
|
|
|
|
ConstantsExplorer.SERVER_ERROR + " creating url.", null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(FileModel child) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
eventBus.fireEvent(new CompletedFileUploadEvent(parent.getIdentifier(),
|
|
|
|
child.getIdentifier(), WS_UPLOAD_TYPE.File, false));
|
2018-03-06 14:37:32 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// explorerPanel.getAsycTreePanel().addItem(parent.getIdentifier(),
|
|
|
|
// child, false);
|
|
|
|
// explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
// notifySubscriber(createUrlEvent);
|
|
|
|
}
|
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-03-17 16:16:01 +01:00
|
|
|
eventBus.addHandler(VRESettingPermissionEvent.TYPE, new VRESettingPermissionEventHandler() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-03-17 14:43:06 +01:00
|
|
|
@Override
|
2014-03-17 16:16:01 +01:00
|
|
|
public void onPermissionSetting(VRESettingPermissionEvent settingPermissionEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (settingPermissionEvent.getSourceFile() != null) {
|
2014-03-17 14:43:06 +01:00
|
|
|
DialogPermission dialog = new DialogPermission(settingPermissionEvent.getSourceFile());
|
|
|
|
dialog.show();
|
2019-02-22 12:18:03 +01:00
|
|
|
} else
|
2014-03-17 14:43:06 +01:00
|
|
|
Info.display("Attention", "Select a VRE Folder to change permissions!");
|
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-03-18 12:50:53 +01:00
|
|
|
eventBus.addHandler(UpdatedVREPermissionEvent.TYPE, new UpdatedVREPermissionEventHandler() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-03-18 12:50:53 +01:00
|
|
|
@Override
|
|
|
|
public void onUpdateVREPermissions(UpdatedVREPermissionEvent updatedVREPermissionEvent) {
|
|
|
|
notifySubscriber(updatedVREPermissionEvent);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-03-18 12:50:53 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
eventBus.addHandler(OpenReportsEvent.TYPE, new OpenReportsEventHandler() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void onClickOpenReports(OpenReportsEvent openReportsEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (openReportsEvent.getSourceFileModel().getGXTFolderItemType()
|
|
|
|
.equals(GXTFolderItemTypeEnum.REPORT_TEMPLATE))
|
2013-02-06 15:40:17 +01:00
|
|
|
doClickOpenReportTemplate(openReportsEvent);
|
|
|
|
else
|
|
|
|
doClickOpenReport(openReportsEvent);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
public void doClickOpenReport(OpenReportsEvent openReportsEvent) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-21 13:00:26 +02:00
|
|
|
final NewBrowserWindow newBrowserWindow = NewBrowserWindow.open("", "_self", "");
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getURLFromApplicationProfile(openReportsEvent.getSourceFileModel().getIdentifier(),
|
|
|
|
new AsyncCallback<String>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR
|
|
|
|
+ " getting application profile - attribute idreport", null);
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(String url) {
|
|
|
|
|
|
|
|
if (url == null || url.isEmpty()) {
|
|
|
|
String currentUrl = portalURL();
|
|
|
|
int last = currentUrl.lastIndexOf("/");
|
|
|
|
String reportUrl = currentUrl.substring(0, last + 1)
|
|
|
|
+ ConstantsExplorer.REPORTGENERATION;
|
|
|
|
// new WindowOpenUrl(reportUrl, "_self",
|
|
|
|
// "");
|
|
|
|
newBrowserWindow.setUrl(reportUrl);
|
|
|
|
} else {
|
|
|
|
String reportUrl = url;
|
|
|
|
// new WindowOpenUrl(reportUrl, "_self",
|
|
|
|
// "");
|
|
|
|
newBrowserWindow.setUrl(reportUrl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private void doClickOpenReportTemplate(OpenReportsEvent openReportTemplateEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-21 13:00:26 +02:00
|
|
|
final NewBrowserWindow newBrowserWindow = NewBrowserWindow.open("", "_self", "");
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getURLFromApplicationProfile(
|
|
|
|
openReportTemplateEvent.getSourceFileModel().getIdentifier(), new AsyncCallback<String>() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR
|
|
|
|
+ " getting application profile - attribute idreport", null);
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(String url) {
|
|
|
|
|
|
|
|
if (url == null || url.isEmpty()) {
|
|
|
|
String currentUrl = portalURL();
|
|
|
|
int last = currentUrl.lastIndexOf("/");
|
|
|
|
String templateUrl = currentUrl.substring(0, last + 1)
|
|
|
|
+ ConstantsExplorer.TEMPLATECREATION;
|
|
|
|
// Log.trace("Url: "+templateUrl);
|
|
|
|
GWT.log("currentUrl " + currentUrl);
|
|
|
|
GWT.log("reportUrl " + templateUrl);
|
|
|
|
newBrowserWindow.setUrl(templateUrl);
|
|
|
|
// new WindowOpenUrl(templateUrl, "_self",
|
|
|
|
// "");
|
|
|
|
} else {
|
|
|
|
|
|
|
|
String templateUrl = url;
|
|
|
|
newBrowserWindow.setUrl(templateUrl);
|
|
|
|
// new WindowOpenUrl(templateUrl, "_self",
|
|
|
|
// "");
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
});
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2014-10-30 18:11:56 +01:00
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* Do update workspace size.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param updateWorkspaceSizeEvent
|
|
|
|
* the update workspace size event
|
2014-10-30 18:11:56 +01:00
|
|
|
*/
|
|
|
|
protected void doUpdateWorkspaceSize(UpdateWorkspaceSizeEvent updateWorkspaceSizeEvent) {
|
|
|
|
notifySubscriber(updateWorkspaceSizeEvent);
|
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Portal url.
|
|
|
|
*
|
|
|
|
* @return the string
|
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
public static native String portalURL()/*-{
|
2019-02-22 12:18:03 +01:00
|
|
|
return $wnd.location.href;
|
2013-02-06 15:40:17 +01:00
|
|
|
}-*/;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// ********END EVENTS TO NOTIFY SUBSCRIBERS
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// Method Notify Subscriber
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Notify subscriber.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param event
|
|
|
|
* the event
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void notifySubscriber(GuiEventInterface event) {
|
2014-01-21 14:55:19 +01:00
|
|
|
if (subscribers.containsKey(event.getKey()))
|
2019-02-22 12:18:03 +01:00
|
|
|
for (SubscriberInterface sub : subscribers.get(event.getKey())) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (event instanceof RenameItemEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
RenameItemEvent renameEvent = (RenameItemEvent) event;
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
sub.renameItem(renameEvent.getFileTarget().getIdentifier(), renameEvent.getNewName(),
|
|
|
|
renameEvent.getExtension());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof DeleteItemEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
DeleteItemEvent deleteEvent = (DeleteItemEvent) event;
|
2015-10-29 18:00:06 +01:00
|
|
|
List<String> ids = new ArrayList<String>(1);
|
|
|
|
ids.add(deleteEvent.getFileTarget().getIdentifier());
|
|
|
|
sub.deleteItems(ids);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof SelectedItemEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
SelectedItemEvent selectedEvent = (SelectedItemEvent) event;
|
|
|
|
|
|
|
|
List<FileModel> listFileModel = new ArrayList<FileModel>();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
FileModel item = explorerPanel.getAsycTreePanel()
|
|
|
|
.getFileModelByIdentifier(selectedEvent.getFileTarget().getIdentifier());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
listFileModel = getListParents(listFileModel, item); // used
|
|
|
|
// for
|
|
|
|
// update
|
|
|
|
// path
|
|
|
|
// bar
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
sub.selectedItem(selectedEvent.getFileTarget(), listFileModel);
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof ExpandFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
ExpandFolderEvent expandEvent = (ExpandFolderEvent) event;
|
|
|
|
|
|
|
|
sub.expandFolderItem(expandEvent.getFolderTarget());
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof AddFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
AddFolderEvent addItemEvent = (AddFolderEvent) event;
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (addItemEvent.getFileSourceModel().isDirectory())
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
sub.addedFolder(addItemEvent.getNewFolder().getIdentifier(), addItemEvent.getFileSourceModel());
|
|
|
|
else
|
2016-02-19 15:59:23 +01:00
|
|
|
sub.addedFolder(addItemEvent.getNewFolder().getIdentifier(), addItemEvent.getParentFileModel());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof SubTreeLoadedEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-12-14 15:12:22 +01:00
|
|
|
GWT.log("SubTreeLoadedEvent...");
|
2014-01-21 14:55:19 +01:00
|
|
|
SubTreeLoadedEvent subTreeEvent = (SubTreeLoadedEvent) event;
|
|
|
|
|
|
|
|
sub.setParentItemSelected(subTreeEvent.getPathParentsList());
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// if(openTreeMenuEvent && isShowTreeMenu==false)
|
|
|
|
// eventBus.fireEvent(new O)
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof SmartFolderSelectedEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
SmartFolderSelectedEvent smartEvent = (SmartFolderSelectedEvent) event;
|
|
|
|
|
2016-09-29 15:28:32 +02:00
|
|
|
sub.smartFolderSelected(smartEvent.getSmartFolderCustomId(), smartEvent.getCategory());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof FileUploadEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// FileUploadEvent fileUpEvent = (FileUploadEvent) event;
|
|
|
|
// sub.addedFile(fileUpEvent.getParentFileModel(), "");
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof CompletedFileUploadEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
CompletedFileUploadEvent fileUpEvent = (CompletedFileUploadEvent) event;
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
sub.addedFile(fileUpEvent.getItemIdentifier(), fileUpEvent.getParentId(),
|
|
|
|
fileUpEvent.getUploadType(), fileUpEvent.isOverwrite());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof CreateUrlEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
CreateUrlEvent createUrlEvent = (CreateUrlEvent) event;
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
sub.addedFile(createUrlEvent.getItemIdentifier(),
|
|
|
|
createUrlEvent.getParentFileModel().getIdentifier(), WS_UPLOAD_TYPE.File, false);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof DragOnTreeMoveItemEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
DragOnTreeMoveItemEvent moveItemEvent = (DragOnTreeMoveItemEvent) event;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
sub.movedItems(moveItemEvent.getFileSourceModel().getIdentifier(),
|
|
|
|
moveItemEvent.getTargetParentFileModel());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof SwitchViewEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
SwitchViewEvent switchView = (SwitchViewEvent) event;
|
|
|
|
|
|
|
|
sub.switchView(switchView.getType());
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof RefreshFolderEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
RefreshFolderEvent refresh = (RefreshFolderEvent) event;
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
sub.refreshFolder(refresh.getFolderTarget(), refresh.isForceRefresh(),
|
|
|
|
refresh.isForceReloadBreadCrumb());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof FileDownloadEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
FileDownloadEvent messageEvent = (FileDownloadEvent) event;
|
|
|
|
|
|
|
|
sub.fileDownloaded(messageEvent.getItemIdentifier());
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof SessionExpiredEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
|
|
|
sub.viewSessionExpiredPanel();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof MoveItemsEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2018-11-28 16:50:18 +01:00
|
|
|
MoveItemsEvent moveEvent = (MoveItemsEvent) event;
|
|
|
|
sub.moveEventIsCompleted(moveEvent.isTreeRefreshable(), moveEvent.getDestionationFolderId());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof CopyItemsEvent) {
|
2018-11-28 16:50:18 +01:00
|
|
|
CopyItemsEvent copyEvent = (CopyItemsEvent) event;
|
|
|
|
sub.copyEventIsCompleted(copyEvent.getDestinationFolderId());
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof TrashEvent) {
|
2014-01-21 14:55:19 +01:00
|
|
|
TrashEvent trashEvent = (TrashEvent) event;
|
2014-05-13 11:26:57 +02:00
|
|
|
sub.trashEvent(trashEvent.getTrashOperation(), trashEvent.getTargetFileModels());
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof UpdatedVREPermissionEvent) {
|
2014-03-18 12:50:53 +01:00
|
|
|
UpdatedVREPermissionEvent vreEvent = (UpdatedVREPermissionEvent) event;
|
|
|
|
sub.updatedVREPermissions(vreEvent.getVreFolderId());
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof UpdateWorkspaceSizeEvent) {
|
2014-10-30 18:11:56 +01:00
|
|
|
sub.updateWorksapaceSize(true);
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof VersioningHistoryShowEvent) {
|
2017-02-20 14:57:07 +01:00
|
|
|
VersioningHistoryShowEvent historyVers = (VersioningHistoryShowEvent) event;
|
|
|
|
sub.versioningHistory(historyVers.getTargetFileModel());
|
2019-02-22 12:18:03 +01:00
|
|
|
} else if (event instanceof LoadFolderEvent) {
|
2018-11-28 16:50:18 +01:00
|
|
|
LoadFolderEvent loadFolderEvent = (LoadFolderEvent) event;
|
|
|
|
sub.loadFolder(loadFolderEvent.getTargetFolder());
|
2014-01-21 14:55:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-06-10 16:34:52 +02:00
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* Tree level is expanded.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param folderId
|
|
|
|
* the folder id
|
2015-09-18 16:51:38 +02:00
|
|
|
* @return true, if successful
|
2013-06-10 16:34:52 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public boolean treeLevelIsExpanded(String folderId) {
|
2013-06-10 16:34:52 +02:00
|
|
|
return explorerPanel.getAsycTreePanel().isExpanded(folderId);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Gets the list parents.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param listParentModel
|
|
|
|
* the list parent model
|
|
|
|
* @param item
|
|
|
|
* the item
|
2015-09-18 16:51:38 +02:00
|
|
|
* @return the list parents
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private List<FileModel> getListParents(List<FileModel> listParentModel, FileModel item) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
getParents(listParentModel, item);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
Collections.reverse(listParentModel);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
return listParentModel;
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Gets the parents.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param listParents
|
|
|
|
* the list parents
|
|
|
|
* @param item
|
|
|
|
* the item
|
2015-09-18 16:51:38 +02:00
|
|
|
* @return the parents
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private void getParents(List<FileModel> listParents, FileModel item) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (item == null || item.getParentFileModel() == null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (item.getParentFileModel().isRoot()) {
|
2014-02-26 17:35:20 +01:00
|
|
|
listParents.add(item.getParentFileModel());
|
|
|
|
return;
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-01-21 14:55:19 +01:00
|
|
|
listParents.add(item.getParentFileModel());
|
|
|
|
getParents(listParents, item.getParentFileModel());
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Subscribe.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param subscriber
|
|
|
|
* the subscriber
|
|
|
|
* @param keys
|
|
|
|
* the keys
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void subscribe(SubscriberInterface subscriber, EventsTypeEnum[] keys) {
|
2014-01-21 14:55:19 +01:00
|
|
|
for (EventsTypeEnum m : keys)
|
|
|
|
subscribe(subscriber, m);
|
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Subscribe.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param subscriber
|
|
|
|
* the subscriber
|
|
|
|
* @param key
|
|
|
|
* the key
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void subscribe(SubscriberInterface subscriber, EventsTypeEnum key) {
|
2014-01-21 14:55:19 +01:00
|
|
|
if (subscribers.containsKey(key))
|
|
|
|
subscribers.get(key).add(subscriber);
|
2019-02-22 12:18:03 +01:00
|
|
|
else {
|
2014-01-21 14:55:19 +01:00
|
|
|
ArrayList<SubscriberInterface> subs = new ArrayList<SubscriberInterface>();
|
|
|
|
subs.add(subscriber);
|
|
|
|
subscribers.put(key, subs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Unsubscribe.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param subscriber
|
|
|
|
* the subscriber
|
|
|
|
* @param key
|
|
|
|
* the key
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void unsubscribe(SubscriberInterface subscriber, EventsTypeEnum key) {
|
2014-01-21 14:55:19 +01:00
|
|
|
if (subscribers.containsKey(key))
|
|
|
|
subscribers.get(key).remove(subscriber);
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Go.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param rootPanel
|
|
|
|
* the root panel
|
|
|
|
* @param onlyTree
|
|
|
|
* the only tree
|
|
|
|
* @param instancingSmartFolder
|
|
|
|
* the instancing smart folder
|
|
|
|
* @param instancingMessages
|
|
|
|
* the instancing messages
|
|
|
|
* @param selectRootItem
|
|
|
|
* the select root item
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void go(final HasWidgets rootPanel, boolean onlyTree, boolean instancingSmartFolder,
|
|
|
|
boolean instancingMessages, boolean selectRootItem) {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (onlyTree) {
|
2013-02-06 15:40:17 +01:00
|
|
|
this.selectRootItem = selectRootItem;
|
2019-02-22 12:18:03 +01:00
|
|
|
this.explorerPanel = new ExplorerPanel(true, this.selectRootItem);
|
|
|
|
this.selectRootItem = false; // set false select root item; only
|
|
|
|
// first time is used
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel.setSize(400, 600);
|
|
|
|
this.explorerPanel.getAsycTreePanel().setSizeTreePanel(350, 550);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// rootPanel.add(new BasicDNDExample()); //it's example of drag&drop
|
|
|
|
} else
|
|
|
|
this.explorerPanel = new ExplorerPanel(instancingSmartFolder, instancingMessages);
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
rootPanel.add(explorerPanel);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* Use method getPanel.
|
|
|
|
*
|
2013-02-06 15:40:17 +01:00
|
|
|
* @return ExplorerPanel
|
2016-02-19 15:59:23 +01:00
|
|
|
* @deprecated
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
2016-05-05 11:49:36 +02:00
|
|
|
@Deprecated
|
2019-02-22 12:18:03 +01:00
|
|
|
public ExplorerPanel getTreePanel() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel = getPanel();
|
|
|
|
return this.explorerPanel;
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
/**
|
2019-02-22 12:18:03 +01:00
|
|
|
* Instance only Async Tree with specific width - height - select by default
|
|
|
|
* the root item .
|
2015-09-18 16:51:38 +02:00
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param width
|
|
|
|
* the width
|
|
|
|
* @param height
|
|
|
|
* the height
|
2013-02-06 15:40:17 +01:00
|
|
|
* @return AsyncTreePanel
|
|
|
|
*/
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
public AsyncTreePanel getTree(int width, int height) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel = getPanel();
|
|
|
|
this.explorerPanel.getAsycTreePanel().setSizeTreePanel(width, height);
|
2016-02-19 15:59:23 +01:00
|
|
|
this.explorerPanel.getAsycTreePanel().setHeaderTreeVisible(false);
|
2013-02-13 18:39:33 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
return explorerPanel.getAsycTreePanel();
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Hide sharing facilities.
|
|
|
|
*/
|
2013-03-25 11:14:26 +01:00
|
|
|
public void hideSharingFacilities() {
|
|
|
|
explorerPanel.getAsycTreePanel().getContextMenuTree().setHideSharing();
|
2016-02-19 15:59:23 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2014-01-15 12:49:40 +01:00
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* Refresh root.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param selectRootItem
|
|
|
|
* the select root item
|
2014-01-15 12:49:40 +01:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void refreshRoot(boolean selectRootItem) {
|
|
|
|
if (explorerPanel.getAsycTreePanel() != null)
|
2014-01-15 12:49:40 +01:00
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot(selectRootItem);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
/**
|
2016-02-19 15:59:23 +01:00
|
|
|
* Instance only Async Tree. Select by default root items of tree.
|
2019-02-22 12:18:03 +01:00
|
|
|
*
|
2013-02-06 15:40:17 +01:00
|
|
|
* @return ExplorerPanel
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public ExplorerPanel getPanel() {
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel = new ExplorerPanel(true, true);
|
2014-02-12 12:49:07 +01:00
|
|
|
loadMyLogin();
|
2016-08-29 15:39:13 +02:00
|
|
|
loadMyFirstName();
|
2013-02-06 15:40:17 +01:00
|
|
|
return this.explorerPanel;
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
/**
|
2019-02-22 12:18:03 +01:00
|
|
|
* Instance by default asyncronus Tree while Smart Folders and Messages was
|
|
|
|
* instanced as input value.
|
2015-09-18 16:51:38 +02:00
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param instancingSmartFolder
|
|
|
|
* the instancing smart folder
|
|
|
|
* @param instancingMessages
|
|
|
|
* the instancing messages
|
|
|
|
* @param selectRootItem
|
|
|
|
* the select root item
|
2013-02-06 15:40:17 +01:00
|
|
|
* @return ExplorerPanel
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public ExplorerPanel getPanel(boolean instancingSmartFolder, boolean instancingMessages, boolean selectRootItem) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel = new ExplorerPanel(instancingSmartFolder, instancingMessages, selectRootItem);
|
2019-02-22 12:18:03 +01:00
|
|
|
this.selectRootItem = selectRootItem;
|
2014-02-12 12:49:07 +01:00
|
|
|
loadMyLogin();
|
2016-08-29 15:39:13 +02:00
|
|
|
loadMyFirstName();
|
2013-02-06 15:40:17 +01:00
|
|
|
return this.explorerPanel;
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Edi permissions.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param file
|
|
|
|
* the file
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2015-01-28 12:42:48 +01:00
|
|
|
private void ediPermissions(final FileModel file) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
GWT.log("Show Permissions on " + file);
|
|
|
|
// MultiDragConstants.HEADING_DIALOG = "Permissions: " + file.getName();
|
|
|
|
/// MultiDragConstants.ALL_CONTACTS_LEFT_LIST = "Shared User/s";
|
|
|
|
// MultiDragConstants.SHARE_WITH_RIGHT_LIST = "Set permissions for
|
|
|
|
// User/s";
|
|
|
|
|
|
|
|
final ShowPermissionsDialog showPermissionDialog = new ShowPermissionsDialog("Permissions: " + file.getName(),
|
|
|
|
file.getIdentifier());
|
|
|
|
showPermissionDialog.show();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* @SuppressWarnings("unused") final MultiDragContactsEditPermissions
|
|
|
|
* multiDragContact = new MultiDragContactsEditPermissions(
|
|
|
|
* LOAD_CONTACTS_AS.SHARED_USER, file.getIdentifier(), true);
|
|
|
|
*
|
|
|
|
* final DialogMultiDragContact multidrag =
|
|
|
|
* multiDragContact.getDialog();
|
|
|
|
*
|
|
|
|
* multidrag.
|
|
|
|
* setTxtHelp("Sets the permission for the user(s) dragged in the right list"
|
|
|
|
* );
|
|
|
|
*
|
|
|
|
* multidrag.getButtonById(Dialog.OK).addListener(Events.Select, new
|
|
|
|
* Listener<BaseEvent>() {
|
|
|
|
*
|
|
|
|
* @Override public void handleEvent(BaseEvent be) { final
|
|
|
|
* List<org.gcube.portlets.widgets.workspacesharingwidget.shared.
|
|
|
|
* InfoContactModel> targets = multiDragContact .getTargetContacts();
|
|
|
|
*
|
|
|
|
* if (targets.size() == 0) { MessageBoxConfirm info = new
|
|
|
|
* MessageBoxConfirm("Any User/s?",
|
|
|
|
* "You have not selected any Users, confirm exit?");
|
|
|
|
*
|
|
|
|
* info.getMessageBoxConfirm().addCallback(new
|
|
|
|
* Listener<MessageBoxEvent>() {
|
|
|
|
*
|
|
|
|
* public void handleEvent(MessageBoxEvent be) { // IF NOT CANCELLED
|
|
|
|
* String clickedButton = be.getButtonClicked().getItemId(); if
|
|
|
|
* (clickedButton.equals(Dialog.YES)) { multidrag.hide(); } } }); }
|
|
|
|
*
|
|
|
|
* // GWT.log(targets.toString());
|
|
|
|
*
|
|
|
|
* if (targets.size() >= 1 && multiDragContact.getSelectedAcl() != null)
|
|
|
|
* {
|
|
|
|
*
|
|
|
|
* final List<String> logins = new ArrayList<String>(targets.size());
|
|
|
|
*
|
|
|
|
* for (org.gcube.portlets.widgets.workspacesharingwidget.shared.
|
|
|
|
* InfoContactModel infoContactModel : targets) {
|
|
|
|
* GWT.log(infoContactModel.toString());
|
|
|
|
* logins.add(infoContactModel.getLogin()); }
|
|
|
|
*
|
|
|
|
* WorkspaceSharingServiceAsync.INSTANCE.validateACLToUser(file.
|
|
|
|
* getIdentifier(), logins, multiDragContact.getSelectedAclID(), new
|
|
|
|
* AsyncCallback<ReportAssignmentACL>() {
|
|
|
|
*
|
|
|
|
* @Override public void onFailure(Throwable caught) { new
|
|
|
|
* MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
*
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* @Override public void onSuccess(ReportAssignmentACL result) {
|
|
|
|
*
|
|
|
|
* String msg = "";
|
|
|
|
*
|
|
|
|
* if (result.getErrors().size() > 0) { for (String error :
|
|
|
|
* result.getErrors()) { msg += "<li>" + error + ";</li><br/>";
|
|
|
|
*
|
|
|
|
* } new MessageBoxAlert("Warning!!", msg, null); return; }
|
|
|
|
*
|
|
|
|
* if (result.getValidLogins().size() == 0) { msg +=
|
|
|
|
* "Setting permission '" + multiDragContact.getSelectedAcl().getLabel()
|
|
|
|
* + "' is not valid for " + file.getName(); MessageBox info =
|
|
|
|
* MessageBox.info("Permissions not valid for " + file.getName(), msg,
|
|
|
|
* null); info.show(); return; }
|
|
|
|
*
|
|
|
|
* String names = ""; for (String name : result.getValidLogins()) {
|
|
|
|
* names += "<li><i>" + name + ";</i></li>"; }
|
|
|
|
*
|
|
|
|
* msg += "Setting permission '" +
|
|
|
|
* multiDragContact.getSelectedAcl().getLabel() + "' for: <ul>" + names
|
|
|
|
* + "</ul> confirm?";
|
|
|
|
*
|
|
|
|
* MessageBoxConfirm confirm = new MessageBoxConfirm(
|
|
|
|
* "Setting new permissions to " + file.getName() + "?", msg);
|
|
|
|
* confirm.getMessageBoxConfirm().addCallback(new
|
|
|
|
* Listener<MessageBoxEvent>() {
|
|
|
|
*
|
|
|
|
* public void handleEvent(MessageBoxEvent be) {
|
|
|
|
*
|
|
|
|
* // IF NOT CANCELLED String clickedButton =
|
|
|
|
* be.getButtonClicked().getItemId(); if
|
|
|
|
* (clickedButton.equals(Dialog.YES)) { //
|
|
|
|
* doAddAdministratorToFolderId(file, // logins);
|
|
|
|
* setACLToFolderId(file.getIdentifier(), logins,
|
|
|
|
* multiDragContact.getSelectedAclID()); multidrag.hide(); } else if
|
|
|
|
* (clickedButton.equals(Dialog.CANCEL)) { multidrag.hide(); }
|
|
|
|
*
|
|
|
|
* } });
|
|
|
|
*
|
|
|
|
* } });
|
|
|
|
*
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* } });
|
|
|
|
*
|
|
|
|
* multidrag.show();
|
|
|
|
*/
|
2015-01-28 12:42:48 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* Show add administrators dialog.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param file
|
|
|
|
* the file
|
2014-07-08 18:41:53 +02:00
|
|
|
*/
|
|
|
|
private void showAddAdministratorsDialog(final FileModel file) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
MultiDragConstants.HEADING_DIALOG = "Edit Administrator/s to: " + file.getName();
|
2015-01-28 18:27:23 +01:00
|
|
|
MultiDragConstants.ALL_CONTACTS_LEFT_LIST = "All Contacts";
|
|
|
|
MultiDragConstants.SHARE_WITH_RIGHT_LIST = "New Administrator/s";
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
final SimpleMultiDragWorkspaceContact multiDragContact = new SimpleMultiDragWorkspaceContact(
|
|
|
|
LOAD_CONTACTS_AS.ADMINISTRATOR, file.getIdentifier(), true, false, true);
|
2015-01-28 12:42:48 +01:00
|
|
|
final Dialog multidrag = multiDragContact.getDialogMultiDragContact();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-09-23 16:15:36 +02:00
|
|
|
multidrag.getButtonById(Dialog.OK).addListener(Events.Select, new Listener<BaseEvent>() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
@Override
|
2014-09-23 16:15:36 +02:00
|
|
|
public void handleEvent(BaseEvent be) {
|
2019-02-22 12:18:03 +01:00
|
|
|
final List<org.gcube.portlets.widgets.workspacesharingwidget.shared.InfoContactModel> targets = multiDragContact
|
|
|
|
.getTargetContactsWithMyLogin();
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (targets.size() == 1) {
|
|
|
|
MessageBoxConfirm info = new MessageBoxConfirm("Any Administrator/s?",
|
|
|
|
"You have not selected any Administrator, confirm only you as Administrator and exit?");
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-09-30 14:49:33 +02:00
|
|
|
info.getMessageBoxConfirm().addCallback(new Listener<MessageBoxEvent>() {
|
2014-07-11 15:56:35 +02:00
|
|
|
|
2014-09-23 16:15:36 +02:00
|
|
|
public void handleEvent(MessageBoxEvent be) {
|
2019-02-22 12:18:03 +01:00
|
|
|
// IF NOT CANCELLED
|
2014-09-23 16:15:36 +02:00
|
|
|
String clickedButton = be.getButtonClicked().getItemId();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (clickedButton.equals(Dialog.YES)) {
|
2014-09-30 12:53:53 +02:00
|
|
|
List<String> logins = new ArrayList<String>(1);
|
|
|
|
logins.add(targets.get(0).getLogin());
|
|
|
|
doAddAdministratorToFolderId(file, logins);
|
2014-09-23 16:15:36 +02:00
|
|
|
multidrag.hide();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-07-11 15:56:35 +02:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (targets.size() > 1) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-09-23 16:15:36 +02:00
|
|
|
final List<String> logins = new ArrayList<String>(targets.size());
|
|
|
|
String names = "<ul>";
|
|
|
|
for (org.gcube.portlets.widgets.workspacesharingwidget.shared.InfoContactModel infoContactModel : targets) {
|
|
|
|
logins.add(infoContactModel.getLogin());
|
2019-02-22 12:18:03 +01:00
|
|
|
names += "<li><i>" + infoContactModel.getName() + ";</i></li>";
|
2014-09-23 16:15:36 +02:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-09-23 16:15:36 +02:00
|
|
|
String tail = "</ul>as new ";
|
2019-02-22 12:18:03 +01:00
|
|
|
tail += logins.size() > 1 ? "administrators" : "administrator";
|
|
|
|
tail += ", confirm?";
|
|
|
|
MessageBoxConfirm confirm = new MessageBoxConfirm("Setting new Administrator/s?",
|
|
|
|
"You have selected: <br/>" + names + tail);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-09-23 16:15:36 +02:00
|
|
|
confirm.getMessageBoxConfirm().addCallback(new Listener<MessageBoxEvent>() {
|
|
|
|
|
|
|
|
public void handleEvent(MessageBoxEvent be) {
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// IF NOT CANCELLED
|
2014-09-23 16:15:36 +02:00
|
|
|
String clickedButton = be.getButtonClicked().getItemId();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (clickedButton.equals(Dialog.YES)) {
|
2014-07-11 15:56:35 +02:00
|
|
|
doAddAdministratorToFolderId(file, logins);
|
2014-09-23 16:15:36 +02:00
|
|
|
multidrag.hide();
|
2014-07-11 15:56:35 +02:00
|
|
|
}
|
2019-02-22 12:18:03 +01:00
|
|
|
if (clickedButton.equals(Dialog.CANCEL)) {
|
2014-09-23 16:15:36 +02:00
|
|
|
multidrag.hide();
|
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
}
|
2014-09-23 16:15:36 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-07-08 18:41:53 +02:00
|
|
|
}
|
|
|
|
});
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2014-09-23 16:15:36 +02:00
|
|
|
multidrag.show();
|
2014-07-08 18:41:53 +02:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Do add administrator to folder id.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param file
|
|
|
|
* the file
|
|
|
|
* @param logins
|
|
|
|
* the logins
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2014-07-08 18:41:53 +02:00
|
|
|
private void doAddAdministratorToFolderId(final FileModel file, final List<String> logins) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
WorkspaceSharingServiceAsync.INSTANCE.addAdministratorsByFolderId(file.getIdentifier(), logins,
|
|
|
|
new AsyncCallback<Boolean>() {
|
2014-07-08 18:41:53 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable arg0) {
|
|
|
|
new MessageBoxAlert("Error", arg0.getMessage(), null);
|
|
|
|
}
|
2014-07-08 18:41:53 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(Boolean arg0) {
|
|
|
|
String msg = "Updating administrator/s completed successfully";
|
|
|
|
MessageBox.info("Operation completed", msg, null);
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
|
|
|
});
|
2014-07-08 18:41:53 +02:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Sets the acl to folder id.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param folderId
|
|
|
|
* the folder id
|
|
|
|
* @param logins
|
|
|
|
* the logins
|
|
|
|
* @param aclTypeID
|
|
|
|
* the acl type id
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2015-01-28 12:42:48 +01:00
|
|
|
private void setACLToFolderId(final String folderId, final List<String> logins, String aclTypeID) {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
MessageBox.info("Attention", "set acls is not directly possible with StorageHub. Please use share or unshare.",
|
|
|
|
null);
|
|
|
|
|
|
|
|
// rpcWorkspaceService.setACLs(folderId, logins, aclTypeID, new
|
|
|
|
// AsyncCallback<Void>() {
|
|
|
|
//
|
|
|
|
// @Override
|
|
|
|
// public void onFailure(Throwable caught) {
|
|
|
|
// new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
//
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// @Override
|
|
|
|
// public void onSuccess(Void result) {
|
|
|
|
// String msg = "Updating permissions completed successfully";
|
|
|
|
// MessageBox.info("Operation completed", msg, null);
|
|
|
|
// }
|
|
|
|
// });
|
2015-01-28 12:42:48 +01:00
|
|
|
}
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Load my login.
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private void loadMyLogin() {
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2016-09-16 11:12:03 +02:00
|
|
|
String currentUrl = Window.Location.getHref().split("\\?")[0];
|
|
|
|
rpcWorkspaceService.getMyLogin(currentUrl, new AsyncCallback<UserBean>() {
|
2014-02-12 12:49:07 +01:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
GWT.log("Error on loading my login is empty");
|
2016-08-29 15:39:13 +02:00
|
|
|
ConstantsExplorer.log("Error on loading my login is empty");
|
2014-02-12 12:49:07 +01:00
|
|
|
myLogin = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2014-10-28 17:12:40 +01:00
|
|
|
public void onSuccess(UserBean user) {
|
2019-02-22 12:18:03 +01:00
|
|
|
ConstantsExplorer.log("UserBean is: " + user.toString());
|
|
|
|
GWT.log("My login is: " + user.getUsername());
|
2016-02-19 15:59:23 +01:00
|
|
|
myLogin = user.getUsername();
|
2014-10-28 17:12:40 +01:00
|
|
|
myLoginFirstName = user.getFirstName();
|
2014-02-12 12:49:07 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2016-08-29 15:39:13 +02:00
|
|
|
/**
|
|
|
|
* Load my first name.
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private void loadMyFirstName() {
|
2016-08-29 15:39:13 +02:00
|
|
|
|
|
|
|
rpcWorkspaceService.getMyFirstName(new AsyncCallback<String>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
ConstantsExplorer.log("Error on loading my first name");
|
|
|
|
myLoginFirstName = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSuccess(String firstName) {
|
2019-02-22 12:18:03 +01:00
|
|
|
ConstantsExplorer.log("getMyFirstName is: " + firstName);
|
2016-08-29 15:39:13 +02:00
|
|
|
myLoginFirstName = firstName;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Load item from workspace.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param itemIdentifier
|
|
|
|
* the item identifier
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private void loadItemFromWorkspace(final String itemIdentifier) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().mask(ConstantsExplorer.LOADING, ConstantsExplorer.LOADINGSTYLE);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getChildrenSubTreeToRootByIdentifier(itemIdentifier,
|
|
|
|
new AsyncCallback<ArrayList<SubTree>>() {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error", "Sorry - getChildrenSubTreeToRootByIdentifier", null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(ArrayList<SubTree> result) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
boolean foundAncestor = false;
|
|
|
|
// int index = 0;
|
|
|
|
int i = 0;
|
|
|
|
try {
|
|
|
|
while (!foundAncestor) {
|
|
|
|
|
|
|
|
if (i < result.size()) {
|
|
|
|
SubTree subTree = result.get(i); // get
|
|
|
|
// SubTree
|
|
|
|
String folderModelId = subTree.getParentId(); // get
|
|
|
|
// folder
|
|
|
|
// id
|
|
|
|
FolderModel folderInTree = (FolderModel) explorerPanel.getAsycTreePanel()
|
|
|
|
.getFileModelByIdentifier(folderModelId);
|
|
|
|
|
|
|
|
if (folderInTree != null && explorerPanel.getAsycTreePanel()
|
|
|
|
.getChildrenNumber(folderInTree.getIdentifier()) == 0)
|
|
|
|
foundAncestor = true;
|
|
|
|
i++;
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
explorerPanel.getAsycTreePanel().setSubTreeLoaded(true);
|
|
|
|
|
|
|
|
if (foundAncestor) {
|
|
|
|
|
|
|
|
for (int j = i - 1; j < result.size(); j++) {
|
|
|
|
|
|
|
|
SubTree subTree = result.get(j); // get
|
|
|
|
// SubTree
|
|
|
|
String folderModelId = subTree.getParentId(); // get
|
|
|
|
// folder
|
|
|
|
// id
|
|
|
|
FolderModel folderInTree = (FolderModel) explorerPanel.getAsycTreePanel()
|
|
|
|
.getFileModelByIdentifier(folderModelId); // get
|
|
|
|
// folder
|
|
|
|
// in
|
|
|
|
// tree
|
|
|
|
|
|
|
|
if (folderInTree.getParentFileModel() != null)
|
|
|
|
subTree.getParent().setParentFileModel(folderInTree.getParentFileModel()); // set
|
|
|
|
// parent
|
|
|
|
|
|
|
|
explorerPanel.getAsycTreePanel().addChildrenToFolder(
|
|
|
|
subTree.getParent().getIdentifier(), subTree.getChildren()); // Add
|
|
|
|
// level
|
|
|
|
explorerPanel.getAsycTreePanel()
|
|
|
|
.setExpandTreeLevel(subTree.getParent().getIdentifier(), true); // Expand
|
|
|
|
// level
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
ArrayList<FileModel> pathParentsList = (ArrayList<FileModel>) getListParentsByIdentifierFromTree(
|
|
|
|
itemIdentifier);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
selectItemInTree(itemIdentifier);
|
|
|
|
explorerPanel.getAsycTreePanel().setSubTreeLoaded(false);
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
eventBus.fireEvent(new SubTreeLoadedEvent(pathParentsList));
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} catch (Exception e) {
|
|
|
|
new MessageBoxAlert("Error", "Sorry, e " + e.getMessage(), null);
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
});
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
2015-12-14 15:12:22 +01:00
|
|
|
* Deselect current selection.
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private void deselectCurrentSelection() {
|
2013-02-06 15:40:17 +01:00
|
|
|
FileModel fileModelSelected = explorerPanel.getAsycTreePanel().getSelectedFileModelItem();
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModelSelected != null)
|
2013-02-06 15:40:17 +01:00
|
|
|
explorerPanel.getAsycTreePanel().deselectItem(fileModelSelected);
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// ********METHODS TO NOTIFY TREE
|
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#getListParentsByIdentifierFromTree(java.lang.
|
|
|
|
* String)
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
2014-01-21 14:55:19 +01:00
|
|
|
public List<FileModel> getListParentsByIdentifierFromTree(String itemIdentifier) {
|
|
|
|
|
2013-02-13 18:39:33 +01:00
|
|
|
List<FileModel> listParentModel = new ArrayList<FileModel>();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
FileModel item = this.explorerPanel.getAsycTreePanel().getFileModelByIdentifier(itemIdentifier);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (item == null) {
|
2013-02-06 15:40:17 +01:00
|
|
|
return null;
|
2019-02-22 12:18:03 +01:00
|
|
|
} else {
|
|
|
|
return getListParents(listParentModel, item);
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#renameItem(java.lang.String, java.lang.String,
|
|
|
|
* java.lang.String)
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public boolean renameItem(String itemIdentifier, String newName, String extension) {
|
|
|
|
return this.explorerPanel.getAsycTreePanel().renameItem(itemIdentifier, newName, extension);
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#deleteItem(java.lang.String)
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public boolean deleteItem(String itemIdentifier) {
|
|
|
|
return this.explorerPanel.getAsycTreePanel().deleteItem(itemIdentifier);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* method not used.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param itemIdentifier
|
|
|
|
* the item identifier
|
|
|
|
* @param name
|
|
|
|
* the name
|
|
|
|
* @param parentIdentifier
|
|
|
|
* the parent identifier
|
2015-09-18 16:51:38 +02:00
|
|
|
* @return true, if successful
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean addFolder(String itemIdentifier, String name, String parentIdentifier) {
|
2019-02-22 12:18:03 +01:00
|
|
|
return false; // not used
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* method not used.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param itemIdentifier
|
|
|
|
* the item identifier
|
|
|
|
* @param name
|
|
|
|
* the name
|
|
|
|
* @param parentIdentifier
|
|
|
|
* the parent identifier
|
2015-09-18 16:51:38 +02:00
|
|
|
* @return true, if successful
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean addFile(String itemIdentifier, String name, String parentIdentifier) {
|
2016-02-19 15:59:23 +01:00
|
|
|
return false;
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* method not used.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param itemIdentifier
|
|
|
|
* the item identifier
|
2015-09-18 16:51:38 +02:00
|
|
|
* @return true, if successful
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean reloadFolderChildren(String itemIdentifier) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* method not used.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param type
|
|
|
|
* the new visualization type
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void setVisualizationType(VisualizationType type) {
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#selectRootItem()
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
2019-02-22 12:18:03 +01:00
|
|
|
public void selectRootItem() {
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel.getAsycTreePanel().selectRootItem();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-09-18 16:51:38 +02:00
|
|
|
* Gets the selected folder in tree.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @return FileModel parent selected or root item if no directory is
|
|
|
|
* selected
|
2013-02-06 15:40:17 +01:00
|
|
|
*/
|
|
|
|
@Override
|
2019-02-22 12:18:03 +01:00
|
|
|
public FileModel getSelectedFolderInTree() {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
FileModel fileModel = this.explorerPanel.getAsycTreePanel().getSelectedFileModelItem();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModel.isDirectory())
|
2013-02-06 15:40:17 +01:00
|
|
|
return fileModel;
|
|
|
|
else
|
2016-02-19 15:59:23 +01:00
|
|
|
return fileModel.getParentFileModel();
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#findItemAndSelectItemInTree(java.lang.String)
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
public void findItemAndSelectItemInTree(String itemIdentifier) {
|
|
|
|
|
|
|
|
FileModel fileModel = this.explorerPanel.getAsycTreePanel().getFileModelByIdentifier(itemIdentifier);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModel == null) { // Loading item by RPC
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
loadItemFromWorkspace(itemIdentifier);
|
|
|
|
}
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
else {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
selectItemInTree(itemIdentifier);
|
|
|
|
}
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Select item in tree.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param itemIdentifier
|
|
|
|
* the item identifier
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
private void selectItemInTree(String itemIdentifier) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
FileModel fileModel = this.explorerPanel.getAsycTreePanel().getFileModelByIdentifier(itemIdentifier);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModel != null) {
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (explorerPanel.getAsycTreePanel().isSearch())
|
2015-12-14 15:12:22 +01:00
|
|
|
deselectCurrentSelection();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModel.isDirectory()) {
|
|
|
|
if (fileModel.getParentFileModel() != null)
|
|
|
|
this.explorerPanel.getAsycTreePanel()
|
|
|
|
.setExpandTreeLevel(fileModel.getParentFileModel().getIdentifier(), true); // expand
|
|
|
|
// parent
|
|
|
|
// folder
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
this.explorerPanel.getAsycTreePanel().selectItem(itemIdentifier);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
} else
|
|
|
|
this.explorerPanel.getAsycTreePanel().selectItem(itemIdentifier); // select
|
|
|
|
// item
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-06-25 15:33:03 +02:00
|
|
|
public AsyncCallback<WindowOpenParameter> downloadHandlerCallback = new AsyncCallback<WindowOpenParameter>() {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error", caught.getMessage(), null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSuccess(WindowOpenParameter windowOpenParam) {
|
2019-02-22 12:18:03 +01:00
|
|
|
String params = "?" + windowOpenParam.getParameters();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (params.length() > 1)
|
|
|
|
params += "&";
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
params += ConstantsExplorer.REDIRECTONERROR + "=" + windowOpenParam.isRedirectOnError();
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
windowOpenParam.getBrowserWindow().setUrl(ConstantsExplorer.DOWNLOAD_WORKSPACE_SERVICE + params);
|
2013-06-25 15:33:03 +02:00
|
|
|
}
|
|
|
|
};
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#expandFolder(java.lang.String)
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
|
|
|
/**
|
|
|
|
* Called when path item is clicked
|
|
|
|
*/
|
2019-02-22 12:18:03 +01:00
|
|
|
public void expandFolder(final String itemIdentifier) {
|
2013-02-06 15:40:17 +01:00
|
|
|
searching(false);
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
FileModel fileModel = this.explorerPanel.getAsycTreePanel().getFileModelByIdentifier(itemIdentifier);
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModel == null) { // Loading by RPC
|
2013-02-06 15:40:17 +01:00
|
|
|
loadItemFromWorkspace(itemIdentifier);
|
2019-02-22 12:18:03 +01:00
|
|
|
} else {
|
2015-12-14 15:12:22 +01:00
|
|
|
deselectCurrentSelection();
|
2019-02-22 12:18:03 +01:00
|
|
|
this.explorerPanel.getAsycTreePanel().selectItem(itemIdentifier); // select
|
|
|
|
// item
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
/*
|
|
|
|
* (non-Javadoc)
|
|
|
|
*
|
|
|
|
* @see org.gcube.portlets.user.workspace.client.interfaces.
|
|
|
|
* TreeAppControllerInterface#searching(boolean)
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
@Override
|
2019-02-22 12:18:03 +01:00
|
|
|
public void searching(boolean isSearch) {
|
|
|
|
// deselecteCurrentSelection();
|
2013-02-06 15:40:17 +01:00
|
|
|
explorerPanel.getAsycTreePanel().setSearch(isSearch);
|
|
|
|
}
|
2014-01-21 14:55:19 +01:00
|
|
|
|
2015-09-18 16:51:38 +02:00
|
|
|
/**
|
|
|
|
* Do click url.
|
|
|
|
*
|
2019-02-22 12:18:03 +01:00
|
|
|
* @param openUrlEvent
|
|
|
|
* the open url event
|
2015-09-18 16:51:38 +02:00
|
|
|
*/
|
2014-09-03 15:52:14 +02:00
|
|
|
public void doClickUrl(OpenUrlEvent openUrlEvent) {
|
|
|
|
|
|
|
|
final FileModel fileModel = openUrlEvent.getSourceFileModel();
|
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
if (fileModel == null)
|
2014-09-03 15:52:14 +02:00
|
|
|
return;
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2015-09-21 13:00:26 +02:00
|
|
|
GWT.log("do click url");
|
|
|
|
final NewBrowserWindow newBrowserWindow = NewBrowserWindow.open("", "_blank", "");
|
2016-02-19 15:59:23 +01:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
rpcWorkspaceService.getUrlById(fileModel.getIdentifier(),
|
|
|
|
fileModel.getGXTFolderItemType().equals(GXTFolderItemTypeEnum.URL_DOCUMENT), false,
|
|
|
|
new AsyncCallback<GWTWorkspaceItem>() {
|
2014-09-03 15:52:14 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onFailure(Throwable caught) {
|
|
|
|
explorerPanel.getAsycTreePanel().unmask();
|
|
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " clicking url.", null);
|
|
|
|
explorerPanel.getAsycTreePanel().removeAllAndRecoveryRoot();
|
2014-09-03 15:52:14 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-09-03 15:52:14 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
@Override
|
|
|
|
public void onSuccess(GWTWorkspaceItem result) {
|
|
|
|
|
|
|
|
if (fileModel.getGXTFolderItemType().equals(GXTFolderItemTypeEnum.URL_DOCUMENT)) {
|
|
|
|
newBrowserWindow.setUrl(((GWTUrlDocument) result).getUrl());
|
|
|
|
// new WindowOpenUrl(((GWTUrlDocument)
|
|
|
|
// result).getUrl(), "_blank", "");
|
|
|
|
GWT.log("URL_DOCUMENT Open " + ((GWTUrlDocument) result).getUrl());
|
|
|
|
} else {
|
|
|
|
// new WindowOpenUrl(((GWTExternalUrl)
|
|
|
|
// result).getUrl(), "_blank", "");
|
|
|
|
newBrowserWindow.setUrl(((GWTExternalUrl) result).getUrl());
|
|
|
|
GWT.log("ExternalUrl Open " + ((GWTExternalUrl) result).getUrl());
|
|
|
|
}
|
2014-09-03 15:52:14 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
}
|
2014-09-03 15:52:14 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
});
|
2014-09-03 15:52:14 +02:00
|
|
|
|
2019-02-22 12:18:03 +01:00
|
|
|
// com.google.gwt.user.client.Window.open(ConstantsExplorer.DOWNLOAD_WORKSPACE_SERVICE+"?id="+fileModel.getIdentifier()+"&viewContent=true",
|
|
|
|
// fileModel.getName(), "");
|
2014-09-03 15:52:14 +02:00
|
|
|
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|