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

   1 package org.argeo.slc.client.ui.dist.views;
   2
   3 import java.util.HashMap;
   4 import java.util.Map;
   5
   6 import javax.jcr.Repository;
   7 import javax.jcr.RepositoryException;
   8
   9 import org.argeo.cms.ArgeoNames;
  10 import org.argeo.cms.ui.workbench.util.CommandUtils;
  11 import org.argeo.eclipse.ui.TreeParent;
  12 import org.argeo.slc.SlcException;
  13 import org.argeo.slc.SlcNames;
  14 import org.argeo.slc.client.ui.dist.DistPlugin;
  15 import org.argeo.slc.client.ui.dist.commands.CopyLocalJavaWorkspace;
  16 import org.argeo.slc.client.ui.dist.commands.CopyWorkspace;
  17 import org.argeo.slc.client.ui.dist.commands.CreateLocalJavaWorkspace;
  18 import org.argeo.slc.client.ui.dist.commands.CreateWorkspace;
  19 import org.argeo.slc.client.ui.dist.commands.DeleteWorkspace;
  20 import org.argeo.slc.client.ui.dist.commands.DisplayRepoInformation;
  21 import org.argeo.slc.client.ui.dist.commands.Fetch;
  22 import org.argeo.slc.client.ui.dist.commands.NormalizeDistribution;
  23 import org.argeo.slc.client.ui.dist.commands.NormalizeWorkspace;
  24 import org.argeo.slc.client.ui.dist.commands.OpenGenerateBinariesWizard;
  25 import org.argeo.slc.client.ui.dist.commands.PublishWorkspace;
  26 import org.argeo.slc.client.ui.dist.commands.RegisterRepository;
  27 import org.argeo.slc.client.ui.dist.commands.RunInOsgi;
  28 import org.argeo.slc.client.ui.dist.commands.UnregisterRemoteRepo;
  29 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparator;
  30 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparer;
  31 import org.argeo.slc.client.ui.dist.controllers.DistTreeContentProvider;
  32 import org.argeo.slc.client.ui.dist.controllers.DistTreeDoubleClickListener;
  33 import org.argeo.slc.client.ui.dist.controllers.DistTreeLabelProvider;
  34 import org.argeo.slc.client.ui.dist.model.DistParentElem;
  35 import org.argeo.slc.client.ui.dist.model.ModularDistVersionBaseElem;
  36 import org.argeo.slc.client.ui.dist.model.ModularDistVersionElem;
  37 import org.argeo.slc.client.ui.dist.model.RepoElem;
  38 import org.argeo.slc.client.ui.dist.model.WkspGroupElem;
  39 import org.argeo.slc.client.ui.dist.model.WorkspaceElem;
  40 import org.eclipse.jface.action.IContributionItem;
  41 import org.eclipse.jface.action.IMenuListener;
  42 import org.eclipse.jface.action.IMenuManager;
  43 import org.eclipse.jface.action.MenuManager;
  44 import org.eclipse.jface.viewers.IStructuredSelection;
  45 import org.eclipse.jface.viewers.TreeViewer;
  46 import org.eclipse.jface.viewers.TreeViewerColumn;
  47 import org.eclipse.jface.viewers.ViewerComparator;
  48 import org.eclipse.swt.SWT;
  49 import org.eclipse.swt.widgets.Composite;
  50 import org.eclipse.swt.widgets.Menu;
  51 import org.eclipse.swt.widgets.Tree;
  52 import org.eclipse.ui.IWorkbenchWindow;
  53 import org.eclipse.ui.part.ViewPart;
  54
  55 /**
  56  * Browse, manipulate and manage distributions across multiple repositories
  57  * (like fetch, merge, publish, etc.).
  58  */
  59 public class DistributionsView extends ViewPart implements SlcNames, ArgeoNames {
  60         // private final static Log log =
  61         // LogFactory.getLog(DistributionsView.class);
  62
  63         public final static String ID = DistPlugin.PLUGIN_ID + ".distributionsView";
  64
  65         /* DEPENDENCY INJECTION */
  66         private Repository nodeRepository;
  67         private DistTreeContentProvider treeContentProvider;
  68
  69         private TreeViewer viewer;
  70
  71         @Override
  72         public void createPartControl(Composite parent) {
  73                 // Define the TableViewer
  74                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
  75                                 | SWT.FULL_SELECTION | SWT.BORDER);
  76
  77                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.NONE);
  78                 col.getColumn().setWidth(400);
  79                 col.setLabelProvider(new DistTreeLabelProvider());
  80
  81                 final Tree tree = viewer.getTree();
  82                 tree.setHeaderVisible(false);
  83                 tree.setLinesVisible(false);
  84
  85                 // viewer.setContentProvider(new DistTreeContentProvider());
  86                 viewer.setContentProvider(treeContentProvider);
  87                 viewer.addDoubleClickListener(new DistTreeDoubleClickListener(viewer));
  88                 viewer.setComparer(new DistTreeComparer());
  89                 viewer.setComparator(new DistTreeComparator());
  90
  91                 @SuppressWarnings("unused")
  92                 ViewerComparator vc = viewer.getComparator();
  93
  94                 // Enable retrieving current tree selected items from outside the view
  95                 getSite().setSelectionProvider(viewer);
  96
  97                 MenuManager menuManager = new MenuManager();
  98                 Menu menu = menuManager.createContextMenu(viewer.getTree());
  99                 menuManager.addMenuListener(new IMenuListener() {
 100                         private static final long serialVersionUID = -1454108001335038652L;
 101
 102                         public void menuAboutToShow(IMenuManager manager) {
 103                                 contextMenuAboutToShow(manager);
 104                         }
 105                 });
 106                 viewer.getTree().setMenu(menu);
 107                 getSite().registerContextMenu(menuManager, viewer);
 108
 109                 // Initialize
 110                 refresh();
 111         }
 112
 113         /** Programatically configure the context menu */
 114         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 115                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 116                                 .getActiveWorkbenchWindow();
 117
 118                 // Most of the implemented commands support only one selected
 119                 // element
 120                 boolean singleElement = ((IStructuredSelection) viewer.getSelection())
 121                                 .size() == 1;
 122                 // Get Current selected item :
 123                 Object firstElement = ((IStructuredSelection) viewer.getSelection())
 124                                 .getFirstElement();
 125
 126                 try {
 127
 128                         if (firstElement instanceof TreeParent
 129                                         || firstElement instanceof DistParentElem) {
 130
 131                                 String targetRepoPath = null, workspaceName = null, workspacePrefix = null;
 132                                 String modularDistBasePath = null;
 133                                 String modularDistPath = null;
 134                                 // String targetRepoUri = null;
 135                                 // Build conditions depending on element type
 136                                 boolean isDistribElem = false, isModularDistVersionBaseElem = false, isRepoElem = false, isDistribGroupElem = false;
 137                                 boolean isLocal = false, isReadOnly = true;
 138
 139                                 RepoElem re = null;
 140
 141                                 if (firstElement instanceof RepoElem) {
 142                                         re = (RepoElem) firstElement;
 143                                         isRepoElem = true;
 144                                         isLocal = re.inHome();
 145                                         isReadOnly = re.isReadOnly();
 146                                 } else if (firstElement instanceof WkspGroupElem) {
 147                                         WkspGroupElem wge = (WkspGroupElem) firstElement;
 148                                         isReadOnly = wge.isReadOnly();
 149                                         isDistribGroupElem = true;
 150                                         re = (RepoElem) wge.getParent();
 151                                         workspacePrefix = wge.getName();
 152                                 } else if (firstElement instanceof WorkspaceElem) {
 153                                         WorkspaceElem we = (WorkspaceElem) firstElement;
 154                                         re = we.getRepoElem();
 155                                         isDistribElem = true;
 156                                         isReadOnly = we.isReadOnly();
 157                                         workspaceName = we.getWorkspaceName();
 158                                         isLocal = we.inHome();
 159                                 } else if (firstElement instanceof ModularDistVersionBaseElem) {
 160                                         ModularDistVersionBaseElem mdbe = (ModularDistVersionBaseElem) firstElement;
 161                                         isModularDistVersionBaseElem = true;
 162                                         re = mdbe.getWkspElem().getRepoElem();
 163                                         isLocal = re.inHome();
 164                                         isReadOnly = re.isReadOnly();
 165                                         workspaceName = mdbe.getWkspElem().getWorkspaceName();
 166                                         modularDistBasePath = mdbe.getModularDistBase().getPath();
 167                                 } else if (firstElement instanceof ModularDistVersionElem) {
 168                                         ModularDistVersionElem mdbe = (ModularDistVersionElem) firstElement;
 169                                         re = mdbe.getWorkspaceElem().getRepoElem();
 170                                         isLocal = re.inHome();
 171                                         isReadOnly = re.isReadOnly();
 172                                         workspaceName = mdbe.getWorkspaceElem().getWorkspaceName();
 173                                         modularDistPath = mdbe.getModularDistVersionNode()
 174                                                         .getPath();
 175                                 }
 176
 177                                 if (re != null) {
 178                                         targetRepoPath = re.getRepoNodePath();
 179                                 }
 180
 181                                 // Display repo info
 182                                 CommandUtils.refreshCommand(menuManager, window,
 183                                                 DisplayRepoInformation.ID,
 184                                                 DisplayRepoInformation.DEFAULT_LABEL,
 185                                                 DisplayRepoInformation.DEFAULT_ICON, isRepoElem
 186                                                                 && singleElement);
 187
 188                                 // create workspace
 189                                 Map<String, String> params = new HashMap<String, String>();
 190                                 params.put(CreateWorkspace.PARAM_TARGET_REPO_PATH,
 191                                                 targetRepoPath);
 192                                 params.put(CreateWorkspace.PARAM_WORKSPACE_PREFIX,
 193                                                 workspacePrefix);
 194                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 195                                                 CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 196                                                 CreateWorkspace.DEFAULT_ICON,
 197                                                 (isRepoElem || isDistribGroupElem) && singleElement
 198                                                                 && !isReadOnly && !isLocal, params);
 199
 200                                 // TODO Manage the case where it is not a java workspace
 201                                 params = new HashMap<String, String>();
 202                                 params.put(CreateLocalJavaWorkspace.PARAM_WORKSPACE_PREFIX,
 203                                                 workspacePrefix);
 204                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 205                                                 CreateLocalJavaWorkspace.ID,
 206                                                 CreateLocalJavaWorkspace.DEFAULT_LABEL,
 207                                                 CreateLocalJavaWorkspace.DEFAULT_ICON,
 208                                                 (isRepoElem || isDistribGroupElem) && singleElement
 209                                                                 && !isReadOnly && isLocal, params);
 210
 211                                 // Register a remote repository
 212                                 CommandUtils.refreshCommand(menuManager, window,
 213                                                 RegisterRepository.ID,
 214                                                 RegisterRepository.DEFAULT_LABEL,
 215                                                 RegisterRepository.DEFAULT_ICON, isRepoElem
 216                                                                 && singleElement);
 217
 218                                 // Unregister a remote repository
 219                                 params = new HashMap<String, String>();
 220                                 params.put(UnregisterRemoteRepo.PARAM_REPO_PATH, targetRepoPath);
 221                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 222                                                 UnregisterRemoteRepo.ID,
 223                                                 UnregisterRemoteRepo.DEFAULT_LABEL,
 224                                                 UnregisterRemoteRepo.DEFAULT_ICON, isRepoElem
 225                                                                 && !isLocal && singleElement, params);
 226
 227                                 // Fetch repository
 228                                 params = new HashMap<String, String>();
 229                                 params.put(Fetch.PARAM_TARGET_REPO_PATH, targetRepoPath);
 230                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 231                                                 Fetch.ID, Fetch.DEFAULT_LABEL, Fetch.DEFAULT_ICON,
 232                                                 isRepoElem && isLocal && singleElement && !isReadOnly,
 233                                                 params);
 234
 235                                 // Normalize workspace
 236                                 params = new HashMap<String, String>();
 237                                 params.put(NormalizeWorkspace.PARAM_TARGET_REPO_PATH,
 238                                                 targetRepoPath);
 239                                 params.put(NormalizeWorkspace.PARAM_WORKSPACE_NAME,
 240                                                 workspaceName);
 241
 242                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 243                                                 NormalizeWorkspace.ID, "Normalize...",
 244                                                 NormalizeWorkspace.DEFAULT_ICON, isDistribElem
 245                                                                 && singleElement && !isReadOnly, params);
 246
 247                                 // Copy workspace
 248                                 params = new HashMap<String, String>();
 249                                 params.put(CopyWorkspace.PARAM_TARGET_REPO_PATH, targetRepoPath);
 250                                 params.put(CopyWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 251                                                 workspaceName);
 252                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 253                                                 CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 254                                                 CopyWorkspace.DEFAULT_ICON, isDistribElem
 255                                                                 && singleElement && !isLocal, params);
 256
 257                                 params = new HashMap<String, String>();
 258                                 params.put(CopyLocalJavaWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 259                                                 workspaceName);
 260                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 261                                                 CopyLocalJavaWorkspace.ID,
 262                                                 CopyLocalJavaWorkspace.DEFAULT_LABEL,
 263                                                 CopyLocalJavaWorkspace.DEFAULT_ICON, isDistribElem
 264                                                                 && singleElement && isLocal, params);
 265
 266                                 // Clear Workspace
 267                                 params = new HashMap<String, String>();
 268                                 params.put(DeleteWorkspace.PARAM_TARGET_REPO_PATH,
 269                                                 targetRepoPath);
 270                                 params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 271                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 272                                                 DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 273                                                 DeleteWorkspace.DEFAULT_ICON, isDistribElem
 274                                                                 && singleElement && !isReadOnly, params);
 275
 276                                 // Advanced submenu
 277                                 MenuManager submenu = new MenuManager("Advanced",
 278                                                 DistPlugin.PLUGIN_ID + ".advancedSubmenu");
 279                                 IContributionItem ici = menuManager.find(DistPlugin.PLUGIN_ID
 280                                                 + ".advancedSubmenu");
 281                                 if (ici != null)
 282                                         menuManager.remove(ici);
 283
 284                                 // Publish workspace
 285                                 params = new HashMap<String, String>();
 286                                 params.put(PublishWorkspace.PARAM_TARGET_REPO_PATH,
 287                                                 targetRepoPath);
 288                                 params.put(PublishWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 289                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 290                                                 PublishWorkspace.ID, PublishWorkspace.DEFAULT_LABEL,
 291                                                 PublishWorkspace.DEFAULT_ICON, isDistribElem
 292                                                                 && singleElement && !isReadOnly, params);
 293
 294                                 // Normalize distribution (Legacy)
 295                                 params = new HashMap<String, String>();
 296                                 params.put(NormalizeDistribution.PARAM_TARGET_REPO_PATH,
 297                                                 targetRepoPath);
 298                                 params.put(NormalizeDistribution.PARAM_WORKSPACE_NAME,
 299                                                 workspaceName);
 300                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 301                                                 NormalizeDistribution.ID,
 302                                                 NormalizeDistribution.DEFAULT_LABEL,
 303                                                 NormalizeDistribution.DEFAULT_ICON, isDistribElem
 304                                                                 && singleElement && !isReadOnly, params);
 305
 306                                 // Run in OSGi
 307                                 params = new HashMap<String, String>();
 308                                 params.put(RunInOsgi.PARAM_MODULE_PATH, modularDistPath);
 309                                 params.put(RunInOsgi.PARAM_WORKSPACE_NAME, workspaceName);
 310                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 311                                                 RunInOsgi.ID, RunInOsgi.DEFAULT_LABEL,
 312                                                 RunInOsgi.DEFAULT_ICON, modularDistPath != null
 313                                                                 && singleElement && isLocal, params);
 314
 315                                 // Open generate binaries
 316                                 params = new HashMap<String, String>();
 317                                 params.put(OpenGenerateBinariesWizard.PARAM_REPO_NODE_PATH,
 318                                                 targetRepoPath);
 319                                 params.put(OpenGenerateBinariesWizard.PARAM_MODULE_PATH,
 320                                                 modularDistBasePath);
 321                                 params.put(OpenGenerateBinariesWizard.PARAM_WORKSPACE_NAME,
 322                                                 workspaceName);
 323
 324                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 325                                                 OpenGenerateBinariesWizard.ID,
 326                                                 OpenGenerateBinariesWizard.DEFAULT_LABEL,
 327                                                 OpenGenerateBinariesWizard.DEFAULT_ICON,
 328                                                 isModularDistVersionBaseElem && !isReadOnly, params);
 329
 330                                 if (submenu.getSize() > 0)
 331                                         menuManager.add(submenu);
 332
 333                                 // // Manage workspace authorizations
 334                                 // params = new HashMap<String, String>();
 335                                 // params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 336                                 // CommandHelpers.refreshParameterizedCommand(menuManager,
 337                                 // window,
 338                                 // ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 339                                 // ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem
 340                                 // && singleElement && !isReadOnly, params);
 341                         }
 342                 } catch (RepositoryException e) {
 343                         throw new SlcException("unexpected errror while "
 344                                         + "building context menu for element " + firstElement, e);
 345                 }
 346         }
 347
 348         @Override
 349         public void setFocus() {
 350                 viewer.getTree().setFocus();
 351         }
 352
 353         /**
 354          * Force refresh of the whole view
 355          */
 356         public void refresh() {
 357                 viewer.setInput(nodeRepository);
 358                 viewer.expandToLevel(2);
 359         }
 360
 361         /* DEPENDENCY INJECTION */
 362         public void setNodeRepository(Repository nodeRepository) {
 363                 this.nodeRepository = nodeRepository;
 364         }
 365
 366         public void setTreeContentProvider(
 367                         DistTreeContentProvider treeContentProvider) {
 368                 this.treeContentProvider = treeContentProvider;
 369         }
 370 }