Search in sources :

Example 1 with XmlProcessReader

use of org.jbpm.compiler.xml.XmlProcessReader in project kie-wb-common by kiegroup.

the class BpmnFileIndexer method fillIndexBuilder.

/* (non-Javadoc)
     * @see org.kie.workbench.common.services.refactoring.backend.server.indexing.AbstractFileIndexer#fillIndexBuilder(org.uberfire.java.nio.file.Path)
     */
@Override
protected DefaultIndexBuilder fillIndexBuilder(Path path) throws Exception {
    final KieModule module = moduleService.resolveModule(Paths.convert(path));
    if (module == null) {
        logger.error("Unable to index " + path.toUri().toString() + ": module could not be resolved.");
        return null;
    }
    // responsible for basic index info: module name, branch, etc
    final DefaultIndexBuilder builder = getIndexBuilder(path, module);
    String bpmnStr = ioService.readAllString(path);
    ClassLoader moduleClassLoader = getModuleClassLoader(module);
    try {
        List<BpmnProcessDataEventListener> processDataList = buildProcessDefinition(bpmnStr, moduleClassLoader);
        if (processDataList != null) {
            for (BpmnProcessDataEventListener processData : processDataList) {
                addReferencedResourcesToIndexBuilder(builder, processData);
                builder.setPackageName(processData.getProcess().getPackageName());
            }
        }
    } catch (Exception e) {
        // log and ignore
        logger.info("Indexing hampered because BPMN2 compilation failed [" + path.toString() + "]: " + e.getMessage());
    }
    /**
     * IMPORTANT: sometimes the build of the BPMN2 might fail for minor reasons, including things like
     * a bad script in a script task
     *
     * When this happens, we (re)parse the process definition, but do not completely "build" it
     * (as in, what org.jbpm.compiler.ProcessBuilderImpl.buildProcess(Process, Resource) does).
     *
     * It *would* be more efficient to basically copy/paste the
     * jbpm-flow-builder org.jbpm.compiler.ProcessBuilderImpl.addProcessFromXml(Resource) logic here,
     * so that we do something like:
     *
     * 1. Use the XmlProcessReader to create a process
     * 2. *try* to build the rest of the process (and fail safely if not)
     * 3. do XmlProcessReader.getProcessBuildData().onBuildComplete(process)
     *    to complete collecting the information
     *
     * But... that's a high maintenance cost for this piece of software
     *
     * So until we can refactor the ProcessBuilderImpl logic (using functional logic for conditional handling?)
     * to be used here, let's keep it simple (as in, parsing the BPMN2 a second time when the build fails..)
     */
    // parse process definitions
    XmlProcessReader processReader = new XmlProcessReader(modules, moduleClassLoader);
    List<Process> processes = Collections.emptyList();
    try {
        processes = processReader.read(new StringReader(bpmnStr));
    } catch (Exception e) {
        logger.info("Unable to index because BPMN2 parsing failed [" + path.toString() + "]: " + e.getMessage());
    }
    // complete process definition processing
    if (processes != null) {
        for (Process process : processes) {
            Resource resource = new ReaderResource(new StringReader(bpmnStr));
            ProcessValidationError[] errors;
            ProcessValidator validator = ProcessValidatorRegistry.getInstance().getValidator(process, resource);
            errors = validator.validateProcess(process);
            if (errors.length > 0) {
                logger.error("Trying to finish indexing process '" + process.getId() + "/" + process.getName() + "' despite " + errors.length + " validation errors.");
            }
            processReader.getProcessBuildData().onBuildComplete(process);
            BpmnProcessDataEventListener helper = (BpmnProcessDataEventListener) process.getMetaData().get(BpmnProcessDataEventListener.NAME);
            addReferencedResourcesToIndexBuilder(builder, helper);
        }
    } else {
        logger.warn("No process was found in file: " + path.toUri());
    }
    return builder;
}
Also used : XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) ReaderResource(org.drools.core.io.impl.ReaderResource) ByteArrayResource(org.drools.core.io.impl.ByteArrayResource) Resource(org.kie.api.io.Resource) Process(org.kie.api.definition.process.Process) DefaultIndexBuilder(org.kie.workbench.common.services.refactoring.backend.server.indexing.DefaultIndexBuilder) ReaderResource(org.drools.core.io.impl.ReaderResource) ProcessValidationError(org.jbpm.process.core.validation.ProcessValidationError) StringReader(java.io.StringReader) KieModule(org.kie.workbench.common.services.shared.project.KieModule) ProcessValidator(org.jbpm.process.core.validation.ProcessValidator)

