public void Execute(IActivityExecution execution)
{
var more = execution.Activity.FindOutgoingTransition("more");
var done = execution.Activity.FindOutgoingTransition("done");
var value = (int?)execution.GetVariable(_variableName);
if (value == null)
{
execution.SetVariable(_variableName, _from);
execution.LeaveActivityViaTransition(more);
}
else
{
value = value + 1;
if (value < _to)
{
execution.SetVariable(_variableName, value);
execution.LeaveActivityViaTransition(more);
}
else
{
execution.LeaveActivityViaTransition(done);
}
}
}
/// <summary>
/// The default behaviour of BPMN, taking every outgoing sequence flow
/// (where the condition evaluates to true), is not valid for an exclusive
/// gateway.
/// Hence, this behaviour is overriden and replaced by the correct behavior:
/// selecting the first sequence flow which condition evaluates to true
/// (or which hasn't got a condition) and leaving the activity through that
/// sequence flow.
/// If no sequence flow is selected (ie all conditions evaluate to false),
/// then the default sequence flow is taken (if defined).
/// </summary>
public override void DoLeave(IActivityExecution execution)
{
Log.LeavingActivity(execution.Activity.Id);
IPvmTransition outgoingSeqFlow = null;
var defaultSequenceFlow = (string)execution.Activity.GetProperty("default");
var transitionIterator = execution.Activity.OutgoingTransitions.GetEnumerator();
while ((outgoingSeqFlow == null) && transitionIterator.MoveNext())
{
var seqFlow = transitionIterator.Current;
var condition = (ICondition)seqFlow.GetProperty(BpmnParse.PropertynameCondition);
if (((condition == null) &&
(ReferenceEquals(defaultSequenceFlow, null) || !defaultSequenceFlow.Equals(seqFlow.Id))) ||
((condition != null) && condition.Evaluate(execution)))
{
Log.OutgoingSequenceFlowSelected(seqFlow.Id);
outgoingSeqFlow = seqFlow;
}
}
if (outgoingSeqFlow != null)
{
execution.LeaveActivityViaTransition(outgoingSeqFlow);
}
else
{
if (!ReferenceEquals(defaultSequenceFlow, null))
{
var defaultTransition = execution.Activity.FindOutgoingTransition(defaultSequenceFlow);
if (defaultTransition != null)
{
execution.LeaveActivityViaTransition(defaultTransition);
}
else
{
throw Log.MissingDefaultFlowException(execution.Activity.Id, defaultSequenceFlow);
}
}
else
{
//No sequence flow could be found, not even a default one
throw Log.StuckExecutionException(execution.Activity.Id);
}
}
}
public void Execute(IActivityExecution execution)
{
IList <IPvmTransition> outgoingTransitions = execution.Activity.OutgoingTransitions;
if (!outgoingTransitions.Any())
{
execution.End(true);
}
else
{
execution.LeaveActivityViaTransition(outgoingTransitions[0]);
}
}
public void Execute(IActivityExecution execution)
{
string @var = (string)execution.GetVariable("var");
IPvmTransition transition = null;
try
{
ExecuteLogic(@var);
transition = execution.Activity.FindOutgoingTransition("no-exception");
}
catch (System.Exception)
{
transition = execution.Activity.FindOutgoingTransition("exception");
}
execution.LeaveActivityViaTransition(transition);
}
public void Execute(IActivityExecution execution)
{
IPvmTransition transition = null;
var creditRating = (string)execution.GetVariable("creditRating");
if (creditRating.Equals("AAA+"))
{
transition = execution.Activity.FindOutgoingTransition("wow");
}
else if (creditRating.Equals("Aaa-"))
{
transition = execution.Activity.FindOutgoingTransition("nice");
}
else
{
transition = execution.Activity.FindOutgoingTransition("default");
}
execution.LeaveActivityViaTransition(transition);
}
/// <summary>
/// Actual implementation of leaving an activity.
/// </summary>
/// <param name="execution">
/// The current execution context
/// </param>
/// <param name="checkConditions">
/// Whether or not to check conditions before determining whether or
/// not to take a transition.
/// </param>
/// <param name="throwExceptionIfExecutionStuck">
/// If true, an <seealso cref="ProcessEngineException" /> will be thrown in case no
/// transition could be found to leave the activity.
/// </param>
protected internal virtual void PerformOutgoingBehavior(IActivityExecution execution, bool checkConditions,
bool throwExceptionIfExecutionStuck, IList <IActivityExecution> reusableExecutions)
{
Log.LeavingActivity(execution.Activity.Id);
var defaultSequenceFlow = (string)execution.Activity.GetProperty("default");
IList <IPvmTransition> transitionsToTake = new List <IPvmTransition>();
IList <IPvmTransition> outgoingTransitions = execution.Activity.OutgoingTransitions;
foreach (IPvmTransition outgoingTransition in outgoingTransitions)
{
if (defaultSequenceFlow == null || outgoingTransition.Id != defaultSequenceFlow)
{
var condition = (ICondition)outgoingTransition.GetProperty(BpmnParse.PropertynameCondition);
if ((condition == null) || !checkConditions || condition.Evaluate(execution))
{
transitionsToTake.Add(outgoingTransition);
}
}
}
if (transitionsToTake.Count == 1)
{
execution.LeaveActivityViaTransition(transitionsToTake.ElementAt(0));
}
else if (transitionsToTake.Count >= 1)
{
if (reusableExecutions == null || reusableExecutions.Count == 0)
{
execution.LeaveActivityViaTransitions(transitionsToTake, new List <IActivityExecution>()
{
execution
});
}
else
{
execution.LeaveActivityViaTransitions(transitionsToTake, reusableExecutions);
}
}
else
{
//if (!ReferenceEquals(defaultSequenceFlow, null))
if (!string.IsNullOrEmpty(defaultSequenceFlow))
{
var defaultTransition = execution.Activity.FindOutgoingTransition(defaultSequenceFlow);
if (defaultTransition != null)
{
execution.LeaveActivityViaTransition(defaultTransition);
}
else
{
throw Log.MissingDefaultFlowException(execution.Activity.Id, defaultSequenceFlow);
}
}
else if (outgoingTransitions.Count > 0)
{
throw Log.MissingConditionalFlowException(execution.Activity.Id);
}
else
{
if (((ActivityImpl)execution.Activity).CompensationHandler &&
IsAncestorCompensationThrowing(execution))
{
execution.EndCompensation();
}
else
{
Log.MissingOutgoingSequenceFlow(execution.Activity.Id);
execution.End(true);
if (throwExceptionIfExecutionStuck)
{
throw Log.StuckExecutionException(execution.Activity.Id);
}
}
}
}
}
public void Signal(IActivityExecution execution, String signalName, Object signalData)
{
IPvmTransition transition = execution.Activity.OutgoingTransitions[0];
execution.LeaveActivityViaTransition(transition);
}
public virtual void Execute(IActivityExecution execution)
{
IPvmTransition transition = execution.Activity.OutgoingTransitions[0];
execution.LeaveActivityViaTransition(transition);
}
public void Signal(IActivityExecution execution, string signalEvent, object signalData)
{
var transition = execution.Activity.OutgoingTransitions[0];
execution.LeaveActivityViaTransition(transition);
}
