plugins/org.argeo.slc.akb.ui/src/main/java/org/argeo/slc/akb/ui/commands/OpenAkbNodeEditor.java

   1 package org.argeo.slc.akb.ui.commands;
   2
   3 import javax.jcr.Node;
   4 import javax.jcr.Property;
   5 import javax.jcr.Repository;
   6 import javax.jcr.RepositoryException;
   7 import javax.jcr.Session;
   8
   9 import org.argeo.eclipse.ui.dialogs.SingleValue;
  10 import org.argeo.jcr.JcrUtils;
  11 import org.argeo.slc.akb.AkbException;
  12 import org.argeo.slc.akb.AkbService;
  13 import org.argeo.slc.akb.AkbTypes;
  14 import org.argeo.slc.akb.ui.AkbMessages;
  15 import org.argeo.slc.akb.ui.AkbUiPlugin;
  16 import org.argeo.slc.akb.ui.dialogs.AddItemDialog;
  17 import org.argeo.slc.akb.ui.editors.AkbNodeEditorInput;
  18 import org.argeo.slc.akb.ui.editors.ConnectorAliasEditor;
  19 import org.argeo.slc.akb.ui.editors.EnvTemplateEditor;
  20 import org.argeo.slc.akb.ui.editors.JdbcQueryTemplateEditor;
  21 import org.argeo.slc.akb.ui.editors.SshCommandTemplateEditor;
  22 import org.argeo.slc.akb.ui.editors.SshFileTemplateEditor;
  23 import org.eclipse.core.commands.AbstractHandler;
  24 import org.eclipse.core.commands.ExecutionEvent;
  25 import org.eclipse.core.commands.ExecutionException;
  26 import org.eclipse.swt.widgets.Display;
  27 import org.eclipse.ui.IWorkbenchPage;
  28 import org.eclipse.ui.PartInitException;
  29 import org.eclipse.ui.handlers.HandlerUtil;
  30
  31 /**
  32  * Opens or show an AKB specific node in a single repository / single workspace
  33  * environment given some parameters, namely :
  34  * <ul>
  35  * <li>PARAM_NODE_JCR_ID: the corresponding JCR ID might be null to create a new
  36  * one</li>
  37  * <li>PARAM_NODE_TYPE: jcr type of the node to create</li>
  38  * <li>PARAM_PARENT_NODE_JCR_ID: Only used in the case of the creation of a new
  39  * node.</li>
  40  * </ul>
  41  */
  42 public class OpenAkbNodeEditor extends AbstractHandler {
  43         public final static String ID = AkbUiPlugin.PLUGIN_ID
  44                         + ".openAkbNodeEditor";
  45
  46         /* DEPENDENCY INJECTION */
  47         private Repository repository;
  48         private AkbService akbService;
  49
  50         public final static String PARAM_NODE_JCR_ID = "param.nodeJcrId";
  51         public final static String PARAM_NODE_TYPE = "param.nodeType";
  52         public final static String PARAM_NODE_SUBTYPE = "param.nodeSubtype";
  53         public final static String PARAM_CURR_ENV_JCR_ID = "param.currEnvJcrId";
  54         public final static String PARAM_PARENT_NODE_JCR_ID = "param.parentNodeJcrId";
  55
  56         public Object execute(ExecutionEvent event) throws ExecutionException {
  57
  58                 String nodeType = event.getParameter(PARAM_NODE_TYPE);
  59                 String nodeSubtype = event.getParameter(PARAM_NODE_SUBTYPE);
  60                 String currEnvJcrId = event.getParameter(PARAM_CURR_ENV_JCR_ID);
  61                 String nodeJcrId = event.getParameter(PARAM_NODE_JCR_ID);
  62                 String parentNodeJcrId = event.getParameter(PARAM_PARENT_NODE_JCR_ID);
  63
  64                 Session session = null;
  65                 try {
  66                         // caches current Page
  67                         IWorkbenchPage currentPage = HandlerUtil.getActiveWorkbenchWindow(
  68                                         event).getActivePage();
  69
  70                         session = repository.login();
  71                         Node node = null;
  72
  73                         if (nodeJcrId == null)
  74                                 if (parentNodeJcrId == null)
  75                                         throw new AkbException(
  76                                                         "Define a parent node to create a new node");
  77                                 else
  78                                         node = createNewNode(session, nodeType, nodeSubtype,
  79                                                         parentNodeJcrId);
  80                         else
  81                                 node = session.getNodeByIdentifier(nodeJcrId);
  82
  83                         // no node has been found or created, return
  84                         if (node == null)
  85                                 return null;
  86
  87                         String editorId = getEditorForNode(node);
  88
  89                         // no editor has been found, return silently
  90                         if (editorId == null)
  91                                 return null;
  92
  93                         AkbNodeEditorInput eei = new AkbNodeEditorInput(currEnvJcrId,
  94                                         node.getIdentifier());
  95
  96                         currentPage.openEditor(eei, editorId);
  97                 } catch (PartInitException pie) {
  98                         throw new AkbException(
  99                                         "Unexpected PartInitException while opening akb node editor",
 100                                         pie);
 101                 } catch (RepositoryException e) {
 102                         throw new AkbException("unexpected JCR error while opening "
 103                                         + nodeType + " editor", e);
 104                 } finally {
 105                         JcrUtils.logoutQuietly(session);
 106                 }
 107                 return null;
 108         }
 109
 110         private Node createNewNode(Session session, String nodeType,
 111                         String nodeSubtype, String parentNodeJcrId)
 112                         throws RepositoryException {
 113                 Node node = null;
 114
 115                 if (AkbTypes.AKB_ITEM.equals(nodeType)) {
 116                         Node parNode = session.getNodeByIdentifier(parentNodeJcrId);
 117                         AddItemDialog dialog = new AddItemDialog(Display.getDefault()
 118                                         .getActiveShell(), "Add new item", parNode);
 119                         dialog.open();
 120                         node = dialog.getNewNode();
 121                 } else {
 122                         String name = SingleValue
 123                                         .ask("Create "
 124                                                         + AkbMessages
 125                                                                         .getLabelForType(nodeSubtype == null ? nodeType
 126                                                                                         : nodeSubtype),
 127                                                         "Please enter a name for the corresponding "
 128                                                                         + AkbMessages
 129                                                                                         .getLabelForType(nodeSubtype == null ? nodeType
 130                                                                                                         : nodeSubtype));
 131                         if (name == null)
 132                                 return null;
 133                         if (AkbTypes.AKB_ENV_TEMPLATE.equals(nodeType)) {
 134                                 node = akbService.createAkbTemplate(
 135                                                 session.getNodeByIdentifier(parentNodeJcrId), name);
 136                         } else if (AkbTypes.AKB_CONNECTOR_ALIAS.equals(nodeType)) {
 137                                 // the Jcr ID of the corresponding template must be passed to
 138                                 // create a new alias
 139                                 node = session.getNodeByIdentifier(parentNodeJcrId);
 140                                 akbService.createConnectorAlias(node, name, nodeSubtype);
 141                         } else {
 142                                 Node parentNode = session.getNodeByIdentifier(parentNodeJcrId);
 143                                 node = parentNode.addNode(name, nodeType);
 144                                 node.setProperty(Property.JCR_TITLE, name);
 145                         }
 146                 }
 147                 // corresponding node is saved but not checked in, in order to ease
 148                 // cancel actions.
 149                 session.save();
 150                 return node;
 151         }
 152
 153         private String getEditorForNode(Node node) throws RepositoryException {
 154                 String editorId = null;
 155                 if (node.isNodeType(AkbTypes.AKB_CONNECTOR_ALIAS))
 156                         editorId = ConnectorAliasEditor.ID;
 157                 else if (node.isNodeType(AkbTypes.AKB_ENV_TEMPLATE))
 158                         editorId = EnvTemplateEditor.ID;
 159                 else if (node.isNodeType(AkbTypes.AKB_SSH_FILE))
 160                         editorId = SshFileTemplateEditor.ID;
 161                 else if (node.isNodeType(AkbTypes.AKB_SSH_COMMAND))
 162                         editorId = SshCommandTemplateEditor.ID;
 163                 else if (node.isNodeType(AkbTypes.AKB_JDBC_QUERY))
 164                         editorId = JdbcQueryTemplateEditor.ID;
 165                 // else
 166                 // throw new AkbException("Editor is undefined for node " + node);
 167                 return editorId;
 168         }
 169
 170         /* DEPENDENCY INJECTION */
 171         public void setRepository(Repository repository) {
 172                 this.repository = repository;
 173         }
 174
 175         public void setAkbService(AkbService akbService) {
 176                 this.akbService = akbService;
 177         }
 178 }