[JBoss JIRA] Created: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
7:09 p.m.
Node, State and ProcessState don't support Conditions on Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
boolean hasTransitioned = false;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (!hasTransitioned) {
this.getDefaultLeavingTransition().removeConditionEnforcement();
log.warn("All transition conditions have evaluated to 'false'.
Taking the default transition.");
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
7:12 p.m.
New subject: [JBoss JIRA] Updated: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=all ]
Britt Miner updated JBPM-1185:
------------------------------
Description:
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
this.getDefaultLeavingTransition().removeConditionEnforcement();
log.warn("All transition conditions have evaluated to 'false'.
Taking the default transition.");
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
was:
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
boolean hasTransitioned = false;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (!hasTransitioned) {
this.getDefaultLeavingTransition().removeConditionEnforcement();
log.warn("All transition conditions have evaluated to 'false'.
Taking the default transition.");
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
this.getDefaultLeavingTransition().removeConditionEnforcement();
log.warn("All transition conditions have evaluated to 'false'.
Taking the default transition.");
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
7:20 p.m.
New subject: [JBoss JIRA] Updated: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=all ]
Britt Miner updated JBPM-1185:
------------------------------
Description:
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
was:
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
this.getDefaultLeavingTransition().removeConditionEnforcement();
log.warn("All transition conditions have evaluated to 'false'.
Taking the default transition.");
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
7:25 p.m.
New subject: [JBoss JIRA] Commented: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=comments#action_12415488 ]
Britt Miner commented on JBPM-1185:
-----------------------------------
This could also be accomplished more easily by simply adding the magic code into the
getDefaultLeavingTransition method, but I wasn't sure what else might be affected by
that.
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:35 a.m.
New subject: [JBoss JIRA] Commented: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=comments#action_12415500 ]
Ronald van Kuijk commented on JBPM-1185:
----------------------------------------
haven't had a look at the rest of the code, but it seems that in this case only one
transition is always returned. With guarded transitions (what they in fact are)
shouldn't there be a list of available transitions? Now only the *first* matching is
returned.
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:41 a.m.
New subject: [JBoss JIRA] Updated: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=all ]
Britt Miner updated JBPM-1185:
------------------------------
Description:
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
was:
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or State,
the schema allows it, the documentation doesn't forbid it, and the current behavior of
a Transition element in the jpdl is inconsistent. The fix to make everything consistent is
fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and a one-liner in
ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
}
} else {
transition = candidate;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:19 a.m.
New subject: [JBoss JIRA] Commented: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=comments#action_12415592 ]
Britt Miner commented on JBPM-1185:
-----------------------------------
calculateLeavingTransition() is a new method. None of the changed functionality currently
returns more than the default transition (one transition) anyway.
Node.leave(ExecutionContext executionContext) uses the default transition, and the line in
ProcessState also uses the default transition. Both of these scenarios are really begging
for the "proper" transition to take, not necessarily the "first" one.
The code changes just ensure that the "proper" transition is what is taken.
Truly, "getDefaultLeavingTransition()" should evolve into always returning the
"proper" calculated leaving transition. But I'm not confident enough with
other areas of the code to know what might be affected by doing that. Also,
getDefaultTransition() doesn't currently take an ExecutionContext, and that's
required to evaluate the Conditions.
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Assigned To: Tom Baeyens
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
7:43 a.m.
New subject: [JBoss JIRA] Updated: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[ http://jira.jboss.com/jira/browse/JBPM-1185?page=all ]
Thomas Diesler updated JBPM-1185:
---------------------------------
Assignee: (was: Tom Baeyens)
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: http://jira.jboss.com/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM jPDL 3.2.2
Reporter: Britt Miner
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://jira.jboss.com/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:42 p.m.
New subject: [JBoss JIRA] Commented: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[
https://jira.jboss.org/jira/browse/JBPM-1185?page=com.atlassian.jira.plug...
]
Ronald van Kuijk commented on JBPM-1185:
----------------------------------------
Britt,
I'm currently going over schema/code differences and was wondering why you choose to
have the conditions added in the code instead of restricting them in the schema (which is
easier)
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: https://jira.jboss.org/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM 3.2.2
Reporter: Britt Miner
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:40 a.m.
New subject: [JBoss JIRA] Updated: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[
https://jira.jboss.org/jira/browse/JBPM-1185?page=com.atlassian.jira.plug...
]
Thomas Diesler updated JBPM-1185:
---------------------------------
Fix Version/s: jBPM 3.3.2 GA
(was: jBPM 3.3.1 GA)
Deferred to 3.3.2
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: https://jira.jboss.org/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM 3.2.2
Reporter: Britt Miner
Fix For: jBPM 3.3.2 GA
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:19 a.m.
New subject: [JBoss JIRA] Commented: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[
https://jira.jboss.org/jira/browse/JBPM-1185?page=com.atlassian.jira.plug...
]
Tom Baeyens commented on JBPM-1185:
-----------------------------------
The best solution for this in jbpm 3 is to bring the docs in sync with the impl. The docs
should explain explicitely that the conditions are only evaluated when a signal is given.
In jBPM 4 we can consider to have 2 separate methods:
* getLeavingTransitions()
* getAvailableLeavingTransitions()
where only the second one will evaluate the conditions.
The node implementations can then decide for themselves which of the two they want.
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: https://jira.jboss.org/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM 3.2.2
Reporter: Britt Miner
Fix For: jBPM 3.3.x
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
6:48 a.m.
New subject: [JBoss JIRA] Commented: (JBPM-1185) Node, State and ProcessState don't support Conditions on Transitions
[
https://jira.jboss.org/jira/browse/JBPM-1185?page=com.atlassian.jira.plug...
]
s p commented on JBPM-1185:
---------------------------
There is workaround we use in our ActionNodes -
every action at the end calls method that evaluates all transitions conditions and calls
signal(first transition that returned true).
Node, State and ProcessState don't support Conditions on
Transitions
--------------------------------------------------------------------
Key: JBPM-1185
URL: https://jira.jboss.org/jira/browse/JBPM-1185
Project: JBoss jBPM
Issue Type: Bug
Components: Core Engine
Affects Versions: jBPM 3.2.2
Reporter: Britt Miner
Fix For: jBPM 3.2.x
Node, State, and ProcessState don't provide any preliminary check for conditions
provided on transitions. No check is performed until the transition is signaled, at which
point the process will barf if a condition is present on the default transition, and that
condition evaluates to false.
Regardless if a person "should" be using transition conditions in Node or
State, the schema allows it, the documentation doesn't forbid it, and the current
behavior of a Transition element in the jpdl is inconsistent. The fix to make everything
consistent is fairly simple--only org.jbpm.graph.def.Node needs to really be altered (and
a one-liner in ProcessState):
In org.jbpm.graph.def.Node, add the following method:
// BRITT--
public Transition calculateLeavingTransition(ExecutionContext executionContext) {
Transition transition = null;
Iterator iter = leavingTransitions.iterator();
while (iter.hasNext()) {
Transition candidate = (Transition) iter.next();
String conditionExpression = candidate.getCondition();
if (conditionExpression != null) {
Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
executionContext);
if (Boolean.TRUE.equals(result)) {
transition = candidate;
break;
}
} else {
transition = candidate;
break;
}
}
if (transition == null) {
log.warn("All transition conditions have evaluated to 'false'.
Returning the default transition, prepped for signalling (condition enforcement has been
removed).");
this.getDefaultLeavingTransition().removeConditionEnforcement();
transition = this.getDefaultLeavingTransition();
}
return transition;
}
// --BRITT
...and modify "leave(ExecutionContext executionContext)":
// BRITT --replace the following line with the code below
// to check conditions before selecting the transition to take...
//leave(executionContext, getDefaultLeavingTransition()); //original line
leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
For consistency, ProcessState should also have one line modified at the very end of
it's "leave(ExecutionContext, Transition)" method:
// BRITT-- rather than specify which transition, let the super class decide...
//super.leave(executionContext, getDefaultLeavingTransition());
super.leave(executionContext, calculateLeavingTransition(executionContext));
// --BRITT
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5548
days inactive
5821
days old
11 comments
5 participants
participants (5)
-
Britt Miner (JIRA) -
Ronald van Kuijk (JIRA)
-
s p (JIRA)
-
Thomas Diesler (JIRA)
-
Tom Baeyens (JIRA)