Example 2 with XmlProcessReader

use of org.jbpm.compiler.xml.XmlProcessReader in project jbpm by kiegroup.

the class ProcessBuilderImpl method addProcessFromXml.

public List<Process> addProcessFromXml(final Resource resource) throws IOException {
    Reader reader = resource.getReader();
    KnowledgeBuilderConfigurationImpl configuration = knowledgeBuilder.getBuilderConfiguration();
    XmlProcessReader xmlReader = new XmlProcessReader(configuration.getSemanticModules(), knowledgeBuilder.getRootClassLoader());
    List<Process> processes = null;
    try {
        String portRuleFlow = System.getProperty("drools.ruleflow.port", "false");
        Reader portedReader = null;
        if (portRuleFlow.equalsIgnoreCase("true")) {
            portedReader = portToCurrentVersion(reader);
        } else {
            portedReader = reader;
        }
        processes = xmlReader.read(portedReader);
        if (processes != null) {
            // stop null pointers
            for (Process process : processes) {
                buildProcess(process, resource);
                xmlReader.getProcessBuildData().onBuildComplete(process);
            }
        } else {
            // @TODO could we maybe add something a bit more informative about what is wrong with the XML ?
            this.errors.add(new ProcessLoadError(resource, "unable to parse xml", null));
        }
    } catch (FactoryConfigurationError e1) {
        this.errors.add(new ProcessLoadError(resource, "FactoryConfigurationError ", e1.getException()));
    } catch (Exception e2) {
        e2.printStackTrace();
        this.errors.add(new ProcessLoadError(resource, "unable to parse xml", e2));
    } finally {
        reader.close();
    }
    return processes;
}
Also used : ProcessLoadError(org.drools.compiler.compiler.ProcessLoadError) KnowledgeBuilderConfigurationImpl(org.drools.compiler.builder.impl.KnowledgeBuilderConfigurationImpl) XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) Reader(java.io.Reader) StringReader(java.io.StringReader) DuplicateProcess(org.drools.compiler.compiler.DuplicateProcess) Process(org.kie.api.definition.process.Process) WorkflowProcess(org.kie.api.definition.process.WorkflowProcess) FactoryConfigurationError(javax.xml.parsers.FactoryConfigurationError) DroolsParserException(org.drools.compiler.compiler.DroolsParserException) IOException(java.io.IOException)

Example 3 with XmlProcessReader

use of org.jbpm.compiler.xml.XmlProcessReader in project jbpm by kiegroup.

the class BPMN2XMLTest method testXML.

public void testXML() throws IOException, SAXException {
    SemanticModules modules = new SemanticModules();
    modules.addSemanticModule(new BPMNSemanticModule());
    modules.addSemanticModule(new BPMNDISemanticModule());
    XmlProcessReader processReader = new XmlProcessReader(modules, getClass().getClassLoader());
    for (String processName : processes) {
        String original = slurp(BPMN2XMLTest.class.getResourceAsStream("/" + processName));
        List<Process> processes = processReader.read(BPMN2XMLTest.class.getResourceAsStream("/" + processName));
        assertNotNull(processes);
        assertEquals(1, processes.size());
        RuleFlowProcess p = (RuleFlowProcess) processes.get(0);
        String result = XmlBPMNProcessDumper.INSTANCE.dump(p, XmlBPMNProcessDumper.META_DATA_USING_DI);
        // Compare original with result using XMLUnit
        Diff diff = new Diff(original, result);
        // Ignore the sequence of nodes (or children nodes) when looking at these nodes
        final HashSet<String> sequenceDoesNotMatter = new HashSet<String>();
        sequenceDoesNotMatter.add("startEvent");
        sequenceDoesNotMatter.add("scriptTask");
        sequenceDoesNotMatter.add("endEvent");
        sequenceDoesNotMatter.add("bpmndi:BPMNShape");
        diff.overrideDifferenceListener(new DifferenceListener() {

            public int differenceFound(Difference diff) {
                String nodeName = diff.getTestNodeDetail().getNode().getNodeName();
                if (sequenceDoesNotMatter.contains(nodeName) && diff.getId() == DifferenceConstants.CHILD_NODELIST_SEQUENCE_ID) {
                    return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
                }
                logger.info("! {}", diff.getTestNodeDetail().getNode().getNodeName());
                return RETURN_ACCEPT_DIFFERENCE;
            }

            public void skippedComparison(Node one, Node two) {
                logger.info("{} : {}", one.getLocalName(), two.getLocalName());
            }
        });
        // nodes should only be compared if their attributes are the same
        diff.overrideElementQualifier(new ElementNameAndAttributeQualifier());
        assertTrue("Original and generated output is not the same.", diff.identical());
    }
}
Also used : RuleFlowProcess(org.jbpm.ruleflow.core.RuleFlowProcess) Diff(org.custommonkey.xmlunit.Diff) XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) Node(org.w3c.dom.Node) Process(org.kie.api.definition.process.Process) RuleFlowProcess(org.jbpm.ruleflow.core.RuleFlowProcess) Difference(org.custommonkey.xmlunit.Difference) SemanticModules(org.drools.core.xml.SemanticModules) BPMNDISemanticModule(org.jbpm.bpmn2.xml.BPMNDISemanticModule) ElementNameAndAttributeQualifier(org.custommonkey.xmlunit.ElementNameAndAttributeQualifier) BPMNSemanticModule(org.jbpm.bpmn2.xml.BPMNSemanticModule) DifferenceListener(org.custommonkey.xmlunit.DifferenceListener) HashSet(java.util.HashSet)

