import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
import java.util.List;
import java.util.Properties;
import java.util.UUID;
+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.EventIterator;
+import javax.jcr.observation.EventListener;
+
import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+import org.argeo.ArgeoException;
+import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
+import org.argeo.eclipse.ui.jcr.NodesWrapper;
+import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
+import org.argeo.eclipse.ui.jcr.WrappedNode;
import org.argeo.slc.SlcException;
-import org.argeo.slc.client.oxm.OxmInterface;
import org.argeo.slc.client.ui.ClientUiPlugin;
import org.argeo.slc.client.ui.controllers.ProcessController;
import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider;
import org.argeo.slc.client.ui.providers.ExecutionModulesContentProvider.FlowNode;
-import org.argeo.slc.execution.ExecutionModuleDescriptor;
+import org.argeo.slc.jcr.SlcJcrConstants;
+import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
import org.argeo.slc.process.RealizedFlow;
import org.argeo.slc.process.SlcExecution;
import org.eclipse.jface.viewers.DoubleClickEvent;
-import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
-import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.ui.ISharedImages;
-import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;
-public class JcrExecutionModulesView extends ViewPart {
+public class JcrExecutionModulesView extends ViewPart implements SlcTypes,
+ SlcNames {
private final static Log log = LogFactory
.getLog(JcrExecutionModulesView.class);
- public static final String ID = "org.argeo.slc.client.ui.executionModulesView";
+ public static final String ID = "org.argeo.slc.client.ui.jcrExecutionModulesView";
private TreeViewer viewer;
- // Ioc
- private IContentProvider contentProvider;
- private OxmInterface oxmBean;
+ private Session session;
+
private ProcessController processController;
public void createPartControl(Composite parent) {
viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
+
+ ViewContentProvider contentProvider = new ViewContentProvider(session);
+
viewer.setContentProvider(contentProvider);
viewer.setLabelProvider(new ViewLabelProvider());
viewer.setInput(getViewSite());
int operations = DND.DROP_COPY | DND.DROP_MOVE;
Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
viewer.addDragSupport(operations, tt, new ViewDragListener());
+
+ try {
+ session.getWorkspace()
+ .getObservationManager()
+ .addEventListener(
+ new VmAgentObserver(),
+ Event.NODE_ADDED | Event.NODE_REMOVED
+ | Event.NODE_MOVED,
+ SlcJcrConstants.VM_AGENT_FACTORY_PATH, true, null,
+ null, false);
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot add observer", e);
+ }
}
public void setFocus() {
viewer.setInput(getViewSite());
}
- class ViewLabelProvider extends LabelProvider implements
+ class ViewContentProvider extends SimpleNodeContentProvider {
+
+ public ViewContentProvider(Session session) {
+ super(session,
+ new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH });
+ }
+
+ @Override
+ protected Object[] getChildren(Node node) throws RepositoryException {
+ if (node.isNodeType(SlcTypes.SLC_AGENT_PROXY)) {
+ List<AgentNodesWrapper> wrappers = new ArrayList<AgentNodesWrapper>();
+ for (NodeIterator nit = node.getNodes(); nit.hasNext();) {
+ wrappers.add(new AgentNodesWrapper(nit.nextNode()));
+ }
+ return wrappers.toArray();
+ }
+ return super.getChildren(node);
+ }
+
+ @Override
+ protected Object[] sort(Object parent, Object[] children) {
+ Object[] sorted = new Object[children.length];
+ System.arraycopy(children, 0, sorted, 0, children.length);
+ Arrays.sort(sorted, new ViewComparator());
+ return sorted;
+ }
+ }
+
+ static class ViewComparator implements Comparator<Object> {
+
+ public int compare(Object o1, Object o2) {
+ try {
+ if (o1 instanceof Node && o2 instanceof Node) {
+ Node node1 = (Node) o1;
+ Node node2 = (Node) o2;
+ if (node1.isNodeType(SLC_EXECUTION_FLOW)
+ && node2.isNodeType(SLC_EXECUTION_FLOW)) {
+ return node1.getName().compareTo(node2.getName());
+ } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
+ && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
+ return 1;
+ } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
+ && node2.isNodeType(SLC_EXECUTION_FLOW)) {
+ return -1;
+ } else {
+ // TODO: check title
+ return node1.getName().compareTo(node2.getName());
+ }
+ }
+ } catch (RepositoryException e) {
+ throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
+ e);
+ }
+ return 0;
+ }
+
+ }
+
+ /** Wraps the execution modules of an agent. */
+ static class AgentNodesWrapper extends NodesWrapper {
+
+ public AgentNodesWrapper(Node node) {
+ super(node);
+ }
+
+ protected List<WrappedNode> getWrappedNodes()
+ throws RepositoryException {
+ List<WrappedNode> children = new ArrayList<WrappedNode>();
+ Node executionModules = getNode().getNode(
+ SlcNames.SLC_EXECUTION_MODULES);
+ for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
+ for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
+ .hasNext();) {
+ children.add(new WrappedNode(this, nitVersions.nextNode()));
+ }
+ }
+ return children;
+ }
+
+ }
+
+ class VmAgentObserver implements EventListener {
+
+ public void onEvent(EventIterator events) {
+ viewer.refresh();
+ }
+
+ }
+
+ class ViewLabelProvider extends DefaultNodeLabelProvider implements
ITableLabelProvider {
public String getColumnText(Object obj, int index) {
- if (obj instanceof ExecutionModulesContentProvider.ExecutionModuleNode) {
- ExecutionModuleDescriptor emd = ((ExecutionModulesContentProvider.ExecutionModuleNode) obj)
- .getDescriptor();
- if (emd.getLabel() != null) {
- return emd.getLabel();
- } else {
- return getText(emd);
- }
- } else
- return getText(obj);
+ return getText(obj);
}
public Image getColumnImage(Object obj, int index) {
return getImage(obj);
}
- public Image getImage(Object obj) {
- if (obj instanceof ExecutionModulesContentProvider.AgentNode)
+ public Image getImage(Node node) throws RepositoryException {
+ if (node.getParent().isNodeType(SlcTypes.SLC_AGENT_PROXY))
return ClientUiPlugin.getDefault().getImageRegistry()
.get("agent");
- else if (obj instanceof ExecutionModulesContentProvider.ExecutionModuleNode)
+ else if (node.isNodeType(SlcTypes.SLC_MODULE))
return ClientUiPlugin.getDefault().getImageRegistry()
.get("executionModule");
- else if (obj instanceof ExecutionModulesContentProvider.FolderNode)
- return ClientUiPlugin.getDefault().getImageRegistry()
- .get("folder");
- else if (obj instanceof ExecutionModulesContentProvider.FlowNode)
+ else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
return ClientUiPlugin.getDefault().getImageRegistry()
.get("flow");
else
- return PlatformUI.getWorkbench().getSharedImages()
- .getImage(ISharedImages.IMG_OBJ_ELEMENT);
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("folder");
}
}
realizedFlow.setExecutionSpec(fn.getExecutionFlowDescriptor()
.getExecutionSpec());
- props.setProperty("RealizedFlowAsXml",
- oxmBean.marshal(realizedFlow));
- System.out
- .println(oxmBean.marshal(fn.getExecutionFlowDescriptor()));
+ // props.setProperty("RealizedFlowAsXml",
+ // oxmBean.marshal(realizedFlow));
+ // System.out
+ // .println(oxmBean.marshal(fn.getExecutionFlowDescriptor()));
}
}
- // IoC
- public void setContentProvider(IContentProvider contentProvider) {
- this.contentProvider = contentProvider;
- }
-
public void setProcessController(ProcessController processController) {
this.processController = processController;
}
- public void setOxmBean(OxmInterface oxmBean) {
- this.oxmBean = oxmBean;
+ public void setSession(Session session) {
+ this.session = session;
}
}
\ No newline at end of file
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
-import javax.jcr.nodetype.NodeType;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.execution.ExecutionModulesListener;
import org.argeo.slc.jcr.SlcJcrConstants;
import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
import org.argeo.slc.runtime.SlcAgent;
/**
.getVersion()) ? moduleName.getNode(moduleDescriptor
.getVersion()) : moduleName.addNode(moduleDescriptor
.getVersion());
- moduleVersion.addMixin(NodeType.MIX_TITLE);
+ moduleVersion.addMixin(SlcTypes.SLC_MODULE);
+ moduleVersion.setProperty(SlcNames.SLC_NAME,
+ moduleDescriptor.getName());
+ moduleVersion.setProperty(SlcNames.SLC_VERSION,
+ moduleDescriptor.getVersion());
moduleVersion.setProperty(Property.JCR_TITLE,
moduleDescriptor.getTitle());
moduleVersion.setProperty(Property.JCR_DESCRIPTION,
ExecutionFlowDescriptor executionFlow) {
String path = getExecutionFlowPath(module, executionFlow);
try {
- Node flowNode;
+ Node flowNode = null;
if (!session.nodeExists(path)) {
Node base = session.getNode(getExecutionModulesPath());
Node moduleNode = base.getNode(module.getName() + '/'
flowNode = currNode.addNode(name);
}
}
+ flowNode.addMixin(SlcTypes.SLC_EXECUTION_FLOW);
+ flowNode.setProperty(SlcNames.SLC_NAME, executionFlow.getName());
session.save();
} else {
flowNode = session.getNode(path);
}
+
+ if (log.isTraceEnabled())
+ log.trace("Flow " + executionFlow + " added to JCR");
} catch (RepositoryException e) {
throw new SlcException("Cannot add flow " + executionFlow
+ " from module " + module, e);
projects / gpl / argeo-slc.git / commitdiff
