protected override Task <BPMNExecutionResult> Handle(BPMNExecutionContext executionContext, T nodeDef, CancellationToken cancellationToken)
{
var flowNodeIds = GetNextFlowNodeIds(executionContext, nodeDef);
if (nodeDef.EventDefinitions.Any())
{
var lst = new List <bool>();
foreach (var evtDef in nodeDef.EventDefinitions)
{
lst.Add(executionContext.Pointer.Incoming.Any(_ => evtDef.IsSatisfied(executionContext.Instance, _)));
}
if ((nodeDef.ParallelMultiple && lst.All(_ => _ == true)) ||
(!nodeDef.ParallelMultiple && lst.Any(_ => _ == true)))
{
var outcome = new List <MessageToken>();
outcome.AddRange(executionContext.Pointer.Incoming);
return(Task.FromResult(BPMNExecutionResult.Next(flowNodeIds, executionContext.Pointer.Incoming.ToList(), isEltInstanceCompleted: false, isNewExecutionPointerRequired: true)));
}
return(Task.FromResult(BPMNExecutionResult.Block()));
}
return(Task.FromResult(BPMNExecutionResult.Next(flowNodeIds, new List <MessageToken>()
{
MessageToken.EmptyMessage()
})));
}
protected override async Task <BPMNExecutionResult> Handle(BPMNExecutionContext executionContext, T elt, CancellationToken cancellationToken)
{
var pointer = executionContext.Pointer;
if (pointer.Incoming.Count() < elt.StartQuantity)
{
return(BPMNExecutionResult.Block());
}
// Page : 428 : BPMN2.0.2
var flowNodeIds = GetNextFlowNodeIds(executionContext, elt);
var instance = executionContext.Instance.GetInstance(pointer.InstanceFlowNodeId);
if (instance.ActivityState == null)
{
executionContext.Instance.UpdateState(instance, ActivityStates.READY);
}
if (instance.ActivityState == ActivityStates.READY)
{
executionContext.Instance.UpdateState(instance, ActivityStates.ACTIVE);
}
if (instance.ActivityState == ActivityStates.ACTIVE)
{
executionContext.Instance.UpdateState(instance, ActivityStates.COMPLETING);
}
var outcome = new List <MessageToken>();
outcome.AddRange(executionContext.Pointer.Incoming);
if (instance.ActivityState == ActivityStates.COMPLETING)
{
try
{
var addOutcome = await Process(executionContext, elt, cancellationToken);
outcome.AddRange(addOutcome);
executionContext.Instance.UpdateState(instance, ActivityStates.COMPLETED);
}
catch (FlowNodeInstanceBlockedException)
{
return(BPMNExecutionResult.Block());
}
catch (Exception ex)
{
executionContext.Instance.UpdateState(instance, ActivityStates.FAILING, ex.ToString());
return(BPMNExecutionResult.Block());
}
}
if (instance.ActivityState == ActivityStates.FAILING)
{
return(BPMNExecutionResult.Block());
}
return(BPMNExecutionResult.Next(flowNodeIds, outcome));
}
protected override Task <BPMNExecutionResult> Handle(BPMNExecutionContext executionContext, InclusiveGateway elt, CancellationToken cancellationToken)
{
var flowNodeIds = GetNextFlowNodeIds(executionContext, elt);
if (flowNodeIds.Count() == 0 && string.IsNullOrWhiteSpace(elt.Default))
{
throw new BPMNProcessorException(Global.NoDefaultSequenceFlow);
}
if (flowNodeIds.Count() == 0)
{
flowNodeIds.Add(elt.Default);
}
return(Task.FromResult(BPMNExecutionResult.Next(flowNodeIds, executionContext.Pointer.Incoming)));
}
protected override Task <BPMNExecutionResult> Handle(BPMNExecutionContext executionContext, ParallelGateway elt, CancellationToken cancellationToken)
{
var outgoingFlowNodeIds = GetOutgoingFlowNodeIds(executionContext, elt);
var incomingFlowNodeIds = GetIncomingFlowNodeIds(executionContext, elt);
if (elt.GatewayDirection == GatewayDirections.CONVERGING && outgoingFlowNodeIds.Count() != 1)
{
throw new BPMNProcessorException("Must have no more than one outgoing sequence flow");
}
if (elt.GatewayDirection == GatewayDirections.DIVERGING && incomingFlowNodeIds.Count() != 1)
{
throw new BPMNProcessorException("Must have no more than one incoming sequence flow");
}
var incoming = executionContext.Pointer.Incoming;
ICollection <MessageToken> outcome = new List <MessageToken>();
if (elt.GatewayDirection == GatewayDirections.CONVERGING)
{
if (incoming.Count() != incomingFlowNodeIds.Count())
{
return(Task.FromResult(BPMNExecutionResult.Block()));
}
foreach (var record in incoming)
{
if (!outcome.Any(_ => _.Name == record.Name))
{
outcome.Add(record);
}
}
}
else
{
outcome = incoming.ToList();
}
return(Task.FromResult(BPMNExecutionResult.Next(outgoingFlowNodeIds, outcome)));
}
