Examples with NonAcceptingEventTypeFilter org.jbpm.process.core.event.NonAcceptingEventTypeFilter used on opensource projects

Example 1 with NonAcceptingEventTypeFilter

use of org.jbpm.process.core.event.NonAcceptingEventTypeFilter in project jbpm by kiegroup.

the class StartEventHandler method handleCompensationNode.

protected void handleCompensationNode(final StartNode startNode, final Element element, final org.w3c.dom.Node xmlNode, final ExtensibleXmlParser parser) throws SAXException {
    if (startNode.isInterrupting()) {
        logger.warn("Compensation Event Sub-Processes [" + startNode.getMetaData("UniqueId") + "] may not be specified as interrupting:" + " overriding attribute and setting to not-interrupting.");
    }
    startNode.setInterrupting(false);
    /**
     * From the BPMN2 spec, P.264:
     * "For a Start Event:
     *  This Event "catches" the compensation for an Event Sub-Process. No further information is required.
     *  The Event Sub-Process will provide the id necessary to match the Compensation Event with the Event
     *  that threw the compensation"
     *
     *  In other words, the id of the Sub-Process containing this Event Sub-Process is what should be used
     *  as the activityRef value in any Intermediate (throw) or End compensation event that targets
     *  this particular Event Sub-Process.
     *
     *  This is similar to the logic used for a Compensation Boundary Event: it's signaled using
     *  the id of the activity to which the CBE is attached to.
     */
    String activityRef = ((Element) xmlNode).getAttribute("activityRef");
    if (activityRef != null && activityRef.length() > 0) {
        logger.warn("activityRef value [" + activityRef + "] on Start Event '" + startNode.getMetaData("UniqueId") + "' ignored per the BPMN2 specification.");
    }
    // so that this node will get processed in ProcessHandler.postProcessNodes(...)
    EventTrigger startTrigger = new EventTrigger();
    EventFilter eventFilter = new NonAcceptingEventTypeFilter();
    ((NonAcceptingEventTypeFilter) eventFilter).setType("Compensation");
    startTrigger.addEventFilter(eventFilter);
    List<Trigger> startTriggers = new ArrayList<Trigger>();
    startTriggers.add(startTrigger);
    startNode.setTriggers(startTriggers);
    String mapping = (String) startNode.getMetaData("TriggerMapping");
    if (mapping != null) {
        startTrigger.addInMapping(mapping, startNode.getOutMapping(mapping));
    }
}

Example 2 with NonAcceptingEventTypeFilter

use of org.jbpm.process.core.event.NonAcceptingEventTypeFilter in project jbpm by kiegroup.

the class CompensationTest method createBoundaryEventCompensationHandler.

private void createBoundaryEventCompensationHandler(org.jbpm.workflow.core.NodeContainer nodeContainer, Node attachedToNode, final List<String> eventList, final String id) throws Exception {
    NodeCreator<BoundaryEventNode> boundaryNodeCreator = new NodeCreator<BoundaryEventNode>(nodeContainer, BoundaryEventNode.class);
    BoundaryEventNode boundaryNode = boundaryNodeCreator.createNode("boundary" + id);
    String attachedTo = (String) attachedToNode.getMetaData().get("UniqueId");
    boundaryNode.setMetaData("AttachedTo", attachedTo);
    boundaryNode.setAttachedToNodeId(attachedTo);
    EventTypeFilter eventFilter = new NonAcceptingEventTypeFilter();
    eventFilter.setType("Compensation");
    List<EventFilter> eventFilters = new ArrayList<EventFilter>();
    boundaryNode.setEventFilters(eventFilters);
    eventFilters.add(eventFilter);
    addCompensationScope(boundaryNode, nodeContainer, attachedTo);
    NodeCreator<ActionNode> actionNodeCreator = new NodeCreator<ActionNode>(nodeContainer, ActionNode.class);
    ActionNode actionNode = actionNodeCreator.createNode("handlerAction" + id);
    actionNode.setMetaData("isForCompensation", true);
    actionNode.setName("Execute");
    DroolsAction action = new DroolsConsequenceAction("java", null);
    action.setMetaData("Action", new Action() {

        public void execute(ProcessContext context) throws Exception {
            eventList.add("action" + id);
        }
    });
    actionNode.setAction(action);
    connect(boundaryNode, actionNode);
}

Example 3 with NonAcceptingEventTypeFilter

use of org.jbpm.process.core.event.NonAcceptingEventTypeFilter in project jbpm by kiegroup.

the class BoundaryEventHandler method handleCompensationNode.

