Example #1
0
        public ExecutionBranch BuildNextBranch()
        {
            var result = new ExecutionBranch(Level + 1);

            NextBranch = result;
            return(result);
        }
Example #2
0
        private async Task ExecuteBranch(CMMNExecutionContext executionContext, ExecutionBranch branch, CancellationToken cancellationToken)
        {
            var taskLst = new List <Task>();

            foreach (var node in branch.Nodes)
            {
                taskLst.Add(HandleCasePlan(executionContext, node, cancellationToken));
            }

            await Task.WhenAll(taskLst);

            if (branch.NextBranch != null)
            {
                await ExecuteBranch(executionContext, branch.NextBranch, cancellationToken);
            }
        }
Example #3
0
        protected override async Task ProtectedProcess(CMMNExecutionContext executionContext, StageElementInstance stageElt, CancellationToken cancellationToken)
        {
            var executionBranch = ExecutionBranch.Build(stageElt.Children);

            await ExecuteBranch(executionContext, executionBranch, cancellationToken);

            if (stageElt.Children.All(_ => IsElementCompleted(_)))
            {
                executionContext.CasePlanInstance.MakeTransition(stageElt, CMMNTransitions.Complete);
                return;
            }

            if (executionContext.CasePlanInstance.IsExitCriteriaSatisfied(stageElt))
            {
                executionContext.CasePlanInstance.MakeTransition(stageElt, CMMNTransitions.Terminate);
            }
        }
Example #4
0
        public static ExecutionBranch Build(ICollection <BaseCasePlanItemInstance> casePlanElementInstances, ExecutionBranch parentExecutionBranch = null)
        {
            IEnumerable <BaseCasePlanItemInstance> filteredCasePlanElementsInstances;

            if (parentExecutionBranch == null)
            {
                parentExecutionBranch             = new ExecutionBranch(0);
                filteredCasePlanElementsInstances = casePlanElementInstances.Where(_ => parentExecutionBranch.IsRoot() && _.EntryCriterions == null || !_.EntryCriterions.Any());
            }
            else
            {
                filteredCasePlanElementsInstances = casePlanElementInstances.Where(_ =>
                {
                    var ids = _.EntryCriterions.SelectMany(ec => ec.SEntry.PlanItemOnParts.Select(pp => pp.SourceRef));
                    return(!casePlanElementInstances.Any(i => ids.Contains(i.Id)));
                });
            }

            foreach (var elt in filteredCasePlanElementsInstances)
            {
                parentExecutionBranch.AddNode(elt);
            }

            var removedIds = filteredCasePlanElementsInstances.Select(_ => _.Id);
            var newCasePlanElementInstances = casePlanElementInstances.Where(_ => !removedIds.Contains(_.Id)).ToList();

            if (!newCasePlanElementInstances.Any())
            {
                return(parentExecutionBranch);
            }

            var nextBranch = parentExecutionBranch.BuildNextBranch();

            Build(newCasePlanElementInstances, nextBranch);
            return(parentExecutionBranch);
        }