plugins/org.argeo.slc.akb.ui/src/main/java/org/argeo/slc/akb/ui/editors/EnvTemplateEditor.java

   1 package org.argeo.slc.akb.ui.editors;
   2
   3 import java.util.HashMap;
   4 import java.util.List;
   5 import java.util.Map;
   6
   7 import javax.jcr.ItemNotFoundException;
   8 import javax.jcr.Node;
   9 import javax.jcr.NodeIterator;
  10 import javax.jcr.RepositoryException;
  11 import javax.jcr.Session;
  12 import javax.jcr.observation.Event;
  13 import javax.jcr.observation.ObservationManager;
  14
  15 import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  16 import org.argeo.eclipse.ui.utils.CommandUtils;
  17 import org.argeo.slc.akb.AkbException;
  18 import org.argeo.slc.akb.AkbNames;
  19 import org.argeo.slc.akb.AkbTypes;
  20 import org.argeo.slc.akb.ui.AkbUiPlugin;
  21 import org.argeo.slc.akb.ui.AkbUiUtils;
  22 import org.argeo.slc.akb.ui.commands.ForceRefresh;
  23 import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;
  24 import org.argeo.slc.akb.ui.composites.AliasListItemComposite;
  25 import org.argeo.slc.akb.ui.composites.MixTitleComposite;
  26 import org.argeo.slc.akb.utils.AkbJcrUtils;
  27 import org.eclipse.jface.action.IContributionItem;
  28 import org.eclipse.jface.action.IMenuListener;
  29 import org.eclipse.jface.action.IMenuManager;
  30 import org.eclipse.jface.action.MenuManager;
  31 import org.eclipse.swt.SWT;
  32 import org.eclipse.swt.layout.GridData;
  33 import org.eclipse.swt.layout.GridLayout;
  34 import org.eclipse.swt.widgets.Composite;
  35 import org.eclipse.swt.widgets.Display;
  36 import org.eclipse.swt.widgets.Group;
  37 import org.eclipse.swt.widgets.Menu;
  38 import org.eclipse.ui.IWorkbenchWindow;
  39 import org.eclipse.ui.forms.AbstractFormPart;
  40 import org.eclipse.ui.forms.IFormPart;
  41 import org.eclipse.ui.forms.IManagedForm;
  42
  43 /**
  44  * Display and edit an environment template
  45  */
  46 public class EnvTemplateEditor extends AbstractAkbNodeEditor {
  47
  48         public final static String ID = AkbUiPlugin.PLUGIN_ID
  49                         + ".envTemplateEditor";
  50
  51         // Observer
  52         private final static String[] observedNodes = { AkbTypes.AKB_CONNECTOR_FOLDER };
  53         private ConnectorObserver connectorObserver;
  54
  55         /* CONTENT CREATION */
  56         @Override
  57         public void populateMainPage(Composite parent, IManagedForm managedForm) {
  58                 parent.setLayout(new GridLayout());
  59                 // First line main info
  60                 MixTitleComposite mixTitleCmp = new MixTitleComposite(parent,
  61                                 SWT.NO_FOCUS, getToolkit(), managedForm, getAkbNode());
  62                 GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
  63                 gd.heightHint = 200;
  64                 mixTitleCmp.setLayoutData(gd);
  65
  66                 // Second line : the defined editor
  67                 Group group = new Group(parent, SWT.NONE);
  68                 group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
  69                 getToolkit().adapt(group, false, false);
  70                 String groupTitle = "Connector Aliases";
  71                 group.setText(groupTitle);
  72                 populateDisplayConnectorPanel(managedForm, group, getAkbNode());
  73
  74                 // add context menu
  75                 MenuManager menuManager = new MenuManager();
  76                 Menu menu = menuManager.createContextMenu(group);
  77                 menuManager.addMenuListener(new IMenuListener() {
  78                         public void menuAboutToShow(IMenuManager manager) {
  79                                 aboutToShow(manager);
  80                         }
  81                 });
  82                 group.setMenu(menu);
  83                 menuManager.setRemoveAllWhenShown(true);
  84         }
  85
  86         protected void aboutToShow(IMenuManager menu) {
  87                 try {
  88                         // initialization
  89                         IWorkbenchWindow window = AkbUiPlugin.getDefault().getWorkbench()
  90                                         .getActiveWorkbenchWindow();
  91                         Node connectorParent = getAkbNode();
  92
  93                         // Refresh
  94                         CommandUtils.refreshCommand(menu, window, ForceRefresh.ID,
  95                                         "Refresh", null, true);
  96
  97                         String submenuID = "subMenu.addAlias";
  98                         IContributionItem ici = menu.find(submenuID);
  99                         if (ici != null)
 100                                 menu.remove(ici);
 101                         Map<String, String> params = new HashMap<String, String>();
 102                         params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,
 103                                         connectorParent.getIdentifier());
 104                         params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
 105                                         AkbTypes.AKB_CONNECTOR_ALIAS);
 106
 107                         MenuManager subMenu = new MenuManager("Add connector alias",
 108                                         submenuID);
 109                         // JDBC
 110                         Map<String, String> tmpParams = new HashMap<String, String>();
 111                         tmpParams.putAll(params);
 112                         tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,
 113                                         AkbTypes.AKB_JDBC_CONNECTOR);
 114                         String currItemId = "cmd.createJDBCAlias";
 115                         IContributionItem currItem = subMenu.find(currItemId);
 116                         if (currItem != null)
 117                                 subMenu.remove(currItem);
 118                         subMenu.add(AkbUiUtils.createContributionItem(subMenu, window,
 119                                         currItemId, OpenAkbNodeEditor.ID, "JDBC", null, tmpParams));
 120
 121                         // SSH
 122                         tmpParams = new HashMap<String, String>();
 123                         tmpParams.putAll(params);
 124                         tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,
 125                                         AkbTypes.AKB_SSH_CONNECTOR);
 126                         currItemId = "cmd.createSSHAlias";
 127                         currItem = subMenu.find(currItemId);
 128                         if (currItem != null)
 129                                 subMenu.remove(currItem);
 130                         subMenu.add(AkbUiUtils.createContributionItem(subMenu, window,
 131                                         currItemId, OpenAkbNodeEditor.ID, "SSH", null, tmpParams));
 132
 133                         if (isTemplate())
 134                                 menu.add(subMenu);
 135
 136                 } catch (RepositoryException e) {
 137                         throw new AkbException("Unable to refresh context menu", e);
 138                 }
 139         }
 140
 141         /** Manage display and update of defined connector aliases */
 142         public void populateDisplayConnectorPanel(final IManagedForm managedForm,
 143                         final Composite panel, final Node entity) {
 144                 GridLayout gl = AkbUiUtils.gridLayoutNoBorder();
 145                 gl.marginTop = 10;
 146                 panel.setLayout(gl);
 147
 148                 final Map<String, Composite> connectorsCmps = new HashMap<String, Composite>();
 149                 AbstractFormPart formPart = new AbstractFormPart() {
 150                         public void refresh() {
 151                                 try {
 152                                         super.refresh();
 153                                         // first: initialise composite for new connectors
 154
 155                                         Node connectorPar = getAkbNode().getNode(
 156                                                         AkbTypes.AKB_CONNECTOR_FOLDER);
 157                                         NodeIterator ni = connectorPar.getNodes();
 158
 159                                         boolean isTemplate = getEnvNode().isNodeType(
 160                                                         AkbTypes.AKB_ENV_TEMPLATE);
 161
 162                                         aliases: while (ni.hasNext()) {
 163                                                 Node currNode = ni.nextNode();
 164                                                 String currJcrId = currNode.getIdentifier();
 165                                                 if (!connectorsCmps.containsKey(currJcrId)) {
 166                                                         Composite currCmp;
 167                                                         if (isTemplate)
 168                                                                 currCmp = new AliasListItemComposite(panel,
 169                                                                                 SWT.NO_FOCUS, getToolkit(),
 170                                                                                 managedForm, getAkbNode(),
 171                                                                                 currNode.getPath(), getAkbService());
 172                                                         else {
 173                                                                 String aliasPath = AkbJcrUtils.get(currNode,
 174                                                                                 AkbNames.AKB_CONNECTOR_ALIAS_PATH);
 175                                                                 if (AkbJcrUtils.isEmptyString(aliasPath)
 176                                                                                 || !getSession().nodeExists(aliasPath))
 177                                                                         continue aliases;
 178
 179                                                                 currCmp = new AliasListItemComposite(panel,
 180                                                                                 SWT.NO_FOCUS, getToolkit(),
 181                                                                                 managedForm, getAkbNode(), aliasPath,
 182                                                                                 getAkbService());
 183                                                         }
 184                                                         currCmp.setLayoutData(new GridData(SWT.FILL,
 185                                                                         SWT.TOP, true, false));
 186                                                         connectorsCmps.put(currJcrId, currCmp);
 187
 188                                                 }
 189                                         }
 190
 191                                         // then remove necessary composites
 192                                         Session session = connectorPar.getSession();
 193                                         for (String jcrId : connectorsCmps.keySet()) {
 194                                                 // TODO: enhance this
 195                                                 Composite currCmp = connectorsCmps.get(jcrId);
 196                                                 try {
 197                                                         session.getNodeByIdentifier(jcrId);
 198                                                 } catch (ItemNotFoundException infe) {
 199                                                         currCmp.dispose();
 200                                                 }
 201                                         }
 202                                         panel.layout();
 203                                 } catch (RepositoryException e) {
 204                                         throw new AkbException("Cannot refresh connectors group", e);
 205                                 }
 206                         }
 207                 };
 208                 formPart.refresh();
 209                 managedForm.addPart(formPart);
 210
 211                 // Initialize observer
 212                 try {
 213                         ObservationManager observationManager = getSession().getWorkspace()
 214                                         .getObservationManager();
 215                         connectorObserver = new ConnectorObserver(panel.getDisplay(),
 216                                         managedForm);
 217                         // observe tree changes under All results
 218                         observationManager.addEventListener(connectorObserver,
 219                                         Event.NODE_ADDED | Event.NODE_REMOVED, getAkbNode()
 220                                                         .getNode(AkbTypes.AKB_CONNECTOR_FOLDER).getPath(),
 221                                         true, null, observedNodes, false);
 222                 } catch (RepositoryException e) {
 223                         throw new AkbException("Cannot register listeners", e);
 224                 }
 225
 226         }
 227
 228         class ConnectorObserver extends AsyncUiEventListener {
 229
 230                 private IManagedForm managedForm;
 231
 232                 public ConnectorObserver(Display display, IManagedForm managedForm) {
 233                         super(display);
 234                         this.managedForm = managedForm;
 235                 }
 236
 237                 @Override
 238                 protected Boolean willProcessInUiThread(List<Event> events)
 239                                 throws RepositoryException {
 240                         return true;
 241                 }
 242
 243                 protected void onEventInUiThread(List<Event> events)
 244                                 throws RepositoryException {
 245                         try {
 246                                 for (IFormPart part : managedForm.getParts())
 247                                         part.refresh();
 248                         } catch (Exception e) {
 249                                 // silently fail
 250                                 e.printStackTrace();
 251                         }
 252                 }
 253         }
 254
 255         @Override
 256         protected String getEditorId() {
 257                 return ID;
 258         }
 259 }