private async Task <bool> Execute(BPMNExecutionContext context, CancellationToken token)
{
var pointer = context.Pointer;
var nodeDef = context.Instance.GetDefinition(pointer.FlowNodeId);
var res = await _processorFactory.Execute(context, nodeDef, token);
var result = res as BPMNExecutionResult;
var isRestarted = result.IsRestarted;
if (result.IsNext)
{
var ids = context.Instance.CompleteExecutionPointer(pointer, result.NextFlowNodeIds, result.Tokens.ToList());
if (result.IsEltInstanceCompleted)
{
context.Instance.CompleteFlowNodeInstance(pointer.InstanceFlowNodeId);
}
if (result.IsNewExecutionPointerRequired)
{
context.Instance.LaunchNewExecutionPointer(pointer);
}
foreach (var id in ids)
{
var executionPointer = context.Instance.GetExecutionPointer(pointer.ExecutionPathId, id);
var newExecutionContext = context.New(executionPointer);
var secondResult = await Execute(newExecutionContext, token);
isRestarted = isRestarted || secondResult;
}
}
return(isRestarted);
}
private async Task Execute(BPMNExecutionContext context, CancellationToken token)
{
var pointer = context.Pointer;
var nodeDef = context.Instance.GetDefinition(pointer.FlowNodeId);
var result = (await _processorFactory.Execute(context, nodeDef, token)) as BPMNExecutionResult;
if (result.IsNext)
{
var ids = context.Instance.CompleteExecutionPointer(pointer, result.NextFlowNodeIds, result.Tokens);
if (result.IsEltInstanceCompleted)
{
context.Instance.CompleteFlowNodeInstance(pointer.InstanceFlowNodeId);
}
if (result.IsNewExecutionPointerRequired)
{
context.Instance.LaunchNewExecutionPointer(pointer);
}
foreach (var id in ids)
{
var executionPointer = context.Instance.GetExecutionPointer(pointer.ExecutionPathId, id);
var newExecutionContext = context.New(executionPointer);
await Execute(newExecutionContext, token);
}
}
}
public async Task Execute(CasePlanInstanceAggregate casePlanInstance, CancellationToken cancellationToken)
{
var terminateSub = await _subscriberRepository.TrySubscribe(casePlanInstance.AggregateId, CMMNConstants.ExternalTransitionNames.Terminate, cancellationToken);
if (casePlanInstance.State == null)
{
casePlanInstance.MakeTransition(CMMNTransitions.Create);
}
if (casePlanInstance.State == CaseStates.Active)
{
var executionContext = new CMMNExecutionContext {
Instance = casePlanInstance
};
foreach (var fileItem in casePlanInstance.FileItems)
{
await _processorFactory.Execute(executionContext, fileItem, cancellationToken);
}
await _processorFactory.Execute(executionContext, casePlanInstance.StageContent, cancellationToken);
if (casePlanInstance.StageContent.State == TaskStageStates.Completed)
{
casePlanInstance.MakeTransition(CMMNTransitions.Complete, false);
return;
}
if (casePlanInstance.StageContent.State == TaskStageStates.Terminated)
{
casePlanInstance.MakeTransition(CMMNTransitions.Terminate, false);
return;
}
if (terminateSub.IsCaptured)
{
await _subscriberRepository.TryReset(casePlanInstance.AggregateId, null, CMMNConstants.ExternalTransitionNames.Terminate, cancellationToken);
casePlanInstance.MakeTransition(CMMNTransitions.Terminate);
}
}
}
private async Task ExecuteNode(CMMNExecutionContext executionContext, BaseCasePlanItemInstance node, CancellationToken token)
{
await _processorFactory.Execute(executionContext, node, token);
var domainEvts = executionContext.Instance.DomainEvents.Where((evt) =>
{
var r = evt as CaseElementTransitionRaisedEvent;
if (r == null)
{
return(false);
}
return(r.ElementId == node.Id);
}).Cast <CaseElementTransitionRaisedEvent>()
.Select(_ => new IncomingTransition(_.Transition, _.IncomingTokens)).ToList();
var nextNodes = executionContext.Instance.GetNextCasePlanItems(node);
foreach (var nextNode in nextNodes)
{
executionContext.Instance.ConsumeTransitionEvts(nextNode, node.Id, domainEvts);
await ExecuteNode(executionContext, nextNode, token);
}
}
private async Task HandleCasePlan(CMMNExecutionContext executionContext, BaseCasePlanItemInstance casePlanElementInstance, CancellationToken token)
{
await _processorFactory.Execute(executionContext, casePlanElementInstance, casePlanElementInstance.GetType(), token);
}
