private Task ProcessNextFlow(TInstance instance, BpmnFlowElement flow, CancellationToken cancellationToken)
{
if (flow is BpmnFlowNode flowNode)
{
if (flowNode.Outgoing != null)
{
var tasks = flowNode.Outgoing.Select(async outgoing =>
{
await ProcessFlowAsync(instance, outgoing.Name, cancellationToken);
});
return(Task.WhenAll(tasks));
}
}
if (flow is BpmnSequenceFlow sequence)
{
return(ProcessFlowAsync(instance, sequence.TargetRef, cancellationToken));
}
if (flow is BpmnEndEvent endEvent)
{
foreach (var item in instance.Flows)
{
if (item.Status != FlowResult.Completed && item.Status != FlowResult.NotProcessing && item.Status != FlowResult.Cancelled)
{
item.Status = FlowResult.Cancelled;
}
}
instance.Status = InstanceStatus.Completed;
}
return(ProcessTargetSequenceFlowAsync(instance, flow.Id, cancellationToken));
}
public static FlowElementType GetItemType(BpmnFlowElement flowElement)
{
if (flowElement is BpmnSequenceFlow)
{
return(FlowElementType.SequenceFlow);
}
if (flowElement is BpmnGateway)
{
if (flowElement is BpmnParallelGateway)
{
return(FlowElementType.ParallelGateway);
}
if (flowElement is BpmnExclusiveGateway)
{
return(FlowElementType.ExclusiveGateway);
}
if (flowElement is BpmnInclusiveGateway)
{
return(FlowElementType.InclusiveGateway);
}
if (flowElement is BpmnComplexGateway)
{
return(FlowElementType.ComplexGateway);
}
if (flowElement is BpmnEventBasedGateway)
{
return(FlowElementType.EventBasedGateway);
}
}
if (flowElement is BpmnTask)
{
if (flowElement is BpmnUserTask)
{
return(FlowElementType.UserTask);
}
if (flowElement is BpmnServiceTask)
{
return(FlowElementType.ServiceTask);
}
if (flowElement is BpmnBusinessRuleTask)
{
return(FlowElementType.BusinessRuleTask);
}
if (flowElement is BpmnManualTask)
{
return(FlowElementType.ManualTask);
}
if (flowElement is BpmnReceiveTask)
{
return(FlowElementType.ReceiveTask);
}
if (flowElement is BpmnScriptTask)
{
return(FlowElementType.ScriptTask);
}
if (flowElement is BpmnSendTask)
{
return(FlowElementType.SendTask);
}
return(FlowElementType.Task);
}
if (flowElement is BpmnEvent)
{
if (flowElement is BpmnStartEvent)
{
return(FlowElementType.StartEvent);
}
if (flowElement is BpmnEndEvent)
{
return(FlowElementType.EndEvent);
}
if (flowElement is BpmnIntermediateCatchEvent)
{
return(FlowElementType.IntermediateCatchEvent);
}
if (flowElement is BpmnImplicitThrowEvent)
{
return(FlowElementType.ImplicitThrowEvent);
}
if (flowElement is BpmnBoundaryEvent)
{
return(FlowElementType.BoundaryEvent);
}
if (flowElement is BpmnIntermediateThrowEvent)
{
return(FlowElementType.IntermediateThrowEvent);
}
return(FlowElementType.Event);
}
if (flowElement is BpmnSubProcess)
{
if (flowElement is BpmnAdHocSubProcess)
{
return(FlowElementType.AdHocSubProcess);
}
if (flowElement is BpmnTransaction)
{
return(FlowElementType.Transaction);
}
return(FlowElementType.SubProcess);
}
if (flowElement is BpmnCallActivity)
{
return(FlowElementType.CallActivity);
}
if (flowElement is BpmnCallChoreography)
{
return(FlowElementType.CallChoreography);
}
if (flowElement is BpmnChoreographyTask)
{
return(FlowElementType.ChoreographyTask);
}
if (flowElement is BpmnSubChoreography)
{
return(FlowElementType.SubChoreography);
}
if (flowElement is BpmnDataObject)
{
return(FlowElementType.DataObject);
}
if (flowElement is BpmnDataObjectReference)
{
return(FlowElementType.DataObjectReference);
}
if (flowElement is BpmnDataStoreReference)
{
return(FlowElementType.DataStoreReference);
}
return(FlowElementType.Flow);
}
public Task OnCompleteAsync <TInstanceFlow>(IProcessInstance <TInstanceFlow> instance, BpmnFlowElement flow, CancellationToken cancellationToken) where TInstanceFlow : IBpmNetInstanceFlow
{
return(Task.FromResult(0));
}
private Task <FlowResult> ExecuteFlowAsync(TInstance instance, BpmnFlowElement flow, CancellationToken cancellationToken)
{
if (flow is BpmnSequenceFlow sequenceFlow)
{
return(_sequenceFlowProcessService.ExecuteAsync(instance, sequenceFlow, cancellationToken));
}
if (flow is BpmnGateway)
{
if (flow is BpmnParallelGateway parallelGateway)
{
return(_parallelGatewayProcessService.ExecuteAsync(instance, parallelGateway, cancellationToken));
}
if (flow is BpmnInclusiveGateway inclusiveGateway)
{
return(_inclusiveGatewayProcessService.ExecuteAsync(instance, inclusiveGateway, cancellationToken));
}
if (flow is BpmnExclusiveGateway exclusiveGateway)
{
return(_exclusiveGatewayProcessService.ExecuteAsync(instance, exclusiveGateway, cancellationToken));
}
if (flow is BpmnComplexGateway complexGateway)
{
return(_complexGatewayProcessService.ExecuteAsync(instance, complexGateway, cancellationToken));
}
if (flow is BpmnEventBasedGateway eventBasedGateway)
{
return(_eventBasedGatewayProcessService.ExecuteAsync(instance, eventBasedGateway, cancellationToken));
}
}
if (flow is BpmnTask task)
{
if (flow is BpmnUserTask userTask)
{
return(_userTaskProcessService.ExecuteAsync(instance, userTask, cancellationToken));
}
if (flow is BpmnServiceTask serviceTask)
{
return(_serviceTaskProcessService.ExecuteAsync(instance, serviceTask, cancellationToken));
}
if (flow is BpmnBusinessRuleTask businessRuleTask)
{
return(_businessRuleTaskProcessService.ExecuteAsync(instance, businessRuleTask, cancellationToken));
}
if (flow is BpmnManualTask manualTask)
{
return(_manualTaskProcessService.ExecuteAsync(instance, manualTask, cancellationToken));
}
if (flow is BpmnReceiveTask receiveTask)
{
return(_receiveTaskProcessService.ExecuteAsync(instance, receiveTask, cancellationToken));
}
if (flow is BpmnScriptTask scriptTask)
{
return(_scriptTaskProcessService.ExecuteAsync(instance, scriptTask, cancellationToken));
}
if (flow is BpmnSendTask sendTask)
{
return(_sendTaskProcessService.ExecuteAsync(instance, sendTask, cancellationToken));
}
return(_taskProcessService.ExecuteAsync(instance, task, cancellationToken));
}
if (flow is BpmnEvent bpmnEvent)
{
if (flow is BpmnStartEvent startEvent)
{
return(_startEventProcessService.ExecuteAsync(instance, startEvent, cancellationToken));
}
if (flow is BpmnEndEvent endEvent)
{
return(_endEventProcessService.ExecuteAsync(instance, endEvent, cancellationToken));
}
if (flow is BpmnIntermediateCatchEvent intermediateCatchEvent)
{
return(_intermediateCatchEventProcessService.ExecuteAsync(instance, intermediateCatchEvent, cancellationToken));
}
if (flow is BpmnImplicitThrowEvent implicitThrowEvent)
{
return(_implicitThrowEventProcessService.ExecuteAsync(instance, implicitThrowEvent, cancellationToken));
}
if (flow is BpmnBoundaryEvent boundaryEvent)
{
return(_boundaryEventProcessService.ExecuteAsync(instance, boundaryEvent, cancellationToken));
}
if (flow is BpmnIntermediateThrowEvent intermediateThrowEvent)
{
return(_intermediateThrowEventProcessService.ExecuteAsync(instance, intermediateThrowEvent, cancellationToken));
}
return(_eventProcessService.ExecuteAsync(instance, bpmnEvent, cancellationToken));
}
if (flow is BpmnSubProcess subProcess)
{
if (flow is BpmnAdHocSubProcess adHocSubProcess)
{
return(_adHocSubProcessProcessService.ExecuteAsync(instance, adHocSubProcess, cancellationToken));
}
if (flow is BpmnTransaction transaction)
{
return(_transactionProcessService.ExecuteAsync(instance, transaction, cancellationToken));
}
return(_subProcessProcessService.ExecuteAsync(instance, subProcess, cancellationToken));
}
if (flow is BpmnCallActivity callActivity)
{
return(_callActivityProcessService.ExecuteAsync(instance, callActivity, cancellationToken));
}
if (flow is BpmnCallChoreography callChoreography)
{
return(_callChoreographyProcessService.ExecuteAsync(instance, callChoreography, cancellationToken));
}
if (flow is BpmnChoreographyTask choreographyTask)
{
return(_choreographyTaskProcessService.ExecuteAsync(instance, choreographyTask, cancellationToken));
}
if (flow is BpmnDataObject dataObject)
{
return(_dataObjectProcessService.ExecuteAsync(instance, dataObject, cancellationToken));
}
if (flow is BpmnDataObjectReference dataObjectReference)
{
return(_dataObjectReferenceProcessService.ExecuteAsync(instance, dataObjectReference, cancellationToken));
}
if (flow is BpmnDataStoreReference dataStoreReference)
{
return(_dataStoreReferenceProcessService.ExecuteAsync(instance, dataStoreReference, cancellationToken));
}
if (flow is BpmnSubChoreography subChoreography)
{
return(_subChoreographyProcessService.ExecuteAsync(instance, subChoreography, cancellationToken));
}
return(_flowElementProcessService.ExecuteAsync(instance, flow, cancellationToken));
}
