Examples with StartNode org.jbpm.workflow.core.node.StartNode used on opensource projects

Example 21 with StartNode

use of org.jbpm.workflow.core.node.StartNode in project jbpm by kiegroup.

the class WorkItemTest method getWorkItemProcess.

private RuleFlowProcess getWorkItemProcess(String processId, String workName) {
    RuleFlowProcess process = new RuleFlowProcess();
    process.setId(processId);
    List<Variable> variables = new ArrayList<Variable>();
    Variable variable = new Variable();
    variable.setName("UserName");
    variable.setType(new StringDataType());
    variables.add(variable);
    variable = new Variable();
    variable.setName("Person");
    variable.setType(new ObjectDataType(Person.class.getName()));
    variables.add(variable);
    variable = new Variable();
    variable.setName("MyObject");
    variable.setType(new ObjectDataType());
    variables.add(variable);
    variable = new Variable();
    variable.setName("Number");
    variable.setType(new IntegerDataType());
    variables.add(variable);
    process.getVariableScope().setVariables(variables);
    StartNode startNode = new StartNode();
    startNode.setName("Start");
    startNode.setId(1);
    WorkItemNode workItemNode = new WorkItemNode();
    workItemNode.setName("workItemNode");
    workItemNode.setId(2);
    workItemNode.addInMapping("Comment", "Person.name");
    workItemNode.addInMapping("Attachment", "MyObject");
    workItemNode.addOutMapping("Result", "MyObject");
    workItemNode.addOutMapping("Result.length()", "Number");
    Work work = new WorkImpl();
    work.setName(workName);
    Set<ParameterDefinition> parameterDefinitions = new HashSet<ParameterDefinition>();
    ParameterDefinition parameterDefinition = new ParameterDefinitionImpl("ActorId", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    parameterDefinition = new ParameterDefinitionImpl("Content", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    parameterDefinition = new ParameterDefinitionImpl("Comment", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    work.setParameterDefinitions(parameterDefinitions);
    work.setParameter("ActorId", "#{UserName}");
    work.setParameter("Content", "#{Person.name}");
    workItemNode.setWork(work);
    EndNode endNode = new EndNode();
    endNode.setName("End");
    endNode.setId(3);
    connect(startNode, workItemNode);
    connect(workItemNode, endNode);
    process.addNode(startNode);
    process.addNode(workItemNode);
    process.addNode(endNode);
    return process;
}

Example 22 with StartNode

use of org.jbpm.workflow.core.node.StartNode in project jbpm by kiegroup.

the class XMLPersistenceTest method testPersistenceOfFullNodes.

@Test
public void testPersistenceOfFullNodes() throws Exception {
    RuleFlowProcess process = new RuleFlowProcess() {

        private static final long serialVersionUID = 510l;

        int id = 0;

        public void addNode(org.kie.api.definition.process.Node node) {
            ((Node) node).setId(++id);
            super.addNode(node);
        }
    };
    process.setMetaData("routerLayout", 1);
    Set<String> imports = new HashSet<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.integrationtests.test.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!");
    }
    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());
    String xml2 = XmlRuleFlowProcessDumper.INSTANCE.dump(process, true);
    if (xml2 == null) {
        throw new IllegalArgumentException("Failed to persist empty nodes!");
    }
    Document control = XMLUnit.buildDocument(XMLUnit.newControlParser(), new StringReader(xml));
    Document test = XMLUnit.buildDocument(XMLUnit.newTestParser(), new StringReader(xml2));
    Diff diff = new Diff(control, test, null, new ElementNameAndAttributeQualifier("name"));
    assertTrue(diff.toString(), diff.similar());
// test serialization of process elements
}

Example 23 with StartNode

use of org.jbpm.workflow.core.node.StartNode in project jbpm by kiegroup.

the class XMLPersistenceTest method testPersistenceOfEmptyNodes.

@Test
public void testPersistenceOfEmptyNodes() throws Exception {
    RuleFlowProcess process = new RuleFlowProcess() {

        private static final long serialVersionUID = 510l;

        int id = 0;

        public void addNode(org.kie.api.definition.process.Node node) {
            ((Node) node).setId(++id);
            super.addNode(node);
        }
    };
    process.addNode(new StartNode());
    process.addNode(new EndNode());
    process.addNode(new ActionNode());
    process.addNode(new Split());
    process.addNode(new Join());
    process.addNode(new MilestoneNode());
    process.addNode(new RuleSetNode());
    process.addNode(new SubProcessNode());
    process.addNode(new WorkItemNode());
    process.addNode(new TimerNode());
    process.addNode(new HumanTaskNode());
    process.addNode(new ForEachNode());
    process.addNode(new CompositeContextNode());
    process.addNode(new EventNode());
    process.addNode(new FaultNode());
    process.addNode(new StateNode());
    process.addNode(new DynamicNode());
    String xml = XmlRuleFlowProcessDumper.INSTANCE.dump(process, false);
    if (xml == null) {
        throw new IllegalArgumentException("Failed to persist empty nodes!");
    }
    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(17, process.getNodes().length);
    String xml2 = XmlRuleFlowProcessDumper.INSTANCE.dump(process, false);
    if (xml2 == null) {
        throw new IllegalArgumentException("Failed to persist empty nodes!");
    }
    assertXMLEqual(xml, xml2);
// assertEquals(xml, xml2);
}

Example 24 with StartNode

use of org.jbpm.workflow.core.node.StartNode in project jbpm by kiegroup.

the class StartNodeHandler method writeNode.

public void writeNode(Node node, StringBuilder xmlDump, boolean includeMeta) {
    StartNode startNode = (StartNode) node;
    writeNode("start", startNode, xmlDump, includeMeta);
    List<Trigger> triggers = startNode.getTriggers();
    if ((triggers == null || triggers.isEmpty()) && (!includeMeta || !containsMetaData(startNode))) {
        endNode(xmlDump);
    } else {
        xmlDump.append(">" + EOL);
        if (includeMeta) {
            writeMetaData(startNode, xmlDump);
        }
        if (triggers != null) {
            xmlDump.append("      <triggers>" + EOL);
            for (Trigger trigger : triggers) {
                if (trigger instanceof ConstraintTrigger) {
                    xmlDump.append("        <trigger type=\"constraint\" >" + EOL);
                    xmlDump.append("          <constraint type=\"rule\" dialect=\"mvel\" >" + ((ConstraintTrigger) trigger).getConstraint() + "</constraint>" + EOL);
                    Map<String, String> inMappings = trigger.getInMappings();
                    if (inMappings != null && !inMappings.isEmpty()) {
                        for (Map.Entry<String, String> entry : inMappings.entrySet()) {
                            xmlDump.append("          <mapping type=\"in\" from=\"" + XmlDumper.replaceIllegalChars(entry.getValue()) + "\" to=\"" + entry.getKey() + "\" />" + EOL);
                        }
                    }
                    xmlDump.append("        </trigger>" + EOL);
                } else if (trigger instanceof EventTrigger) {
                    xmlDump.append("        <trigger type=\"event\" >" + EOL);
                    xmlDump.append("          <eventFilters>" + EOL);
                    for (EventFilter filter : ((EventTrigger) trigger).getEventFilters()) {
                        if (filter instanceof EventTypeFilter) {
                            xmlDump.append("             <eventFilter " + "type=\"eventType\" " + "eventType=\"" + ((EventTypeFilter) filter).getType() + "\" />" + EOL);
                        } else {
                            throw new IllegalArgumentException("Unknown filter type: " + filter);
                        }
                    }
                    xmlDump.append("          </eventFilters>" + EOL);
                    Map<String, String> inMappings = trigger.getInMappings();
                    if (inMappings != null && !inMappings.isEmpty()) {
                        for (Map.Entry<String, String> entry : inMappings.entrySet()) {
                            xmlDump.append("          <mapping type=\"in\" from=\"" + XmlDumper.replaceIllegalChars(entry.getValue()) + "\" to=\"" + entry.getKey() + "\" />" + EOL);
                        }
                    }
                    xmlDump.append("        </trigger>" + EOL);
                } else {
                    throw new IllegalArgumentException("Unknown trigger type " + trigger);
                }
            }
            xmlDump.append("      </triggers>" + EOL);
        }
        endNode("start", xmlDump);
    }
}

Example 25 with StartNode

use of org.jbpm.workflow.core.node.StartNode in project jbpm by kiegroup.

the class TriggerHandler method start.

public Object start(final String uri, final String localName, final Attributes attrs, final ExtensibleXmlParser parser) throws SAXException {
    parser.startElementBuilder(localName, attrs);
    StartNode startNode = (StartNode) parser.getParent();
    String type = attrs.getValue("type");
    emptyAttributeCheck(localName, "type", type, parser);
    Trigger trigger = null;
    if ("constraint".equals(type)) {
        trigger = new ConstraintTrigger();
    } else if ("event".equals(type)) {
        trigger = new EventTrigger();
    } else {
        throw new SAXException("Unknown trigger type " + type);
    }
    startNode.addTrigger(trigger);
    return trigger;
}