Example 4 with XmlProcessReader

use of org.jbpm.compiler.xml.XmlProcessReader in project jbpm by kiegroup.

the class BPMN2XMLTest method testInvalidXMLInCompositeNode.

public void testInvalidXMLInCompositeNode() throws Exception, SAXException {
    SemanticModules modules = new SemanticModules();
    modules.addSemanticModule(new BPMNSemanticModule());
    modules.addSemanticModule(new BPMNDISemanticModule());
    XmlProcessReader processReader = new XmlProcessReader(modules, getClass().getClassLoader()) {

        @Override
        protected String processParserMessage(LinkedList<Object> parents, org.xml.sax.Attributes attr, String errorMessage) {
            setErrorMessage(super.processParserMessage(parents, attr, errorMessage));
            return errorMessage;
        }
    };
    processReader.read(BPMN2XMLTest.class.getResourceAsStream("/BPMN2-XMLProcessWithErrorInCompositeNode.bpmn2"));
    assertNotNull(getErrorMessage());
    assertThat(getErrorMessage()).contains("Process Info: id:abc.abc, pkg:org.drools.bpmn2, name:abc, version:1.0 \n" + "Node Info: id:_47489F3D-FEBD-4452-B62E-B04EF191C6C3 name: \n" + "Parser message: (null: 24, 185): cvc-complex-type.2.4.a: Invalid content was found");
}
Also used : SemanticModules(org.drools.core.xml.SemanticModules) BPMNDISemanticModule(org.jbpm.bpmn2.xml.BPMNDISemanticModule) XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) BPMNSemanticModule(org.jbpm.bpmn2.xml.BPMNSemanticModule) LinkedList(java.util.LinkedList)

Example 5 with XmlProcessReader

