import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
+import java.util.UUID;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
+import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
import javax.jcr.observation.Event;
import javax.jcr.observation.EventIterator;
import javax.jcr.observation.ObservationManager;
import org.argeo.ArgeoException;
+import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.client.ui.SlcImages;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.layout.RowData;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
public class ProcessBuilderPage extends FormPage implements SlcNames, SlcTypes {
public final static String ID = "processBuilderPage";
- //private final static Log log = LogFactory.getLog(ProcessBuilderPage.class);
+ // private final static Log log =
+ // LogFactory.getLog(ProcessBuilderPage.class);
private Node processNode;
private TreeViewer flowsViewer;
- private Label status;
+ private Label statusLabel;
+ private Button run;
+ private Button remove;
+ private Button clear;
private AbstractFormPart formPart;
- private StatusObserver statusObserver;
+ private EventListener statusObserver;
public ProcessBuilderPage(ProcessEditor editor, Node processNode) {
super(editor, ID, "Definition");
this.processNode = processNode;
-
}
@Override
};
getManagedForm().addPart(formPart);
- if (getProcessStatus().equals(ExecutionProcess.UNINITIALIZED))
- formPart.markDirty();
// observation
- statusObserver = new StatusObserver();
+ statusObserver = new AsyncUiEventListener() {
+ protected void onEventInUiThread(EventIterator events) {
+ statusChanged();
+ }
+ };
ObservationManager observationManager = processNode.getSession()
.getWorkspace().getObservationManager();
observationManager.addEventListener(statusObserver,
controls.setLayout(new RowLayout());
controls.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
- Button run = tk.createButton(controls, null, SWT.PUSH);
+ run = tk.createButton(controls, null, SWT.PUSH);
run.setToolTipText("Run");
run.setImage(SlcImages.LAUNCH);
run.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
- ((ProcessEditor) getEditor()).process();
+ if (isFinished(getProcessStatus())) {
+ relaunch();
+ } else {
+ ((ProcessEditor) getEditor()).process();
+ }
}
public void widgetDefaultSelected(SelectionEvent e) {
}
});
- Button remove = tk.createButton(controls, null, SWT.PUSH);
+ remove = tk.createButton(controls, null, SWT.PUSH);
remove.setImage(SlcImages.REMOVE_ONE);
remove.setToolTipText("Remove selected flows");
remove.addSelectionListener(new SelectionListener() {
}
});
- Button clear = tk.createButton(controls, null, SWT.PUSH);
+ clear = tk.createButton(controls, null, SWT.PUSH);
clear.setImage(SlcImages.REMOVE_ALL);
clear.setToolTipText("Clear all flows");
clear.addSelectionListener(new SelectionListener() {
}
});
- status = tk.createLabel(controls, getProcessStatus());
+ Composite statusComposite = tk.createComposite(controls);
+ RowData rowData = new RowData();
+ rowData.width = 100;
+ rowData.height = 16;
+ statusComposite.setLayoutData(rowData);
+ statusComposite.setLayout(new FillLayout());
+ statusLabel = tk.createLabel(statusComposite, getProcessStatus());
+
+ // make sure all controls are in line with status
+ statusChanged();
+ }
+
+ protected void relaunch() {
+ try {
+ Node duplicatedNode = duplicateProcess();
+ PlatformUI
+ .getWorkbench()
+ .getActiveWorkbenchWindow()
+ .getActivePage()
+ .openEditor(
+ new ProcessEditorInput(duplicatedNode.getPath()),
+ ProcessEditor.ID);
+ getEditor().close(false);
+ } catch (Exception e1) {
+ throw new SlcException("Cannot relaunch " + processNode, e1);
+ }
+ }
+
+ protected Node duplicateProcess() {
+ try {
+ Session session = processNode.getSession();
+ String uuid = UUID.randomUUID().toString();
+ String destPath = SlcJcrUtils.createExecutionProcessPath(uuid);
+ Node newNode = JcrUtils.mkdirs(session, destPath, SLC_PROCESS);
+ JcrUtils.copy(processNode, newNode);
+// session.getWorkspace().copy(processNode.getPath(), destPath);
+// Node newNode = session.getNode(destPath);
+ // make sure that we kept the mixins
+// newNode.addMixin(NodeType.MIX_CREATED);
+// newNode.addMixin(NodeType.MIX_LAST_MODIFIED);
+ newNode.setProperty(SLC_UUID, uuid);
+ newNode.setProperty(SLC_STATUS, ExecutionProcess.INITIALIZED);
+ session.save();
+ return newNode;
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot duplicate process", e);
+ }
}
protected String getProcessStatus() {
}
}
+ protected void statusChanged() {
+ String status = getProcessStatus();
+ statusLabel.setText(status);
+ Boolean isEditable = isEditable(status);
+ run.setEnabled(isEditable);
+ remove.setEnabled(isEditable);
+ clear.setEnabled(isEditable);
+ // flowsViewer.getTree().setEnabled(isEditable);
+ if (status.equals(ExecutionProcess.COMPLETED)
+ || status.equals(ExecutionProcess.ERROR)) {
+ run.setEnabled(true);
+ run.setImage(SlcImages.RELAUNCH);
+ run.setToolTipText("Relaunch");
+ }
+ }
+
+ /** Optimization so that we don't call the node each time */
+ protected Boolean isEditable(String status) {
+ return status.equals(ExecutionProcess.NEW)
+ || status.equals(ExecutionProcess.INITIALIZED);
+ }
+
+ protected Boolean isFinished(String status) {
+ return status.equals(ExecutionProcess.COMPLETED)
+ || status.equals(ExecutionProcess.ERROR);
+ }
+
protected void createBuilder(Composite parent) {
FormToolkit tk = getManagedForm().getToolkit();
SashForm sashForm = new SashForm(parent, SWT.HORIZONTAL);
}
public void commit(Boolean onSave) {
+ if (onSave)
+ statusLabel.setText(getProcessStatus());
formPart.commit(onSave);
}
- @Override
- public void setFocus() {
- flowsViewer.getTree().setFocus();
- }
-
@Override
public void dispose() {
JcrUtils.unregisterQuietly(processNode, statusObserver);
@Override
public boolean validateDrop(Object target, int operation,
TransferData transferType) {
- return true;
+ return isEditable(getProcessStatus());
}
}
-
- class StatusObserver implements EventListener {
-
- public void onEvent(EventIterator events) {
- PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
- public void run() {
- status.setText(getProcessStatus());
- }
- });
- // flowsViewer.refresh();
- }
-
- }
}
package org.argeo.slc.client.ui.editors;
-import java.util.Calendar;
-import java.util.GregorianCalendar;
import java.util.UUID;
import javax.jcr.Node;
import org.argeo.slc.client.ui.ClientUiPlugin;
import org.argeo.slc.client.ui.controllers.ProcessController;
import org.argeo.slc.execution.ExecutionProcess;
-import org.argeo.slc.jcr.SlcJcrConstants;
+import org.argeo.slc.jcr.SlcJcrUtils;
import org.argeo.slc.jcr.SlcNames;
import org.argeo.slc.jcr.SlcTypes;
import org.eclipse.core.runtime.IProgressMonitor;
private ProcessBuilderPage builderPage;
private ProcessLogPage logPage;
-
+
@Override
public void init(IEditorSite site, IEditorInput input)
throws PartInitException {
protected Node newProcessNode(ProcessEditorInput pei)
throws RepositoryException {
- Calendar now = new GregorianCalendar();
String uuid = UUID.randomUUID().toString();
- String processPath = SlcJcrConstants.PROCESSES_BASE_PATH + '/'
- + JcrUtils.dateAsPath(now, true) + uuid;
+ String processPath = SlcJcrUtils.createExecutionProcessPath(uuid);
Node processNode = JcrUtils.mkdirs(session, processPath, SLC_PROCESS);
processNode.setProperty(SLC_UUID, uuid);
- processNode.setProperty(SLC_STATUS, ExecutionProcess.UNINITIALIZED);
+ processNode.setProperty(SLC_STATUS, ExecutionProcess.NEW);
Node processFlow = processNode.addNode(SLC_FLOW);
processFlow.addMixin(SLC_REALIZED_FLOW);
return processNode;
}
+ @Override
+ public boolean isDirty() {
+ if (getProcessStatus().equals(ExecutionProcess.NEW))
+ return true;
+ return super.isDirty();
+ }
+
+ protected String getProcessStatus() {
+ try {
+ return processNode.getProperty(SLC_STATUS).getString();
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot retrieve status for " + processNode,
+ e);
+ }
+ }
+
@Override
public void dispose() {
JcrUtils.logoutQuietly(session);
public void doSave(IProgressMonitor monitor) {
try {
String status = processNode.getProperty(SLC_STATUS).getString();
- if (status.equals(ExecutionProcess.UNINITIALIZED))
+ if (status.equals(ExecutionProcess.NEW))
processNode.setProperty(SLC_STATUS,
ExecutionProcess.INITIALIZED);
session.save();
builderPage.commit(true);
- firePropertyChange(PROP_DIRTY);
+ editorDirtyStateChanged();
} catch (RepositoryException e) {
throw new SlcException("Cannot save " + processNode, e);
} finally {
projects / gpl / argeo-slc.git / commitdiff
