plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/views/DistributionsView.java

   1 /*
   2  * Copyright (C) 2007-2012 Argeo GmbH
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.views;
  17
  18 import java.util.HashMap;
  19 import java.util.Map;
  20
  21 import javax.jcr.Repository;
  22 import javax.jcr.RepositoryException;
  23
  24 import org.argeo.eclipse.ui.TreeParent;
  25 import org.argeo.jcr.ArgeoNames;
  26 import org.argeo.slc.SlcException;
  27 import org.argeo.slc.client.ui.dist.DistPlugin;
  28 import org.argeo.slc.client.ui.dist.commands.CopyWorkspace;
  29 import org.argeo.slc.client.ui.dist.commands.CreateWorkspace;
  30 import org.argeo.slc.client.ui.dist.commands.DeleteWorkspace;
  31 import org.argeo.slc.client.ui.dist.commands.DisplayRepoInformation;
  32 import org.argeo.slc.client.ui.dist.commands.Fetch;
  33 import org.argeo.slc.client.ui.dist.commands.MergeWorkspaces;
  34 import org.argeo.slc.client.ui.dist.commands.NormalizeDistribution;
  35 import org.argeo.slc.client.ui.dist.commands.PublishWorkspace;
  36 import org.argeo.slc.client.ui.dist.commands.RefreshDistributionsView;
  37 import org.argeo.slc.client.ui.dist.commands.RegisterRepository;
  38 import org.argeo.slc.client.ui.dist.commands.UnregisterRemoteRepo;
  39 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparator;
  40 import org.argeo.slc.client.ui.dist.controllers.DistTreeContentProvider;
  41 import org.argeo.slc.client.ui.dist.controllers.DistTreeDoubleClickListener;
  42 import org.argeo.slc.client.ui.dist.controllers.DistTreeLabelProvider;
  43 import org.argeo.slc.client.ui.dist.model.DistParentElem;
  44 import org.argeo.slc.client.ui.dist.model.GroupElem;
  45 import org.argeo.slc.client.ui.dist.model.RepoElem;
  46 import org.argeo.slc.client.ui.dist.model.WorkspaceElem;
  47 import org.argeo.slc.client.ui.dist.utils.CommandHelpers;
  48 import org.argeo.slc.jcr.SlcNames;
  49 import org.eclipse.jface.action.IMenuListener;
  50 import org.eclipse.jface.action.IMenuManager;
  51 import org.eclipse.jface.action.MenuManager;
  52 import org.eclipse.jface.dialogs.MessageDialog;
  53 import org.eclipse.jface.viewers.IStructuredSelection;
  54 import org.eclipse.jface.viewers.TreeViewer;
  55 import org.eclipse.jface.viewers.TreeViewerColumn;
  56 import org.eclipse.jface.viewers.Viewer;
  57 import org.eclipse.jface.viewers.ViewerDropAdapter;
  58 import org.eclipse.swt.SWT;
  59 import org.eclipse.swt.dnd.DND;
  60 import org.eclipse.swt.dnd.DragSourceAdapter;
  61 import org.eclipse.swt.dnd.DragSourceEvent;
  62 import org.eclipse.swt.dnd.TextTransfer;
  63 import org.eclipse.swt.dnd.Transfer;
  64 import org.eclipse.swt.dnd.TransferData;
  65 import org.eclipse.swt.widgets.Composite;
  66 import org.eclipse.swt.widgets.Menu;
  67 import org.eclipse.swt.widgets.Tree;
  68 import org.eclipse.ui.IWorkbenchWindow;
  69 import org.eclipse.ui.part.ViewPart;
  70
  71 /**
  72  * Browse, manipulate and manage distributions accross multiple repositories
  73  * (like fetch, merge, publish, etc.).
  74  */
  75 public class DistributionsView extends ViewPart implements SlcNames, ArgeoNames {
  76         // private final static Log log =
  77         // LogFactory.getLog(DistributionsView.class);
  78         public final static String ID = DistPlugin.ID + ".distributionsView";
  79
  80         /* DEPENDENCY INJECTION */
  81         private Repository nodeRepository;
  82         private DistTreeContentProvider treeContentProvider;
  83
  84         private TreeViewer viewer;
  85
  86         @Override
  87         public void createPartControl(Composite parent) {
  88                 // Define the TableViewer
  89                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
  90                                 | SWT.FULL_SELECTION | SWT.BORDER);
  91
  92                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.NONE);
  93                 col.getColumn().setWidth(400);
  94                 col.setLabelProvider(new DistTreeLabelProvider());
  95
  96                 final Tree tree = viewer.getTree();
  97                 tree.setHeaderVisible(false);
  98                 tree.setLinesVisible(false);
  99
 100                 // viewer.setContentProvider(new DistTreeContentProvider());
 101                 viewer.setContentProvider(treeContentProvider);
 102                 viewer.addDoubleClickListener(new DistTreeDoubleClickListener());
 103                 viewer.setComparator(new DistTreeComparator());
 104
 105                 // Enable selection retrieving from outside the view
 106                 getSite().setSelectionProvider(viewer);
 107
 108                 // Drag'n drop
 109                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
 110                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
 111                 viewer.addDragSupport(operations, tt, new ViewDragListener());
 112                 viewer.addDropSupport(operations, tt, new ViewDropListener(viewer));
 113
 114                 MenuManager menuManager = new MenuManager();
 115                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 116                 menuManager.addMenuListener(new IMenuListener() {
 117                         public void menuAboutToShow(IMenuManager manager) {
 118                                 contextMenuAboutToShow(manager);
 119                         }
 120                 });
 121                 viewer.getTree().setMenu(menu);
 122                 getSite().registerContextMenu(menuManager, viewer);
 123
 124                 // Initialize
 125                 refresh();
 126         }
 127
 128         /** Programatically configure the context menu */
 129         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 130                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 131                                 .getActiveWorkbenchWindow();
 132
 133                 try {
 134                         // Most of the implemented commands support only one selected
 135                         // element
 136                         boolean singleElement = ((IStructuredSelection) viewer
 137                                         .getSelection()).size() == 1;
 138                         // Get Current selected item :
 139                         Object firstElement = ((IStructuredSelection) viewer.getSelection())
 140                                         .getFirstElement();
 141
 142                         if (firstElement instanceof TreeParent
 143                                         || firstElement instanceof DistParentElem) {
 144
 145                                 String targetRepoPath = null, workspaceName = null, workspacePrefix = null;
 146                                 // String targetRepoUri = null;
 147                                 // Build conditions depending on element type
 148                                 boolean isDistribElem = false, isRepoElem = false, isDistribGroupElem = false;
 149                                 boolean isHomeRepo = false, isReadOnly = true;
 150
 151                                 RepoElem re = null;
 152
 153                                 if (firstElement instanceof WorkspaceElem) {
 154                                         WorkspaceElem de = (WorkspaceElem) firstElement;
 155                                         re = de.getRepoElem();
 156                                         isDistribElem = true;
 157                                         isReadOnly = de.isReadOnly();
 158                                         workspaceName = de.getWorkspaceName();
 159                                 } else if (firstElement instanceof RepoElem) {
 160                                         re = (RepoElem) firstElement;
 161                                         isRepoElem = true;
 162                                         isHomeRepo = re.inHome();
 163                                         isReadOnly = re.isReadOnly();
 164                                 } else if (firstElement instanceof GroupElem) {
 165                                         GroupElem dge = (GroupElem) firstElement;
 166                                         isReadOnly = dge.isReadOnly();
 167                                         isDistribGroupElem = true;
 168                                         re = dge.getRepoElem();
 169                                         workspacePrefix = dge.getLabel();
 170                                 }
 171
 172                                 if (re != null) {
 173                                         // targetRepoUri = re.getUri();
 174                                         targetRepoPath = re.getRepoNode().getPath();
 175                                 }
 176
 177                                 // Display repo info
 178                                 CommandHelpers.refreshCommand(menuManager, window,
 179                                                 DisplayRepoInformation.ID,
 180                                                 DisplayRepoInformation.DEFAULT_LABEL,
 181                                                 DisplayRepoInformation.DEFAULT_ICON_PATH, isRepoElem
 182                                                                 && singleElement);
 183
 184                                 // create workspace
 185                                 Map<String, String> params = new HashMap<String, String>();
 186                                 params.put(CreateWorkspace.PARAM_TARGET_REPO_PATH,
 187                                                 targetRepoPath);
 188                                 params.put(CreateWorkspace.PARAM_WORKSPACE_PREFIX,
 189                                                 workspacePrefix);
 190                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 191                                                 CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 192                                                 CreateWorkspace.DEFAULT_ICON_PATH,
 193                                                 (isRepoElem || isDistribGroupElem) && singleElement
 194                                                                 && !isReadOnly, params);
 195
 196                                 // publish workspace
 197                                 params = new HashMap<String, String>();
 198                                 params.put(PublishWorkspace.PARAM_TARGET_REPO_PATH,
 199                                                 targetRepoPath);
 200                                 params.put(PublishWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 201                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 202                                                 PublishWorkspace.ID, PublishWorkspace.DEFAULT_LABEL,
 203                                                 PublishWorkspace.DEFAULT_ICON_PATH, isDistribElem
 204                                                                 && singleElement && !isReadOnly, params);
 205
 206                                 // Register a remote repository
 207                                 CommandHelpers.refreshCommand(menuManager, window,
 208                                                 RegisterRepository.ID,
 209                                                 RegisterRepository.DEFAULT_LABEL,
 210                                                 RegisterRepository.DEFAULT_ICON_PATH, isRepoElem
 211                                                                 && singleElement);
 212
 213                                 // Unregister a remote repository
 214                                 params = new HashMap<String, String>();
 215                                 params.put(UnregisterRemoteRepo.PARAM_REPO_PATH, targetRepoPath);
 216                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 217                                                 UnregisterRemoteRepo.ID,
 218                                                 UnregisterRemoteRepo.DEFAULT_LABEL,
 219                                                 UnregisterRemoteRepo.DEFAULT_ICON_PATH, isRepoElem
 220                                                                 && !isHomeRepo && singleElement, params);
 221
 222                                 // Fetch repository
 223                                 params = new HashMap<String, String>();
 224                                 params.put(Fetch.PARAM_TARGET_REPO_PATH, targetRepoPath);
 225                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 226                                                 Fetch.ID, Fetch.DEFAULT_LABEL, Fetch.DEFAULT_ICON_PATH,
 227                                                 isRepoElem && singleElement && !isReadOnly, params);
 228
 229                                 // Normalize workspace
 230                                 params = new HashMap<String, String>();
 231                                 params.put(NormalizeDistribution.PARAM_TARGET_REPO_PATH,
 232                                                 targetRepoPath);
 233                                 params.put(NormalizeDistribution.PARAM_WORKSPACE_NAME,
 234                                                 workspaceName);
 235                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 236                                                 NormalizeDistribution.ID,
 237                                                 NormalizeDistribution.DEFAULT_LABEL,
 238                                                 NormalizeDistribution.DEFAULT_ICON_PATH, isDistribElem
 239                                                                 && singleElement && !isReadOnly, params);
 240
 241                                 // Copy workspace
 242                                 params = new HashMap<String, String>();
 243                                 params.put(CopyWorkspace.PARAM_TARGET_REPO_PATH, targetRepoPath);
 244                                 params.put(CopyWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 245                                                 workspaceName);
 246                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 247                                                 CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 248                                                 CopyWorkspace.DEFAULT_ICON_PATH, isDistribElem
 249                                                                 && singleElement, params);
 250
 251                                 // Clear Workspace
 252                                 params = new HashMap<String, String>();
 253                                 params.put(DeleteWorkspace.PARAM_TARGET_REPO_PATH,
 254                                                 targetRepoPath);
 255                                 params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 256                                 CommandHelpers.refreshParameterizedCommand(menuManager, window,
 257                                                 DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 258                                                 DeleteWorkspace.DEFAULT_ICON_PATH, isDistribElem
 259                                                                 && singleElement && !isReadOnly, params);
 260
 261                                 // // Manage workspace authorizations
 262                                 // params = new HashMap<String, String>();
 263                                 // params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 264                                 // CommandHelpers.refreshParameterizedCommand(menuManager,
 265                                 // window,
 266                                 // ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 267                                 // ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem
 268                                 // && singleElement && !isReadOnly, params);
 269                         }
 270                 } catch (RepositoryException e) {
 271                         throw new SlcException("unexpected errror while "
 272                                         + "building context menu", e);
 273                 }
 274         }
 275
 276         @Override
 277         public void setFocus() {
 278                 viewer.getTree().setFocus();
 279         }
 280
 281         /**
 282          * Force refresh of the whole view
 283          */
 284         public void refresh() {
 285                 viewer.setInput(nodeRepository);
 286                 viewer.expandToLevel(2);
 287         }
 288
 289         /** Listens to drag */
 290         class ViewDragListener extends DragSourceAdapter {
 291                 public void dragSetData(DragSourceEvent event) {
 292                         IStructuredSelection selection = (IStructuredSelection) viewer
 293                                         .getSelection();
 294                         if (selection.getFirstElement() instanceof WorkspaceElem) {
 295                                 WorkspaceElem de = (WorkspaceElem) selection.getFirstElement();
 296                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 297                                         event.data = de.getRepoElem().getUri() + "/"
 298                                                         + de.getWorkspaceName();
 299                                 }
 300                         }
 301                 }
 302         }
 303
 304         /** Listens to drop */
 305         class ViewDropListener extends ViewerDropAdapter {
 306
 307                 public ViewDropListener(Viewer viewer) {
 308                         super(viewer);
 309                 }
 310
 311                 @Override
 312                 public boolean performDrop(Object data) {
 313                         WorkspaceElem sourceDist = (WorkspaceElem) getSelectedObject();
 314                         RepoElem targetRepo = (RepoElem) getCurrentTarget();
 315
 316                         Boolean ok = MessageDialog.openConfirm(getSite().getShell(),
 317                                         "Confirm distribution merge", "Do you want to merge "
 318                                                         + sourceDist.getWorkspaceName() + " (from repo "
 319                                                         + sourceDist.getRepoElem().getLabel()
 320                                                         + ") to repo " + targetRepo.getLabel() + "?");
 321                         if (!ok)
 322                                 return false;
 323
 324                         try {
 325                                 Map<String, String> params = new HashMap<String, String>();
 326                                 params.put(MergeWorkspaces.PARAM_TARGET_REPO_PATH, targetRepo
 327                                                 .getRepoNode().getPath());
 328                                 params.put(MergeWorkspaces.PARAM_SOURCE_REPO_PATH, sourceDist
 329                                                 .getRepoElem().getRepoNode().getPath());
 330                                 params.put(MergeWorkspaces.PARAM_SOURCE_WORKSPACE_NAME,
 331                                                 sourceDist.getWorkspaceName());
 332                                 CommandHelpers.callCommand(RefreshDistributionsView.ID, params);
 333                                 return true;
 334                         } catch (RepositoryException e) {
 335                                 throw new SlcException("Cannot process drop from " + sourceDist
 336                                                 + " to " + targetRepo, e);
 337                         }
 338                 }
 339
 340                 @Override
 341                 public boolean validateDrop(Object target, int operation,
 342                                 TransferData transferType) {
 343                         if (target instanceof RepoElem) {
 344                                 if (getSelectedObject() instanceof WorkspaceElem) {
 345                                         // check if not same repository
 346                                         String srcRepoUri = ((WorkspaceElem) getSelectedObject())
 347                                                         .getRepoElem().getUri();
 348                                         String targetRepoUri = ((RepoElem) target).getUri();
 349                                         return !targetRepoUri.equals(srcRepoUri);
 350                                 }
 351                         }
 352                         return false;
 353                 }
 354         }
 355
 356         /*
 357          * DEPENDENCY INJECTION
 358          */
 359         public void setNodeRepository(Repository repository) {
 360                 this.nodeRepository = repository;
 361         }
 362
 363         public void setTreeContentProvider(
 364                         DistTreeContentProvider treeContentProvider) {
 365                 this.treeContentProvider = treeContentProvider;
 366         }
 367 }