protected void handleCompensationNode(final Node node, final Element element, final String uri, final String localName, final ExtensibleXmlParser parser, final String attachedTo, final boolean cancelActivity) throws SAXException {
    BoundaryEventNode eventNode = (BoundaryEventNode) parser.getCurrent();
    super.handleNode(node, element, uri, localName, parser);
    NodeList childs = element.getChildNodes();
    for (int i = 0; i < childs.getLength(); i++) {
        if (childs.item(i) instanceof Element) {
            Element el = (Element) childs.item(i);
            if ("compensateEventDefinition".equalsIgnoreCase(el.getNodeName())) {
                String activityRef = el.getAttribute("activityRef");
                if (activityRef != null && activityRef.length() > 0) {
                    logger.warn("activityRef value [" + activityRef + "] on Boundary Event '" + eventNode.getMetaData("UniqueId") + "' ignored per the BPMN2 specification.");
                }
            }
        }
    }
    eventNode.setMetaData("AttachedTo", attachedTo);
    eventNode.setAttachedToNodeId(attachedTo);
    // 1. Find the parent (sub-)process
    NodeContainer parentContainer = (NodeContainer) parser.getParent();
    // 2. Add the event filter (never fires, purely for dumping purposes)
    EventTypeFilter eventFilter = new NonAcceptingEventTypeFilter();
    eventFilter.setType("Compensation");
    List<EventFilter> eventFilters = new ArrayList<EventFilter>();
    eventNode.setEventFilters(eventFilters);
    eventFilters.add(eventFilter);
    // 3. Add compensation scope (with key/id: attachedTo)
    ProcessHandler.addCompensationScope((RuleFlowProcess) parser.getParent(RuleFlowProcess.class), eventNode, parentContainer, attachedTo);
}

Example 4 with NonAcceptingEventTypeFilter

use of org.jbpm.process.core.event.NonAcceptingEventTypeFilter in project jbpm by kiegroup.

the class CompensationTest method createCompensationEventSubProcessProcess.

private RuleFlowProcess createCompensationEventSubProcessProcess(String processId, String[] workItemNames, final List<String> eventList) throws Exception {
    RuleFlowProcess process = new RuleFlowProcess();
    process.setAutoComplete(true);
    process.setId(processId);
    process.setName("CESP Process");
    process.setMetaData("Compensation", true);
    NodeCreator<StartNode> startNodeCreator = new NodeCreator<StartNode>(process, StartNode.class);
    NodeCreator<WorkItemNode> workItemNodeCreator = new NodeCreator<WorkItemNode>(process, WorkItemNode.class);
    NodeCreator<CompositeContextNode> compNodeCreator = new NodeCreator<CompositeContextNode>(process, CompositeContextNode.class);
    NodeCreator<EndNode> endNodeCreator = new NodeCreator<EndNode>(process, EndNode.class);
    // outer process
    StartNode startNode = startNodeCreator.createNode("start0");
    WorkItemNode workItemNode = workItemNodeCreator.createNode("work0-pre");
    workItemNode.getWork().setName(workItemNames[0]);
    connect(startNode, workItemNode);
    CompositeNode compositeNode = compNodeCreator.createNode("sub0");
    connect(workItemNode, compositeNode);
    workItemNode = workItemNodeCreator.createNode("work0-post");
    workItemNode.getWork().setName(workItemNames[2]);
    connect(compositeNode, workItemNode);
    EndNode endNode = endNodeCreator.createNode("end0");
    connect(workItemNode, endNode);
    // 1rst level nested subprocess
    startNodeCreator.setNodeContainer(compositeNode);
    workItemNodeCreator.setNodeContainer(compositeNode);
    endNodeCreator.setNodeContainer(compositeNode);
    startNode = startNodeCreator.createNode("start1");
    workItemNode = workItemNodeCreator.createNode("work1");
    workItemNode.getWork().setName(workItemNames[1]);
    connect(startNode, workItemNode);
    endNode = endNodeCreator.createNode("end1");
    connect(workItemNode, endNode);
    // 2nd level nested event subprocess in 1rst level subprocess
    NodeCreator<EventSubProcessNode> espNodeCreator = new NodeCreator<EventSubProcessNode>(compositeNode, EventSubProcessNode.class);
    EventSubProcessNode espNode = espNodeCreator.createNode("eventSub1");
    EventTypeFilter eventFilter = new NonAcceptingEventTypeFilter();
    eventFilter.setType("Compensation");
    espNode.addEvent(eventFilter);
    addCompensationScope(espNode, process, (String) compositeNode.getMetaData("UniqueId"));
    startNodeCreator.setNodeContainer(espNode);
    endNodeCreator.setNodeContainer(espNode);
    NodeCreator<ActionNode> actionNodeCreator = new NodeCreator<ActionNode>(espNode, ActionNode.class);
    startNode = startNodeCreator.createNode("start1*");
    ActionNode actionNode = actionNodeCreator.createNode("action1*");
    actionNode.setName("Execute");
    DroolsAction action = new DroolsConsequenceAction("java", null);
    action.setMetaData("Action", new Action() {

        public void execute(ProcessContext context) throws Exception {
            eventList.add("Executed action");
        }
    });
    actionNode.setAction(action);
    connect(startNode, actionNode);
    endNode = endNodeCreator.createNode("end1*");
    connect(actionNode, endNode);
    return process;
}

