plugins/org.argeo.slc.akb.ui/src/main/java/org/argeo/slc/akb/ui/views/AkbActiveEnvsTreeView.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.akb.ui.views;
  17
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import javax.jcr.Node;
  24 import javax.jcr.NodeIterator;
  25 import javax.jcr.Repository;
  26 import javax.jcr.RepositoryException;
  27 import javax.jcr.Session;
  28 import javax.jcr.observation.Event;
  29
  30 import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  31 import org.argeo.eclipse.ui.utils.CommandUtils;
  32 import org.argeo.jcr.JcrUtils;
  33 import org.argeo.slc.akb.AkbException;
  34 import org.argeo.slc.akb.AkbNames;
  35 import org.argeo.slc.akb.AkbService;
  36 import org.argeo.slc.akb.AkbTypes;
  37 import org.argeo.slc.akb.ui.AkbUiPlugin;
  38 import org.argeo.slc.akb.ui.AkbUiUtils;
  39 import org.argeo.slc.akb.ui.commands.DeleteAkbNodes;
  40 import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;
  41 import org.argeo.slc.akb.ui.providers.AkbTreeLabelProvider;
  42 import org.argeo.slc.akb.ui.providers.TemplatesTreeContentProvider;
  43 import org.argeo.slc.akb.ui.utils.Refreshable;
  44 import org.argeo.slc.akb.utils.AkbJcrUtils;
  45 import org.eclipse.jface.action.IContributionItem;
  46 import org.eclipse.jface.action.IMenuListener;
  47 import org.eclipse.jface.action.IMenuManager;
  48 import org.eclipse.jface.action.MenuManager;
  49 import org.eclipse.jface.viewers.DoubleClickEvent;
  50 import org.eclipse.jface.viewers.IDoubleClickListener;
  51 import org.eclipse.jface.viewers.IStructuredSelection;
  52 import org.eclipse.jface.viewers.TreeViewer;
  53 import org.eclipse.swt.SWT;
  54 import org.eclipse.swt.layout.GridData;
  55 import org.eclipse.swt.widgets.Composite;
  56 import org.eclipse.swt.widgets.Display;
  57 import org.eclipse.swt.widgets.Menu;
  58 import org.eclipse.ui.IWorkbenchWindow;
  59 import org.eclipse.ui.part.ViewPart;
  60 import org.eclipse.ui.services.IServiceLocator;
  61
  62 /** AKB Active environment tree view. */
  63 public class AkbActiveEnvsTreeView extends ViewPart implements Refreshable {
  64
  65         public final static String ID = AkbUiPlugin.PLUGIN_ID
  66                         + ".akbActiveEnvsTreeView";
  67
  68         /* DEPENDENCY INJECTION */
  69         private Session session;
  70         private AkbService akbService;
  71
  72         // This page widgets
  73         private TreeViewer envTreeViewer;
  74
  75         // Usefull business objects
  76         private Node activeEnvsParentNode;
  77
  78         private void initialize() {
  79                 try {
  80                         activeEnvsParentNode = session
  81                                         .getNode(AkbNames.AKB_ENVIRONMENTS_BASE_PATH);
  82                 } catch (RepositoryException e) {
  83                         throw new AkbException("unable to initialize AKB Browser view", e);
  84                 }
  85         }
  86
  87         @Override
  88         public void createPartControl(Composite parent) {
  89                 initialize();
  90                 envTreeViewer = createTreeViewer(parent);
  91                 envTreeViewer.setInput(initializeTree());
  92         }
  93
  94         // The main tree viewer
  95         protected TreeViewer createTreeViewer(Composite parent) {
  96                 parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
  97                 int style = SWT.BORDER | SWT.MULTI;
  98
  99                 TreeViewer viewer = new TreeViewer(parent, style);
 100                 viewer.getTree().setLayoutData(
 101                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 102
 103                 viewer.setContentProvider(new TemplatesTreeContentProvider());
 104                 viewer.setLabelProvider(new AkbTreeLabelProvider());
 105                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
 106
 107                 getSite().setSelectionProvider(viewer);
 108
 109                 // context menu
 110                 MenuManager menuManager = new MenuManager();
 111                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 112                 menuManager.addMenuListener(new IMenuListener() {
 113                         public void menuAboutToShow(IMenuManager manager) {
 114                                 contextMenuAboutToShow(manager);
 115                         }
 116                 });
 117                 viewer.getTree().setMenu(menu);
 118                 menuManager.setRemoveAllWhenShown(true);
 119                 getSite().registerContextMenu(menuManager, viewer);
 120
 121                 return viewer;
 122         }
 123
 124         private Node[] initializeTree() {
 125                 try {
 126                         NodeIterator ni = activeEnvsParentNode.getNodes();
 127                         List<Node> envs = new ArrayList<Node>();
 128                         while (ni.hasNext()) {
 129                                 Node currNode = ni.nextNode();
 130                                 if (currNode.isNodeType(AkbTypes.AKB_ENV))
 131                                         envs.add(currNode);
 132                         }
 133                         Node[] envArr = envs.toArray(new Node[envs.size()]);
 134                         return envArr;
 135                 } catch (RepositoryException re) {
 136                         throw new AkbException("Error while initializing the "
 137                                         + "tree of active environments.", re);
 138                 }
 139         }
 140
 141         //////////////////////
 142         /// LIFE CYCLE
 143
 144         @Override
 145         public void forceRefresh(Object object) {
 146                 envTreeViewer.setInput(initializeTree());
 147         }
 148
 149         @Override
 150         public void setFocus() {
 151         }
 152
 153         @Override
 154         public void dispose() {
 155                 JcrUtils.logoutQuietly(session);
 156                 super.dispose();
 157         }
 158
 159         // ///////////////////////////
 160         // CONTEXT MENU MANAGEMENT
 161         /**
 162          * Defines the commands that will pop up in the context menu.
 163          **/
 164         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 165                 IWorkbenchWindow window = AkbUiPlugin.getDefault().getWorkbench()
 166                                 .getActiveWorkbenchWindow();
 167                 try {
 168                         // Build conditions
 169                         IStructuredSelection selection = (IStructuredSelection) envTreeViewer
 170                                         .getSelection();
 171
 172                         Node selected = (Node) selection.getFirstElement();
 173                         Node currEnv = null;
 174
 175                         boolean hasSelection = selected != null;
 176
 177                         if (hasSelection)
 178                                 currEnv = AkbJcrUtils.getCurrentTemplate(selected);
 179
 180                         boolean isTemplate = hasSelection ? selected
 181                                         .isNodeType(AkbTypes.AKB_ENV_TEMPLATE) : false;
 182                         boolean isParentItemsFolder = hasSelection ? selected
 183                                         .isNodeType(AkbTypes.AKB_ITEM_FOLDER) : false;
 184                         // boolean isParentConnectorsFolder = hasSelection ? selected
 185                         // .isNodeType(AkbTypes.AKB_CONNECTOR_FOLDER) : false;
 186                         boolean isDeletable = hasSelection ? true : false;
 187
 188                         // Add Connector Alias
 189                         Map<String, String> params = new HashMap<String, String>();
 190                         if (hasSelection && isTemplate) {
 191                                 params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,
 192                                                 selected.getIdentifier());
 193                                 params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
 194                                                 currEnv.getIdentifier());
 195                         }
 196                         params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
 197                                         AkbTypes.AKB_CONNECTOR_ALIAS);
 198
 199                         // Connector Alias submenu
 200                         refreshAliasesSubmenu(menuManager, window, "menu.aliasesSubmenu",
 201                                         "Add Connector Alias", isTemplate, params);
 202
 203                         // Item Submenu
 204                         params = new HashMap<String, String>();
 205                         if (hasSelection) {
 206                                 params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,
 207                                                 selected.getIdentifier());
 208                                 params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
 209                                                 currEnv.getIdentifier());
 210                         }
 211                         refreshItemsSubmenu(menuManager, window, "menu.itemsSubmenu",
 212                                         "Add Item", isParentItemsFolder || isTemplate, params);
 213
 214                         // Add Item Folder
 215                         params = new HashMap<String, String>();
 216                         if (hasSelection) {
 217                                 params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,
 218                                                 selected.getIdentifier());
 219                                 params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
 220                                                 currEnv.getIdentifier());
 221                         }
 222                         params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
 223                                         AkbTypes.AKB_ITEM_FOLDER);
 224
 225                         AkbUiUtils.refreshParameterizedCommand(menuManager, window,
 226                                         "cmd.addItemFolder", OpenAkbNodeEditor.ID,
 227                                         "Add item folder", null, isParentItemsFolder || isTemplate,
 228                                         params);
 229
 230                         // Delete Item
 231                         params = new HashMap<String, String>();
 232                         if (hasSelection)
 233                                 params.put(DeleteAkbNodes.PARAM_NODE_JCR_ID,
 234                                                 selected.getIdentifier());
 235                         AkbUiUtils.refreshParameterizedCommand(menuManager, window,
 236                                         "cmd.deleteItem", DeleteAkbNodes.ID,
 237                                         "Delete selected item(s)", null, isDeletable, params);
 238
 239                         // create template
 240                         params = new HashMap<String, String>();
 241                         params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,
 242                                         activeEnvsParentNode.getIdentifier());
 243                         params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
 244                                         AkbTypes.AKB_ENV_TEMPLATE);
 245                         AkbUiUtils.refreshParameterizedCommand(menuManager, window,
 246                                         "cmd.createTemplate", OpenAkbNodeEditor.ID,
 247                                         "Create new template...", null,
 248                                         !hasSelection || isTemplate, params);
 249
 250                 } catch (RepositoryException re) {
 251                         throw new AkbException("Error while refreshing context menu", re);
 252                 }
 253         }
 254
 255         /**
 256          *
 257          * refreshes submenu with various connector types
 258          *
 259          * @param menuManager
 260          * @param locator
 261          * @param itemId
 262          * @param label
 263          * @param isVisible
 264          * @param params
 265          */
 266         private void refreshItemsSubmenu(IMenuManager menuManager,
 267                         IServiceLocator locator, String itemId, String label,
 268                         boolean isVisible, Map<String, String> params) {
 269
 270                 // clean
 271                 IContributionItem ici = menuManager.find(itemId);
 272                 if (ici != null)
 273                         menuManager.remove(ici);
 274
 275                 MenuManager subMenu = new MenuManager(label, itemId);
 276
 277                 // JDBC Query
 278                 Map<String, String> tmpParams = new HashMap<String, String>();
 279                 tmpParams.putAll(params);
 280                 tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
 281                                 AkbTypes.AKB_JDBC_QUERY);
 282                 String currItemId = "cmd.createJDBCQuery";
 283                 IContributionItem currItem = subMenu.find(currItemId);
 284                 if (currItem != null)
 285                         subMenu.remove(currItem);
 286                 subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,
 287                                 currItemId, OpenAkbNodeEditor.ID, "JDBC", null, tmpParams));
 288
 289                 // SSH COMMAND
 290                 tmpParams = new HashMap<String, String>();
 291                 tmpParams.putAll(params);
 292                 tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
 293                                 AkbTypes.AKB_SSH_COMMAND);
 294                 currItemId = "cmd.createSSHCommand";
 295                 currItem = subMenu.find(currItemId);
 296                 if (currItem != null)
 297                         subMenu.remove(currItem);
 298                 subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,
 299                                 currItemId, OpenAkbNodeEditor.ID, "SSH Command", null,
 300                                 tmpParams));
 301
 302                 // SSH FILE
 303                 tmpParams = new HashMap<String, String>();
 304                 tmpParams.putAll(params);
 305                 tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_TYPE, AkbTypes.AKB_SSH_FILE);
 306                 currItemId = "cmd.createSSHFile";
 307                 currItem = subMenu.find(currItemId);
 308                 if (currItem != null)
 309                         subMenu.remove(currItem);
 310                 subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,
 311                                 currItemId, OpenAkbNodeEditor.ID, "SSH File", null, tmpParams));
 312
 313                 // refresh
 314                 menuManager.add(subMenu);
 315                 subMenu.setVisible(isVisible);
 316         }
 317
 318         /**
 319          *
 320          * refreshes submenu with various connector types
 321          *
 322          * @param menuManager
 323          * @param locator
 324          * @param itemId
 325          * @param label
 326          * @param isVisible
 327          * @param params
 328          */
 329         private void refreshAliasesSubmenu(IMenuManager menuManager,
 330                         IServiceLocator locator, String itemId, String label,
 331                         boolean isVisible, Map<String, String> params) {
 332
 333                 // clean
 334                 IContributionItem ici = menuManager.find(itemId);
 335                 if (ici != null)
 336                         menuManager.remove(ici);
 337
 338                 // TODO use dynamic contribution to dynamically retrieve specific
 339                 // connector types
 340                 // CompoundContributionItem comConI = new MyCompoundCI(menuManager,
 341                 // locator, itemId);
 342                 MenuManager subMenu = new MenuManager(label, itemId);
 343
 344                 // JDBC
 345                 Map<String, String> tmpParams = new HashMap<String, String>();
 346                 tmpParams.putAll(params);
 347                 tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,
 348                                 AkbTypes.AKB_JDBC_CONNECTOR);
 349                 String currItemId = "cmd.createJDBCAlias";
 350                 IContributionItem currItem = subMenu.find(currItemId);
 351                 if (currItem != null)
 352                         subMenu.remove(currItem);
 353                 subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,
 354                                 currItemId, OpenAkbNodeEditor.ID, "JDBC", null, tmpParams));
 355
 356                 // SSH
 357                 tmpParams = new HashMap<String, String>();
 358                 tmpParams.putAll(params);
 359                 tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,
 360                                 AkbTypes.AKB_SSH_CONNECTOR);
 361                 currItemId = "cmd.createSSHAlias";
 362                 currItem = subMenu.find(currItemId);
 363                 if (currItem != null)
 364                         subMenu.remove(currItem);
 365                 subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,
 366                                 currItemId, OpenAkbNodeEditor.ID, "SSH", null, tmpParams));
 367
 368                 // refresh
 369                 menuManager.add(subMenu);
 370                 subMenu.setVisible(isVisible);
 371         }
 372
 373         /* INNER CLASSES */
 374         class ViewDoubleClickListener implements IDoubleClickListener {
 375                 public void doubleClick(DoubleClickEvent evt) {
 376                         Object obj = ((IStructuredSelection) evt.getSelection())
 377                                         .getFirstElement();
 378                         try {
 379                                 if (obj instanceof Node) {
 380                                         Node node = (Node) obj;
 381                                         Node currEnv = AkbJcrUtils.getCurrentTemplate(node);
 382
 383                                         // Add Connector Alias
 384                                         Map<String, String> params = new HashMap<String, String>();
 385                                         params.put(OpenAkbNodeEditor.PARAM_NODE_JCR_ID,
 386                                                         node.getIdentifier());
 387                                         params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
 388                                                         currEnv.getIdentifier());
 389
 390                                         CommandUtils.callCommand(OpenAkbNodeEditor.ID, params);
 391                                 }
 392                         } catch (RepositoryException e) {
 393                                 throw new AkbException("Cannot open " + obj, e);
 394                         }
 395                 }
 396         }
 397
 398         /* DEPENDENCY INJECTION */
 399         public void setRepository(Repository repository) {
 400                 try {
 401                         session = repository.login();
 402                 } catch (RepositoryException e) {
 403                         throw new AkbException("unable to log in for " + ID + " view");
 404                 }
 405         }
 406
 407         public void setAkbService(AkbService akbService) {
 408                 this.akbService = akbService;
 409
 410         }
 411 }