/**
* Copyright 2005 Red Hat, Inc. and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jbpm.ruleflow.core.validation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import org.drools.core.process.core.Work;
import org.drools.core.process.core.datatype.DataType;
import org.drools.core.time.impl.CronExpression;
import org.jbpm.process.core.context.exception.CompensationScope;
import org.jbpm.process.core.context.variable.Variable;
import org.jbpm.process.core.event.EventFilter;
import org.jbpm.process.core.event.EventTypeFilter;
import org.jbpm.process.core.timer.DateTimeUtils;
import org.jbpm.process.core.timer.Timer;
import org.jbpm.process.core.validation.ProcessValidationError;
import org.jbpm.process.core.validation.ProcessValidator;
import org.jbpm.process.core.validation.impl.ProcessValidationErrorImpl;
import org.jbpm.ruleflow.core.RuleFlowProcess;
import org.jbpm.workflow.core.WorkflowProcess;
import org.jbpm.workflow.core.impl.DroolsConsequenceAction;
import org.jbpm.workflow.core.impl.NodeImpl;
import org.jbpm.workflow.core.node.ActionNode;
import org.jbpm.workflow.core.node.BoundaryEventNode;
import org.jbpm.workflow.core.node.CatchLinkNode;
import org.jbpm.workflow.core.node.CompositeNode;
import org.jbpm.workflow.core.node.CompositeNode.CompositeNodeEnd;
import org.jbpm.workflow.core.node.CompositeNode.NodeAndType;
import org.jbpm.workflow.core.node.DynamicNode;
import org.jbpm.workflow.core.node.EndNode;
import org.jbpm.workflow.core.node.EventNode;
import org.jbpm.workflow.core.node.EventSubProcessNode;
import org.jbpm.workflow.core.node.FaultNode;
import org.jbpm.workflow.core.node.ForEachNode;
import org.jbpm.workflow.core.node.ForEachNode.ForEachJoinNode;
import org.jbpm.workflow.core.node.ForEachNode.ForEachSplitNode;
import org.jbpm.workflow.core.node.Join;
import org.jbpm.workflow.core.node.MilestoneNode;
import org.jbpm.workflow.core.node.RuleSetNode;
import org.jbpm.workflow.core.node.Split;
import org.jbpm.workflow.core.node.StartNode;
import org.jbpm.workflow.core.node.StateNode;
import org.jbpm.workflow.core.node.SubProcessNode;
import org.jbpm.workflow.core.node.ThrowLinkNode;
import org.jbpm.workflow.core.node.TimerNode;
import org.jbpm.workflow.core.node.WorkItemNode;
import org.kie.api.definition.process.Connection;
import org.kie.api.definition.process.Node;
import org.kie.api.definition.process.NodeContainer;
import org.kie.api.definition.process.Process;
import org.kie.api.io.Resource;
import org.mvel2.ErrorDetail;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExpressionCompiler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Default implementation of a RuleFlow validator.
*
*/
public class RuleFlowProcessValidator implements ProcessValidator {
public static final String ASSOCIATIONS = "BPMN.Associations";
// TODO: make this pluggable
// TODO: extract generic process stuff and generic workflow stuff
private static RuleFlowProcessValidator instance;
private static final Logger logger = LoggerFactory.getLogger(RuleFlowProcessValidator.class);
private RuleFlowProcessValidator() {
}
public static RuleFlowProcessValidator getInstance() {
if ( instance == null ) {
instance = new RuleFlowProcessValidator();
}
return instance;
}
public ProcessValidationError[] validateProcess(final RuleFlowProcess process) {
final List<ProcessValidationError> errors = new ArrayList<ProcessValidationError>();
if (process.getName() == null) {
errors.add(new ProcessValidationErrorImpl(process,
"Process has no name."));
}
if (process.getId() == null || "".equals(process.getId())) {
errors.add(new ProcessValidationErrorImpl(process,
"Process has no id."));
}
// check start node of process
if ( process.getStartNodes().isEmpty() && !process.isDynamic()) {
errors.add(new ProcessValidationErrorImpl(process,
"Process has no start node."));
}
// Check end node of the process.
if (process.getEndNodes().isEmpty() && !process.isDynamic()) {
errors.add(new ProcessValidationErrorImpl(process,
"Process has no end node."));
}
validateNodes(process.getNodes(), errors, process);
validateVariables(errors, process);
checkAllNodesConnectedToStart(process, process.isDynamic(), errors, process);
return errors.toArray(new ProcessValidationError[errors.size()]);
}
private void validateNodes(Node[] nodes, List<ProcessValidationError> errors, RuleFlowProcess process) {
String isForCompensation = "isForCompensation";
for ( int i = 0; i < nodes.length; i++ ) {
final Node node = nodes[i];
if (node instanceof StartNode) {
final StartNode startNode = (StartNode) node;
if (startNode.getTo() == null) {
addErrorMessage(process, node, errors, "Start has no outgoing connection.");
}
if (startNode.getTimer() != null) {
validateTimer(startNode.getTimer(), node, process, errors);
}
} else if (node instanceof EndNode) {
final EndNode endNode = (EndNode) node;
if (endNode.getFrom() == null) {
addErrorMessage(process, node, errors, "End has no incoming connection.");
}
validateCompensationIntermediateOrEndEvent(endNode, process, errors);
} else if (node instanceof RuleSetNode) {
final RuleSetNode ruleSetNode = (RuleSetNode) node;
if (ruleSetNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "RuleSet has no incoming connection.");
}
if (ruleSetNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process, node, errors, "RuleSet has no outgoing connection.");
}
final String language = ruleSetNode.getLanguage();
if (RuleSetNode.DRL_LANG.equals(language)) {
final String ruleFlowGroup = ruleSetNode.getRuleFlowGroup();
if (ruleFlowGroup == null || "".equals(ruleFlowGroup)) {
addErrorMessage(process, node, errors, "RuleSet (DRL) has no ruleflow-group.");
}
} else if (RuleSetNode.DMN_LANG.equals(language)) {
final String namespace = ruleSetNode.getNamespace();
if (namespace == null || "".equals(namespace)) {
addErrorMessage(process, node, errors, "RuleSet (DMN) has no namespace.");
}
final String model = ruleSetNode.getModel();
if (model == null || "".equals(model)) {
addErrorMessage(process, node, errors, "RuleSet (DMN) has no model.");
}
} else {
addErrorMessage(process, node, errors, "Unsupported rule language '" + language + "'");
}
if (ruleSetNode.getTimers() != null) {
for (Timer timer: ruleSetNode.getTimers().keySet()) {
validateTimer(timer, node, process, errors);
}
}
} else if (node instanceof Split) {
final Split split = (Split) node;
if (split.getType() == Split.TYPE_UNDEFINED) {
addErrorMessage(process, node, errors, "Split has no type.");
}
if (split.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Split has no incoming connection.");
}
if (split.getDefaultOutgoingConnections().size() < 2) {
addErrorMessage(process, node, errors, "Split does not have more than one outgoing connection: " + split.getOutgoingConnections().size() + ".");
}
if (split.getType() == Split.TYPE_XOR || split.getType() == Split.TYPE_OR ) {
for ( final Iterator<Connection> it = split.getDefaultOutgoingConnections().iterator(); it.hasNext(); ) {
final Connection connection = it.next();
if (split.getConstraint(connection) == null && !split.isDefault(connection)
|| (!split.isDefault(connection)
&& (split.getConstraint(connection).getConstraint() == null
|| split.getConstraint(connection).getConstraint().trim().length() == 0))) {
addErrorMessage(process, node, errors, "Split does not have a constraint for " + connection.toString() + ".");
}
}
}
} else if (node instanceof Join) {
final Join join = (Join) node;
if (join.getType() == Join.TYPE_UNDEFINED) {
addErrorMessage(process, node, errors, "Join has no type.");
}
if (join.getDefaultIncomingConnections().size() < 2) {
addErrorMessage(process, node, errors, "Join does not have more than one incoming connection: " + join.getIncomingConnections().size() + ".");
}
if (join.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process, node, errors, "Join has no outgoing connection.");
}
if (join.getType() == Join.TYPE_N_OF_M) {
String n = join.getN();
if (!n.startsWith("#{") || !n.endsWith("}")) {
try {
new Integer(n);
} catch (NumberFormatException e) {
addErrorMessage(process, node, errors, "Join has illegal n value: " + n);
}
}
}
} else if (node instanceof MilestoneNode) {
final MilestoneNode milestone = (MilestoneNode) node;
if (milestone.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Milestone has no incoming connection.");
}
if (milestone.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process, node, errors, "Milestone has no outgoing connection.");
}
if (milestone.getConstraint() == null) {
addErrorMessage(process, node, errors, "Milestone has no constraint.");
}
if (milestone.getTimers() != null) {
for (Timer timer: milestone.getTimers().keySet()) {
validateTimer(timer, node, process, errors);
}
}
} else if (node instanceof StateNode) {
final StateNode stateNode = (StateNode) node;
if (stateNode.getDefaultIncomingConnections().size() == 0 && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "State has no incoming connection");
}
}
else if (node instanceof SubProcessNode) {
final SubProcessNode subProcess = (SubProcessNode) node;
if (subProcess.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "SubProcess has no incoming connection.");
}
if (subProcess.getTo() == null && !acceptsNoOutgoingConnections(node)) {
Object compensationObj = subProcess.getMetaData(isForCompensation);
if( compensationObj == null || ! ((Boolean) compensationObj) ) {
addErrorMessage(process, node, errors, "SubProcess has no outgoing connection.");
}
}
if (subProcess.getProcessId() == null && subProcess.getProcessName() == null) {
addErrorMessage(process, node, errors, "SubProcess has no process id.");
}
if (subProcess.getTimers() != null) {
for (Timer timer: subProcess.getTimers().keySet()) {
validateTimer(timer, node, process, errors);
}
}
if(!subProcess.isIndependent() && !subProcess.isWaitForCompletion()){
addErrorMessage(process, node, errors, "SubProcess you can only set " +
"independent to 'false' only when 'Wait for completion' is set to true.");
}
} else if (node instanceof ActionNode) {
final ActionNode actionNode = (ActionNode) node;
if (actionNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Action has no incoming connection.");
}
if (actionNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
Object compensationObj = actionNode.getMetaData(isForCompensation);
if( compensationObj == null || ! ((Boolean) compensationObj) ) {
addErrorMessage(process, node, errors, "Action has no outgoing connection.");
}
}
if (actionNode.getAction() == null) {
addErrorMessage(process, node, errors, "Action has no action.");
} else if (actionNode.getAction() instanceof DroolsConsequenceAction) {
DroolsConsequenceAction droolsAction = (DroolsConsequenceAction) actionNode.getAction();
String actionString = droolsAction.getConsequence();
if (actionString == null) {
addErrorMessage(process, node, errors, "Action has empty action.");
} else if( "mvel".equals( droolsAction.getDialect() ) ) {
try {
ParserContext parserContext = new ParserContext();
//parserContext.setStrictTypeEnforcement(true);
ExpressionCompiler compiler = new ExpressionCompiler(actionString, parserContext);
compiler.setVerifying(true);
compiler.compile();
List<ErrorDetail> mvelErrors = parserContext.getErrorList();
if (mvelErrors != null) {
for (Iterator<ErrorDetail> iterator = mvelErrors.iterator(); iterator.hasNext(); ) {
ErrorDetail error = iterator.next();
addErrorMessage(process, node, errors, "Action has invalid action: " + error.getMessage() + ".");
}
}
} catch (Throwable t) {
addErrorMessage(process, node, errors, "Action has invalid action: " + t.getMessage() + ".");
}
}
// TODO: validation for "java" and "drools" scripts!
validateCompensationIntermediateOrEndEvent(actionNode, process, errors);
}
} else if (node instanceof WorkItemNode) {
final WorkItemNode workItemNode = (WorkItemNode) node;
if (workItemNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Task has no incoming connection.");
}
if (workItemNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
Object compensationObj = workItemNode.getMetaData(isForCompensation);
if( compensationObj == null || ! ((Boolean) compensationObj) ) {
addErrorMessage(process, node, errors, "Task has no outgoing connection.");
}
}
if (workItemNode.getWork() == null) {
addErrorMessage(process, node, errors, "Task has no work specified.");
} else {
Work work = workItemNode.getWork();
if (work.getName() == null || work.getName().trim().length() == 0) {
addErrorMessage(process, node, errors, "Task has no task type.");
}
}
if (workItemNode.getTimers() != null) {
for (Timer timer: workItemNode.getTimers().keySet()) {
validateTimer(timer, node, process, errors);
}
}
} else if (node instanceof ForEachNode) {
final ForEachNode forEachNode = (ForEachNode) node;
String variableName = forEachNode.getVariableName();
if (variableName == null || "".equals(variableName)) {
addErrorMessage(process, node, errors, "ForEach has no variable name");
}
String collectionExpression = forEachNode.getCollectionExpression();
if (collectionExpression == null || "".equals(collectionExpression)) {
addErrorMessage(process, node, errors, "ForEach has no collection expression");
}
if (forEachNode.getDefaultIncomingConnections().size() == 0 && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "ForEach has no incoming connection");
}
if (forEachNode.getDefaultOutgoingConnections().size() == 0 && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process, node, errors, "ForEach has no outgoing connection");
}
// TODO: check, if no linked connections, for start and end node(s)
// if (forEachNode.getLinkedIncomingNode(org.drools.workflow.core.Node.CONNECTION_DEFAULT_TYPE) == null) {
// errors.add(new ProcessValidationErrorImpl(process,
// "ForEach node '%s' [%d] has no linked start node"));
// }
// if (forEachNode.getLinkedOutgoingNode(org.drools.workflow.core.Node.CONNECTION_DEFAULT_TYPE) == null) {
// errors.add(new ProcessValidationErrorImpl(process,
// "ForEach node '%s' [%d] has no linked end node"));
// }
validateNodes(forEachNode.getNodes(), errors, process);
} else if (node instanceof DynamicNode) {
final DynamicNode dynamicNode = (DynamicNode) node;
if (dynamicNode.getDefaultIncomingConnections().size() == 0 && !acceptsNoIncomingConnections(dynamicNode)) {
addErrorMessage(process, node, errors, "Dynamic has no incoming connection");
}
if (dynamicNode.getDefaultOutgoingConnections().size() == 0 && !acceptsNoOutgoingConnections(dynamicNode)) {
addErrorMessage(process, node, errors, "Dynamic has no outgoing connection");
}
if ("".equals(dynamicNode.getCompletionExpression()) && !dynamicNode.isAutoComplete()) {
addErrorMessage(process, node, errors, "Dynamic has no completion condition set");
}
validateNodes(dynamicNode.getNodes(), errors, process);
} else if (node instanceof CompositeNode) {
final CompositeNode compositeNode = (CompositeNode) node;
for (Map.Entry<String, NodeAndType> inType: compositeNode.getLinkedIncomingNodes().entrySet()) {
if (compositeNode.getIncomingConnections(inType.getKey()).size() == 0 && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Composite has no incoming connection for type " + inType.getKey());
}
if (inType.getValue().getNode() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process, node, errors, "Composite has invalid linked incoming node for type " + inType.getKey());
}
}
for (Map.Entry<String, NodeAndType> outType: compositeNode.getLinkedOutgoingNodes().entrySet()) {
if (compositeNode.getOutgoingConnections(outType.getKey()).size() == 0) {
addErrorMessage(process, node, errors, "Composite has no outgoing connection for type " + outType.getKey());
}
if (outType.getValue().getNode() == null) {
addErrorMessage(process, node, errors, "Composite has invalid linked outgoing node for type " + outType.getKey());
}
}
if( compositeNode instanceof EventSubProcessNode ) {
if( compositeNode.getIncomingConnections().size() > 0 ) {
addErrorMessage(process, node, errors, "Event subprocess is not allowed to have any incoming connections." );
}
if( compositeNode.getOutgoingConnections().size() > 0 ) {
addErrorMessage(process, node, errors, "Event subprocess is not allowed to have any outgoing connections." );
}
Node [] eventSubProcessNodes = compositeNode.getNodes();
int startEventCount = 0;
for( int j = 0; j < eventSubProcessNodes.length; ++j ) {
if( eventSubProcessNodes[j] instanceof StartNode ) {
StartNode startNode = (StartNode) eventSubProcessNodes[j];
if( ++startEventCount == 2 ) {
addErrorMessage(process, compositeNode, errors, "Event subprocess is not allowed to have more than one start node.");
}
if( startNode.getTriggers() == null || startNode.getTriggers().isEmpty() ) {
addErrorMessage(process, startNode, errors, "Start in Event SubProcess '" + compositeNode.getName() + "' [" + compositeNode.getId() + "] must contain a trigger (event definition).");
}
}
}
} else {
Boolean isForCompensationObject = (Boolean) compositeNode.getMetaData("isForCompensation");
if( compositeNode.getIncomingConnections().size() == 0 && !Boolean.TRUE.equals(isForCompensationObject)) {
addErrorMessage(process, node, errors, "Embedded subprocess does not have incoming connection.");
}
if( compositeNode.getOutgoingConnections().size() == 0 && !Boolean.TRUE.equals(isForCompensationObject)) {
addErrorMessage(process, node, errors, "Embedded subprocess does not have outgoing connection.");
}
}
if (compositeNode.getTimers() != null) {
for (Timer timer: compositeNode.getTimers().keySet()) {
validateTimer(timer, node, process, errors);
}
}
validateNodes(compositeNode.getNodes(), errors, process);
} else if (node instanceof EventNode) {
final EventNode eventNode = (EventNode) node;
if (eventNode.getEventFilters().size() == 0) {
addErrorMessage(process, node, errors, "Event should specify an event type");
}
if (eventNode.getDefaultOutgoingConnections().size() == 0) {
addErrorMessage(process, node, errors, "Event has no outgoing connection");
} else {
List<EventFilter> eventFilters = eventNode.getEventFilters();
boolean compensationHandler = false;
for( EventFilter eventFilter : eventFilters ) {
if( ((EventTypeFilter) eventFilter).getType().startsWith("Compensation") ) {
compensationHandler = true;
break;
}
}
if( compensationHandler && eventNode instanceof BoundaryEventNode) {
Connection connection = eventNode.getDefaultOutgoingConnections().get(0);
Boolean isAssociation = (Boolean) connection.getMetaData().get("association");
if( isAssociation == null ) {
isAssociation = false;
}
if( ! (eventNode.getDefaultOutgoingConnections().size() == 1 && connection != null && isAssociation) ) {
addErrorMessage(process, node, errors, "Compensation Boundary Event is only allowed to have 1 association to 1 compensation activity.");
}
}
}
} else if (node instanceof FaultNode) {
final FaultNode faultNode = (FaultNode) node;
if (faultNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Fault has no incoming connection.");
}
if (faultNode.getFaultName() == null) {
addErrorMessage(process, node, errors, "Fault has no fault name.");
}
} else if (node instanceof TimerNode) {
TimerNode timerNode = (TimerNode) node;
if (timerNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process, node, errors, "Timer has no incoming connection.");
}
if (timerNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process, node, errors, "Timer has no outgoing connection.");
}
if (timerNode.getTimer() == null) {
addErrorMessage(process, node, errors, "Timer has no timer specified.");
} else {
validateTimer(timerNode.getTimer(), node, process, errors);
}
} else if (node instanceof CatchLinkNode) {
// catchlink validation here, there also are validations in
// ProcessHandler regarding connection issues
}
else if (node instanceof ThrowLinkNode) {
// throw validation here, there also are validations in
// ProcessHandler regarding connection issues
}
else {
errors.add(new ProcessValidationErrorImpl(process,
"Unknown node type '" + node.getClass().getName() + "'"));
}
}
}
private void checkAllNodesConnectedToStart(final NodeContainer container, boolean isDynamic,
final List<ProcessValidationError> errors, RuleFlowProcess process) {
final Map<Node, Boolean> processNodes = new HashMap<Node, Boolean>();
final Node[] nodes;
if (container instanceof CompositeNode) {
nodes = ((CompositeNode) container).internalGetNodes();
} else {
nodes = container.getNodes();
}
List<Node> eventNodes = new ArrayList<Node>();
List<CompositeNode> compositeNodes = new ArrayList<CompositeNode>();
for (int i = 0; i < nodes.length; i++) {
final Node node = nodes[i];
processNodes.put(node, Boolean.FALSE);
if (node instanceof EventNode) {
eventNodes.add(node);
}
if (node instanceof CompositeNode) {
compositeNodes.add((CompositeNode) node);
}
}
if (isDynamic) {
for (Node node: nodes) {
if (node.getIncomingConnections(NodeImpl.CONNECTION_DEFAULT_TYPE).isEmpty()) {
processNode(node, processNodes);
}
}
} else {
final List<Node> start = RuleFlowProcess.getStartNodes(nodes);
if (start != null) {
for (Node s : start) {
processNode(s, processNodes);
}
}
if (container instanceof CompositeNode) {
for (CompositeNode.NodeAndType nodeAndTypes: ((CompositeNode) container).getLinkedIncomingNodes().values()) {
processNode(nodeAndTypes.getNode(), processNodes);
}
}
}
for (Node eventNode: eventNodes) {
processNode(eventNode, processNodes);
}
for (CompositeNode compositeNode: compositeNodes) {
checkAllNodesConnectedToStart(
compositeNode, compositeNode instanceof DynamicNode, errors, process);
}
for ( final Iterator<Node> it = processNodes.keySet().iterator(); it.hasNext(); ) {
final Node node = it.next();
if (Boolean.FALSE.equals(processNodes.get(node)) && !(node instanceof StartNode) && !(node instanceof EventSubProcessNode)) {
addErrorMessage(process, node, errors, "Has no connection to the start node.");
}
}
}
private void processNode(final Node node, final Map<Node, Boolean> nodes) {
if (!nodes.containsKey(node) && !((node instanceof CompositeNodeEnd) || (node instanceof ForEachSplitNode) || (node instanceof ForEachJoinNode))) {
throw new IllegalStateException("A process node is connected with a node that does not belong to the process: " + node.getName());
}
final Boolean prevValue = (Boolean) nodes.put(node, Boolean.TRUE);
if (prevValue == Boolean.FALSE || prevValue == null) {
for (final Iterator<List<Connection>> it = node.getOutgoingConnections().values().iterator(); it.hasNext(); ) {
final List<Connection> list = it.next();
for (final Iterator<Connection> it2 = list.iterator(); it2.hasNext(); ) {
processNode(it2.next().getTo(), nodes);
}
}
}
}
private boolean acceptsNoIncomingConnections(Node node) {
NodeContainer nodeContainer = node.getNodeContainer();
return nodeContainer instanceof DynamicNode ||
(nodeContainer instanceof WorkflowProcess && ((WorkflowProcess) nodeContainer).isDynamic());
}
private boolean acceptsNoOutgoingConnections(Node node) {
NodeContainer nodeContainer = node.getNodeContainer();
return nodeContainer instanceof DynamicNode ||
(nodeContainer instanceof WorkflowProcess && ((WorkflowProcess) nodeContainer).isDynamic());
}
private void validateTimer(final Timer timer, final Node node,
final RuleFlowProcess process, final List<ProcessValidationError> errors) {
if (timer.getDelay() == null && timer.getDate() == null) {
addErrorMessage(process, node, errors, "Has timer with no delay or date specified.");
} else {
if (timer.getDelay() != null && !timer.getDelay().contains("#{")) {
try {
switch (timer.getTimeType()) {
case Timer.TIME_CYCLE:
if (CronExpression.isValidExpression(timer.getDelay())){
} else {
// when using ISO date/time period is not set
DateTimeUtils.parseRepeatableDateTime(timer.getDelay());
}
break;
case Timer.TIME_DURATION:
DateTimeUtils.parseDuration(timer.getDelay());
break;
case Timer.TIME_DATE:
DateTimeUtils.parseDateAsDuration(timer.getDate());
break;
default:
break;
}
} catch (RuntimeException e) {
addErrorMessage(process, node, errors, "Could not parse delay '" + timer.getDelay() + "': " + e.getMessage());
}
}
}
if (timer.getPeriod() != null) {
if (!timer.getPeriod().contains("#{")) {
try {
if (CronExpression.isValidExpression(timer.getPeriod())){
} else {
// when using ISO date/time period is not set
DateTimeUtils.parseRepeatableDateTime(timer.getPeriod());
}
} catch (RuntimeException e) {
addErrorMessage(process, node, errors, "Could not parse period '" + timer.getPeriod() + "': " + e.getMessage());
}
}
}
if (timer.getDate() != null) {
if (!timer.getDate().contains("#{")) {
try {
DateTimeUtils.parseDateAsDuration(timer.getDate());
} catch (RuntimeException e) {
addErrorMessage(process, node, errors, "Could not parse date '" + timer.getDate() + "': " + e.getMessage());
}
}
}
}
public ProcessValidationError[] validateProcess(Process process) {
if (!(process instanceof RuleFlowProcess)) {
throw new IllegalArgumentException(
"This validator can only validate ruleflow processes!");
}
return validateProcess((RuleFlowProcess) process);
}
private void validateVariables(List<ProcessValidationError> errors, RuleFlowProcess process) {
List<Variable> variables = process.getVariableScope().getVariables();
if (variables != null) {
for (Variable var : variables) {
DataType varDataType = var.getType();
if (varDataType == null) {
errors.add(new ProcessValidationErrorImpl(process, "Variable '" + var.getName() + "' has no type."));
}
}
}
}
@Override
public boolean accept(Process process, Resource resource) {
if (RuleFlowProcess.RULEFLOW_TYPE.equals(process.getType())) {
return true;
}
return false;
}
protected void validateCompensationIntermediateOrEndEvent(Node node, RuleFlowProcess process, List<ProcessValidationError> errors) {
if( node.getMetaData().containsKey("Compensation") ) {
// Validate that activityRef in throw/end compensation event refers to "visible" compensation
String activityRef = (String) node.getMetaData().get("Compensation");
Node refNode = null;
if( activityRef != null ) {
Queue<Node> nodeQueue = new LinkedList<Node>();
nodeQueue.addAll(Arrays.asList(process.getNodes()));
while( ! nodeQueue.isEmpty() ) {
Node polledNode = nodeQueue.poll();
if( activityRef.equals(polledNode.getMetaData().get("UniqueId")) ) {
refNode = polledNode;
break;
}
if( node instanceof NodeContainer ) {
nodeQueue.addAll(Arrays.asList(((NodeContainer) node).getNodes()));
}
}
}
if( refNode == null ) {
addErrorMessage(process, node, errors,
"Does not reference an activity that exists (" + activityRef
+ ") in its compensation event definition.");
}
CompensationScope compensationScope
= (CompensationScope) ((NodeImpl) node).resolveContext(CompensationScope.COMPENSATION_SCOPE, activityRef);
if( compensationScope == null ) {
addErrorMessage(process, node, errors,
"References an activity (" + activityRef
+ ") in its compensation event definition that is not visible to it.");
}
}
}
@Override
public boolean compilationSupported() {
return true;
}
protected void addErrorMessage(RuleFlowProcess process, Node node, List<ProcessValidationError> errors, String message) {
String error = String.format("Node '%s' [%d] " + message, node.getName(), node.getId());
errors.add(new ProcessValidationErrorImpl(process, error));
}
}