<property name="akbService" ref="akbService" />
</bean>
- <!-- deletes an AKB specific node-->
+ <!-- Creates an AKB node given some params. -->
+ <bean id="createAkbNode" class="org.argeo.slc.akb.ui.commands.CreateAkbNode"
+ scope="prototype">
+ <property name="akbService" ref="akbService" />
+ </bean>
+
+ <!-- deletes an AKB specific node -->
<bean id="deleteAkbNodes" class="org.argeo.slc.akb.ui.commands.DeleteAkbNodes"
scope="prototype">
<property name="repository" ref="repository" />
scope="prototype">
<property name="repository" ref="repository" />
</bean>
+ <bean id="environmentsTreeView" class="org.argeo.slc.akb.ui.views.EnvironmentsTreeView"
+ scope="prototype">
+ <property name="repository" ref="repository" />
+ </bean>
<bean id="akbTemplatesTreeView" class="org.argeo.slc.akb.ui.views.AkbTemplatesTreeView"
scope="prototype">
<property name="repository" ref="repository" />
name="Akb Templates"
restorable="true">
</view>
+ <view
+ class="org.argeo.eclipse.spring.SpringExtensionFactory"
+ icon="icons/treeView.png"
+ id="org.argeo.slc.akb.ui.environmentsTreeView"
+ name="Akb Environments"
+ restorable="true">
+ </view>
</extension>
<!-- Editors -->
<extension
name="The Parent Node JCR ID if needed">
</commandParameter>
</command>
+ <command
+ defaultHandler="org.argeo.eclipse.spring.SpringExtensionFactory"
+ id="org.argeo.slc.akb.ui.createAkbNode"
+ name="Create a new Akb Node">
+ <commandParameter
+ id="param.nodeType"
+ name="Corresponding JCR node type">
+ </commandParameter>
+ <commandParameter
+ id="param.parentNodeJcrId"
+ name="The Parent Node JCR ID if needed">
+ </commandParameter>
+ </command>
<command
defaultHandler="org.argeo.eclipse.spring.SpringExtensionFactory"
id="org.argeo.slc.akb.ui.deleteAkbNodes"
tooltip="Refresh the whole browser">
</command>
</menuContribution>
+ <menuContribution
+ locationURI="toolbar:org.argeo.slc.akb.ui.environmentsTreeView">
+ <command
+ commandId="org.argeo.slc.akb.ui.forceRefresh"
+ icon="icons/refresh.png"
+ label="Refresh"
+ tooltip="Refresh the whole browser">
+ </command>
+ </menuContribution>
<menuContribution
locationURI="menu:org.eclipse.ui.main.menu">
package org.argeo.slc.akb.ui;
import org.argeo.slc.akb.ui.views.AkbDefaultView;
-import org.argeo.slc.akb.ui.views.AkbTemplatesTreeView;
+import org.argeo.slc.akb.ui.views.EnvironmentsTreeView;
import org.eclipse.ui.IFolderLayout;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;
public class AkbEnvPerspective implements IPerspectiveFactory {
- public static final String ID = AkbUiPlugin.PLUGIN_ID + ".akbEnvPerspective";
-
+ public static final String ID = AkbUiPlugin.PLUGIN_ID
+ + ".akbEnvPerspective";
+
@Override
public void createInitialLayout(IPageLayout layout) {
String editorArea = layout.getEditorArea();
IFolderLayout left = layout.createFolder("left", IPageLayout.LEFT,
0.3f, editorArea);
+ left.addView(EnvironmentsTreeView.ID);
left.addView(AkbDefaultView.ID);
}
}
--- /dev/null
+package org.argeo.slc.akb.ui.commands;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+
+import org.argeo.jcr.JcrUtils;
+import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.AkbService;
+import org.argeo.slc.akb.AkbTypes;
+import org.argeo.slc.akb.ui.AkbUiPlugin;
+import org.argeo.slc.akb.ui.dialogs.AddItemDialog;
+import org.argeo.slc.akb.ui.wizards.CreateEnvInstanceWizard;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.jface.wizard.WizardDialog;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/**
+ * Opens corresponding wizard to create a new AKB Node
+ */
+public class CreateAkbNode extends AbstractHandler {
+ public final static String ID = AkbUiPlugin.PLUGIN_ID + ".createAkbNode";
+
+ /* DEPENDENCY INJECTION */
+ private AkbService akbService;
+
+ public final static String PARAM_PARENT_NODE_JCR_ID = "param.parentNodeJcrId";
+ public final static String PARAM_NODE_TYPE = "param.nodeType";
+
+ public Object execute(ExecutionEvent event) throws ExecutionException {
+
+ String parentNodeJcrId = event.getParameter(PARAM_PARENT_NODE_JCR_ID);
+ String nodeType = event.getParameter(PARAM_NODE_TYPE);
+ Session session = null;
+ try {
+ session = akbService.getRepository().login();
+ Node node = createNewNode(HandlerUtil.getActiveShell(event),
+ session, nodeType, parentNodeJcrId);
+ // no node has been created, return
+ if (node == null)
+ return null;
+ } catch (RepositoryException e) {
+ throw new AkbException("unexpected JCR error while opening "
+ + nodeType + " editor", e);
+ } finally {
+ JcrUtils.logoutQuietly(session);
+ }
+ return null;
+ }
+
+ private Node createNewNode(Shell shell, Session session, String nodeType,
+ String parentNodeJcrId) throws RepositoryException {
+ Node node = null;
+ if (AkbTypes.AKB_ITEM.equals(nodeType)) {
+ Node parNode = session.getNodeByIdentifier(parentNodeJcrId);
+ AddItemDialog dialog = new AddItemDialog(shell, "Add new item",
+ parNode);
+ dialog.open();
+ node = dialog.getNewNode();
+ } else if (AkbTypes.AKB_ENV.equals(nodeType)) {
+ CreateEnvInstanceWizard wizard = new CreateEnvInstanceWizard(
+ akbService, session);
+ WizardDialog dialog = new WizardDialog(shell, wizard);
+ dialog.open();
+ node = wizard.getCreatedNode();
+ } else
+ return null;
+ // {
+ // String name = SingleValue
+ // .ask("Create "
+ // + AkbMessages
+ // .getLabelForType(nodeSubtype == null ? nodeType
+ // : nodeSubtype),
+ // "Please enter a name for the corresponding "
+ // + AkbMessages
+ // .getLabelForType(nodeSubtype == null ? nodeType
+ // : nodeSubtype));
+ // if (name == null)
+ // return null;
+ // if (AkbTypes.AKB_ENV_TEMPLATE.equals(nodeType)) {
+ // node = akbService.createAkbTemplate(
+ // session.getNodeByIdentifier(parentNodeJcrId), name);
+ // } else if (AkbTypes.AKB_CONNECTOR_ALIAS.equals(nodeType)) {
+ // // the Jcr ID of the corresponding template must be passed to
+ // // create a new alias
+ // node = session.getNodeByIdentifier(parentNodeJcrId);
+ // akbService.createConnectorAlias(node, name, nodeSubtype);
+ // } else {
+ // Node parentNode = session.getNodeByIdentifier(parentNodeJcrId);
+ // node = parentNode.addNode(name, nodeType);
+ // node.setProperty(Property.JCR_TITLE, name);
+ // }
+ // }
+ // corresponding node is saved but not checked in, in order to ease
+ // cancel actions.
+ session.save();
+ return node;
+ }
+
+ public void setAkbService(AkbService akbService) {
+ this.akbService = akbService;
+ }
+}
\ No newline at end of file
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.AkbTypes;
import org.argeo.slc.akb.ui.AkbUiPlugin;
import org.argeo.slc.akb.ui.editors.AkbNodeEditorInput;
import org.argeo.slc.akb.utils.AkbJcrUtils;
if (nodeJcrId != null)
node = session.getNodeByIdentifier(nodeJcrId);
- // We must be in a template to delete nodes...
- Node template = AkbJcrUtils.getCurrentTemplate(node);
+ // We must be in a template or on the root of an env instance to
+ // delete nodes.
+ Node template = node.isNodeType(AkbTypes.AKB_ENV) ? node
+ : AkbJcrUtils.getCurrentTemplate(node);
if (node != null) {
Boolean ok = MessageDialog.openConfirm(
--- /dev/null
+package org.argeo.slc.akb.ui.composites;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+
+import org.argeo.eclipse.ui.utils.CommandUtils;
+import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.AkbNames;
+import org.argeo.slc.akb.AkbService;
+import org.argeo.slc.akb.ui.commands.ForceRefresh;
+import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;
+import org.argeo.slc.akb.utils.AkbJcrUtils;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Link;
+import org.eclipse.ui.forms.AbstractFormPart;
+import org.eclipse.ui.forms.IManagedForm;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+
+public class ActiveItemHeaderComposite extends Composite {
+
+ private final AkbService akbService;
+ private final Node envNode;
+ private final Node itemNode;
+ private final FormToolkit toolkit;
+ private final IManagedForm form;
+ // Don't forget to unregister on dispose
+ private AbstractFormPart formPart;
+
+ /**
+ *
+ * @param parent
+ * @param style
+ * @param toolkit
+ * @param form
+ * @param envNode
+ * @param itemNode
+ * @param akbService
+ */
+ public ActiveItemHeaderComposite(Composite parent, int style,
+ FormToolkit toolkit, IManagedForm form, Node envNode,
+ Node itemNode, AkbService akbService) {
+ super(parent, style);
+ this.envNode = envNode;
+ this.itemNode = itemNode;
+ this.toolkit = toolkit;
+ this.form = form;
+ this.akbService = akbService;
+ populate();
+ toolkit.adapt(this);
+ }
+
+ private void populate() {
+ // Initialization
+ Composite parent = this;
+
+ parent.setLayout(new GridLayout(3, false));
+
+ final Label envLbl = toolkit.createLabel(parent, "");
+
+ final Link editActiveConnLk = new Link(parent, SWT.NONE);
+ toolkit.adapt(editActiveConnLk, false, false);
+ editActiveConnLk.setText("<a>Edit Connector</a>");
+ editActiveConnLk.setLayoutData(new GridData(SWT.RIGHT, SWT.TOP, true,
+ false));
+
+ final Link refreshLk = new Link(parent, SWT.NONE);
+ toolkit.adapt(refreshLk, false, false);
+ refreshLk.setText("<a>Refresh</a>");
+
+ new Label(parent, SWT.SEPARATOR | SWT.SHADOW_OUT | SWT.HORIZONTAL)
+ .setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false,
+ 3, 1));
+
+ // Part Management
+ final AbstractFormPart part = new AbstractFormPart() {
+ public void refresh() {
+ super.refresh();
+ // update display value
+ envLbl.setText("Environment: "
+ + AkbJcrUtils.get(envNode, Property.JCR_TITLE)
+ + " - Connector:"
+ + AkbJcrUtils.get(itemNode, Property.JCR_TITLE));
+
+ // Node activeConnector =
+ // akbService.getActiveConnectorByAlias(envNode,
+ // AkbJcrUtils.get(itemNode,
+ // AkbNames.AKB_CONNECTOR_ALIAS_PATH));
+ // if
+ // (AkbJcrUtils.isEmptyString(AkbJcrUtils.get(activeConnector,
+ // AkbNames.AKB_CONNECTOR_URL)))
+ // conLbl.setImage(SWT.);
+ }
+ };
+
+ // Listeners
+ editActiveConnLk.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(final SelectionEvent event) {
+ try {
+ String pathId = AkbJcrUtils.get(itemNode,
+ AkbNames.AKB_USED_CONNECTOR);
+
+ Node activeConnector = akbService
+ .getActiveConnectorByAlias(envNode, pathId);
+
+ String id = AkbJcrUtils
+ .getIdentifierQuietly(activeConnector);
+ Map<String, String> params = new HashMap<String, String>();
+ params.put(OpenAkbNodeEditor.PARAM_NODE_JCR_ID, id);
+ params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
+ AkbJcrUtils.getIdentifierQuietly(envNode));
+
+ CommandUtils.callCommand(OpenAkbNodeEditor.ID, params);
+ } catch (RepositoryException e) {
+ throw new AkbException("Error opening active connector", e);
+ }
+ }
+ });
+
+ refreshLk.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(final SelectionEvent event) {
+ CommandUtils.callCommand(ForceRefresh.ID);
+ }
+ });
+ form.addPart(part);
+ }
+
+ @Override
+ public boolean setFocus() {
+ return true;
+ }
+
+ protected void disposePart(AbstractFormPart part) {
+ if (part != null) {
+ form.removePart(part);
+ part.dispose();
+ }
+ }
+
+ @Override
+ public void dispose() {
+ disposePart(formPart);
+ super.dispose();
+ }
+}
\ No newline at end of file
ScrolledForm form = managedForm.getForm();
form.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
Composite parent = form.getBody();
- populateTestPage(parent);
+ populateTestPage(parent, managedForm);
}
}
- protected void populateTestPage(Composite parent) {
+ protected void populateTestPage(Composite parent, IManagedForm managedForm) {
parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
getToolkit().createLabel(
parent,
import org.argeo.slc.akb.AkbNames;
import org.argeo.slc.akb.AkbService;
import org.argeo.slc.akb.ui.AkbUiUtils;
+import org.argeo.slc.akb.ui.composites.ActiveItemHeaderComposite;
+import org.argeo.slc.akb.ui.utils.Refreshable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.ui.forms.widgets.ScrolledForm;
/** Test JDBC. */
-public class JdbcTestPage extends FormPage implements AkbNames {
+public class JdbcTestPage extends FormPage implements AkbNames, Refreshable {
private Node currItem;
// A template or an active environment
private Node currEnv;
parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
FormToolkit toolkit = getEditor().getToolkit();
+
+ // the header
+ ActiveItemHeaderComposite header = new ActiveItemHeaderComposite(
+ parent, SWT.NONE, toolkit, managedForm, currEnv, currItem,
+ akbService);
+ header.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
+
+ // the table
Table table = toolkit.createTable(parent, SWT.VIRTUAL);
table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
table.setHeaderVisible(true);
viewer.setContentProvider(contentProvider);
// viewer.setLabelProvider(new ColumnLabelProvider(){});
+ forceRefresh(null);
+ }
+
+ public void forceRefresh(Object object) {
+ silentlyCloseStatement();
statement = akbService.prepareJdbcQuery(currEnv, currItem);
- PrivilegedJob job = new PrivilegedJob("Execute query on " + currItem) {
-
- @Override
- protected IStatus doRun(IProgressMonitor progressMonitor) {
- try {
- final ResultSet resultSet = statement.executeQuery();
- getEditorSite().getWorkbenchWindow().getShell()
- .getDisplay().syncExec(new Runnable() {
-
- @Override
- public void run() {
- viewer.setInput(resultSet);
- }
- });
- return Status.OK_STATUS;
- } catch (SQLException e) {
- throw new SlcException("Cannot execute " + currItem, e);
+ if (statement != null) {
+ PrivilegedJob job = new PrivilegedJob("Execute query on "
+ + currItem) {
+
+ @Override
+ protected IStatus doRun(IProgressMonitor progressMonitor) {
+ try {
+ final ResultSet resultSet = statement.executeQuery();
+ getEditorSite().getWorkbenchWindow().getShell()
+ .getDisplay().syncExec(new Runnable() {
+
+ @Override
+ public void run() {
+ viewer.setInput(resultSet);
+ }
+ });
+ return Status.OK_STATUS;
+ } catch (SQLException e) {
+ throw new SlcException("Cannot execute " + currItem, e);
+ }
}
- }
- };
- job.schedule();
+ };
+ job.schedule();
+ }
}
- @Override
- public void dispose() {
+ private void silentlyCloseStatement() {
try {
if (statement != null) {
statement.close();
}
}
+ @Override
+ public void dispose() {
+ silentlyCloseStatement();
+ }
+
private class JdbcTestContentProvider implements ILazyContentProvider {
private TableViewer viewer;
private ResultSet resultSet;
import org.argeo.slc.akb.AkbNames;
import org.argeo.slc.akb.ui.AkbUiPlugin;
import org.argeo.slc.akb.ui.AkbUiUtils;
+import org.argeo.slc.akb.ui.composites.ActiveItemHeaderComposite;
+import org.argeo.slc.akb.ui.utils.Refreshable;
+import org.argeo.slc.akb.utils.AkbJcrUtils;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.layout.GridData;
/**
* Display and edit a SSH Command Template ITEM
*/
-public class SshCommandTemplateEditor extends AkbItemTemplateEditor {
+public class SshCommandTemplateEditor extends AkbItemTemplateEditor implements
+ Refreshable {
public final static String ID = AkbUiPlugin.PLUGIN_ID
+ ".sshCommandTemplateEditor";
+ private Text outputDisplay;
+
@Override
protected String getEditorId() {
return ID;
}
@Override
- protected void populateTestPage(Composite parent) {
+ protected void populateTestPage(Composite parent, IManagedForm managedForm) {
parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
- Text outputDisplay = getToolkit().createText(parent, "", SWT.MULTI);
+ ActiveItemHeaderComposite header = new ActiveItemHeaderComposite(
+ parent, SWT.NONE, getToolkit(), managedForm, getEnvNode(),
+ getAkbNode(), getAkbService());
+ header.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
+
+ outputDisplay = getToolkit().createText(parent, "", SWT.MULTI);
outputDisplay.setFont(new Font(parent.getDisplay(), "Monospaced", 10,
SWT.NONE));
outputDisplay.setEditable(false);
outputDisplay
.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ forceRefresh(null);
+ }
+ public void forceRefresh(Object object) {
String output = getAkbService().executeCommand(getEnvNode(),
getAkbNode());
- outputDisplay.setText(output);
+ if (AkbJcrUtils.checkNotEmptyString(output))
+ outputDisplay.setText(output);
}
@Override
import org.argeo.slc.akb.AkbNames;
import org.argeo.slc.akb.ui.AkbUiPlugin;
import org.argeo.slc.akb.ui.AkbUiUtils;
+import org.argeo.slc.akb.ui.composites.ActiveItemHeaderComposite;
+import org.argeo.slc.akb.ui.utils.Refreshable;
+import org.argeo.slc.akb.utils.AkbJcrUtils;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.layout.GridData;
/**
* Display and edit a connection to a file on a distant accessible by SSH server
*/
-public class SshFileTemplateEditor extends AkbItemTemplateEditor {
+public class SshFileTemplateEditor extends AkbItemTemplateEditor implements
+ Refreshable {
public final static String ID = AkbUiPlugin.PLUGIN_ID
+ ".sshFileTemplateEditor";
+ private Text outputDisplay;
+
@Override
protected String getEditorId() {
return ID;
}
@Override
- protected void populateTestPage(Composite parent) {
+ protected void populateTestPage(Composite parent, IManagedForm managedForm) {
parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
- Text outputDisplay = getToolkit().createText(parent, "", SWT.MULTI);
+ ActiveItemHeaderComposite header = new ActiveItemHeaderComposite(
+ parent, SWT.NONE, getToolkit(), managedForm, getEnvNode(),
+ getAkbNode(), getAkbService());
+ header.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
+
+ outputDisplay = getToolkit().createText(parent, "", SWT.MULTI);
outputDisplay.setFont(new Font(parent.getDisplay(), "Monospaced", 10,
SWT.NONE));
outputDisplay.setEditable(false);
outputDisplay
.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ forceRefresh(null);
+ }
+
+ public void forceRefresh(Object object) {
String output = getAkbService()
.retrieveFile(getEnvNode(), getAkbNode());
- outputDisplay.setText(output);
+ if (AkbJcrUtils.checkNotEmptyString(output))
+ outputDisplay.setText(output);
}
@Override
/**
* @param parent
- * Pass current user home as parameter
+ * Pass base parent node as parameter
*
*/
public Object[] getElements(Object parent) {
- if (parent instanceof Object[])
- return (Object[]) parent;
+ if (parent instanceof Node)
+ return initializeTree((Node) parent);
else
return null;
}
+ private ActiveTreeItem[] initializeTree(Node activeEnvsParentNode) {
+ try {
+ NodeIterator ni = activeEnvsParentNode.getNodes();
+ List<ActiveTreeItem> envs = new ArrayList<ActiveTreeItem>();
+ while (ni.hasNext()) {
+ Node currNode = ni.nextNode();
+ if (currNode.isNodeType(AkbTypes.AKB_ENV)) {
+ envs.add(new ActiveTreeItem(null, currNode, currNode));
+ }
+ }
+ ActiveTreeItem[] envArr = envs.toArray(new ActiveTreeItem[envs
+ .size()]);
+ return envArr;
+ } catch (RepositoryException re) {
+ throw new AkbException("Error while initializing the "
+ + "tree of active environments.", re);
+ }
+ }
+
public Object getParent(Object child) {
return ((ActiveTreeItem) child).getParent();
}
@Override
public String getText(Object element) {
try {
+ if (element instanceof ActiveTreeItem)
+ element = ((ActiveTreeItem) element).getNode();
+
if (element instanceof Node) {
Node node = (Node) element;
if (node.isNodeType(NodeType.MIX_TITLE))
public Image getImage(Object element) {
try {
+ if (element instanceof ActiveTreeItem)
+ element = ((ActiveTreeItem) element).getNode();
+
if (element instanceof Node) {
Node node = (Node) element;
if (node.isNodeType(AkbTypes.AKB_ITEM_FOLDER))
}
return null;
}
-}
+}
\ No newline at end of file
+++ /dev/null
-/*\r
- * Copyright (C) 2007-2012 Argeo GmbH\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-package org.argeo.slc.akb.ui.views;\r
-\r
-import java.util.ArrayList;\r
-import java.util.HashMap;\r
-import java.util.List;\r
-import java.util.Map;\r
-\r
-import javax.jcr.Node;\r
-import javax.jcr.NodeIterator;\r
-import javax.jcr.Repository;\r
-import javax.jcr.RepositoryException;\r
-import javax.jcr.Session;\r
-import javax.jcr.observation.Event;\r
-\r
-import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;\r
-import org.argeo.eclipse.ui.utils.CommandUtils;\r
-import org.argeo.jcr.JcrUtils;\r
-import org.argeo.slc.akb.AkbException;\r
-import org.argeo.slc.akb.AkbNames;\r
-import org.argeo.slc.akb.AkbService;\r
-import org.argeo.slc.akb.AkbTypes;\r
-import org.argeo.slc.akb.ui.AkbUiPlugin;\r
-import org.argeo.slc.akb.ui.AkbUiUtils;\r
-import org.argeo.slc.akb.ui.commands.DeleteAkbNodes;\r
-import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;\r
-import org.argeo.slc.akb.ui.providers.AkbTreeLabelProvider;\r
-import org.argeo.slc.akb.ui.providers.TemplatesTreeContentProvider;\r
-import org.argeo.slc.akb.ui.utils.Refreshable;\r
-import org.argeo.slc.akb.utils.AkbJcrUtils;\r
-import org.eclipse.jface.action.IContributionItem;\r
-import org.eclipse.jface.action.IMenuListener;\r
-import org.eclipse.jface.action.IMenuManager;\r
-import org.eclipse.jface.action.MenuManager;\r
-import org.eclipse.jface.viewers.DoubleClickEvent;\r
-import org.eclipse.jface.viewers.IDoubleClickListener;\r
-import org.eclipse.jface.viewers.IStructuredSelection;\r
-import org.eclipse.jface.viewers.TreeViewer;\r
-import org.eclipse.swt.SWT;\r
-import org.eclipse.swt.layout.GridData;\r
-import org.eclipse.swt.widgets.Composite;\r
-import org.eclipse.swt.widgets.Display;\r
-import org.eclipse.swt.widgets.Menu;\r
-import org.eclipse.ui.IWorkbenchWindow;\r
-import org.eclipse.ui.part.ViewPart;\r
-import org.eclipse.ui.services.IServiceLocator;\r
-\r
-/** AKB Active environment tree view. */\r
-public class AkbActiveEnvsTreeView extends ViewPart implements Refreshable {\r
-\r
- public final static String ID = AkbUiPlugin.PLUGIN_ID\r
- + ".akbActiveEnvsTreeView";\r
-\r
- /* DEPENDENCY INJECTION */\r
- private Session session;\r
- private AkbService akbService;\r
-\r
- // This page widgets\r
- private TreeViewer envTreeViewer;\r
-\r
- // Usefull business objects\r
- private Node activeEnvsParentNode;\r
-\r
- private void initialize() {\r
- try {\r
- activeEnvsParentNode = session\r
- .getNode(AkbNames.AKB_ENVIRONMENTS_BASE_PATH);\r
- } catch (RepositoryException e) {\r
- throw new AkbException("unable to initialize AKB Browser view", e);\r
- }\r
- }\r
-\r
- @Override\r
- public void createPartControl(Composite parent) {\r
- initialize();\r
- envTreeViewer = createTreeViewer(parent);\r
- envTreeViewer.setInput(initializeTree());\r
- }\r
-\r
- // The main tree viewer\r
- protected TreeViewer createTreeViewer(Composite parent) {\r
- parent.setLayout(AkbUiUtils.gridLayoutNoBorder());\r
- int style = SWT.BORDER | SWT.MULTI;\r
-\r
- TreeViewer viewer = new TreeViewer(parent, style);\r
- viewer.getTree().setLayoutData(\r
- new GridData(SWT.FILL, SWT.FILL, true, true));\r
-\r
- viewer.setContentProvider(new TemplatesTreeContentProvider());\r
- viewer.setLabelProvider(new AkbTreeLabelProvider());\r
- viewer.addDoubleClickListener(new ViewDoubleClickListener());\r
-\r
- getSite().setSelectionProvider(viewer);\r
-\r
- // context menu\r
- MenuManager menuManager = new MenuManager();\r
- Menu menu = menuManager.createContextMenu(viewer.getTree());\r
- menuManager.addMenuListener(new IMenuListener() {\r
- public void menuAboutToShow(IMenuManager manager) {\r
- contextMenuAboutToShow(manager);\r
- }\r
- });\r
- viewer.getTree().setMenu(menu);\r
- menuManager.setRemoveAllWhenShown(true);\r
- getSite().registerContextMenu(menuManager, viewer);\r
-\r
- return viewer;\r
- }\r
-\r
- private Node[] initializeTree() {\r
- try {\r
- NodeIterator ni = activeEnvsParentNode.getNodes();\r
- List<Node> envs = new ArrayList<Node>();\r
- while (ni.hasNext()) {\r
- Node currNode = ni.nextNode();\r
- if (currNode.isNodeType(AkbTypes.AKB_ENV))\r
- envs.add(currNode);\r
- }\r
- Node[] envArr = envs.toArray(new Node[envs.size()]);\r
- return envArr;\r
- } catch (RepositoryException re) {\r
- throw new AkbException("Error while initializing the "\r
- + "tree of active environments.", re);\r
- }\r
- }\r
-\r
- //////////////////////\r
- /// LIFE CYCLE\r
- \r
- @Override\r
- public void forceRefresh(Object object) {\r
- envTreeViewer.setInput(initializeTree());\r
- }\r
- \r
- @Override\r
- public void setFocus() {\r
- }\r
-\r
- @Override\r
- public void dispose() {\r
- JcrUtils.logoutQuietly(session);\r
- super.dispose();\r
- }\r
- \r
- // ///////////////////////////\r
- // CONTEXT MENU MANAGEMENT\r
- /**\r
- * Defines the commands that will pop up in the context menu.\r
- **/\r
- protected void contextMenuAboutToShow(IMenuManager menuManager) {\r
- IWorkbenchWindow window = AkbUiPlugin.getDefault().getWorkbench()\r
- .getActiveWorkbenchWindow();\r
- try {\r
- // Build conditions\r
- IStructuredSelection selection = (IStructuredSelection) envTreeViewer\r
- .getSelection();\r
-\r
- Node selected = (Node) selection.getFirstElement();\r
- Node currEnv = null;\r
-\r
- boolean hasSelection = selected != null;\r
-\r
- if (hasSelection)\r
- currEnv = AkbJcrUtils.getCurrentTemplate(selected);\r
-\r
- boolean isTemplate = hasSelection ? selected\r
- .isNodeType(AkbTypes.AKB_ENV_TEMPLATE) : false;\r
- boolean isParentItemsFolder = hasSelection ? selected\r
- .isNodeType(AkbTypes.AKB_ITEM_FOLDER) : false;\r
- // boolean isParentConnectorsFolder = hasSelection ? selected\r
- // .isNodeType(AkbTypes.AKB_CONNECTOR_FOLDER) : false;\r
- boolean isDeletable = hasSelection ? true : false;\r
-\r
- // Add Connector Alias\r
- Map<String, String> params = new HashMap<String, String>();\r
- if (hasSelection && isTemplate) {\r
- params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,\r
- selected.getIdentifier());\r
- params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,\r
- currEnv.getIdentifier());\r
- }\r
- params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
- AkbTypes.AKB_CONNECTOR_ALIAS);\r
-\r
- // Connector Alias submenu\r
- refreshAliasesSubmenu(menuManager, window, "menu.aliasesSubmenu",\r
- "Add Connector Alias", isTemplate, params);\r
-\r
- // Item Submenu\r
- params = new HashMap<String, String>();\r
- if (hasSelection) {\r
- params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,\r
- selected.getIdentifier());\r
- params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,\r
- currEnv.getIdentifier());\r
- }\r
- refreshItemsSubmenu(menuManager, window, "menu.itemsSubmenu",\r
- "Add Item", isParentItemsFolder || isTemplate, params);\r
-\r
- // Add Item Folder\r
- params = new HashMap<String, String>();\r
- if (hasSelection) {\r
- params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,\r
- selected.getIdentifier());\r
- params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,\r
- currEnv.getIdentifier());\r
- }\r
- params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
- AkbTypes.AKB_ITEM_FOLDER);\r
-\r
- AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
- "cmd.addItemFolder", OpenAkbNodeEditor.ID,\r
- "Add item folder", null, isParentItemsFolder || isTemplate,\r
- params);\r
-\r
- // Delete Item\r
- params = new HashMap<String, String>();\r
- if (hasSelection)\r
- params.put(DeleteAkbNodes.PARAM_NODE_JCR_ID,\r
- selected.getIdentifier());\r
- AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
- "cmd.deleteItem", DeleteAkbNodes.ID,\r
- "Delete selected item(s)", null, isDeletable, params);\r
-\r
- // create template\r
- params = new HashMap<String, String>();\r
- params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,\r
- activeEnvsParentNode.getIdentifier());\r
- params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
- AkbTypes.AKB_ENV_TEMPLATE);\r
- AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
- "cmd.createTemplate", OpenAkbNodeEditor.ID,\r
- "Create new template...", null,\r
- !hasSelection || isTemplate, params);\r
-\r
- } catch (RepositoryException re) {\r
- throw new AkbException("Error while refreshing context menu", re);\r
- }\r
- }\r
-\r
- /**\r
- * \r
- * refreshes submenu with various connector types\r
- * \r
- * @param menuManager\r
- * @param locator\r
- * @param itemId\r
- * @param label\r
- * @param isVisible\r
- * @param params\r
- */\r
- private void refreshItemsSubmenu(IMenuManager menuManager,\r
- IServiceLocator locator, String itemId, String label,\r
- boolean isVisible, Map<String, String> params) {\r
-\r
- // clean\r
- IContributionItem ici = menuManager.find(itemId);\r
- if (ici != null)\r
- menuManager.remove(ici);\r
-\r
- MenuManager subMenu = new MenuManager(label, itemId);\r
-\r
- // JDBC Query\r
- Map<String, String> tmpParams = new HashMap<String, String>();\r
- tmpParams.putAll(params);\r
- tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
- AkbTypes.AKB_JDBC_QUERY);\r
- String currItemId = "cmd.createJDBCQuery";\r
- IContributionItem currItem = subMenu.find(currItemId);\r
- if (currItem != null)\r
- subMenu.remove(currItem);\r
- subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,\r
- currItemId, OpenAkbNodeEditor.ID, "JDBC", null, tmpParams));\r
-\r
- // SSH COMMAND\r
- tmpParams = new HashMap<String, String>();\r
- tmpParams.putAll(params);\r
- tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
- AkbTypes.AKB_SSH_COMMAND);\r
- currItemId = "cmd.createSSHCommand";\r
- currItem = subMenu.find(currItemId);\r
- if (currItem != null)\r
- subMenu.remove(currItem);\r
- subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,\r
- currItemId, OpenAkbNodeEditor.ID, "SSH Command", null,\r
- tmpParams));\r
-\r
- // SSH FILE\r
- tmpParams = new HashMap<String, String>();\r
- tmpParams.putAll(params);\r
- tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_TYPE, AkbTypes.AKB_SSH_FILE);\r
- currItemId = "cmd.createSSHFile";\r
- currItem = subMenu.find(currItemId);\r
- if (currItem != null)\r
- subMenu.remove(currItem);\r
- subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,\r
- currItemId, OpenAkbNodeEditor.ID, "SSH File", null, tmpParams));\r
-\r
- // refresh\r
- menuManager.add(subMenu);\r
- subMenu.setVisible(isVisible);\r
- }\r
-\r
- /**\r
- * \r
- * refreshes submenu with various connector types\r
- * \r
- * @param menuManager\r
- * @param locator\r
- * @param itemId\r
- * @param label\r
- * @param isVisible\r
- * @param params\r
- */\r
- private void refreshAliasesSubmenu(IMenuManager menuManager,\r
- IServiceLocator locator, String itemId, String label,\r
- boolean isVisible, Map<String, String> params) {\r
-\r
- // clean\r
- IContributionItem ici = menuManager.find(itemId);\r
- if (ici != null)\r
- menuManager.remove(ici);\r
-\r
- // TODO use dynamic contribution to dynamically retrieve specific\r
- // connector types\r
- // CompoundContributionItem comConI = new MyCompoundCI(menuManager,\r
- // locator, itemId);\r
- MenuManager subMenu = new MenuManager(label, itemId);\r
-\r
- // JDBC\r
- Map<String, String> tmpParams = new HashMap<String, String>();\r
- tmpParams.putAll(params);\r
- tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,\r
- AkbTypes.AKB_JDBC_CONNECTOR);\r
- String currItemId = "cmd.createJDBCAlias";\r
- IContributionItem currItem = subMenu.find(currItemId);\r
- if (currItem != null)\r
- subMenu.remove(currItem);\r
- subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,\r
- currItemId, OpenAkbNodeEditor.ID, "JDBC", null, tmpParams));\r
-\r
- // SSH\r
- tmpParams = new HashMap<String, String>();\r
- tmpParams.putAll(params);\r
- tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,\r
- AkbTypes.AKB_SSH_CONNECTOR);\r
- currItemId = "cmd.createSSHAlias";\r
- currItem = subMenu.find(currItemId);\r
- if (currItem != null)\r
- subMenu.remove(currItem);\r
- subMenu.add(AkbUiUtils.createContributionItem(menuManager, locator,\r
- currItemId, OpenAkbNodeEditor.ID, "SSH", null, tmpParams));\r
-\r
- // refresh\r
- menuManager.add(subMenu);\r
- subMenu.setVisible(isVisible);\r
- }\r
-\r
- /* INNER CLASSES */\r
- class ViewDoubleClickListener implements IDoubleClickListener {\r
- public void doubleClick(DoubleClickEvent evt) {\r
- Object obj = ((IStructuredSelection) evt.getSelection())\r
- .getFirstElement();\r
- try {\r
- if (obj instanceof Node) {\r
- Node node = (Node) obj;\r
- Node currEnv = AkbJcrUtils.getCurrentTemplate(node);\r
-\r
- // Add Connector Alias\r
- Map<String, String> params = new HashMap<String, String>();\r
- params.put(OpenAkbNodeEditor.PARAM_NODE_JCR_ID,\r
- node.getIdentifier());\r
- params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,\r
- currEnv.getIdentifier());\r
-\r
- CommandUtils.callCommand(OpenAkbNodeEditor.ID, params);\r
- }\r
- } catch (RepositoryException e) {\r
- throw new AkbException("Cannot open " + obj, e);\r
- }\r
- }\r
- }\r
-\r
- /* DEPENDENCY INJECTION */\r
- public void setRepository(Repository repository) {\r
- try {\r
- session = repository.login();\r
- } catch (RepositoryException e) {\r
- throw new AkbException("unable to log in for " + ID + " view");\r
- }\r
- }\r
-\r
- public void setAkbService(AkbService akbService) {\r
- this.akbService = akbService;\r
-\r
- }\r
-}
\ No newline at end of file
--- /dev/null
+package org.argeo.slc.akb.ui.views;\r
+\r
+import java.util.HashMap;\r
+import java.util.Map;\r
+\r
+import javax.jcr.Node;\r
+import javax.jcr.Repository;\r
+import javax.jcr.RepositoryException;\r
+import javax.jcr.Session;\r
+\r
+import org.argeo.eclipse.ui.utils.CommandUtils;\r
+import org.argeo.jcr.JcrUtils;\r
+import org.argeo.slc.akb.AkbException;\r
+import org.argeo.slc.akb.AkbNames;\r
+import org.argeo.slc.akb.AkbService;\r
+import org.argeo.slc.akb.AkbTypes;\r
+import org.argeo.slc.akb.ui.AkbUiPlugin;\r
+import org.argeo.slc.akb.ui.AkbUiUtils;\r
+import org.argeo.slc.akb.ui.commands.CreateAkbNode;\r
+import org.argeo.slc.akb.ui.commands.DeleteAkbNodes;\r
+import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;\r
+import org.argeo.slc.akb.ui.providers.ActiveEnvsTreeContentProvider;\r
+import org.argeo.slc.akb.ui.providers.ActiveTreeItem;\r
+import org.argeo.slc.akb.ui.providers.AkbTreeLabelProvider;\r
+import org.argeo.slc.akb.ui.utils.Refreshable;\r
+import org.eclipse.jface.action.IMenuListener;\r
+import org.eclipse.jface.action.IMenuManager;\r
+import org.eclipse.jface.action.MenuManager;\r
+import org.eclipse.jface.viewers.DoubleClickEvent;\r
+import org.eclipse.jface.viewers.IDoubleClickListener;\r
+import org.eclipse.jface.viewers.IStructuredSelection;\r
+import org.eclipse.jface.viewers.TreeViewer;\r
+import org.eclipse.swt.SWT;\r
+import org.eclipse.swt.layout.GridData;\r
+import org.eclipse.swt.widgets.Composite;\r
+import org.eclipse.swt.widgets.Menu;\r
+import org.eclipse.ui.IWorkbenchWindow;\r
+import org.eclipse.ui.part.ViewPart;\r
+\r
+/** AKB Active environment tree view. */\r
+public class EnvironmentsTreeView extends ViewPart implements Refreshable {\r
+\r
+ public final static String ID = AkbUiPlugin.PLUGIN_ID\r
+ + ".environmentsTreeView";\r
+\r
+ /* DEPENDENCY INJECTION */\r
+ private Session session;\r
+ private AkbService akbService;\r
+\r
+ // This page widgets\r
+ private TreeViewer envTreeViewer;\r
+\r
+ // Usefull business objects\r
+ private Node activeEnvsParentNode;\r
+\r
+ private void initialize() {\r
+ try {\r
+ activeEnvsParentNode = session\r
+ .getNode(AkbNames.AKB_ENVIRONMENTS_BASE_PATH);\r
+ } catch (RepositoryException e) {\r
+ throw new AkbException("unable to initialize AKB Browser view", e);\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public void createPartControl(Composite parent) {\r
+ initialize();\r
+ envTreeViewer = createTreeViewer(parent);\r
+ envTreeViewer.setInput(activeEnvsParentNode);\r
+ }\r
+\r
+ // The main tree viewer\r
+ protected TreeViewer createTreeViewer(Composite parent) {\r
+ parent.setLayout(AkbUiUtils.gridLayoutNoBorder());\r
+ int style = SWT.BORDER | SWT.MULTI;\r
+\r
+ TreeViewer viewer = new TreeViewer(parent, style);\r
+ viewer.getTree().setLayoutData(\r
+ new GridData(SWT.FILL, SWT.FILL, true, true));\r
+\r
+ viewer.setContentProvider(new ActiveEnvsTreeContentProvider());\r
+ viewer.setLabelProvider(new AkbTreeLabelProvider());\r
+ viewer.addDoubleClickListener(new ViewDoubleClickListener());\r
+\r
+ getSite().setSelectionProvider(viewer);\r
+\r
+ // context menu\r
+ MenuManager menuManager = new MenuManager();\r
+ Menu menu = menuManager.createContextMenu(viewer.getTree());\r
+ menuManager.addMenuListener(new IMenuListener() {\r
+ public void menuAboutToShow(IMenuManager manager) {\r
+ contextMenuAboutToShow(manager);\r
+ }\r
+ });\r
+ viewer.getTree().setMenu(menu);\r
+ menuManager.setRemoveAllWhenShown(true);\r
+ getSite().registerContextMenu(menuManager, viewer);\r
+\r
+ return viewer;\r
+ }\r
+\r
+ // ////////////////////\r
+ // / LIFE CYCLE\r
+\r
+ @Override\r
+ public void forceRefresh(Object object) {\r
+ envTreeViewer.setInput(activeEnvsParentNode);\r
+ }\r
+\r
+ @Override\r
+ public void setFocus() {\r
+ }\r
+\r
+ @Override\r
+ public void dispose() {\r
+ JcrUtils.logoutQuietly(session);\r
+ super.dispose();\r
+ }\r
+\r
+ // ///////////////////////////\r
+ // CONTEXT MENU MANAGEMENT\r
+ /**\r
+ * Defines the commands that will pop up in the context menu.\r
+ **/\r
+ protected void contextMenuAboutToShow(IMenuManager menuManager) {\r
+ IWorkbenchWindow window = AkbUiPlugin.getDefault().getWorkbench()\r
+ .getActiveWorkbenchWindow();\r
+ try {\r
+ // Build conditions\r
+ IStructuredSelection selection = (IStructuredSelection) envTreeViewer\r
+ .getSelection();\r
+\r
+ ActiveTreeItem item = (ActiveTreeItem) selection.getFirstElement();\r
+\r
+ boolean hasSelection = item != null;\r
+ Node selected = null, currEnv = null;\r
+\r
+ if (hasSelection) {\r
+ selected = item.getNode();\r
+ currEnv = item.getEnvironment();\r
+ }\r
+ boolean isEnv = hasSelection ? selected\r
+ .isNodeType(AkbTypes.AKB_ENV) : false;\r
+ boolean isDeletable = hasSelection ? isEnv : false;\r
+ Map<String, String> params = new HashMap<String, String>();\r
+\r
+ // Delete Item\r
+ params = new HashMap<String, String>();\r
+ if (hasSelection)\r
+ params.put(DeleteAkbNodes.PARAM_NODE_JCR_ID,\r
+ selected.getIdentifier());\r
+ AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
+ "cmd.deleteItem", DeleteAkbNodes.ID,\r
+ "Delete selected active environment", null, isDeletable,\r
+ params);\r
+\r
+ // create template\r
+ params = new HashMap<String, String>();\r
+ params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE, AkbTypes.AKB_ENV);\r
+ AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
+ "cmd.instanciateEnv", CreateAkbNode.ID,\r
+ "Create new environment instance", null, !hasSelection\r
+ || isEnv, params);\r
+\r
+ } catch (RepositoryException re) {\r
+ throw new AkbException("Error while refreshing context menu", re);\r
+ }\r
+ }\r
+\r
+ /* INNER CLASSES */\r
+ class ViewDoubleClickListener implements IDoubleClickListener {\r
+ public void doubleClick(DoubleClickEvent evt) {\r
+ Object obj = ((IStructuredSelection) evt.getSelection())\r
+ .getFirstElement();\r
+ try {\r
+ if (obj instanceof ActiveTreeItem) {\r
+ ActiveTreeItem currItem = (ActiveTreeItem) obj;\r
+ Node node = currItem.getNode();\r
+ Node currEnv = currItem.getEnvironment();\r
+ Map<String, String> params = new HashMap<String, String>();\r
+ params.put(OpenAkbNodeEditor.PARAM_NODE_JCR_ID,\r
+ node.getIdentifier());\r
+ params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,\r
+ currEnv.getIdentifier());\r
+ CommandUtils.callCommand(OpenAkbNodeEditor.ID, params);\r
+ }\r
+ } catch (RepositoryException e) {\r
+ throw new AkbException("Cannot open " + obj, e);\r
+ }\r
+ }\r
+ }\r
+\r
+ /* DEPENDENCY INJECTION */\r
+ public void setRepository(Repository repository) {\r
+ try {\r
+ session = repository.login();\r
+ } catch (RepositoryException e) {\r
+ throw new AkbException("unable to log in for " + ID + " view");\r
+ }\r
+ }\r
+\r
+ public void setAkbService(AkbService akbService) {\r
+ this.akbService = akbService;\r
+\r
+ }\r
+}
\ No newline at end of file
--- /dev/null
+package org.argeo.slc.akb.ui.wizards;
+
+import java.util.List;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+
+import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.AkbService;
+import org.argeo.slc.akb.utils.AkbJcrUtils;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+
+/** Creates a new active instance of an AKB env template */
+public class CreateEnvInstanceWizard extends Wizard {
+ // private final static Log log = LogFactory
+ // .getLog(CreateEnvInstanceWizard.class);
+
+ private Session session;
+ private AkbService akbService;
+ private Node createdNode;
+
+ // pages
+ private ChooseTemplatePage chooseTemplatePage;
+
+ public CreateEnvInstanceWizard(AkbService akbService, Session session) {
+ this.akbService = akbService;
+ this.session = session;
+ }
+
+ @Override
+ public void addPages() {
+ chooseTemplatePage = new ChooseTemplatePage();
+ addPage(chooseTemplatePage);
+ }
+
+ public Node getCreatedNode() {
+ return createdNode;
+ }
+
+ @Override
+ public boolean performFinish() {
+ if (!canFinish())
+ return false;
+ try {
+ createdNode = akbService.createActiveEnv(
+ chooseTemplatePage.getTemplate(),
+ chooseTemplatePage.getActiveEnvName(),
+ chooseTemplatePage.getUseDefaultConnectors());
+
+ return true;
+ } catch (RepositoryException re) {
+ throw new AkbException("Unable to create environment instance", re);
+ }
+ }
+
+ public boolean canFinish() {
+ if (chooseTemplatePage.getActiveEnvName() != null
+ && chooseTemplatePage.getTemplate() != null)
+ return true;
+ else
+ return false;
+ }
+
+ // //////////////////////
+ // Pages definition
+ /**
+ * Displays a combo box that enables user to choose which action to perform
+ */
+ private class ChooseTemplatePage extends WizardPage {
+ private Text valueTxt;
+ private Combo chooseTemplateCmb;
+ private Button useDefaultConnChk;
+
+ public ChooseTemplatePage() {
+ super("Choose template");
+ setTitle("Choose template.");
+ setDescription("Define the new instance parameters");
+ }
+
+ @Override
+ public void createControl(Composite parent) {
+ Composite container = new Composite(parent, SWT.NO_FOCUS);
+ GridLayout gl = new GridLayout(2, false);
+ container.setLayout(gl);
+
+ new Label(container, NONE).setText("Name");
+ valueTxt = new Text(container, SWT.NONE);
+ valueTxt.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
+ valueTxt.addModifyListener(new ModifyListener() {
+ @Override
+ public void modifyText(ModifyEvent e) {
+ //TODO implement here name validation.
+ getWizard().getContainer().updateButtons();
+ }
+ });
+
+ new Label(container, NONE).setText("Parent template");
+ chooseTemplateCmb = new Combo(container, SWT.NO_FOCUS);
+ chooseTemplateCmb.setItems(getTemplates());
+ chooseTemplateCmb.setLayoutData(new GridData(SWT.FILL, SWT.TOP,
+ true, false));
+
+ chooseTemplateCmb.addModifyListener(new ModifyListener() {
+ @Override
+ public void modifyText(ModifyEvent e) {
+ getWizard().getContainer().updateButtons();
+ }
+ });
+
+ new Label(container, SWT.SEPARATOR | SWT.SHADOW_OUT
+ | SWT.HORIZONTAL).setLayoutData(new GridData(SWT.FILL,
+ SWT.FILL, false, false, 3, 1));
+
+ useDefaultConnChk = new Button(container, SWT.CHECK);
+ useDefaultConnChk.setText("Import default connectors");
+
+ setControl(container);
+ }
+
+ private String[] getTemplates() {
+ List<Node> templates = AkbJcrUtils.getDefinedTemplate(session);
+ String[] values = new String[templates.size()];
+ int i = 0;
+ for (Node node : templates) {
+ values[i++] = AkbJcrUtils.get(node, Property.JCR_TITLE);
+ }
+ return values;
+ }
+
+ protected String getActiveEnvName() {
+ return AkbJcrUtils.isEmptyString(valueTxt.getText()) ? null
+ : valueTxt.getText();
+ }
+
+ protected Node getTemplate() {
+ int index = chooseTemplateCmb.getSelectionIndex();
+ if (index >= 0) {
+ return AkbJcrUtils.getTemplateByName(session,
+ chooseTemplateCmb.getItem(index));
+ } else
+ return null;
+ }
+
+ protected boolean getUseDefaultConnectors() {
+ return useDefaultConnChk.getSelection();
+ }
+ }
+}
\ No newline at end of file
import javax.jcr.Node;
import javax.jcr.NodeIterator;
+import javax.jcr.Repository;
import javax.jcr.RepositoryException;
/** Provides method interfaces to manage an AKB repository */
public interface AkbService {
+ /** Exposes injected Repository */
+ public Repository getRepository();
+
/** Creates a pre-configured AKB Template */
public Node createAkbTemplate(Node parent, String name)
throws RepositoryException;
+ /** Creates an instance of a template */
+ public Node createActiveEnv(Node template, String name,
+ boolean copyDefaultConnectors) throws RepositoryException;
+
/** Creates a new pre-configured AKB connector Alias for the given template */
public Node createConnectorAlias(Node templateNode, String name,
String connectorType) throws RepositoryException;
public NodeIterator getDefinedAliases(Node templateNode,
String connectorType) throws RepositoryException;
+
/**
* @param envNode
* an environment or a template
@Override
public Node createAkbTemplate(Node parentNode, String name)
throws RepositoryException {
- String connectorParentName = "Connectors";
-
Node newTemplate = parentNode.addNode(name, AkbTypes.AKB_ENV_TEMPLATE);
newTemplate.setProperty(Property.JCR_TITLE, name);
- Node connectorParent = newTemplate.addNode(
- AkbTypes.AKB_CONNECTOR_FOLDER, AkbTypes.AKB_CONNECTOR_FOLDER);
- connectorParent.setProperty(Property.JCR_TITLE, connectorParentName);
+ // Node connectorParent =
+ newTemplate.addNode(AkbTypes.AKB_CONNECTOR_FOLDER,
+ AkbTypes.AKB_CONNECTOR_FOLDER);
+ // connectorParent.setProperty(Property.JCR_TITLE, connectorParentName);
return newTemplate;
}
+ // //////////////////////////
+ // ENVIRONMENTS
+ @Override
+ public Node createActiveEnv(Node template, String name,
+ boolean copyDefaultConnectors) throws RepositoryException {
+
+ Session session = template.getSession();
+ Node parentEnvNode = session.getNode(AKB_ENVIRONMENTS_BASE_PATH);
+ Node createdEnv = parentEnvNode.addNode(name, AkbTypes.AKB_ENV);
+ createdEnv.setProperty(AKB_ENV_TEMPLATE_PATH, template.getPath());
+ createdEnv.setProperty(Property.JCR_TITLE, name);
+
+ Node connectorParent = createdEnv.addNode(
+ AkbTypes.AKB_CONNECTOR_FOLDER, AkbTypes.AKB_CONNECTOR_FOLDER);
+
+ NodeIterator ni = template.getNode(AkbTypes.AKB_CONNECTOR_FOLDER)
+ .getNodes();
+ while (ni.hasNext()) {
+ Node currNode = ni.nextNode();
+ if (currNode.isNodeType(AkbTypes.AKB_CONNECTOR_ALIAS)) {
+ Node newConnector = connectorParent.addNode(currNode.getName(),
+ AkbTypes.AKB_CONNECTOR);
+ newConnector.setProperty(AKB_CONNECTOR_ALIAS_PATH,
+ currNode.getPath());
+ if (copyDefaultConnectors
+ && currNode
+ .hasNode(AkbNames.AKB_DEFAULT_TEST_CONNECTOR)) {
+ Node defaultConn = currNode
+ .getNode(AkbNames.AKB_DEFAULT_TEST_CONNECTOR);
+ if (defaultConn.hasProperty(AkbNames.AKB_CONNECTOR_URL))
+ newConnector
+ .setProperty(
+ AkbNames.AKB_CONNECTOR_URL,
+ defaultConn.getProperty(
+ AkbNames.AKB_CONNECTOR_URL)
+ .getString());
+ if (defaultConn.hasProperty(AkbNames.AKB_CONNECTOR_USER))
+ newConnector.setProperty(
+ AkbNames.AKB_CONNECTOR_USER,
+ defaultConn.getProperty(
+ AkbNames.AKB_CONNECTOR_USER)
+ .getString());
+ }
+ }
+ }
+ return createdEnv;
+ }
+
// ///////////////////////////////////////
- // / CONNECTORS
+ // CONNECTORS
@Override
public Node createConnectorAlias(Node templateNode, String name,
// Node defaultConnector =
Node defaultConn = newConnector.addNode(
AkbNames.AKB_DEFAULT_TEST_CONNECTOR, connectorType);
- defaultConn.setProperty(AkbNames.AKB_CONNECTOR_ALIAS_PATH, newConnector.getPath());
+ defaultConn.setProperty(AkbNames.AKB_CONNECTOR_ALIAS_PATH,
+ newConnector.getPath());
return newConnector;
}
String sqlQuery = node.getProperty(AKB_QUERY_TEXT).getString();
- String connectorUrl = connectorNode.getProperty(
- AKB_CONNECTOR_URL).getString();
- String connectorUser = connectorNode.getProperty(
- AKB_CONNECTOR_USER).getString();
+ String connectorUrl = AkbJcrUtils.get(connectorNode,
+ AKB_CONNECTOR_URL);
+ String connectorUser = AkbJcrUtils.get(connectorNode,
+ AKB_CONNECTOR_USER);
+
+ // Sanity check
+ if (AkbJcrUtils.isEmptyString(connectorUrl)
+ || AkbJcrUtils.isEmptyString(connectorUser))
+ return null;
String pwdPath = getPasswordPath(connectorNode);
// String pwdPath = connectorNode.getPath() + '/'
String command = node.getProperty(AkbNames.AKB_COMMAND_TEXT)
.getString();
- String connectorUrl = connectorNode.getProperty(AKB_CONNECTOR_URL)
- .getString();
- String connectorUser = connectorNode
- .getProperty(AKB_CONNECTOR_USER).getString();
+ String connectorUrl = AkbJcrUtils.get(connectorNode,
+ AKB_CONNECTOR_URL);
+ String connectorUser = AkbJcrUtils.get(connectorNode,
+ AKB_CONNECTOR_USER);
+
+ // Sanity check
+ if (AkbJcrUtils.isEmptyString(connectorUrl)
+ || AkbJcrUtils.isEmptyString(connectorUser))
+ return null;
+
String pwdPath = getPasswordPath(connectorNode);
char[] pwd = keyring.getAsChars(pwdPath);
connectorAliasStr);
// TODO do a proper scp
- String connectorUrl = connectorNode.getProperty(AKB_CONNECTOR_URL)
- .getString();
- String connectorUser = connectorNode
- .getProperty(AKB_CONNECTOR_USER).getString();
+ String connectorUrl = AkbJcrUtils.get(connectorNode,
+ AKB_CONNECTOR_URL);
+ String connectorUser = AkbJcrUtils.get(connectorNode,
+ AKB_CONNECTOR_USER);
+
+ // Sanity check
+ if (AkbJcrUtils.isEmptyString(connectorUrl)
+ || AkbJcrUtils.isEmptyString(connectorUser))
+ return null;
+
String pwdPath = getPasswordPath(connectorNode);
char[] pwd = keyring.getAsChars(pwdPath);
}
- // /** Expose injected repository */
- // public Repository getRepository() {
- // return repository;
- // }
+ /** Expose injected repository */
+ public Repository getRepository() {
+ return repository;
+ }
/* DEPENDENCY INJECTION */
public void setRepository(Repository repository) {
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
-import javax.jcr.query.QueryManager;
-import javax.jcr.query.QueryResult;
import javax.jcr.query.Row;
import javax.jcr.query.RowIterator;
-import javax.jcr.query.qom.Constraint;
-import javax.jcr.query.qom.Ordering;
-import javax.jcr.query.qom.QueryObjectModel;
-import javax.jcr.query.qom.QueryObjectModelConstants;
-import javax.jcr.query.qom.QueryObjectModelFactory;
-import javax.jcr.query.qom.Selector;
import org.argeo.jcr.JcrUtils;
import org.argeo.jcr.PropertyDiff;
// /////////////////////////
// SPECIFIC METHOS
+ /**
+ * Returns the list of environment templates that are visible for the
+ * current user.
+ */
+ public static List<Node> getDefinedTemplate(Session session) {
+ try {
+ if (session.nodeExists(AkbNames.AKB_TEMPLATES_BASE_PATH)) {
+ NodeIterator ni = session.getNode(
+ AkbNames.AKB_TEMPLATES_BASE_PATH).getNodes();
+ List<Node> templates = new ArrayList<Node>();
+ while (ni.hasNext()) {
+ Node currN = ni.nextNode();
+ if (currN.isNodeType(AkbTypes.AKB_ENV_TEMPLATE))
+ templates.add(currN);
+ }
+ return templates;
+ }
+ return null;
+ } catch (RepositoryException re) {
+ throw new AkbException("Unable to list templates", re);
+ }
+ }
+
+ /**
+ * Returns a template given it's name
+ */
+ public static Node getTemplateByName(Session session, String name) {
+ try {
+ if (name == null)
+ return null;
+ if (session.nodeExists(AkbNames.AKB_TEMPLATES_BASE_PATH)) {
+ NodeIterator ni = session.getNode(
+ AkbNames.AKB_TEMPLATES_BASE_PATH).getNodes();
+ while (ni.hasNext()) {
+ Node currN = ni.nextNode();
+ if (name.equals(AkbJcrUtils.get(currN, Property.JCR_TITLE)))
+ return currN;
+ }
+ }
+ return null;
+ } catch (RepositoryException re) {
+ throw new AkbException("Unable to list templates", re);
+ }
+ }
+
/**
* Return the type of alias that must be used given current item type
*/
}
}
- /**
- * Return defined alias in the current environment given current item type
- */
- @Deprecated
- public static List<Node> getDefinedAliasForNode(Node itemTemplate) {
- try {
- Session session = itemTemplate.getSession();
- QueryManager queryManager = session.getWorkspace()
- .getQueryManager();
- QueryObjectModelFactory factory = queryManager.getQOMFactory();
-
- Selector source = factory.selector(AkbTypes.AKB_CONNECTOR_ALIAS,
- AkbTypes.AKB_CONNECTOR_ALIAS);
- String basePath = getCurrentEnvBasePath(itemTemplate);
- Constraint defaultC = factory.descendantNode(
- source.getSelectorName(), basePath);
-
- String nodeType = getAliasTypeForNode(itemTemplate);
- Constraint connType = factory.comparison(factory.propertyValue(
- source.getSelectorName(), AkbNames.AKB_CONNECTOR_TYPE),
- QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO, factory
- .literal(session.getValueFactory().createValue(
- nodeType)));
-
- // Order by default by JCR TITLE
- // TODO check if node definition has MIX_TITLE mixin
- // TODO Apparently case insensitive ordering is not implemented in
- // current used JCR implementation
- Ordering order = factory
- .ascending(factory.upperCase(factory.propertyValue(
- source.getSelectorName(), Property.JCR_TITLE)));
- QueryObjectModel query;
- query = factory.createQuery(source,
- factory.and(defaultC, connType), new Ordering[] { order },
- null);
- QueryResult result = query.execute();
-
- NodeIterator ni = result.getNodes();
-
- return JcrUtils.nodeIteratorToList(ni);
- } catch (RepositoryException e) {
- throw new AkbException("Unable to list connector", e);
- }
- }
-
/**
* Return current template depending on the passed node
*/
projects / gpl / argeo-slc.git / commitdiff