use of org.jbpm.compiler.xml.XmlProcessReader 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
}
Also used : RuleFlowProcess(org.jbpm.ruleflow.core.RuleFlowProcess) DroolsConsequenceAction(org.jbpm.workflow.core.impl.DroolsConsequenceAction) HashMap(java.util.HashMap) IntegerDataType(org.jbpm.process.core.datatype.impl.type.IntegerDataType) Constraint(org.jbpm.workflow.core.Constraint) Diff(org.custommonkey.xmlunit.Diff) HumanTaskNode(org.jbpm.workflow.core.node.HumanTaskNode) ForEachNode(org.jbpm.workflow.core.node.ForEachNode) DynamicNode(org.jbpm.workflow.core.node.DynamicNode) StartNode(org.jbpm.workflow.core.node.StartNode) StateNode(org.jbpm.workflow.core.node.StateNode) RuleSetNode(org.jbpm.workflow.core.node.RuleSetNode) SubProcessNode(org.jbpm.workflow.core.node.SubProcessNode) CompositeContextNode(org.jbpm.workflow.core.node.CompositeContextNode) Node(org.jbpm.workflow.core.Node) MilestoneNode(org.jbpm.workflow.core.node.MilestoneNode) TimerNode(org.jbpm.workflow.core.node.TimerNode) FaultNode(org.jbpm.workflow.core.node.FaultNode) WorkItemNode(org.jbpm.workflow.core.node.WorkItemNode) ActionNode(org.jbpm.workflow.core.node.ActionNode) EndNode(org.jbpm.workflow.core.node.EndNode) EventNode(org.jbpm.workflow.core.node.EventNode) ArrayList(java.util.ArrayList) StateNode(org.jbpm.workflow.core.node.StateNode) Process(org.kie.api.definition.process.Process) RuleFlowProcess(org.jbpm.ruleflow.core.RuleFlowProcess) Document(org.w3c.dom.Document) ExceptionScope(org.jbpm.process.core.context.exception.ExceptionScope) SemanticModules(org.drools.core.xml.SemanticModules) StringDataType(org.jbpm.process.core.datatype.impl.type.StringDataType) ConstraintImpl(org.jbpm.workflow.core.impl.ConstraintImpl) SubProcessNode(org.jbpm.workflow.core.node.SubProcessNode) Work(org.jbpm.process.core.Work) WorkImpl(org.jbpm.process.core.impl.WorkImpl) HashSet(java.util.HashSet) EventTrigger(org.jbpm.workflow.core.node.EventTrigger) ConstraintTrigger(org.jbpm.workflow.core.node.ConstraintTrigger) DroolsAction(org.jbpm.workflow.core.DroolsAction) XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) ParameterDefinitionImpl(org.jbpm.process.core.impl.ParameterDefinitionImpl) FaultNode(org.jbpm.workflow.core.node.FaultNode) EndNode(org.jbpm.workflow.core.node.EndNode) Split(org.jbpm.workflow.core.node.Split) Person(org.jbpm.integrationtests.test.Person) VariableScope(org.jbpm.process.core.context.variable.VariableScope) ParameterDefinition(org.jbpm.process.core.ParameterDefinition) Variable(org.jbpm.process.core.context.variable.Variable) RuleSetNode(org.jbpm.workflow.core.node.RuleSetNode) CompositeContextNode(org.jbpm.workflow.core.node.CompositeContextNode) ActionNode(org.jbpm.workflow.core.node.ActionNode) ConnectionImpl(org.jbpm.workflow.core.impl.ConnectionImpl) ObjectDataType(org.jbpm.process.core.datatype.impl.type.ObjectDataType) MilestoneNode(org.jbpm.workflow.core.node.MilestoneNode) ProcessSemanticModule(org.jbpm.compiler.xml.ProcessSemanticModule) EventTypeFilter(org.jbpm.process.core.event.EventTypeFilter) EventNode(org.jbpm.workflow.core.node.EventNode) ElementNameAndAttributeQualifier(org.custommonkey.xmlunit.ElementNameAndAttributeQualifier) WorkItemNode(org.jbpm.workflow.core.node.WorkItemNode) StringReader(java.io.StringReader) TimerNode(org.jbpm.workflow.core.node.TimerNode) HumanTaskNode(org.jbpm.workflow.core.node.HumanTaskNode) StartNode(org.jbpm.workflow.core.node.StartNode) ListDataType(org.jbpm.process.core.datatype.impl.type.ListDataType) Connection(org.jbpm.workflow.core.Connection) Join(org.jbpm.workflow.core.node.Join) ActionExceptionHandler(org.jbpm.process.core.context.exception.ActionExceptionHandler) Swimlane(org.jbpm.process.core.context.swimlane.Swimlane) Timer(org.jbpm.process.core.timer.Timer) ForEachNode(org.jbpm.workflow.core.node.ForEachNode) Test(org.junit.Test)

Aggregations

XmlProcessReader (org.jbpm.compiler.xml.XmlProcessReader)10 Process (org.kie.api.definition.process.Process)8 StringReader (java.io.StringReader)7 SemanticModules (org.drools.core.xml.SemanticModules)6 RuleFlowProcess (org.jbpm.ruleflow.core.RuleFlowProcess)5 BPMNDISemanticModule (org.jbpm.bpmn2.xml.BPMNDISemanticModule)4 BPMNSemanticModule (org.jbpm.bpmn2.xml.BPMNSemanticModule)4 ArrayList (java.util.ArrayList)2 HashSet (java.util.HashSet)2 LinkedList (java.util.LinkedList)2 Diff (org.custommonkey.xmlunit.Diff)2 ElementNameAndAttributeQualifier (org.custommonkey.xmlunit.ElementNameAndAttributeQualifier)2 KnowledgeBuilderConfigurationImpl (org.drools.compiler.builder.impl.KnowledgeBuilderConfigurationImpl)2 ProcessSemanticModule (org.jbpm.compiler.xml.ProcessSemanticModule)2 Node (org.jbpm.workflow.core.Node)2 ActionNode (org.jbpm.workflow.core.node.ActionNode)2 CompositeContextNode (org.jbpm.workflow.core.node.CompositeContextNode)2 DynamicNode (org.jbpm.workflow.core.node.DynamicNode)2 EndNode (org.jbpm.workflow.core.node.EndNode)2 EventNode (org.jbpm.workflow.core.node.EventNode)2