Example 5 with NonAcceptingEventTypeFilter

use of org.jbpm.process.core.event.NonAcceptingEventTypeFilter in project jbpm by kiegroup.

the class CompensationTest method createNestedCompensationEventSubProcessProcess.

private RuleFlowProcess createNestedCompensationEventSubProcessProcess(String processId, String[] workItemNames, final List<String> eventList) throws Exception {
    RuleFlowProcess process = new RuleFlowProcess();
    process.setAutoComplete(true);
    process.setId(processId);
    process.setName("CESP Process");
    process.setMetaData("Compensation", true);
    NodeCreator<StartNode> startNodeCreator = new NodeCreator<StartNode>(process, StartNode.class);
    NodeCreator<WorkItemNode> workItemNodeCreator = new NodeCreator<WorkItemNode>(process, WorkItemNode.class);
    NodeCreator<CompositeContextNode> compNodeCreator = new NodeCreator<CompositeContextNode>(process, CompositeContextNode.class);
    NodeCreator<EndNode> endNodeCreator = new NodeCreator<EndNode>(process, EndNode.class);
    // outer process
    CompositeContextNode compositeNode = compNodeCreator.createNode("sub0");
    {
        StartNode startNode = startNodeCreator.createNode("start0");
        WorkItemNode workItemNode = workItemNodeCreator.createNode("work0-pre");
        workItemNode.getWork().setName(workItemNames[0]);
        connect(startNode, workItemNode);
        connect(workItemNode, compositeNode);
        EndNode endNode = endNodeCreator.createNode("end0");
        connect(compositeNode, endNode);
    }
    // 1rst level nested subprocess (contains compensation visibility scope)
    CompositeContextNode compensationScopeContainerNode = compositeNode;
    {
        startNodeCreator.setNodeContainer(compositeNode);
        workItemNodeCreator.setNodeContainer(compositeNode);
        compNodeCreator.setNodeContainer(compositeNode);
        endNodeCreator.setNodeContainer(compositeNode);
        StartNode startNode = startNodeCreator.createNode("start1");
        CompositeContextNode subCompNode = compNodeCreator.createNode("sub1");
        connect(startNode, subCompNode);
        WorkItemNode workItemNode = workItemNodeCreator.createNode("work1-post");
        workItemNode.getWork().setName(workItemNames[2]);
        connect(subCompNode, workItemNode);
        EndNode endNode = endNodeCreator.createNode("end1");
        connect(workItemNode, endNode);
        compositeNode = subCompNode;
    }
    // 2nd level nested subprocess
    {
        startNodeCreator.setNodeContainer(compositeNode);
        workItemNodeCreator.setNodeContainer(compositeNode);
        endNodeCreator.setNodeContainer(compositeNode);
        StartNode startNode = startNodeCreator.createNode("start2");
        WorkItemNode workItemNode = workItemNodeCreator.createNode("work2");
        workItemNode.getWork().setName(workItemNames[1]);
        connect(startNode, workItemNode);
        EndNode endNode = endNodeCreator.createNode("end2");
        connect(workItemNode, endNode);
    }
    // 3nd level nested event subprocess in 2nd level subprocess
    {
        NodeCreator<EventSubProcessNode> espNodeCreator = new NodeCreator<EventSubProcessNode>(compositeNode, EventSubProcessNode.class);
        EventSubProcessNode espNode = espNodeCreator.createNode("eventSub2");
        startNodeCreator.setNodeContainer(espNode);
        endNodeCreator.setNodeContainer(espNode);
        NodeCreator<ActionNode> actionNodeCreator = new NodeCreator<ActionNode>(espNode, ActionNode.class);
        EventTypeFilter eventFilter = new NonAcceptingEventTypeFilter();
        eventFilter.setType("Compensation");
        espNode.addEvent(eventFilter);
        addCompensationScope(espNode, compensationScopeContainerNode, (String) compositeNode.getMetaData("UniqueId"));
        StartNode startNode = startNodeCreator.createNode("start3*");
        ActionNode actionNode = actionNodeCreator.createNode("action3*");
        actionNode.setName("Execute");
        DroolsAction action = new DroolsConsequenceAction("java", null);
        action.setMetaData("Action", new Action() {

            public void execute(ProcessContext context) throws Exception {
                eventList.add("Executed action");
            }
        });
        actionNode.setAction(action);
        connect(startNode, actionNode);
        EndNode endNode = endNodeCreator.createNode("end3*");
        connect(actionNode, endNode);
    }
    return process;
}