<bean id="envTemplateEditor" class="org.argeo.slc.akb.ui.editors.EnvTemplateEditor"
scope="prototype">
<property name="repository" ref="repository" />
+ <property name="akbService" ref="akbService" />
</bean>
<bean id="connectorAliasEditor" class="org.argeo.slc.akb.ui.editors.ConnectorAliasEditor"
id="param.nodeType"
name="Corresponding JCR node type">
</commandParameter>
+ <commandParameter
+ id="param.nodeSubtype"
+ name="A subtype if needed">
+ </commandParameter>
<commandParameter
id="param.nodeJcrId"
name="The Node JCR ID if needed">
</commandParameter>
+ <commandParameter
+ id="param.currEnvJcrId"
+ name="The current environment JCR ID, might be an active or a template env">
+ </commandParameter>
<commandParameter
id="param.parentNodeJcrId"
name="The Parent Node JCR ID if needed">
name="The Node JCR ID if needed">
</commandParameter>
</command>
+ <command
+ defaultHandler="org.argeo.slc.akb.ui.commands.ForceRefresh"
+ id="org.argeo.slc.akb.ui.forceRefresh"
+ name="Force refresh of the current active part if such an action is possible">
+ </command>
+ <command
+ defaultHandler="org.argeo.slc.akb.ui.commands.OpenTracker"
+ id="org.argeo.slc.akb.ui.openTracker"
+ name="Report a bug in Argeo's tracker">
+ </command>
</extension>
<!-- Menus -->
<extension
point="org.eclipse.ui.menus">
+ <menuContribution
+ locationURI="toolbar:org.argeo.slc.akb.ui.akbTemplatesTreeView">
+ <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">
+ <menu
+ id="help"
+ label="Help">
+ <command
+ commandId="org.argeo.slc.akb.ui.openTracker"
+ label="Report a bug..."
+ style="push">
+ </command>
+ <command
+ commandId="org.eclipse.ui.help.aboutAction"
+ label="About"
+ style="push">
+ </command> </menu>
+ </menuContribution>
</extension>
</plugin>
package org.argeo.slc.akb.ui;
+import org.argeo.slc.akb.AkbTypes;
import org.eclipse.swt.graphics.Image;
/** Shared icons. */
"icons/sshCommand.png").createImage();
public final static Image SSH_FILE = AkbUiPlugin.getImageDescriptor(
"icons/sshFile.gif").createImage();
+
+ public static Image getImageForAkbNodeType(String nodeType) {
+ if (AkbTypes.AKB_JDBC_CONNECTOR.equals(nodeType))
+ return JDBC_CONNECTOR;
+ else if (AkbTypes.AKB_SSH_CONNECTOR.equals(nodeType))
+ return SSH_CONNECTOR;
+ else
+ return null;
+ }
}
--- /dev/null
+package org.argeo.slc.akb.ui;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.argeo.slc.akb.AkbTypes;
+
+// TODO implement i18n
+public class AkbMessages {
+
+ // Shortcut to provide a label for each nodeType
+ public final static Map<String, String> typeLabels = new HashMap<String, String>() {
+ private static final long serialVersionUID = 6790463815849374432L;
+
+ {
+ put(AkbTypes.AKB_ENV_TEMPLATE, "Template environment");
+ put(AkbTypes.AKB_ENV, "Active environment");
+ put(AkbTypes.AKB_CONNECTOR_FOLDER, "Connector folder");
+ put(AkbTypes.AKB_CONNECTOR, "Connector");
+ put(AkbTypes.AKB_CONNECTOR_ALIAS, "Connector alias");
+ put(AkbTypes.AKB_SSH_CONNECTOR, "SSH connector");
+ put(AkbTypes.AKB_JDBC_CONNECTOR, "JDBC connector");
+ put(AkbTypes.AKB_JCR_CONNECTOR, "JCR connector");
+ put(AkbTypes.AKB_ITEM_FOLDER, "Item folder");
+ put(AkbTypes.AKB_ITEM, "Item");
+ put(AkbTypes.AKB_SSH_FILE, "SSH file");
+ put(AkbTypes.AKB_SSH_COMMAND, "SSH command");
+ put(AkbTypes.AKB_JDBC_QUERY, "JDBC query");
+ put(AkbTypes.AKB_NOTE, "Note");
+ }
+ };
+
+ public final static String getLabelForType(String nodeType) {
+ return typeLabels.get(nodeType);
+ }
+
+}
package org.argeo.slc.akb.ui;
import java.util.Calendar;
+import java.util.Map;
import javax.jcr.Node;
import javax.jcr.PropertyType;
import org.argeo.slc.akb.AkbException;
import org.argeo.slc.akb.utils.AkbJcrUtils;
+import org.eclipse.jface.action.IContributionItem;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.forms.AbstractFormPart;
import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.menus.CommandContributionItem;
+import org.eclipse.ui.menus.CommandContributionItemParameter;
+import org.eclipse.ui.services.IServiceLocator;
/** Some helper methods that factorize widely used snippets in people UI */
public class AkbUiUtils {
text.setEnabled(AkbJcrUtils.isNodeCheckedOutByMe(entity));
return tmpStr;
}
-
-
+
/**
* Shortcut to refresh a <code>Text</code> widget given a Node in a form and
- * a property Name. Also manages its enable state and set a default message if corresponding Text value is empty
+ * a property Name. Also manages its enable state and set a default message
+ * if corresponding Text value is empty
*/
public static String refreshFormTextWidget(Text text, Node entity,
String propName, String defaultMsg) {
String tmpStr = refreshFormTextWidget(text, entity, propName);
- if (AkbJcrUtils.isEmptyString(tmpStr) && AkbJcrUtils.checkNotEmptyString(defaultMsg))
+ if (AkbJcrUtils.isEmptyString(tmpStr)
+ && AkbJcrUtils.checkNotEmptyString(defaultMsg))
text.setMessage(defaultMsg);
return tmpStr;
}
formData.bottom = new FormAttachment(bottom, 0);
return formData;
}
+
+ // //////////////////////////////
+ // / COMMANDS
+ public static CommandContributionItem createContributionItem(
+ IMenuManager menuManager, IServiceLocator locator, String itemId,
+ String cmdId, String label, ImageDescriptor icon,
+ Map<String, String> params) {
+
+ CommandContributionItemParameter contributionItemParameter = new CommandContributionItemParameter(
+ locator, itemId, cmdId, SWT.PUSH);
+
+ contributionItemParameter.label = label;
+ contributionItemParameter.icon = icon;
+
+ if (params != null)
+ contributionItemParameter.parameters = params;
+ CommandContributionItem cci = new CommandContributionItem(
+ contributionItemParameter);
+ return cci;
+ }
+
+ /**
+ * Commodities the refresh of a single command with a map of parameters in a
+ * Menu.aboutToShow method to simplify further development
+ *
+ * @param menuManager
+ * @param locator
+ * @param cmdId
+ * @param label
+ * @param iconPath
+ * @param showCommand
+ */
+ public static void refreshParameterizedCommand(IMenuManager menuManager,
+ IServiceLocator locator, String itemId, String cmdId, String label,
+ ImageDescriptor icon, boolean showCommand,
+ Map<String, String> params) {
+ IContributionItem ici = menuManager.find(itemId);
+ if (ici != null)
+ menuManager.remove(ici);
+ if (showCommand)
+ menuManager.add(createContributionItem(menuManager, locator,
+ itemId, cmdId, label, icon, params));
+ }
+
}
\ No newline at end of file
import org.argeo.slc.akb.AkbException;
import org.argeo.slc.akb.ui.AkbUiPlugin;
import org.argeo.slc.akb.ui.editors.AkbNodeEditorInput;
+import org.argeo.slc.akb.utils.AkbJcrUtils;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
if (nodeJcrId != null)
node = session.getNodeByIdentifier(nodeJcrId);
+ // We must be in a template to delete nodes...
+ Node template = AkbJcrUtils.getCurrentTemplate(node);
+
IEditorPart currPart = currentPage
- .findEditor(new AkbNodeEditorInput(nodeJcrId));
+ .findEditor(new AkbNodeEditorInput(
+ template.getIdentifier(), nodeJcrId));
if (currPart != null)
currPart.dispose();
--- /dev/null
+package org.argeo.slc.akb.ui.commands;
+
+import org.argeo.slc.akb.ui.AkbUiPlugin;
+import org.argeo.slc.akb.ui.utils.Refreshable;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/**
+ * Force refreshment of the active part if it implements
+ * <Code>Refreshable</code> interface.
+ */
+public class ForceRefresh extends AbstractHandler {
+
+ public final static String ID = AkbUiPlugin.PLUGIN_ID + ".forceRefresh";
+
+ public Object execute(ExecutionEvent event) throws ExecutionException {
+
+ IWorkbenchPart part = HandlerUtil.getActiveWorkbenchWindow(event)
+ .getActivePage().getActivePart();
+ if (part instanceof Refreshable)
+ ((Refreshable) part).forceRefresh(null);
+ return null;
+ }
+}
\ No newline at end of file
import org.argeo.slc.akb.AkbException;
import org.argeo.slc.akb.AkbService;
import org.argeo.slc.akb.AkbTypes;
+import org.argeo.slc.akb.ui.AkbMessages;
import org.argeo.slc.akb.ui.AkbUiPlugin;
import org.argeo.slc.akb.ui.dialogs.AddItemDialog;
import org.argeo.slc.akb.ui.editors.AkbNodeEditorInput;
public final static String PARAM_NODE_JCR_ID = "param.nodeJcrId";
public final static String PARAM_NODE_TYPE = "param.nodeType";
+ public final static String PARAM_NODE_SUBTYPE = "param.nodeSubtype";
+ public final static String PARAM_CURR_ENV_JCR_ID = "param.currEnvJcrId";
public final static String PARAM_PARENT_NODE_JCR_ID = "param.parentNodeJcrId";
public Object execute(ExecutionEvent event) throws ExecutionException {
String nodeType = event.getParameter(PARAM_NODE_TYPE);
+ String nodeSubtype = event.getParameter(PARAM_NODE_SUBTYPE);
+ String currEnvJcrId = event.getParameter(PARAM_CURR_ENV_JCR_ID);
String nodeJcrId = event.getParameter(PARAM_NODE_JCR_ID);
String parentNodeJcrId = event.getParameter(PARAM_PARENT_NODE_JCR_ID);
throw new AkbException(
"Define a parent node to create a new node");
else
- node = createNewNode(session, nodeType, parentNodeJcrId);
+ node = createNewNode(session, nodeType, nodeSubtype,
+ parentNodeJcrId);
else
node = session.getNodeByIdentifier(nodeJcrId);
if (editorId == null)
return null;
- AkbNodeEditorInput eei = new AkbNodeEditorInput(
+ AkbNodeEditorInput eei = new AkbNodeEditorInput(currEnvJcrId,
node.getIdentifier());
currentPage.openEditor(eei, editorId);
}
private Node createNewNode(Session session, String nodeType,
- String parentNodeJcrId) throws RepositoryException {
+ String nodeSubtype, String parentNodeJcrId)
+ throws RepositoryException {
Node node = null;
if (AkbTypes.AKB_ITEM.equals(nodeType)) {
dialog.open();
node = dialog.getNewNode();
} else {
- String name = SingleValue.ask("New name", "Create AKB item");
+ 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);
--- /dev/null
+package org.argeo.slc.akb.ui.commands;
+
+import java.net.URL;
+
+import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.ui.AkbUiPlugin;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.ui.PlatformUI;
+
+/**
+ * Open a browser with bugzilla
+ */
+public class OpenTracker extends AbstractHandler {
+
+ public final static String ID = AkbUiPlugin.PLUGIN_ID + ".forceRefresh";
+
+ private final static String TRACKER_URL = "https://www.argeo.org/bugzilla/enter_bug.cgi?product=slc";
+
+ public Object execute(ExecutionEvent event) throws ExecutionException {
+
+ try {
+ PlatformUI.getWorkbench().getBrowserSupport().getExternalBrowser()
+ .openURL(new URL(TRACKER_URL));
+ } catch (Exception e) {
+ throw new AkbException("Unable to open browser page", e);
+ }
+ return null;
+ }
+}
\ No newline at end of file
--- /dev/null
+package org.argeo.slc.akb.ui.composites;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+
+import org.argeo.eclipse.ui.ErrorFeedback;
+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.AkbImages;
+import org.argeo.slc.akb.ui.AkbUiUtils;
+import org.argeo.slc.akb.ui.commands.DeleteAkbNodes;
+import org.argeo.slc.akb.utils.AkbJcrUtils;
+import org.eclipse.jface.dialogs.MessageDialog;
+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.swt.widgets.Text;
+import org.eclipse.ui.forms.AbstractFormPart;
+import org.eclipse.ui.forms.IManagedForm;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+
+/** Default composite to display a connector alias. */
+public class ConnectorAliasSmallComposite extends Composite {
+
+ private final AkbService akbService;
+ private final Node connectorAlias;
+ private final Node activeConnector;
+ private final FormToolkit toolkit;
+ private final IManagedForm form;
+
+ // Don't forget to unregister on dispose
+ private AbstractFormPart formPart;
+
+ // To enable set focus
+ private Text titleTxt;
+
+ public ConnectorAliasSmallComposite(Composite parent, int style,
+ FormToolkit toolkit, IManagedForm form, Node akbNode,
+ AkbService akbService) {
+ super(parent, style);
+ this.connectorAlias = akbNode;
+ try {
+ this.activeConnector = akbNode
+ .getNode(AkbNames.AKB_DEFAULT_TEST_CONNECTOR);
+ } catch (RepositoryException e) {
+ throw new AkbException("Unable to get activeConnector for node", e);
+ }
+ this.toolkit = toolkit;
+ this.form = form;
+ this.akbService = akbService;
+ populate();
+ toolkit.adapt(this);
+ }
+
+ private void populate() {
+ // Initialization
+ Composite parent = this;
+ createConnectorAliasInfoCmp(parent);
+ }
+
+ private void createConnectorAliasInfoCmp(Composite parent) {
+ GridLayout gl = AkbUiUtils.gridLayoutNoBorder();
+ gl.marginBottom = 15;
+
+ parent.setLayout(gl);
+ Composite firstLine = toolkit.createComposite(parent, SWT.NO_FOCUS);
+ firstLine.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
+ firstLine.setLayout(new GridLayout(9, false));
+
+ // Image
+ final Label image = toolkit.createLabel(firstLine, "", SWT.NONE);
+ GridData gd = new GridData(SWT.LEFT, SWT.CENTER, false, false);
+ try {
+ image.setImage(AkbImages.getImageForAkbNodeType(activeConnector
+ .getPrimaryNodeType().getName()));
+ } catch (RepositoryException e2) {
+ // silent
+ }
+ image.setLayoutData(gd);
+
+ // Name
+ final Text titleTxt = toolkit.createText(firstLine, "", SWT.BORDER);
+ gd = new GridData(SWT.FILL, SWT.TOP, false, false);
+ gd.widthHint = 150;
+ titleTxt.setLayoutData(gd);
+
+ toolkit.createLabel(firstLine, "URL");
+ final Text urlTxt = toolkit.createText(firstLine, "", SWT.BORDER);
+ urlTxt.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
+
+ toolkit.createLabel(firstLine, "User");
+ final Text userTxt = toolkit.createText(firstLine, "", SWT.BORDER);
+ gd = new GridData(SWT.LEFT, SWT.TOP, false, false);
+ gd.widthHint = 150;
+ userTxt.setLayoutData(gd);
+
+ final Link testBtn = new Link(firstLine, SWT.NONE);
+ toolkit.adapt(testBtn, false, false);
+ testBtn.setText("<a>Test</a>");
+
+ final Link removeBtn = new Link(firstLine, SWT.NONE);
+ toolkit.adapt(removeBtn, false, false);
+ removeBtn.setText("<a>Delete</a>");
+
+ // createDefaultTestConnectorCmp(secondLine);
+
+ // Description
+ final Text descTxt = toolkit.createText(parent, "", SWT.NONE);
+ gd = new GridData(SWT.FILL, SWT.TOP, true, false);
+ descTxt.setLayoutData(gd);
+
+ // Part Management
+ formPart = new AbstractFormPart() {
+ public void refresh() {
+ super.refresh();
+ // update display value
+ AkbUiUtils.refreshFormTextWidget(titleTxt, connectorAlias,
+ Property.JCR_TITLE, "Name");
+ AkbUiUtils.refreshFormTextWidget(descTxt, connectorAlias,
+ Property.JCR_DESCRIPTION, "Short description");
+ AkbUiUtils.refreshFormTextWidget(urlTxt, activeConnector,
+ AkbNames.AKB_CONNECTOR_URL);
+ AkbUiUtils.refreshFormTextWidget(userTxt, activeConnector,
+ AkbNames.AKB_CONNECTOR_USER);
+ }
+ };
+ // Listeners
+ AkbUiUtils.addTextModifyListener(titleTxt, connectorAlias,
+ Property.JCR_TITLE, formPart);
+ AkbUiUtils.addTextModifyListener(urlTxt, activeConnector,
+ AkbNames.AKB_CONNECTOR_URL, formPart);
+ AkbUiUtils.addTextModifyListener(userTxt, activeConnector,
+ AkbNames.AKB_CONNECTOR_USER, formPart);
+ AkbUiUtils.addTextModifyListener(descTxt, connectorAlias,
+ Property.JCR_DESCRIPTION, formPart);
+
+ testBtn.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ boolean testSuccesfull;
+ try {
+ testSuccesfull = akbService.testConnector(activeConnector);
+ } catch (Exception e1) {
+ testSuccesfull = false;
+ ErrorFeedback.show("Cannot test connection", e1);
+ }
+ String name = AkbJcrUtils.get(activeConnector,
+ Property.JCR_TITLE);
+ String url = AkbJcrUtils.get(activeConnector,
+ AkbNames.AKB_CONNECTOR_URL);
+ String msg = " to " + name + " (" + url + ")";
+ if (testSuccesfull)
+ MessageDialog.openInformation(
+ getDisplay().getActiveShell(), "Test successful",
+ "Successfully connected " + msg);
+ else
+ MessageDialog.openError(getDisplay().getActiveShell(),
+ "Test failure", "Unable to connect" + msg);
+ }
+ });
+
+ removeBtn.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ CommandUtils.CallCommandWithOneParameter(DeleteAkbNodes.ID,
+ DeleteAkbNodes.PARAM_NODE_JCR_ID,
+ AkbJcrUtils.getIdentifierQuietly(connectorAlias));
+ // for (IFormPart part : form.getParts())
+ // if (!formPart.equals(part))
+ // part.refresh();
+ }
+ });
+ form.addPart(formPart);
+ }
+
+ @Override
+ public boolean setFocus() {
+ return titleTxt.setFocus();
+ }
+
+ protected void disposePart(AbstractFormPart part) {
+ if (part != null) {
+ form.removePart(part);
+ part.dispose();
+ }
+ }
+
+ @Override
+ public void dispose() {
+ disposePart(formPart);
+ super.dispose();
+ }
+}
import javax.jcr.Session;
import org.argeo.eclipse.ui.utils.CommandUtils;
+import org.argeo.jcr.JcrUtils;
import org.argeo.slc.akb.AkbException;
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.commands.OpenAkbNodeEditor;
import org.argeo.slc.akb.utils.AkbJcrUtils;
// private final static Log log =
// LogFactory.getLog(MixTitleComposite.class);
+ private final AkbService akbService;
private final Node akbNode;
private final FormToolkit toolkit;
private final IManagedForm form;
private List<Node> definedAliases;
public ItemTemplateTitleComposite(Composite parent, int style,
- FormToolkit toolkit, IManagedForm form, Node akbNode) {
+ FormToolkit toolkit, IManagedForm form, Node akbNode,
+ AkbService akbService) {
super(parent, style);
this.akbNode = akbNode;
this.toolkit = toolkit;
this.form = form;
+ this.akbService = akbService;
populate();
toolkit.adapt(this);
}
"No selected alias");
}
});
- //
- // final Link testAliasLk= new Link(parent, SWT.NONE);
- // openAliasLk.setText("<a> Edit Alias </a>");
- // openAliasLk.addSelectionListener(new SelectionAdapter() {
- // private static final long serialVersionUID = 1L;
- //
- // @Override
- // public void widgetSelected(final SelectionEvent event) {
- // MessageDialog.openInformation(getShell(), "test", "test");
- // }
- // });
// 3rd line: description
Label lbl = toolkit.createLabel(parent, "Description");
// set new alias
Node newAlias = definedAliases.get(selIndex);
- akbNode.setProperty(AkbNames.AKB_USED_CONNECTOR,
- newAlias.getPath());
+
+ // Only relies on the alias
+ akbNode.setProperty(AkbNames.AKB_USED_CONNECTOR, newAlias
+ .getProperty(Property.JCR_TITLE).getString());
part.markDirty();
} catch (RepositoryException e) {
throw new AkbException(
}
private void refreshTypeCmbValues() {
- List<Node> newAliases = AkbJcrUtils.getDefinedAliasForNode(akbNode);
+ List<Node> newAliases;
+ try {
+ newAliases = JcrUtils.nodeIteratorToList(akbService
+ .getDefinedAliases(AkbJcrUtils.getCurrentTemplate(akbNode),
+ AkbJcrUtils.getAliasTypeForNode(akbNode)));
+ } catch (RepositoryException e) {
+ throw new AkbException("Unable to get defined aliases for node "
+ + akbNode, e);
+ }
boolean hasChanged = false;
// manually ckeck if something has changed
if (definedAliases == null
parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
// First line main info
ItemTemplateTitleComposite ittCmp = new ItemTemplateTitleComposite(
- parent, SWT.NO_FOCUS, getToolkit(), managedForm, getAkbNode());
+ parent, SWT.NO_FOCUS, getToolkit(), managedForm, getAkbNode(), getAkbService());
GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
gd.minimumHeight = 250;
ittCmp.setLayoutData(gd);
/**
* Editor input for all editors that display info on a given AKB JCR Node.
- * Relies on the Jcr ID
+ *
+ * Relies on the Jcr ID,
*/
public class AkbNodeEditorInput implements IEditorInput {
+ private final String envJcrId;
+ // Only null if current node is a environment (active or template)
private final String jcrId;
- /** the Jcr ID cannot be null */
- public AkbNodeEditorInput(String jcrId) {
+ /**
+ * the Env Jcr ID cannot be null, JcrId can only be null if current node is
+ * an environment (active or template)
+ */
+ public AkbNodeEditorInput(String envJcrId, String jcrId) {
+ this.envJcrId = envJcrId;
this.jcrId = jcrId;
}
public String getIdentifier() {
- return jcrId;
+ if (jcrId == null)
+ return envJcrId;
+ else
+ return jcrId;
+ }
+
+ public String getEnvIdentifier() {
+ return envJcrId;
}
public boolean exists() {
if (getClass() != obj.getClass())
return false;
AkbNodeEditorInput other = (AkbNodeEditorInput) obj;
- if (!jcrId.equals(other.getIdentifier()))
+ if (!jcrId.equals(other.getIdentifier())
+ || !envJcrId.equals(other.getEnvIdentifier()))
return false;
return true;
}
package org.argeo.slc.akb.ui.editors;
+import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import org.argeo.eclipse.ui.ErrorFeedback;
import org.argeo.slc.akb.AkbException;
import org.argeo.slc.akb.AkbNames;
-import org.argeo.slc.akb.AkbTypes;
import org.argeo.slc.akb.ui.AkbUiPlugin;
import org.argeo.slc.akb.ui.AkbUiUtils;
import org.argeo.slc.akb.utils.AkbJcrUtils;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.ModifyEvent;
-import org.eclipse.swt.events.ModifyListener;
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.Button;
-import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Text;
public final static String ID = AkbUiPlugin.PLUGIN_ID
+ ".connectorAliasEditor";
- private String[] connectorTypesLbl = new String[] { "JDBC", "SSH", "JCR" };
- private String[] connectorTypes = new String[] {
- AkbTypes.AKB_JDBC_CONNECTOR, AkbTypes.AKB_SSH_CONNECTOR,
- AkbTypes.AKB_JCR_CONNECTOR };
-
private IManagedForm managedForm;
+ private Node activeConnector;
/* CONTENT CREATION */
@Override
public void populateMainPage(Composite parent, IManagedForm managedForm) {
parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
+
+ // TODO clean this
+ // Initialization
this.managedForm = managedForm;
+ // enable dynamic change of the active connector
+ try {
+ activeConnector = getAkbNode().getNode(
+ AkbNames.AKB_DEFAULT_TEST_CONNECTOR);
+ } catch (RepositoryException e) {
+ throw new AkbException("unable to retrieve active connector node",
+ e);
+ }
// First line main info
Composite firstLine = getToolkit()
}
private void createConnectorAliasInfoCmp(Composite parent) {
- parent.setLayout(new GridLayout(4, false));
-
- // first line: connector type and name
- getToolkit().createLabel(parent, "Connector Type");
- final Combo typeCmb = new Combo(parent, SWT.READ_ONLY);
- typeCmb.setItems(connectorTypesLbl);
+ parent.setLayout(new GridLayout(2, false));
- getToolkit().createLabel(parent, "Name");
+ // Name
final Text titleTxt = getToolkit().createText(parent, "", SWT.BORDER);
- GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
+ GridData gd = new GridData(SWT.FILL, SWT.TOP, false, false);
+ gd.minimumWidth = 200;
+ gd.widthHint = 200;
titleTxt.setLayoutData(gd);
- // 2nd line: description
- getToolkit().createLabel(parent, "Short Description");
+ // Description
final Text descTxt = getToolkit().createText(parent, "", SWT.BORDER);
- gd = new GridData(SWT.FILL, SWT.TOP, true, false, 3, 1);
+ gd = new GridData(SWT.FILL, SWT.TOP, true, false);
descTxt.setLayoutData(gd);
// Part Management
super.refresh();
// update display value
AkbUiUtils.refreshFormTextWidget(titleTxt, getAkbNode(),
- Property.JCR_TITLE);
+ Property.JCR_TITLE, "Name");
AkbUiUtils.refreshFormTextWidget(descTxt, getAkbNode(),
- Property.JCR_DESCRIPTION);
- typeCmb.select(getCurrTypeIndex());
- typeCmb.setEnabled(AkbJcrUtils
- .isNodeCheckedOutByMe(getAkbNode()));
+ Property.JCR_DESCRIPTION, "Short description");
}
};
// Listeners
AkbUiUtils.addTextModifyListener(descTxt, getAkbNode(),
Property.JCR_DESCRIPTION, part);
- typeCmb.addModifyListener(new ModifyListener() {
- @Override
- public void modifyText(ModifyEvent event) {
-
- try { // TODO enhance this
- // retrieve old and new node type
- int oldIndex = getCurrTypeIndex();
- int selIndex = typeCmb.getSelectionIndex();
-
- // insure something has really been modified
- if (selIndex < 0 || oldIndex == selIndex)
- return;
-
- // remove old mixin, add new and notify form
- if (oldIndex > -1)
- getAkbNode().removeMixin(connectorTypes[oldIndex]);
- getAkbNode().addMixin(connectorTypes[selIndex]);
- part.markDirty();
- } catch (RepositoryException e) {
- throw new AkbException(
- "Error while updating connector type", e);
- }
- }
- });
managedForm.addPart(part);
}
- private int getCurrTypeIndex() {
- try {
- int oldIndex = -1;
- for (int i = 0; i < connectorTypes.length; i++) {
- if (getAkbNode().isNodeType(connectorTypes[i])) {
- oldIndex = i;
- break;
-
- }
- }
- return oldIndex;
- } catch (RepositoryException e) {
- throw new AkbException("Error while getting connector type", e);
- }
-
+ protected void updatePartNameAndToolTip() {
+ super.updatePartNameAndToolTip();
+ // TODO update editor image
}
private void createDefaultTestConnectorCmp(Composite parent) {
group.setText(groupTitle);
group.setLayout(AkbUiUtils.gridLayoutNoBorder());
- // 1st line: the URL
+ // 1st line: the URL
Composite firstLine = getToolkit().createComposite(group);
firstLine.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
firstLine.setLayout(new GridLayout(2, false));
public void refresh() {
super.refresh();
// update display value
- AkbUiUtils.refreshFormTextWidget(urlTxt, getAkbNode(),
+ AkbUiUtils.refreshFormTextWidget(urlTxt, activeConnector,
AkbNames.AKB_CONNECTOR_URL);
- AkbUiUtils.refreshFormTextWidget(userTxt, getAkbNode(),
+ AkbUiUtils.refreshFormTextWidget(userTxt, activeConnector,
AkbNames.AKB_CONNECTOR_USER);
}
};
// Listeners
- AkbUiUtils.addTextModifyListener(urlTxt, getAkbNode(),
+ AkbUiUtils.addTextModifyListener(urlTxt, activeConnector,
AkbNames.AKB_CONNECTOR_URL, part);
- AkbUiUtils.addTextModifyListener(userTxt, getAkbNode(),
+ AkbUiUtils.addTextModifyListener(userTxt, activeConnector,
AkbNames.AKB_CONNECTOR_USER, part);
testBtn.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
boolean testSuccesfull;
+
try {
- testSuccesfull = getAkbService()
- .testConnector(getAkbNode());
+ testSuccesfull = getAkbService().testConnector(
+ activeConnector);
} catch (Exception e1) {
testSuccesfull = false;
ErrorFeedback.show("Cannot test connection", e1);
}
- String name = AkbJcrUtils.get(getAkbNode(), Property.JCR_TITLE);
- String url = AkbJcrUtils.get(getAkbNode(),
+ String name = AkbJcrUtils.get(activeConnector,
+ Property.JCR_TITLE);
+ String url = AkbJcrUtils.get(activeConnector,
AkbNames.AKB_CONNECTOR_URL);
String msg = "to " + name + " (" + url + ")";
package org.argeo.slc.akb.ui.editors;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.jcr.ItemNotFoundException;
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.observation.Event;
+import javax.jcr.observation.ObservationManager;
+
+import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
+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.AkbUiUtils;
+import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;
+import org.argeo.slc.akb.ui.composites.ConnectorAliasSmallComposite;
import org.argeo.slc.akb.ui.composites.MixTitleComposite;
+import org.eclipse.jface.action.IContributionItem;
+import org.eclipse.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.forms.AbstractFormPart;
import org.eclipse.ui.forms.IManagedForm;
/**
public final static String ID = AkbUiPlugin.PLUGIN_ID
+ ".envTemplateEditor";
+ // Observer
+ private final static String[] observedNodes = { AkbTypes.AKB_CONNECTOR_FOLDER };
+ private ConnectorObserver connectorObserver;
+
/* CONTENT CREATION */
@Override
public void populateMainPage(Composite parent, IManagedForm managedForm) {
- parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
+ parent.setLayout(new GridLayout());
// First line main info
MixTitleComposite mixTitleCmp = new MixTitleComposite(parent,
SWT.NO_FOCUS, getToolkit(), managedForm, getAkbNode());
- mixTitleCmp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
+ gd.heightHint = 200;
+ mixTitleCmp.setLayoutData(gd);
+
+ // Second line : the defined editor
+ Group group = new Group(parent, SWT.NONE);
+ group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ getToolkit().adapt(group, false, false);
+ String groupTitle = "Connector Aliases";
+ group.setText(groupTitle);
+ populateDisplayConnectorPanel(managedForm, group, getAkbNode());
+
+ // add context menu
+ MenuManager menuManager = new MenuManager();
+ Menu menu = menuManager.createContextMenu(group);
+ menuManager.addMenuListener(new IMenuListener() {
+ public void menuAboutToShow(IMenuManager manager) {
+ aboutToShow(manager);
+ }
+ });
+ group.setMenu(menu);
+ menuManager.setRemoveAllWhenShown(true);
+ }
+
+ private void aboutToShow(IMenuManager menu) {
+ try {
+ // initialization
+ String submenuID = "subMenu.addAlias";
+ IWorkbenchWindow window = AkbUiPlugin.getDefault().getWorkbench()
+ .getActiveWorkbenchWindow();
+ Node connectorParent = getAkbNode();
+ IContributionItem ici = menu.find(submenuID);
+ if (ici != null)
+ menu.remove(ici);
+ Map<String, String> params = new HashMap<String, String>();
+ params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,
+ connectorParent.getIdentifier());
+ params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,
+ AkbTypes.AKB_CONNECTOR_ALIAS);
+
+ MenuManager subMenu = new MenuManager("Add connector alias",
+ submenuID);
+ // JDBC
+ Map<String, String> tmpParams = new HashMap<String, String>();
+ tmpParams.putAll(params);
+ tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,
+ AkbTypes.AKB_JDBC_CONNECTOR);
+ String currItemId = "cmd.createJDBCAlias";
+ IContributionItem currItem = subMenu.find(currItemId);
+ if (currItem != null)
+ subMenu.remove(currItem);
+ subMenu.add(AkbUiUtils.createContributionItem(subMenu, window,
+ currItemId, OpenAkbNodeEditor.ID, "JDBC", null, tmpParams));
+
+ // SSH
+ tmpParams = new HashMap<String, String>();
+ tmpParams.putAll(params);
+ tmpParams.put(OpenAkbNodeEditor.PARAM_NODE_SUBTYPE,
+ AkbTypes.AKB_SSH_CONNECTOR);
+ currItemId = "cmd.createSSHAlias";
+ currItem = subMenu.find(currItemId);
+ if (currItem != null)
+ subMenu.remove(currItem);
+ subMenu.add(AkbUiUtils.createContributionItem(subMenu, window,
+ currItemId, OpenAkbNodeEditor.ID, "SSH", null, tmpParams));
+
+ menu.add(subMenu);
+
+ } catch (RepositoryException e) {
+ throw new AkbException("Unable to refresh context menu", e);
+ }
+ }
+
+ /** Manage display and update of defined connector aliases */
+ public void populateDisplayConnectorPanel(final IManagedForm managedForm,
+ final Composite panel, final Node entity) {
+ GridLayout gl = AkbUiUtils.gridLayoutNoBorder();
+ gl.marginTop = 10;
+ panel.setLayout(gl);
+
+ final Map<String, Composite> connectorsCmps = new HashMap<String, Composite>();
+ AbstractFormPart formPart = new AbstractFormPart() {
+ public void refresh() {
+ try {
+ super.refresh();
+ // first: initialise composite for new connectors
+ Node connectorPar = getAkbNode().getNode(
+ AkbTypes.AKB_CONNECTOR_FOLDER);
+ NodeIterator ni = connectorPar.getNodes();
+ while (ni.hasNext()) {
+ Node currNode = ni.nextNode();
+ String currJcrId = currNode.getIdentifier();
+ if (!connectorsCmps.containsKey(currJcrId)) {
+ Composite currCmp = new ConnectorAliasSmallComposite(
+ panel, SWT.NO_FOCUS, getToolkit(),
+ managedForm, currNode, getAkbService());
+ currCmp.setLayoutData(new GridData(SWT.FILL,
+ SWT.TOP, true, false));
+ connectorsCmps.put(currJcrId, currCmp);
+ }
+ }
+
+ // then remove necessary composites
+ Session session = connectorPar.getSession();
+ for (String jcrId : connectorsCmps.keySet()) {
+ // TODO: enhance this
+ Composite currCmp = connectorsCmps.get(jcrId);
+ try {
+ session.getNodeByIdentifier(jcrId);
+ } catch (ItemNotFoundException infe) {
+ currCmp.dispose();
+ }
+ }
+ panel.layout();
+ } catch (RepositoryException e) {
+ throw new AkbException("Cannot refresh connectors group", e);
+ }
+ }
+ };
+ formPart.refresh();
+ managedForm.addPart(formPart);
+
+ // Initialize observer
+ try {
+ ObservationManager observationManager = getSession().getWorkspace()
+ .getObservationManager();
+ connectorObserver = new ConnectorObserver(panel.getDisplay(),
+ formPart);
+ // observe tree changes under All results
+ observationManager.addEventListener(connectorObserver,
+ Event.NODE_ADDED | Event.NODE_REMOVED, getAkbNode()
+ .getNode(AkbTypes.AKB_CONNECTOR_FOLDER).getPath(),
+ true, null, observedNodes, false);
+ } catch (RepositoryException e) {
+ throw new AkbException("Cannot register listeners", e);
+ }
+
+ }
+
+ class ConnectorObserver extends AsyncUiEventListener {
+
+ private AbstractFormPart formPart;
+
+ public ConnectorObserver(Display display, AbstractFormPart formPart) {
+ super(display);
+ this.formPart = formPart;
+ }
+
+ @Override
+ protected Boolean willProcessInUiThread(List<Event> events)
+ throws RepositoryException {
+ return true;
+ }
+
+ protected void onEventInUiThread(List<Event> events)
+ throws RepositoryException {
+ try {
+ formPart.refresh();
+ } catch (Exception e) {
+ // silently fail
+ e.printStackTrace();
+ }
+ }
}
@Override
/** Test JDBC. */
public class JdbcTestPage extends FormPage implements AkbNames {
- private Node node;
+ private Node currItem;
+ // A template or an active environment
+ private Node currEnv;
private AkbService akbService;
private TableViewer viewer = null;
private PreparedStatement statement;
public JdbcTestPage(AkbService akbService, FormEditor editor, String id,
- String title, Node node) {
+ String title, Node currEnv, Node currItem) {
super(editor, id, title);
this.akbService = akbService;
- this.node = node;
+ this.currItem = currItem;
+ this.currEnv = currEnv;
}
protected void createFormContent(IManagedForm managedForm) {
viewer.setContentProvider(contentProvider);
// viewer.setLabelProvider(new ColumnLabelProvider(){});
- statement = akbService.prepareJdbcQuery(node);
- PrivilegedJob job = new PrivilegedJob("Execute query on " + node) {
+ statement = akbService.prepareJdbcQuery(currEnv, currItem);
+ PrivilegedJob job = new PrivilegedJob("Execute query on " + currItem) {
@Override
protected IStatus doRun(IProgressMonitor progressMonitor) {
});
return Status.OK_STATUS;
} catch (SQLException e) {
- throw new SlcException("Cannot execute " + node, e);
+ throw new SlcException("Cannot execute " + currItem, e);
}
}
};
*/
package org.argeo.slc.akb.ui.providers;
+import java.util.ArrayList;
import java.util.List;
import javax.jcr.Node;
+import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
-import org.argeo.jcr.JcrUtils;
import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.AkbTypes;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
public Object[] getChildren(Object parent) {
try {
- List<Node> nodes = JcrUtils.nodeIteratorToList(((Node) parent)
- .getNodes());
+ NodeIterator ni = ((Node) parent).getNodes();
+ List<Node> nodes = new ArrayList<Node>();
+
+ while (ni.hasNext()) {
+ Node currNode = ni.nextNode();
+ if (!currNode.isNodeType(AkbTypes.AKB_CONNECTOR_FOLDER))
+ nodes.add(currNode);
+ }
+
return nodes.toArray();
} catch (RepositoryException e) {
throw new AkbException("Error while getting children nodes", e);
public boolean hasChildren(Object parent) {
try {
+ // refine this
return ((Node) parent).hasNodes();
} catch (RepositoryException e) {
throw new AkbException("Error while checking children nodes", e);
--- /dev/null
+package org.argeo.slc.akb.ui.utils;
+
+/**
+ * WorkbenchPart should implement this interface to enable refresh command to
+ * refresh them
+ */
+public interface Refreshable {
+
+ public void forceRefresh(Object object);
+
+}
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.ui.views.AkbTemplatesTreeView.ViewDoubleClickListener;\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.resource.ImageDescriptor;\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.swt.widgets.Display;\r
import org.eclipse.swt.widgets.Menu;\r
import org.eclipse.ui.IWorkbenchWindow;\r
-import org.eclipse.ui.menus.CommandContributionItem;\r
-import org.eclipse.ui.menus.CommandContributionItemParameter;\r
import org.eclipse.ui.part.ViewPart;\r
import org.eclipse.ui.services.IServiceLocator;\r
\r
/** SLC generic JCR Result tree view. */\r
-public class AkbTemplatesTreeView extends ViewPart {\r
+public class AkbTemplatesTreeView extends ViewPart implements Refreshable {\r
// private final static Log log =\r
- // LogFactory.getLog(JcrResultTreeView.class);\r
+ // LogFactory.getLog(AkbTemplatesTreeView.class);\r
\r
public final static String ID = AkbUiPlugin.PLUGIN_ID\r
+ ".akbTemplatesTreeView";\r
private Session session;\r
\r
// This page widgets\r
- private TreeViewer resultTreeViewer;\r
+ private TreeViewer envTreeViewer;\r
\r
// Usefull business objects\r
private Node templatesParentNode;\r
\r
// Observer\r
- private EventListener allResultsObserver = null;\r
- private final static String[] observedNodeTypesUnderAllResults = {\r
+ private EventListener akbNodesObserver = null;\r
+ private final static String[] observedNodeTypes = {\r
AkbTypes.AKB_ENV_TEMPLATE, AkbTypes.AKB_CONNECTOR_ALIAS,\r
AkbTypes.AKB_ITEM, AkbTypes.AKB_ITEM_FOLDER,\r
AkbTypes.AKB_CONNECTOR_FOLDER };\r
\r
- // private EventListener myResultsObserver = null;\r
- // private EventListener allResultsObserver = null;\r
- //\r
- // // under My Results\r
- // private final static String[] observedNodeTypesUnderMyResult = {\r
- // SlcTypes.SLC_TEST_RESULT, SlcTypes.SLC_RESULT_FOLDER,\r
- // SlcTypes.SLC_MY_RESULT_ROOT_FOLDER };\r
- //\r
- // private final static String[] observedNodeTypesUnderAllResults = {\r
- // SlcTypes.SLC_TEST_RESULT, NodeType.NT_UNSTRUCTURED };\r
- //\r
- // private boolean isResultFolder = false;\r
-\r
- // /**\r
- // * To be overridden to adapt size of form and result frames.\r
- // */\r
- // protected int[] getWeights() {\r
- // return new int[] { 70, 30 };\r
- // }\r
-\r
private void initialize() {\r
try {\r
templatesParentNode = session\r
public void createPartControl(Composite parent) {\r
initialize();\r
\r
- resultTreeViewer = createResultsTreeViewer(parent);\r
- resultTreeViewer.setInput(initializeResultTree());\r
+ envTreeViewer = createResultsTreeViewer(parent);\r
+ envTreeViewer.setInput(initializeResultTree());\r
\r
// parent.setLayout(new FillLayout());\r
// // Main layout\r
ObservationManager observationManager = session.getWorkspace()\r
.getObservationManager();\r
\r
- allResultsObserver = new AllResultsObserver(viewer.getTree()\r
+ akbNodesObserver = new AkbNodesObserver(viewer.getTree()\r
.getDisplay());\r
-\r
- // observe tree changes under All results\r
- observationManager.addEventListener(allResultsObserver,\r
+ observationManager.addEventListener(akbNodesObserver,\r
Event.NODE_ADDED | Event.NODE_REMOVED,\r
templatesParentNode.getPath(), true, null,\r
- observedNodeTypesUnderAllResults, false);\r
+ observedNodeTypes, false);\r
} catch (RepositoryException e) {\r
throw new AkbException("Cannot register listeners", e);\r
}\r
-\r
- // add change listener to display TestResult information in the property\r
- // viewer\r
- // viewer.addSelectionChangedListener(new MySelectionChangedListener());\r
return viewer;\r
}\r
\r
- class AllResultsObserver extends AsyncUiEventListener {\r
-\r
- public AllResultsObserver(Display display) {\r
- super(display);\r
- }\r
-\r
- @Override\r
- protected Boolean willProcessInUiThread(List<Event> events)\r
- throws RepositoryException {\r
- // unfiltered for the time being\r
- return true;\r
- }\r
-\r
- protected void onEventInUiThread(List<Event> events)\r
- throws RepositoryException {\r
- boolean fullRefresh = false;\r
-\r
- eventLoop: for (Event event : events) {\r
- String currPath = event.getPath();\r
- if (session.nodeExists(currPath)) {\r
- Node node = session.getNode(currPath);\r
- if (node.isNodeType(AkbTypes.AKB_ENV_TEMPLATE)) {\r
- fullRefresh = true;\r
- break eventLoop;\r
- }\r
- }\r
- }\r
-\r
- Object[] visibles = resultTreeViewer.getExpandedElements();\r
- if (fullRefresh)\r
- resultTreeViewer.setInput(initializeResultTree());\r
- else\r
- resultTreeViewer.refresh();\r
-\r
- resultTreeViewer.setExpandedElements(visibles);\r
- }\r
- }\r
-\r
- // Detailed property viewer\r
- // protected TableViewer createPropertiesViewer(Composite parent) {\r
- // }\r
-\r
@Override\r
public void setFocus() {\r
}\r
try {\r
NodeIterator ni = templatesParentNode.getNodes();\r
List<Node> templates = new ArrayList<Node>();\r
-\r
while (ni.hasNext()) {\r
Node currNode = ni.nextNode();\r
if (currNode.isNodeType(AkbTypes.AKB_ENV_TEMPLATE))\r
templates.add(currNode);\r
}\r
-\r
Node[] templateArr = templates.toArray(new Node[templates.size()]);\r
return templateArr;\r
} catch (RepositoryException re) {\r
}\r
}\r
\r
- // Manage context menu\r
+ @Override\r
+ public void forceRefresh(Object object) {\r
+ envTreeViewer.setInput(initializeResultTree());\r
+ }\r
+\r
+ // ///////////////////////////\r
+ // CONTEXT MENU MANAGEMENT\r
+\r
/**\r
* Defines the commands that will pop up in the context menu.\r
**/\r
try {\r
\r
// Build conditions\r
- Node selected = (Node) ((IStructuredSelection) resultTreeViewer\r
- .getSelection()).getFirstElement();\r
+ IStructuredSelection selection = (IStructuredSelection) envTreeViewer\r
+ .getSelection();\r
+\r
+ Node selected = (Node) selection.getFirstElement();\r
\r
boolean hasSelection = selected != null;\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 ? !(selected.getParent()\r
- .isNodeType(AkbTypes.AKB_ENV_TEMPLATE)) : 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)\r
+ if (hasSelection && isTemplate)\r
params.put(OpenAkbNodeEditor.PARAM_PARENT_NODE_JCR_ID,\r
selected.getIdentifier());\r
params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
AkbTypes.AKB_CONNECTOR_ALIAS);\r
- refreshParameterizedCommand(menuManager, window,\r
- "cmd.addConnector", OpenAkbNodeEditor.ID,\r
- "Add connector Alias", null, isParentConnectorsFolder,\r
- params);\r
\r
- // Add Item\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_NODE_TYPE, AkbTypes.AKB_ITEM);\r
- refreshParameterizedCommand(menuManager, window, "cmd.addItem",\r
- OpenAkbNodeEditor.ID, "Add item", null,\r
- isParentItemsFolder, params);\r
+ refreshItemsSubmenu(menuManager, window, "menu.itemsSubmenu",\r
+ "Add Item", isParentItemsFolder || isTemplate, params);\r
\r
// Add Item Folder\r
params = new HashMap<String, String>();\r
selected.getIdentifier());\r
params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
AkbTypes.AKB_ITEM_FOLDER);\r
- refreshParameterizedCommand(menuManager, window,\r
+ AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
"cmd.addItemFolder", OpenAkbNodeEditor.ID,\r
- "Add item folder", null, isParentItemsFolder, params);\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
- refreshParameterizedCommand(menuManager, window, "cmd.deleteItem",\r
- DeleteAkbNodes.ID, "Delete selected item(s)", null,\r
- isDeletable, params);\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
templatesParentNode.getIdentifier());\r
params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE,\r
AkbTypes.AKB_ENV_TEMPLATE);\r
- refreshParameterizedCommand(menuManager, window,\r
+ AkbUiUtils.refreshParameterizedCommand(menuManager, window,\r
"cmd.createTemplate", OpenAkbNodeEditor.ID,\r
- "Create new template...", null, true, params);\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
- * Commodities the refresh of a single command with a map of parameters in a\r
- * Menu.aboutToShow method to simplify further development\r
+ * \r
+ * refreshes submenu with various connector types\r
* \r
* @param menuManager\r
* @param locator\r
- * @param cmdId\r
+ * @param itemId\r
* @param label\r
- * @param iconPath\r
- * @param showCommand\r
+ * @param isVisible\r
+ * @param params\r
*/\r
- private void refreshParameterizedCommand(IMenuManager menuManager,\r
- IServiceLocator locator, String itemId, String cmdId, String label,\r
- ImageDescriptor icon, boolean showCommand,\r
- Map<String, String> params) {\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
- CommandContributionItemParameter contributionItemParameter = new CommandContributionItemParameter(\r
- locator, itemId, cmdId, SWT.PUSH);\r
\r
- if (showCommand) {\r
- // Set Params\r
- contributionItemParameter.label = label;\r
- contributionItemParameter.icon = icon;\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
- if (params != null)\r
- contributionItemParameter.parameters = params;\r
+ // clean\r
+ IContributionItem ici = menuManager.find(itemId);\r
+ if (ici != null)\r
+ menuManager.remove(ici);\r
\r
- CommandContributionItem cci = new CommandContributionItem(\r
- contributionItemParameter);\r
- menuManager.add(cci);\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
+ // private class MyCompoundCI extends CompoundContributionItem {\r
+ // private IMenuManager menuManager;\r
+ // private IServiceLocator locator;\r
+ //\r
+ // public MyCompoundCI(IMenuManager menuManager, IServiceLocator locator,\r
+ // String itemId) {\r
+ // super(itemId);\r
+ // this.menuManager = menuManager;\r
+ // this.locator = locator;\r
+ // }\r
+ //\r
+ // @Override\r
+ // protected IContributionItem[] getContributionItems() {\r
+ //\r
+ // CommandContributionItem[] submenu = new CommandContributionItem[2];\r
+ // submenu[0] = createContributionItem(menuManager, locator, "uid.1",\r
+ // OpenAkbNodeEditor.ID, "test1" + System.currentTimeMillis(),\r
+ // null, null);\r
+ // submenu[1] = createContributionItem(menuManager, locator, "uid.2",\r
+ // OpenAkbNodeEditor.ID, "test2", null, null);\r
+ // return submenu;\r
+ // }\r
+ // }\r
+\r
/* INNER CLASSES */\r
+ private class AkbNodesObserver extends AsyncUiEventListener {\r
+\r
+ public AkbNodesObserver(Display display) {\r
+ super(display);\r
+ }\r
+\r
+ @Override\r
+ protected Boolean willProcessInUiThread(List<Event> events)\r
+ throws RepositoryException {\r
+ // unfiltered for the time being\r
+ return true;\r
+ }\r
+\r
+ protected void onEventInUiThread(List<Event> events)\r
+ throws RepositoryException {\r
+ boolean fullRefresh = false;\r
+\r
+ eventLoop: for (Event event : events) {\r
+ String currPath = event.getPath();\r
+ if (session.nodeExists(currPath)) {\r
+ Node node = session.getNode(currPath);\r
+ if (node.isNodeType(AkbTypes.AKB_ENV_TEMPLATE)) {\r
+ fullRefresh = true;\r
+ break eventLoop;\r
+ }\r
+ }\r
+ }\r
+\r
+ Object[] visibles = envTreeViewer.getExpandedElements();\r
+ if (fullRefresh)\r
+ envTreeViewer.setInput(initializeResultTree());\r
+ else\r
+ envTreeViewer.refresh();\r
+\r
+ envTreeViewer.setExpandedElements(visibles);\r
+ }\r
+ }\r
+\r
class ViewDoubleClickListener implements IDoubleClickListener {\r
public void doubleClick(DoubleClickEvent evt) {\r
Object obj = ((IStructuredSelection) evt.getSelection())\r
/* CONNECTOR PROPERTIES */
public final static String AKB_CONNECTOR_URL = "akb:connectorUrl";
+ public final static String AKB_CONNECTOR_ALIAS_NAME = "akb:connectorName";
public final static String AKB_CONNECTOR_USER = "akb:connectorUser";
+ // Alias specific
+ public final static String AKB_DEFAULT_TEST_CONNECTOR = "defaultTestConnector";
+ public final static String AKB_CONNECTOR_TYPE = "akb:connectorType";
/* ITEMS PROPERTIES */
public final static String AKB_USED_CONNECTOR = "akb:usedConnector";
import java.sql.PreparedStatement;
import javax.jcr.Node;
+import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
/** Provides method interfaces to manage an AKB repository */
public interface AkbService {
- /** Creates a preconfigured AKB Template */
+ /** Creates a pre-configured AKB Template */
public Node createAkbTemplate(Node parent, String name)
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;
+
+ /**
+ * @param templateNode
+ * @param connectorType
+ * if null, returns all defined connector for this template
+ * @return
+ * @throws RepositoryException
+ */
+ public NodeIterator getDefinedAliases(Node templateNode,
+ String connectorType) throws RepositoryException;
+
+ /**
+ * @param envNode
+ * an environment or a template
+ * @param aliasName
+ * the alias of the node to get
+ * @return
+ * @throws RepositoryException
+ */
+ public Node getConnectorByAlias(Node envNode, String aliasName)
+ throws RepositoryException;
+
/**
* Shortcut to perform whatever test on a given connector only to check if
* URL is correctly defined, if the target system is there and if the
* current user has the sufficient credentials to connect
+ *
+ * If no active environment is defined, try to
*/
public boolean testConnector(Node connector);
- public PreparedStatement prepareJdbcQuery(Node node);
+ /**
+ * If no active environment is defined, tries to execute query with default
+ * connector defined for the template
+ */
+ public PreparedStatement prepareJdbcQuery(Node activeEnvironment, Node node);
- public String executeCommand(Node node);
+ public String executeCommand(Node activeEnvironment, Node node);
- public String retrieveFile(Node node);
-}
+ public String retrieveFile(Node activeEnvironment, Node node);
+}
\ No newline at end of file
public final static String AKB_ENV = "akb:env";
// Connectors
-
public final static String AKB_CONNECTOR_FOLDER = "akb:connectorFolder";
public final static String AKB_CONNECTOR = "akb:connector";
public final static String AKB_CONNECTOR_ALIAS = "akb:connectorAlias";
import javax.annotation.Resource;
import javax.jcr.Node;
+import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
+import javax.jcr.query.QueryManager;
+import javax.jcr.query.QueryResult;
+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.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
public Node createAkbTemplate(Node parentNode, String name)
throws RepositoryException {
String connectorParentName = "Connectors";
- String itemsParentName = "Items";
Node newTemplate = parentNode.addNode(name, AkbTypes.AKB_ENV_TEMPLATE);
newTemplate.setProperty(Property.JCR_TITLE, name);
AkbTypes.AKB_CONNECTOR_FOLDER, AkbTypes.AKB_CONNECTOR_FOLDER);
connectorParent.setProperty(Property.JCR_TITLE, connectorParentName);
- Node itemsParent = newTemplate.addNode(AkbTypes.AKB_ITEM_FOLDER,
- AkbTypes.AKB_ITEM_FOLDER);
- itemsParent.setProperty(Property.JCR_TITLE, itemsParentName);
-
return newTemplate;
}
// ///////////////////////////////////////
// / CONNECTORS
+ @Override
+ public Node createConnectorAlias(Node templateNode, String name,
+ String connectorType) throws RepositoryException {
+ Node parent = JcrUtils.mkdirs(templateNode,
+ AkbTypes.AKB_CONNECTOR_FOLDER, AkbTypes.AKB_CONNECTOR_FOLDER);
+ Node newConnector = parent.addNode(name, AkbTypes.AKB_CONNECTOR_ALIAS);
+ newConnector.setProperty(Property.JCR_TITLE, name);
+ newConnector.setProperty(AkbNames.AKB_CONNECTOR_TYPE, connectorType);
+
+ // Node defaultConnector =
+ Node defaultConn = newConnector.addNode(
+ AkbNames.AKB_DEFAULT_TEST_CONNECTOR, connectorType);
+ defaultConn.setProperty(AkbNames.AKB_CONNECTOR_ALIAS_NAME, name);
+ return newConnector;
+ }
+
+ @Override
+ public NodeIterator getDefinedAliases(Node itemTemplate,
+ String connectorType) throws RepositoryException {
+ 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);
+ Constraint defaultC = factory.descendantNode(
+ source.getSelectorName(), itemTemplate.getPath());
+
+ if (connectorType != null) {
+ Constraint connType = factory.comparison(factory.propertyValue(
+ source.getSelectorName(), AkbNames.AKB_CONNECTOR_TYPE),
+ QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO,
+ factory.literal(session.getValueFactory().createValue(
+ connectorType)));
+ defaultC = factory.and(defaultC, connType);
+ }
+
+ // 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, defaultC,
+ new Ordering[] { order }, null);
+ QueryResult result = query.execute();
+ return result.getNodes();
+ } catch (RepositoryException e) {
+ throw new AkbException("Unable to list connector", e);
+ }
+ }
+
+ @Override
+ public Node getConnectorByAlias(Node envNode, String aliasName)
+ throws RepositoryException {
+ try {
+ Session session = envNode.getSession();
+ QueryManager queryManager = session.getWorkspace()
+ .getQueryManager();
+ QueryObjectModelFactory factory = queryManager.getQOMFactory();
+
+ Selector source = factory.selector(AkbTypes.AKB_CONNECTOR,
+ AkbTypes.AKB_CONNECTOR);
+ Constraint defaultC = factory.descendantNode(
+ source.getSelectorName(), envNode.getPath());
+
+ Constraint connType = factory.comparison(
+ factory.propertyValue(source.getSelectorName(),
+ AkbNames.AKB_CONNECTOR_ALIAS_NAME),
+ QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO, factory
+ .literal(session.getValueFactory().createValue(
+ aliasName)));
+ defaultC = factory.and(defaultC, connType);
+
+ QueryObjectModel query;
+ query = factory.createQuery(source, defaultC, null, null);
+ QueryResult result = query.execute();
+ NodeIterator ni = result.getNodes();
+
+ if (!ni.hasNext())
+ return null;
+ else {
+ Node connector = ni.nextNode();
+ if (ni.hasNext())
+ throw new AkbException("More than one alias with name "
+ + aliasName + " has been defined for environment "
+ + envNode);
+ else
+ return connector;
+ }
+ } catch (RepositoryException e) {
+ throw new AkbException("Unable to get connector " + aliasName
+ + " in " + envNode, e);
+ }
+ }
+
+ @Override
public boolean testConnector(Node connectorNode) {
try {
if (connectorNode.isNodeType(AkbTypes.AKB_JDBC_CONNECTOR)) {
* Opens a new connection each time. All resources must be cleaned by
* caller.
*/
- public PreparedStatement prepareJdbcQuery(Node node) {
+ public PreparedStatement prepareJdbcQuery(Node activeEnv, Node node) {
PreparedStatement statement = null;
try {
+
if (node.isNodeType(AkbTypes.AKB_JDBC_QUERY)) {
- String sqlQuery = node.getProperty(AKB_QUERY_TEXT).getString();
-
String connectorPath = node.getProperty(AKB_USED_CONNECTOR)
.getString();
Node connectorNode = node.getSession().getNode(connectorPath);
+
+ if (activeEnv != null){
+ String aliasName = connectorNode.getProperty(Property.JCR_TITLE).getString();
+ connectorNode = getConnectorByAlias(activeEnv, aliasName);
+ }
+
+ String sqlQuery = node.getProperty(AKB_QUERY_TEXT).getString();
+
String connectorUrl = connectorNode.getProperty(
AKB_CONNECTOR_URL).getString();
String connectorUser = connectorNode.getProperty(
}
}
- public String executeCommand(Node node) {
+ public String executeCommand(Node activeEnv, Node node) {
try {
String command = node.getProperty(AkbNames.AKB_COMMAND_TEXT)
.getString();
}
- public String retrieveFile(Node node) {
+ public String retrieveFile(Node activeEnv, Node node) {
try {
String filePath = node.getProperty(AkbNames.AKB_FILE_PATH)
.getString();
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;
import org.argeo.slc.akb.AkbException;
+import org.argeo.slc.akb.AkbNames;
import org.argeo.slc.akb.AkbTypes;
/** Some static utils methods that might be factorized in a near future */
/**
* 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();
- String nodeType = getAliasTypeForNode(itemTemplate);
- Selector source = factory.selector(nodeType, nodeType);
+ 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
.ascending(factory.upperCase(factory.propertyValue(
source.getSelectorName(), Property.JCR_TITLE)));
QueryObjectModel query;
- query = factory.createQuery(source, defaultC,
- new Ordering[] { order }, null);
+ query = factory.createQuery(source,
+ factory.and(defaultC, connType), new Ordering[] { order },
+ null);
QueryResult result = query.execute();
NodeIterator ni = result.getNodes();
}
}
+ /**
+ * Return current template depending on the passed node
+ */
+ public static Node getCurrentTemplate(Node akbNode) {
+ try {
+ if (akbNode.getDepth() == 0)
+ // no base path for root node
+ return null;
+ Node parNode = akbNode.getParent();
+
+ while (parNode != null)
+ if (akbNode.isNodeType(AkbTypes.AKB_ENV_TEMPLATE))
+ return akbNode;
+ else if (parNode.getDepth() == 0)
+ // we found not fitting node
+ return null;
+ else {
+ akbNode = parNode;
+ parNode = parNode.getParent();
+ }
+ return null;
+ } catch (RepositoryException re) {
+ throw new AkbException("Unable to find template for node "
+ + akbNode, re);
+ }
+ }
+
/**
* Return the current env base path
*/
// GENERIC TYPE FOR A CONNECTOR
[akb:connector] > nt:unstructured, mix:title
- akb:connectorUrl (STRING)
+// the name of the corresponding alias. We assume it is unique.
+- akb:connectorName (STRING)
+
// add argeo keyring
// ease retrieval and enable adding alias specific properties
-[akb:connectorAlias] > akb:connector
-// Use akb:connectorUrl property to define default test connector
-
+[akb:connectorAlias] > nt:unstructured, mix:title
++ defaultTestConnector (akb:connector)
+- akb:connectorType (STRING)
// HELPER
[akb:connectorFolder] > nt:unstructured, mix:title
+ * (akb:connector, akb:connectorAlias) *
-
-// Various connector types as mixin
-[akb:sshConnector]
-mixin
+// Various connectors
+[akb:sshConnector] > akb:connector
-[akb:jdbcConnector]
-mixin
-[akb:jcrConnector]
-mixin
+[akb:jdbcConnector] > akb:connector
+
+
+[akb:jcrConnector] > akb:connector
projects / gpl / argeo-slc.git / commitdiff
