private static Node findNodeByIdOrUniqueIdInMetadata(NodeContainer nodeContainer, final String nodeRef, String errorMsg) { Node node = null; // try looking for a node with same "UniqueId" (in metadata) for (Node containerNode: nodeContainer.getNodes()) { if (nodeRef.equals(containerNode.getMetaData().get("UniqueId"))) { node = containerNode; break; } } if (node == null) { throw new IllegalArgumentException(errorMsg); } return node; }
private static Node findNodeByIdOrUniqueIdInMetadata(NodeContainer nodeContainer, final String nodeRef, String errorMsg) { Node node = null; // try looking for a node with same "UniqueId" (in metadata) for (Node containerNode : nodeContainer.getNodes()) { if (nodeRef.equals(containerNode.getMetaData().get("UniqueId"))) { node = containerNode; break; } } if (node == null) { throw new IllegalArgumentException(errorMsg); } return node; }
private Node findNode(String nodeId) { Node found = null; Queue<Node> allProcessNodes = new LinkedList<Node>(); allProcessNodes.addAll(Arrays.asList( instance.getNodeContainer().getNodes() )); while( ! allProcessNodes.isEmpty() ) { Node node = allProcessNodes.poll(); if( nodeId.equals(node.getMetaData().get("UniqueId")) ) { found = node; break; } if( node instanceof NodeContainer ) { allProcessNodes.addAll(Arrays.asList( ((NodeContainer) node).getNodes())); } } return found; }
private void visitLane(NodeContainer container, String lane, StringBuilder xmlDump) { for (Node node: container.getNodes()) { if (node instanceof HumanTaskNode) { String swimlane = ((HumanTaskNode) node).getSwimlane(); if (lane.equals(swimlane)) { xmlDump.append(" <flowNodeRef>" + XmlBPMNProcessDumper.getUniqueNodeId(node) + "</flowNodeRef>" + EOL); } } else { String swimlane = (String) node.getMetaData().get("Lane"); if (lane.equals(swimlane)) { xmlDump.append(" <flowNodeRef>" + XmlBPMNProcessDumper.getUniqueNodeId(node) + "</flowNodeRef>" + EOL); } } if (node instanceof NodeContainer) { visitLane((NodeContainer) node, lane, xmlDump); } } }
for (Node node : ((NodeContainer) topNode).getNodes()) { nodeStack.push(node);
private void assignLanes(NodeContainer nodeContainer, Map<String, String> laneMapping) { for (Node node: nodeContainer.getNodes()) { String lane = null; String uniqueId = (String) node.getMetaData().get("UniqueId"); if (uniqueId != null) { lane = laneMapping.get(uniqueId); } else { lane = laneMapping.get(XmlBPMNProcessDumper.getUniqueNodeId(node)); } if (lane != null) { ((NodeImpl) node).setMetaData("Lane", lane); if (node instanceof HumanTaskNode) { ((HumanTaskNode) node).setSwimlane(lane); } } if (node instanceof NodeContainer) { assignLanes((NodeContainer) node, laneMapping); } } }
nodeQueue.addAll(Arrays.asList(((NodeContainer) node).getNodes()));
private void postProcessNodeOffset(Node[] nodes, int xOffset, int yOffset) { for (Node node: nodes) { Integer x = (Integer) node.getMetaData().get("x"); if (x != null) { ((org.jbpm.workflow.core.Node) node).setMetaData("x", x - xOffset); } Integer y = (Integer) node.getMetaData().get("y"); if (y != null) { ((org.jbpm.workflow.core.Node) node).setMetaData("y", y - yOffset); } if (node instanceof NodeContainer) { postProcessNodeOffset(((NodeContainer) node).getNodes(), xOffset + (x == null ? 0 : x), yOffset + (y == null ? 0 : y)); } } }
public static void linkBoundaryEvents(NodeContainer nodeContainer) { for (Node node : nodeContainer.getNodes()) { if (node instanceof EventNode) { final String attachedTo = (String) node.getMetaData().get("AttachedTo"); if (attachedTo != null) { for (EventFilter filter : ((EventNode) node).getEventFilters()) { String type = ((EventTypeFilter) filter).getType(); Node attachedNode = findNodeByIdOrUniqueIdInMetadata(nodeContainer, attachedTo, "Could not find node to attach to: " + attachedTo); // if (!(attachedNode instanceof StateBasedNode) && !type.equals("Compensation")) { throw new IllegalArgumentException("Boundary events are supported only on StateBasedNode, found node: " + attachedNode.getClass().getName() + " [" + attachedNode.getMetaData().get( "UniqueId") + "]"); } if (type.startsWith("Escalation")) { linkBoundaryEscalationEvent(nodeContainer, node, attachedTo, attachedNode); } else if (type.startsWith("Error-")) { linkBoundaryErrorEvent(nodeContainer, node, attachedTo, attachedNode); } else if (type.startsWith("Timer-")) { linkBoundaryTimerEvent(nodeContainer, node, attachedTo, attachedNode); } else if (node.getMetaData().get("SignalName") != null || type.startsWith("Message-")) { linkBoundarySignalEvent(nodeContainer, node, attachedTo, attachedNode); } else if (type.startsWith("Condition-")) { linkBoundaryConditionEvent(nodeContainer, node, attachedTo, attachedNode); } } } } } }
public static void linkBoundaryEvents(NodeContainer nodeContainer) { for (Node node: nodeContainer.getNodes()) { if (node instanceof EventNode) { final String attachedTo = (String) node.getMetaData().get("AttachedTo");
private boolean processConnectionInfo(ConnectionInfo connectionInfo, Node[] nodes) { for (Node node: nodes) { for (List<Connection> connections: node.getOutgoingConnections().values()) { for (Connection connection: connections) { String id = (String) connection.getMetaData().get("UniqueId"); if (id != null && id.equals(connectionInfo.getElementRef())) { ((ConnectionImpl) connection).setMetaData( "bendpoints", connectionInfo.getBendpoints()); return true; } } } if (node instanceof NodeContainer) { boolean found = processConnectionInfo(connectionInfo, ((NodeContainer) node).getNodes()); if (found) { return true; } } } return false; }
private void visitSubVariableScopes(Node[] nodes, StringBuilder xmlDump, Set<String> dumpedItemDefs) { for (Node node: nodes) { if (node instanceof ContextContainer) { VariableScope variableScope = (VariableScope) ((ContextContainer) node).getDefaultContext(VariableScope.VARIABLE_SCOPE); if (variableScope != null) { visitVariableScope(variableScope, XmlBPMNProcessDumper.getUniqueNodeId(node) + "-", xmlDump, dumpedItemDefs); } } if (node instanceof NodeContainer) { visitSubVariableScopes(((NodeContainer) node).getNodes(), xmlDump, dumpedItemDefs); } } }
private Node findNode(RuleFlowProcess process, String nodeName) { Node found = null; Queue<org.kie.api.definition.process.Node> nodes = new LinkedList<org.kie.api.definition.process.Node>(); nodes.addAll(Arrays.asList(process.getNodes())); while( ! nodes.isEmpty() ) { org.kie.api.definition.process.Node node = nodes.poll(); if (node.getName().equals(nodeName) ) { found = (Node) node; } if( node instanceof NodeContainer ) { nodes.addAll(Arrays.asList(((NodeContainer) node).getNodes())); } } assertNotNull("Could not find node (" + nodeName + ").", found); return found; }
public void assertNodeExists(ProcessInstance process, String... nodeNames) { WorkflowProcessInstanceImpl instance = (WorkflowProcessInstanceImpl) process; List<String> names = new ArrayList<String>(); for (String nodeName : nodeNames) { names.add(nodeName); } for (Node node : instance.getNodeContainer().getNodes()) { if (names.contains(node.getName())) { names.remove(node.getName()); } } if (!names.isEmpty()) { String s = names.get(0); for (int i = 1; i < names.size(); i++) { s += ", " + names.get(i); } fail("Node(s) do not exist: " + s); } }
public void start(String trigger) { synchronized (this) { registerExternalEventNodeListeners(); // activate timer event sub processes Node[] nodes = getNodeContainer().getNodes(); for (Node node : nodes) { if (node instanceof EventSubProcessNode) { Map<Timer, DroolsAction> timers = ((EventSubProcessNode) node).getTimers(); if (timers != null && !timers.isEmpty()) { EventSubProcessNodeInstance eventSubprocess = (EventSubProcessNodeInstance) getNodeInstance(node); eventSubprocess.trigger(null, org.jbpm.workflow.core.Node.CONNECTION_DEFAULT_TYPE); } } } super.start(trigger); } }
private void processNodes( Node[] nodes, Process process, ProcessDescr processDescr, ProcessBuildContext context) { for ( Node node : nodes ) { ProcessNodeBuilder builder = ProcessNodeBuilderRegistry.INSTANCE.getNodeBuilder( node ); if ( builder != null ) { // only build if there is a registered builder for this node type builder.build( process, processDescr, context, node ); } if ( node instanceof NodeContainer ) { processNodes( ((NodeContainer) node).getNodes(), process, processDescr, context ); } if ( node instanceof ContextContainer ) { buildContexts( (ContextContainer) node, context ); } if ("true".equals(System.getProperty("jbpm.enable.multi.con"))) { builder = ProcessNodeBuilderRegistry.INSTANCE.getNodeBuilder( NodeImpl.class ); if (builder != null) { builder.build(process, processDescr, context, node); } } } }
public void assertNumOfIncommingConnections(ProcessInstance process, String nodeName, int num) { assertNodeExists(process, nodeName); WorkflowProcessInstanceImpl instance = (WorkflowProcessInstanceImpl) process; for (Node node : instance.getNodeContainer().getNodes()) { if (node.getName().equals(nodeName)) { if (node.getIncomingConnections().size() != num) { fail("Expected incomming connections: " + num + " - found " + node.getIncomingConnections().size()); } else { break; } } } }
public void assertNumOfOutgoingConnections(ProcessInstance process, String nodeName, int num) { assertNodeExists(process, nodeName); WorkflowProcessInstanceImpl instance = (WorkflowProcessInstanceImpl) process; for (Node node : instance.getNodeContainer().getNodes()) { if (node.getName().equals(nodeName)) { if (node.getOutgoingConnections().size() != num) { fail("Expected outgoing connections: " + num + " - found " + node.getOutgoingConnections().size()); } else { break; } } } }
private boolean processNodeInfo(NodeInfo nodeInfo, Node[] nodes) { if (nodeInfo == null || nodeInfo.getNodeRef() == null) { return false; } for (Node node: nodes) { String id = (String) node.getMetaData().get("UniqueId"); if (nodeInfo.getNodeRef().equals(id)) { ((org.jbpm.workflow.core.Node) node).setMetaData("x", nodeInfo.getX()); ((org.jbpm.workflow.core.Node) node).setMetaData("y", nodeInfo.getY()); ((org.jbpm.workflow.core.Node) node).setMetaData("width", nodeInfo.getWidth()); ((org.jbpm.workflow.core.Node) node).setMetaData("height", nodeInfo.getHeight()); return true; } if (node instanceof NodeContainer) { boolean found = processNodeInfo(nodeInfo, ((NodeContainer) node).getNodes()); if (found) { return true; } } } return false; }
private void postProcessNodes(RuleFlowProcess process, NodeContainer container, ProcessBuildData buildData, ExtensibleXmlParser parser) { for (Node node : container.getNodes()) { if (node instanceof SubProcessNode) { Map<String, String> processes = (Map<String, String>) buildData.getMetaData("ProcessElements"); if (processes != null) { SubProcessNode subprocessNode = (SubProcessNode) node; subprocessNode.setProcessId(processes.getOrDefault(subprocessNode.getProcessId(), subprocessNode.getProcessId())); } } else if (node instanceof RuleSetNode) { Map<String, Decision> decisions = (Map<String, Decision>) buildData.getMetaData("DecisionElements"); RuleSetNode ruleSetNode = (RuleSetNode) node; if (decisions != null && decisions.containsKey(ruleSetNode.getRuleFlowGroup())) { Decision decision = decisions.get(ruleSetNode.getRuleFlowGroup()); ruleSetNode.setRuleFlowGroup(null); ruleSetNode.setLanguage(RuleSetNode.DMN_LANG); ruleSetNode.setNamespace((String) parser.getNamespaceURI(decision.getNamespace())); ruleSetNode.setModel(decision.getModel()); ruleSetNode.setDecision(decision.getDecision()); } } if (node instanceof NodeContainer) { postProcessNodes(process, (NodeContainer) node, buildData, parser); } } }