private Collection<KnowledgePackage> getProcessWorkItems() {
RuleFlowProcess process = new RuleFlowProcess();
process.setId("org.drools.test.TestProcess");
process.setName("TestProcess");
process.setPackageName("org.drools.test");
StartNode start = new StartNode();
start.setId(1);
start.setName("Start");
process.addNode(start);
ActionNode actionNode = new ActionNode();
actionNode.setId(2);
actionNode.setName("Action");
DroolsConsequenceAction action = new DroolsConsequenceAction();
action.setDialect("java");
action.setConsequence("System.out.println(\"Executed action\");");
actionNode.setAction(action);
process.addNode(actionNode);
new ConnectionImpl(
start, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
WorkItemNode workItemNode = new WorkItemNode();
workItemNode.setId(3);
workItemNode.setName("WorkItem1");
Work work = new WorkImpl();
work.setName("MyWork");
workItemNode.setWork(work);
process.addNode(workItemNode);
new ConnectionImpl(
actionNode, Node.CONNECTION_DEFAULT_TYPE, workItemNode, Node.CONNECTION_DEFAULT_TYPE);
WorkItemNode workItemNode2 = new WorkItemNode();
workItemNode2.setId(4);
workItemNode2.setName("WorkItem2");
work = new WorkImpl();
work.setName("MyWork");
workItemNode2.setWork(work);
process.addNode(workItemNode2);
new ConnectionImpl(
workItemNode, Node.CONNECTION_DEFAULT_TYPE, workItemNode2, Node.CONNECTION_DEFAULT_TYPE);
WorkItemNode workItemNode3 = new WorkItemNode();
workItemNode3.setId(5);
workItemNode3.setName("WorkItem3");
work = new WorkImpl();
work.setName("MyWork");
workItemNode3.setWork(work);
process.addNode(workItemNode3);
new ConnectionImpl(
workItemNode2, Node.CONNECTION_DEFAULT_TYPE, workItemNode3, Node.CONNECTION_DEFAULT_TYPE);
EndNode end = new EndNode();
end.setId(6);
end.setName("End");
process.addNode(end);
new ConnectionImpl(
workItemNode3, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE);
PackageBuilder packageBuilder = new PackageBuilder();
ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder);
processBuilder.buildProcess(process, null);
List<KnowledgePackage> list = new ArrayList<KnowledgePackage>();
list.add(new KnowledgePackageImp(packageBuilder.getPackage()));
return list;
}
public Object end(
final String uri, final String localName, final ExtensibleXmlParser xmlPackageReader)
throws SAXException {
final Element element = xmlPackageReader.endElementBuilder();
ActionNode actionNode = (ActionNode) xmlPackageReader.getCurrent();
String text = ((org.w3c.dom.Text) element.getChildNodes().item(0)).getWholeText();
DroolsConsequenceAction actionText =
new DroolsConsequenceAction("mvel", "list.add(\"" + text + "\")");
actionNode.setAction(actionText);
return actionNode;
}
@SuppressWarnings("unused")
private List<KnowledgePackage> getProcessTimer2() {
final RuleFlowProcess process = new RuleFlowProcess();
process.setId("org.drools.test.TestProcess");
process.setName("TestProcess");
process.setPackageName("org.drools.test");
final StartNode start = new StartNode();
start.setId(1);
start.setName("Start");
process.addNode(start);
final TimerNode timerNode = new TimerNode();
timerNode.setId(2);
timerNode.setName("Timer");
final Timer timer = new Timer();
timer.setDelay("0");
timerNode.setTimer(timer);
process.addNode(timerNode);
new ConnectionImpl(
start, Node.CONNECTION_DEFAULT_TYPE, timerNode, Node.CONNECTION_DEFAULT_TYPE);
final ActionNode actionNode = new ActionNode();
actionNode.setId(3);
actionNode.setName("Action");
final DroolsConsequenceAction action = new DroolsConsequenceAction();
action.setDialect("java");
action.setConsequence(
"try { Thread.sleep(1000); } catch (Throwable t) {} System.out.println(\"Executed action\");");
actionNode.setAction(action);
process.addNode(actionNode);
new ConnectionImpl(
timerNode, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
final EndNode end = new EndNode();
end.setId(6);
end.setName("End");
process.addNode(end);
new ConnectionImpl(actionNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE);
final PackageBuilder packageBuilder = new PackageBuilder();
final ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder);
processBuilder.buildProcess(process, null);
final List<KnowledgePackage> list = new ArrayList<KnowledgePackage>();
list.add(new KnowledgePackageImp(packageBuilder.getPackage()));
return list;
}
private List<KnowledgePackage> getProcessTimer() {
RuleFlowProcess process = new RuleFlowProcess();
process.setId("org.drools.test.TestProcess");
process.setName("TestProcess");
process.setPackageName("org.drools.test");
StartNode start = new StartNode();
start.setId(1);
start.setName("Start");
process.addNode(start);
TimerNode timerNode = new TimerNode();
timerNode.setId(2);
timerNode.setName("Timer");
Timer timer = new Timer();
timer.setDelay("2000");
timerNode.setTimer(timer);
process.addNode(timerNode);
new ConnectionImpl(
start, Node.CONNECTION_DEFAULT_TYPE, timerNode, Node.CONNECTION_DEFAULT_TYPE);
ActionNode actionNode = new ActionNode();
actionNode.setId(3);
actionNode.setName("Action");
DroolsConsequenceAction action = new DroolsConsequenceAction();
action.setDialect("java");
action.setConsequence("System.out.println(\"Executed action\");");
actionNode.setAction(action);
process.addNode(actionNode);
new ConnectionImpl(
timerNode, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
EndNode end = new EndNode();
end.setId(6);
end.setName("End");
process.addNode(end);
new ConnectionImpl(actionNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE);
PackageBuilder packageBuilder = new PackageBuilder();
ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder);
processBuilder.buildProcess(process, null);
List<KnowledgePackage> list = new ArrayList<KnowledgePackage>();
list.add(new KnowledgePackageImp(packageBuilder.getPackage()));
return list;
}
protected void handleNode(
final Node node,
final Element element,
final String uri,
final String localName,
final ExtensibleXmlParser parser)
throws SAXException {
super.handleNode(node, element, uri, localName, parser);
ActionNode actionNode = (ActionNode) node;
node.setMetaData("NodeType", "ScriptTask");
DroolsConsequenceAction action = (DroolsConsequenceAction) actionNode.getAction();
if (action == null) {
action = new DroolsConsequenceAction();
actionNode.setAction(action);
}
String language = element.getAttribute("scriptFormat");
if (XmlBPMNProcessDumper.JAVA_LANGUAGE.equals(language)) {
action.setDialect(JavaDialect.ID);
} else if (XmlBPMNProcessDumper.JAVASCRIPT_LANGUAGE.equals(language)) {
action.setDialect("JavaScript");
}
action.setConsequence("");
org.w3c.dom.Node xmlNode = element.getFirstChild();
while (xmlNode != null) {
if (xmlNode instanceof Element && "script".equals(xmlNode.getNodeName())) {
action.setConsequence(xmlNode.getTextContent());
}
xmlNode = xmlNode.getNextSibling();
}
String compensation = element.getAttribute("isForCompensation");
if (compensation != null) {
boolean isForCompensation = Boolean.parseBoolean(compensation);
if (isForCompensation) {
actionNode.setMetaData("isForCompensation", isForCompensation);
}
}
}
private Package getProcessSubProcess() {
RuleFlowProcess process = new RuleFlowProcess();
process.setId("org.drools.test.TestProcess");
process.setName("TestProcess");
process.setPackageName("org.drools.test");
StartNode start = new StartNode();
start.setId(1);
start.setName("Start");
process.addNode(start);
ActionNode actionNode = new ActionNode();
actionNode.setId(2);
actionNode.setName("Action");
DroolsConsequenceAction action = new DroolsConsequenceAction();
action.setDialect("java");
action.setConsequence("System.out.println(\"Executed action\");");
actionNode.setAction(action);
process.addNode(actionNode);
new ConnectionImpl(
start, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
SubProcessNode subProcessNode = new SubProcessNode();
subProcessNode.setId(3);
subProcessNode.setName("SubProcess");
subProcessNode.setProcessId("org.drools.test.SubProcess");
process.addNode(subProcessNode);
new ConnectionImpl(
actionNode, Node.CONNECTION_DEFAULT_TYPE, subProcessNode, Node.CONNECTION_DEFAULT_TYPE);
EndNode end = new EndNode();
end.setId(4);
end.setName("End");
process.addNode(end);
new ConnectionImpl(
subProcessNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE);
PackageBuilder packageBuilder = new PackageBuilder();
ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder);
processBuilder.buildProcess(process, null);
process = new RuleFlowProcess();
process.setId("org.drools.test.SubProcess");
process.setName("SubProcess");
process.setPackageName("org.drools.test");
start = new StartNode();
start.setId(1);
start.setName("Start");
process.addNode(start);
actionNode = new ActionNode();
actionNode.setId(2);
actionNode.setName("Action");
action = new DroolsConsequenceAction();
action.setDialect("java");
action.setConsequence("System.out.println(\"Executed action\");");
actionNode.setAction(action);
process.addNode(actionNode);
new ConnectionImpl(
start, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
WorkItemNode workItemNode = new WorkItemNode();
workItemNode.setId(3);
workItemNode.setName("WorkItem1");
Work work = new WorkImpl();
work.setName("MyWork");
workItemNode.setWork(work);
process.addNode(workItemNode);
new ConnectionImpl(
actionNode, Node.CONNECTION_DEFAULT_TYPE, workItemNode, Node.CONNECTION_DEFAULT_TYPE);
end = new EndNode();
end.setId(6);
end.setName("End");
process.addNode(end);
new ConnectionImpl(
workItemNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE);
processBuilder.buildProcess(process, null);
return packageBuilder.getPackage();
}
public void testEvent1() {
RuleFlowProcess process = new RuleFlowProcess();
process.setId("org.drools.process.event");
process.setName("Event Process");
List<Variable> variables = new ArrayList<Variable>();
Variable variable = new Variable();
variable.setName("event");
ObjectDataType personDataType = new ObjectDataType();
personDataType.setClassName("org.drools.Person");
variable.setType(personDataType);
variables.add(variable);
process.getVariableScope().setVariables(variables);
StartNode startNode = new StartNode();
startNode.setName("Start");
startNode.setId(1);
process.addNode(startNode);
MilestoneNode milestoneNode = new MilestoneNode();
milestoneNode.setName("Milestone");
milestoneNode.setConstraint("eval(false)");
milestoneNode.setId(2);
process.addNode(milestoneNode);
new ConnectionImpl(
startNode, Node.CONNECTION_DEFAULT_TYPE,
milestoneNode, Node.CONNECTION_DEFAULT_TYPE);
EventNode eventNode = new EventNode();
EventTypeFilter eventFilter = new EventTypeFilter();
eventFilter.setType("myEvent");
eventNode.addEventFilter(eventFilter);
eventNode.setVariableName("event");
eventNode.setId(3);
process.addNode(eventNode);
final List<String> myList = new ArrayList<String>();
ActionNode actionNode = new ActionNode();
actionNode.setName("Print");
DroolsAction action = new DroolsConsequenceAction("java", null);
action.setMetaData(
"Action",
new Action() {
public void execute(ProcessContext context) throws Exception {
System.out.println(
"Detected event for person " + ((Person) context.getVariable("event")).getName());
myList.add("Executed action");
}
});
actionNode.setAction(action);
actionNode.setId(4);
process.addNode(actionNode);
new ConnectionImpl(
eventNode, Node.CONNECTION_DEFAULT_TYPE,
actionNode, Node.CONNECTION_DEFAULT_TYPE);
Join join = new Join();
join.setName("XOR Join");
join.setType(Join.TYPE_XOR);
join.setId(5);
process.addNode(join);
new ConnectionImpl(
milestoneNode, Node.CONNECTION_DEFAULT_TYPE,
join, Node.CONNECTION_DEFAULT_TYPE);
new ConnectionImpl(
actionNode, Node.CONNECTION_DEFAULT_TYPE,
join, Node.CONNECTION_DEFAULT_TYPE);
EndNode endNode = new EndNode();
endNode.setName("EndNode");
endNode.setId(6);
process.addNode(endNode);
new ConnectionImpl(
join, Node.CONNECTION_DEFAULT_TYPE,
endNode, Node.CONNECTION_DEFAULT_TYPE);
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
((AbstractRuleBase) ((InternalKnowledgeBase) kbase).getRuleBase()).addProcess(process);
StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
ProcessInstance processInstance = ksession.startProcess("org.drools.process.event");
assertEquals(0, myList.size());
Person jack = new Person();
jack.setName("Jack");
processInstance.signalEvent("myEvent", jack);
assertEquals(1, myList.size());
assertEquals(ProcessInstance.STATE_COMPLETED, processInstance.getState());
}
@Test
public void testProcessEventListener() throws Exception {
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
// create a simple package with one process to test the events
final InternalKnowledgePackage pkg = new KnowledgePackageImpl("org.drools.test");
RuleFlowProcess process = new RuleFlowProcess();
process.setId("org.drools.core.process.event");
process.setName("Event Process");
StartNode startNode = new StartNode();
startNode.setName("Start");
startNode.setId(1);
process.addNode(startNode);
ActionNode actionNode = new ActionNode();
actionNode.setName("Print");
DroolsAction action = new DroolsConsequenceAction("java", null);
action.setMetaData(
"Action",
new Action() {
public void execute(ProcessContext context) throws Exception {
logger.info("Executed action");
}
});
actionNode.setAction(action);
actionNode.setId(2);
process.addNode(actionNode);
new ConnectionImpl(
startNode, Node.CONNECTION_DEFAULT_TYPE,
actionNode, Node.CONNECTION_DEFAULT_TYPE);
EndNode endNode = new EndNode();
endNode.setName("End");
endNode.setId(3);
process.addNode(endNode);
new ConnectionImpl(
actionNode, Node.CONNECTION_DEFAULT_TYPE,
endNode, Node.CONNECTION_DEFAULT_TYPE);
pkg.addProcess(process);
List<KnowledgePackage> pkgs = new ArrayList<KnowledgePackage>();
pkgs.add(pkg);
kbase.addKnowledgePackages(pkgs);
StatefulKnowledgeSession session = kbase.newStatefulKnowledgeSession();
final List<ProcessEvent> processEventList = new ArrayList<ProcessEvent>();
final ProcessEventListener processEventListener =
new ProcessEventListener() {
public void afterNodeLeft(ProcessNodeLeftEvent event) {
processEventList.add(event);
}
public void afterNodeTriggered(ProcessNodeTriggeredEvent event) {
processEventList.add(event);
}
public void afterProcessCompleted(ProcessCompletedEvent event) {
processEventList.add(event);
}
public void afterProcessStarted(ProcessStartedEvent event) {
processEventList.add(event);
}
public void beforeNodeLeft(ProcessNodeLeftEvent event) {
processEventList.add(event);
}
public void beforeNodeTriggered(ProcessNodeTriggeredEvent event) {
processEventList.add(event);
}
public void beforeProcessCompleted(ProcessCompletedEvent event) {
processEventList.add(event);
}
public void beforeProcessStarted(ProcessStartedEvent event) {
processEventList.add(event);
}
public void beforeVariableChanged(ProcessVariableChangedEvent event) {
processEventList.add(event);
}
public void afterVariableChanged(ProcessVariableChangedEvent event) {
processEventList.add(event);
}
};
session.addEventListener(processEventListener);
// execute the process
session.startProcess("org.drools.core.process.event");
assertEquals(16, processEventList.size());
assertEquals(
"org.drools.core.process.event",
((ProcessStartedEvent) processEventList.get(0)).getProcessInstance().getProcessId());
assertEquals(
"Start",
((ProcessNodeTriggeredEvent) processEventList.get(1)).getNodeInstance().getNodeName());
assertEquals(
"Start", ((ProcessNodeLeftEvent) processEventList.get(2)).getNodeInstance().getNodeName());
assertEquals(
"Print",
((ProcessNodeTriggeredEvent) processEventList.get(3)).getNodeInstance().getNodeName());
assertEquals(
"Print", ((ProcessNodeLeftEvent) processEventList.get(4)).getNodeInstance().getNodeName());
assertEquals(
"End",
((ProcessNodeTriggeredEvent) processEventList.get(5)).getNodeInstance().getNodeName());
assertEquals(
"End", ((ProcessNodeLeftEvent) processEventList.get(6)).getNodeInstance().getNodeName());
assertEquals(
"org.drools.core.process.event",
((ProcessCompletedEvent) processEventList.get(7)).getProcessInstance().getProcessId());
assertEquals(
"org.drools.core.process.event",
((ProcessCompletedEvent) processEventList.get(8)).getProcessInstance().getProcessId());
assertEquals(
"End", ((ProcessNodeLeftEvent) processEventList.get(9)).getNodeInstance().getNodeName());
assertEquals(
"End",
((ProcessNodeTriggeredEvent) processEventList.get(10)).getNodeInstance().getNodeName());
assertEquals(
"Print", ((ProcessNodeLeftEvent) processEventList.get(11)).getNodeInstance().getNodeName());
assertEquals(
"Print",
((ProcessNodeTriggeredEvent) processEventList.get(12)).getNodeInstance().getNodeName());
assertEquals(
"Start", ((ProcessNodeLeftEvent) processEventList.get(13)).getNodeInstance().getNodeName());
assertEquals(
"Start",
((ProcessNodeTriggeredEvent) processEventList.get(14)).getNodeInstance().getNodeName());
assertEquals(
"org.drools.core.process.event",
((ProcessStartedEvent) processEventList.get(15)).getProcessInstance().getProcessId());
}
public void testPersistenceOfFullNodes() throws Exception {
RuleFlowProcess process =
new RuleFlowProcess() {
private static final long serialVersionUID = 510l;
int id = 0;
public void addNode(org.kie.definition.process.Node node) {
((Node) node).setId(++id);
super.addNode(node);
}
};
process.setMetaData("routerLayout", 1);
List<String> imports = new ArrayList<String>();
imports.add("import1");
imports.add("import2");
process.setImports(imports);
Map<String, String> globals = new HashMap<String, String>();
globals.put("name1", "type1");
globals.put("name2", "type2");
process.setGlobals(globals);
List<Variable> variables = new ArrayList<Variable>();
Variable variable = new Variable();
variable.setName("variable1");
variable.setType(new StringDataType());
variable.setValue("value");
variables.add(variable);
variable = new Variable();
variable.setName("variable2");
variable.setType(new IntegerDataType());
variable.setValue(2);
variables.add(variable);
variable = new Variable();
variable.setName("variable3");
variable.setType(new ObjectDataType("org.jbpm.Person"));
Person person = new Person();
person.setName("John");
variable.setValue(person);
variables.add(variable);
variable = new Variable();
variable.setName("variable4");
ListDataType listDataType = new ListDataType();
listDataType.setType(new ObjectDataType("java.lang.Integer"));
variable.setType(listDataType);
List<Integer> list = new ArrayList<Integer>();
list.add(10);
list.add(20);
variable.setValue(list);
variables.add(variable);
process.getVariableScope().setVariables(variables);
Swimlane swimlane = new Swimlane();
swimlane.setName("actor1");
process.getSwimlaneContext().addSwimlane(swimlane);
swimlane = new Swimlane();
swimlane.setName("actor2");
process.getSwimlaneContext().addSwimlane(swimlane);
ActionExceptionHandler exceptionHandler = new ActionExceptionHandler();
exceptionHandler.setFaultVariable("faultVariable");
DroolsConsequenceAction action = new DroolsConsequenceAction("dialect", "consequence");
exceptionHandler.setAction(action);
process.getExceptionScope().setExceptionHandler("myFault", exceptionHandler);
exceptionHandler = new ActionExceptionHandler();
exceptionHandler.setFaultVariable("faultVariable2");
action = new DroolsConsequenceAction("dialect2", "consequence2");
exceptionHandler.setAction(action);
process.getExceptionScope().setExceptionHandler("myFault2", exceptionHandler);
StartNode startNode = new StartNode();
startNode.setName("start");
startNode.setMetaData("x", 1);
startNode.setMetaData("y", 2);
startNode.setMetaData("width", 3);
startNode.setMetaData("height", 4);
startNode.setMetaData("meta1", "someValue");
startNode.setMetaData("meta2", "someOtherValue");
ConstraintTrigger constraintTrigger = new ConstraintTrigger();
constraintTrigger.setConstraint("constraint");
Map<String, String> inMapping = new HashMap<String, String>();
inMapping.put("key", "value");
inMapping.put("key2", "value2");
constraintTrigger.setInMappings(inMapping);
startNode.addTrigger(constraintTrigger);
EventTrigger eventTrigger = new EventTrigger();
EventTypeFilter eventTypeFilter = new EventTypeFilter();
eventTypeFilter.setType("eventType");
eventTrigger.addEventFilter(eventTypeFilter);
inMapping = new HashMap<String, String>();
inMapping.put("key", "value");
inMapping.put("key2", "value2");
eventTrigger.setInMappings(inMapping);
startNode.addTrigger(eventTrigger);
process.addNode(startNode);
ActionNode actionNode = new ActionNode();
actionNode.setName("action");
actionNode.setMetaData("x", 1);
actionNode.setMetaData("y", 2);
actionNode.setMetaData("width", 3);
actionNode.setMetaData("height", 4);
action = new DroolsConsequenceAction("dialect", "consequence");
actionNode.setAction(action);
process.addNode(actionNode);
RuleSetNode ruleSetNode = new RuleSetNode();
ruleSetNode.setName("action");
ruleSetNode.setMetaData("x", 1);
ruleSetNode.setMetaData("y", 2);
ruleSetNode.setMetaData("width", 3);
ruleSetNode.setMetaData("height", 4);
ruleSetNode.setRuleFlowGroup("ruleFlowGroup");
Timer timer = new Timer();
timer.setDelay("100");
timer.setPeriod("100");
action = new DroolsConsequenceAction("dialect", "consequence");
ruleSetNode.addTimer(timer, action);
timer = new Timer();
timer.setDelay("200");
timer.setPeriod("200");
action = new DroolsConsequenceAction("dialect", "consequence");
ruleSetNode.addTimer(timer, action);
process.addNode(ruleSetNode);
FaultNode faultNode = new FaultNode();
faultNode.setName("action");
faultNode.setMetaData("x", 1);
faultNode.setMetaData("y", 2);
faultNode.setMetaData("width", 3);
faultNode.setMetaData("height", 4);
faultNode.setFaultName("faultName");
faultNode.setFaultVariable("faultVariable");
process.addNode(faultNode);
Split split = new Split();
split.setName("split");
split.setMetaData("x", 1);
split.setMetaData("y", 2);
split.setMetaData("width", 3);
split.setMetaData("height", 4);
split.setType(Split.TYPE_XOR);
Connection connection =
new ConnectionImpl(
split, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
Constraint constraint = new ConstraintImpl();
constraint.setName("constraint1 ><&&");
constraint.setPriority(1);
constraint.setDialect("dialect1");
constraint.setType("type1");
constraint.setConstraint("constraint-text1");
split.setConstraint(connection, constraint);
connection =
new ConnectionImpl(
split, Node.CONNECTION_DEFAULT_TYPE, ruleSetNode, Node.CONNECTION_DEFAULT_TYPE);
constraint = new ConstraintImpl();
constraint.setName("constraint2");
constraint.setPriority(2);
constraint.setDialect("dialect2");
constraint.setType("type2");
constraint.setConstraint("constraint-text2");
split.setConstraint(connection, constraint);
process.addNode(split);
new ConnectionImpl(
startNode, Node.CONNECTION_DEFAULT_TYPE, split, Node.CONNECTION_DEFAULT_TYPE);
EventNode eventNode = new EventNode();
eventNode.setName("action");
eventNode.setMetaData("x", 1);
eventNode.setMetaData("y", 2);
eventNode.setMetaData("width", 3);
eventNode.setMetaData("height", 4);
eventNode.setVariableName("eventVariable");
EventTypeFilter eventFilter = new EventTypeFilter();
eventFilter.setType("eventType");
eventNode.addEventFilter(eventFilter);
process.addNode(eventNode);
Join join = new Join();
join.setName("join");
join.setMetaData("x", 1);
join.setMetaData("y", 2);
join.setMetaData("width", 3);
join.setMetaData("height", 4);
join.setType(Join.TYPE_N_OF_M);
join.setN("#{var1}");
process.addNode(join);
new ConnectionImpl(
actionNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
new ConnectionImpl(
ruleSetNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
new ConnectionImpl(eventNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
MilestoneNode milestone = new MilestoneNode();
milestone.setName("milestone");
milestone.setMetaData("x", 1);
milestone.setMetaData("y", 2);
milestone.setMetaData("width", 3);
milestone.setMetaData("height", 4);
milestone.setConstraint("constraint");
timer = new Timer();
timer.setDelay("100");
timer.setPeriod("100");
action = new DroolsConsequenceAction("dialect", "consequence");
milestone.addTimer(timer, action);
timer = new Timer();
timer.setDelay("200");
timer.setPeriod("200");
action = new DroolsConsequenceAction("dialect", "consequence");
milestone.addTimer(timer, action);
List<DroolsAction> actions = new ArrayList<DroolsAction>();
DroolsAction action1 = new DroolsConsequenceAction("java", "System.out.println(\"action1\");");
actions.add(action1);
DroolsAction action2 = new DroolsConsequenceAction("java", "System.out.println(\"action2\");");
actions.add(action2);
milestone.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
milestone.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
process.addNode(milestone);
connection =
new ConnectionImpl(
join, Node.CONNECTION_DEFAULT_TYPE, milestone, Node.CONNECTION_DEFAULT_TYPE);
connection.setMetaData("bendpoints", "[10,10;20,20]");
SubProcessNode subProcess = new SubProcessNode();
subProcess.setName("subProcess");
subProcess.setMetaData("x", 1);
subProcess.setMetaData("y", 2);
subProcess.setMetaData("width", 3);
subProcess.setMetaData("height", 4);
subProcess.setProcessId("processId");
subProcess.setWaitForCompletion(false);
subProcess.setIndependent(false);
subProcess.addInMapping("subvar1", "var1");
subProcess.addOutMapping("subvar2", "var2");
timer = new Timer();
timer.setDelay("100");
timer.setPeriod("100");
action = new DroolsConsequenceAction("dialect", "consequence");
subProcess.addTimer(timer, action);
timer = new Timer();
timer.setDelay("200");
timer.setPeriod("200");
action = new DroolsConsequenceAction("dialect", "consequence");
subProcess.addTimer(timer, action);
subProcess.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
subProcess.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
process.addNode(subProcess);
connection =
new ConnectionImpl(
milestone, Node.CONNECTION_DEFAULT_TYPE, subProcess, Node.CONNECTION_DEFAULT_TYPE);
connection.setMetaData("bendpoints", "[10,10]");
WorkItemNode workItemNode = new WorkItemNode();
workItemNode.setName("WorkItem");
Work work = new WorkImpl();
work.setName("workname");
Set<ParameterDefinition> parameterDefinitions = new HashSet<ParameterDefinition>();
ParameterDefinition parameterDefinition =
new ParameterDefinitionImpl("param1", new StringDataType());
parameterDefinitions.add(parameterDefinition);
parameterDefinition = new ParameterDefinitionImpl("param2", new IntegerDataType());
parameterDefinitions.add(parameterDefinition);
work.setParameterDefinitions(parameterDefinitions);
work.setParameter("param1", "value1");
work.setParameter("param2", 1);
workItemNode.setWork(work);
workItemNode.setWaitForCompletion(false);
workItemNode.addInMapping("param1", "var1");
workItemNode.addOutMapping("param2", "var2");
timer = new Timer();
timer.setDelay("100");
timer.setPeriod("100");
action = new DroolsConsequenceAction("dialect", "consequence");
workItemNode.addTimer(timer, action);
timer = new Timer();
timer.setDelay("200");
timer.setPeriod("200");
action = new DroolsConsequenceAction("dialect", "consequence");
workItemNode.addTimer(timer, action);
workItemNode.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
workItemNode.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
process.addNode(workItemNode);
connection =
new ConnectionImpl(
subProcess, Node.CONNECTION_DEFAULT_TYPE, workItemNode, Node.CONNECTION_DEFAULT_TYPE);
connection.setMetaData("bendpoints", "[]");
HumanTaskNode humanTaskNode = new HumanTaskNode();
humanTaskNode.setName("Human Task");
work = humanTaskNode.getWork();
parameterDefinitions = new HashSet<ParameterDefinition>();
parameterDefinition = new ParameterDefinitionImpl("TaskName", new StringDataType());
parameterDefinitions.add(parameterDefinition);
parameterDefinition = new ParameterDefinitionImpl("ActorId", new StringDataType());
parameterDefinitions.add(parameterDefinition);
parameterDefinition = new ParameterDefinitionImpl("Priority", new StringDataType());
parameterDefinitions.add(parameterDefinition);
parameterDefinition = new ParameterDefinitionImpl("Comment", new StringDataType());
parameterDefinitions.add(parameterDefinition);
work.setParameterDefinitions(parameterDefinitions);
work.setParameter("TaskName", "Do something");
work.setParameter("ActorId", "John Doe");
humanTaskNode.setWaitForCompletion(false);
humanTaskNode.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
humanTaskNode.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
process.addNode(humanTaskNode);
connection =
new ConnectionImpl(
workItemNode,
Node.CONNECTION_DEFAULT_TYPE,
humanTaskNode,
Node.CONNECTION_DEFAULT_TYPE);
TimerNode timerNode = new TimerNode();
timerNode.setName("timer");
timerNode.setMetaData("x", 1);
timerNode.setMetaData("y", 2);
timerNode.setMetaData("width", 3);
timerNode.setMetaData("height", 4);
timer = new Timer();
timer.setDelay("1000");
timer.setPeriod("1000");
timerNode.setTimer(timer);
process.addNode(timerNode);
new ConnectionImpl(
humanTaskNode, Node.CONNECTION_DEFAULT_TYPE, timerNode, Node.CONNECTION_DEFAULT_TYPE);
ForEachNode forEachNode = new ForEachNode();
forEachNode.setName("ForEach");
forEachNode.setCollectionExpression("collection");
forEachNode.setVariable("variableName", new ObjectDataType());
forEachNode.setWaitForCompletion(false);
ActionNode subActionNode1 = new ActionNode();
forEachNode.getCompositeNode().addNode(subActionNode1);
ActionNode subActionNode2 = new ActionNode();
forEachNode.getCompositeNode().addNode(subActionNode2);
new ConnectionImpl(
subActionNode1, Node.CONNECTION_DEFAULT_TYPE, subActionNode2, Node.CONNECTION_DEFAULT_TYPE);
forEachNode
.getCompositeNode()
.linkIncomingConnections(
Node.CONNECTION_DEFAULT_TYPE, subActionNode1.getId(), Node.CONNECTION_DEFAULT_TYPE);
forEachNode
.getCompositeNode()
.linkOutgoingConnections(
subActionNode2.getId(), Node.CONNECTION_DEFAULT_TYPE, Node.CONNECTION_DEFAULT_TYPE);
process.addNode(forEachNode);
new ConnectionImpl(
timerNode, Node.CONNECTION_DEFAULT_TYPE, forEachNode, Node.CONNECTION_DEFAULT_TYPE);
CompositeContextNode compositeNode = new CompositeContextNode();
compositeNode.setName("Composite");
VariableScope variableScope = new VariableScope();
compositeNode.addContext(variableScope);
compositeNode.setDefaultContext(variableScope);
variableScope.setVariables(variables);
ExceptionScope exceptionScope = new ExceptionScope();
compositeNode.addContext(exceptionScope);
compositeNode.setDefaultContext(exceptionScope);
exceptionHandler = new ActionExceptionHandler();
exceptionHandler.setFaultVariable("faultVariable");
action = new DroolsConsequenceAction("dialect", "consequence");
exceptionHandler.setAction(action);
exceptionScope.setExceptionHandler("MyFault", exceptionHandler);
exceptionHandler = new ActionExceptionHandler();
exceptionHandler.setFaultVariable("faultVariable2");
action = new DroolsConsequenceAction("dialect2", "consequence2");
exceptionHandler.setAction(action);
exceptionScope.setExceptionHandler("MyFault2", exceptionHandler);
subActionNode1 = new ActionNode();
compositeNode.addNode(subActionNode1);
subActionNode2 = new ActionNode();
compositeNode.addNode(subActionNode2);
new ConnectionImpl(
subActionNode1, Node.CONNECTION_DEFAULT_TYPE, subActionNode2, Node.CONNECTION_DEFAULT_TYPE);
compositeNode.linkIncomingConnections(
Node.CONNECTION_DEFAULT_TYPE, subActionNode1.getId(), Node.CONNECTION_DEFAULT_TYPE);
compositeNode.linkOutgoingConnections(
subActionNode2.getId(), Node.CONNECTION_DEFAULT_TYPE, Node.CONNECTION_DEFAULT_TYPE);
process.addNode(compositeNode);
new ConnectionImpl(
forEachNode, Node.CONNECTION_DEFAULT_TYPE, compositeNode, Node.CONNECTION_DEFAULT_TYPE);
EndNode endNode = new EndNode();
endNode.setName("end");
endNode.setTerminate(false);
endNode.setMetaData("x", 1);
endNode.setMetaData("y", 2);
endNode.setMetaData("width", 3);
endNode.setMetaData("height", 4);
process.addNode(endNode);
StateNode stateNode = new StateNode();
stateNode.setName("state");
stateNode.setMetaData("x", 1);
stateNode.setMetaData("y", 2);
stateNode.setMetaData("width", 3);
stateNode.setMetaData("height", 4);
timer = new Timer();
timer.setDelay("100");
timer.setPeriod("100");
action = new DroolsConsequenceAction("dialect", "consequence");
stateNode.addTimer(timer, action);
timer = new Timer();
timer.setDelay("200");
timer.setPeriod("200");
action = new DroolsConsequenceAction("dialect", "consequence");
stateNode.addTimer(timer, action);
actions = new ArrayList<DroolsAction>();
action1 = new DroolsConsequenceAction("java", "System.out.println(\"action1\");");
actions.add(action1);
action2 = new DroolsConsequenceAction("java", "System.out.println(\"action2\");");
actions.add(action2);
stateNode.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
stateNode.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
new ConnectionImpl(
compositeNode, Node.CONNECTION_DEFAULT_TYPE, stateNode, Node.CONNECTION_DEFAULT_TYPE);
connection =
new ConnectionImpl(
stateNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
constraint = new ConstraintImpl();
constraint.setName("constraint1 ><&&");
constraint.setPriority(1);
constraint.setDialect("dialect1");
constraint.setType("type1");
constraint.setConstraint("constraint-text1 %&<>");
stateNode.setConstraint(connection, constraint);
connection =
new ConnectionImpl(
stateNode, Node.CONNECTION_DEFAULT_TYPE, endNode, Node.CONNECTION_DEFAULT_TYPE);
constraint = new ConstraintImpl();
constraint.setName("constraint2");
constraint.setPriority(2);
constraint.setDialect("dialect2");
constraint.setType("type2");
constraint.setConstraint("constraint-text2");
stateNode.setConstraint(connection, constraint);
process.addNode(stateNode);
String xml = XmlRuleFlowProcessDumper.INSTANCE.dump(process, true);
if (xml == null) {
throw new IllegalArgumentException("Failed to persist full nodes!");
}
System.out.println(xml);
SemanticModules modules = new SemanticModules();
modules.addSemanticModule(new ProcessSemanticModule());
XmlProcessReader reader = new XmlProcessReader(modules, getClass().getClassLoader());
List<Process> processes = reader.read(new StringReader(xml));
assertNotNull(processes);
process = (RuleFlowProcess) processes.get(0);
if (process == null) {
throw new IllegalArgumentException("Failed to reload process!");
}
assertEquals(16, process.getNodes().length);
assertEquals(2, process.getImports().size());
assertEquals(2, process.getGlobals().size());
assertEquals(4, process.getVariableScope().getVariables().size());
assertEquals(2, process.getSwimlaneContext().getSwimlanes().size());
assertEquals(2, process.getExceptionScope().getExceptionHandlers().size());
System.out.println("************************************");
String xml2 = XmlRuleFlowProcessDumper.INSTANCE.dump(process, true);
if (xml2 == null) {
throw new IllegalArgumentException("Failed to persist empty nodes!");
}
System.out.println(xml2);
assertEquals(xml, xml2);
// test serialization of process elements
new ObjectOutputStream(new ByteArrayOutputStream()).writeObject(process);
}
protected Node createNode(Attributes attrs) {
ActionNode result = new ActionNode();
result.setAction(new DroolsConsequenceAction());
return result;
}