public async Task <SearchResult <ProcessInstanceResult> > Handle(CreateProcessInstanceCommand request, CancellationToken cancellationToken)
{
var processFile = await _eventStoreRepository.GetLastAggregate <ProcessFileAggregate>(request.ProcessFileId, ProcessFileAggregate.GetStreamName(request.ProcessFileId));
if (processFile == null || string.IsNullOrWhiteSpace(processFile.AggregateId))
{
_logger.LogError($"the process file '{request.ProcessFileId}' doesn't exist");
throw new UnknownProcessFileException(string.Format(Global.UnknownProcessFile, request.ProcessFileId));
}
var processInstances = BPMNParser.BuildInstances(processFile.Payload, request.ProcessFileId);
var result = new List <ProcessInstanceResult>();
foreach (var processInstance in processInstances)
{
var pi = ProcessInstanceAggregate.New(request.ProcessFileId,
processFile.Name,
processInstance.ElementDefs.ToList(),
processInstance.Interfaces.ToList(),
processInstance.Messages.ToList(),
processInstance.ItemDefs.ToList(),
processInstance.SequenceFlows.ToList());
await _commitAggregateHelper.Commit(pi, pi.GetStreamName(), cancellationToken);
result.Add(ProcessInstanceResult.ToDto(pi));
}
return(new SearchResult <ProcessInstanceResult>
{
Content = result
});
}
public Task Add(ProcessInstanceAggregate processInstance, CancellationToken token)
{
_dbContext.ProcessInstances.Add(processInstance.ToModel());
var ets = _dbContext.ChangeTracker.Entries <ProcessInstanceModel>();
return(Task.CompletedTask);
}
public async Task Handle(ProcessInstanceCreatedEvent message, CancellationToken token)
{
var record = ProcessInstanceAggregate.New(new List <DomainEvent>
{
message
});
await _processInstanceCommandRepository.Add(record, token);
await _processInstanceCommandRepository.SaveChanges(token);
}
public static ProcessInstanceResult ToDto(ProcessInstanceAggregate processInstance)
{
return(new ProcessInstanceResult
{
Id = processInstance.AggregateId,
Status = Enum.GetName(typeof(ProcessInstanceStatus), processInstance.Status),
ProcessFileId = processInstance.ProcessFileId,
ProcessFileName = processInstance.ProcessFileName,
CreateDateTime = processInstance.CreateDateTime,
UpdateDateTime = processInstance.UpdateDateTime,
ExecutionPaths = processInstance.ExecutionPathLst.Select(_ => ExecutionPathResult.ToDto(_, processInstance.ElementInstances.ToList())).ToList()
});
}
public async Task Execute(ProcessInstanceAggregate processInstance, CancellationToken token)
{
foreach (var executionPath in processInstance.ExecutionPathLst)
{
var activePointers = executionPath.Pointers.Where(_ => _.IsActive).ToList();
foreach (var activePointer in activePointers)
{
var executionContext = new BPMNExecutionContext
{
Instance = processInstance,
Path = executionPath,
Pointer = activePointer
};
await Execute(executionContext, token);
}
}
}
public static ProcessInstanceModel ToModel(this ProcessInstanceAggregate processInstance)
{
return(new ProcessInstanceModel
{
AggregateId = processInstance.AggregateId,
CreateDateTime = processInstance.CreateDateTime,
ProcessFileName = processInstance.ProcessFileName,
Version = processInstance.Version,
Status = (int)processInstance.Status,
UpdateDateTime = processInstance.UpdateDateTime,
ElementInstances = processInstance.ElementInstances.Select(_ => _.ToModel()).ToList(),
Interfaces = processInstance.Interfaces.Select(_ => _.ToModel()).ToList(),
StateTransitions = processInstance.StateTransitions.Select(_ => _.ToModel()).ToList(),
ExecutionPathLst = processInstance.ExecutionPathLst.Select(_ => _.ToModel()).ToList(),
ElementDefs = processInstance.ElementDefs.Select(_ => _.ToModel()).ToList(),
ItemDefs = processInstance.ItemDefs.Select(_ => _.ToModel()).ToList(),
Messages = processInstance.Messages.Select(_ => _.ToModel()).ToList(),
SequenceFlows = processInstance.SequenceFlows.Select(_ => _.ToModel()).ToList(),
ProcessFileId = processInstance.ProcessFileId,
});
}
public async Task <bool> Execute(ProcessInstanceAggregate processInstance, CancellationToken token)
{
var isRestarted = false;
foreach (var executionPath in processInstance.ExecutionPathLst)
{
var activePointers = executionPath.Pointers.Where(_ => _.IsActive).ToList();
foreach (var activePointer in activePointers)
{
var executionContext = new BPMNExecutionContext
{
Instance = processInstance,
Path = executionPath,
Pointer = activePointer
};
var secondResult = await Execute(executionContext, token);
isRestarted = secondResult || isRestarted;
}
}
return(isRestarted);
}
public ProcessInstanceAggregate Build()
{
var elts = new List <BaseFlowNode>();
var interfaces = new List <BPMNInterface>();
foreach (var builder in Builders)
{
elts.Add(builder.Build());
}
foreach (var gateway in Gateways)
{
elts.Add(gateway);
}
foreach (var interfaceBuilder in InterfaceBuilders)
{
interfaces.Add(interfaceBuilder.Build());
}
var result = ProcessInstanceAggregate.New(ProcessFileId, "", elts, interfaces, Messages, ItemDefs, SequenceFlows);
return(result);
}
public Task Update(ProcessInstanceAggregate processInstance, CancellationToken token)
{
_dbContext.ProcessInstances.Update(processInstance);
return(Task.CompletedTask);
}
protected override async Task ProcessMessage(ProcessInstanceNotification notification, CancellationToken cancellationToken)
{
string lockName = $"processinstances:{notification.Id}";
if (!await _distributedLock.TryAcquireLock(lockName, cancellationToken))
{
return;
}
var processInstance = await _eventStoreRepository.GetLastAggregate <ProcessInstanceAggregate>(notification.ProcessInstanceId, ProcessInstanceAggregate.GetStreamName(notification.ProcessInstanceId));
try
{
if (processInstance == null || string.IsNullOrWhiteSpace(processInstance.AggregateId))
{
throw new InvalidOperationException($"process instance '{notification.ProcessInstanceId}' doesn't exist");
}
if (notification.IsNewInstance)
{
processInstance.NewExecutionPath();
}
await _processInstanceProcessor.Execute(processInstance, cancellationToken);
await _commitAggregateHelper.Commit(processInstance, processInstance.GetStreamName(), cancellationToken);
}
finally
{
await _distributedLock.ReleaseLock(lockName, cancellationToken);
}
}
public async Task <bool> Handle(StartProcessInstanceCommand request, CancellationToken cancellationToken)
{
var processInstance = await _eventStoreRepository.GetLastAggregate <ProcessInstanceAggregate>(request.ProcessInstanceId, ProcessInstanceAggregate.GetStreamName(request.ProcessInstanceId));
if (request == null || string.IsNullOrWhiteSpace(processInstance.AggregateId))
{
_logger.LogError($"unknown process instance '{request.ProcessInstanceId}'");
throw new UnknownFlowInstanceException(string.Format(Global.UnknownProcessInstance, request.ProcessInstanceId));
}
processInstance.Start(request.NameIdentifier);
await _commitAggregateHelper.Commit(processInstance, processInstance.GetStreamName(), cancellationToken);
await _messageBroker.QueueProcessInstance(request.ProcessInstanceId, true, cancellationToken);
return(true);
}
protected override async Task ProcessMessage(StateTransitionNotification message, CancellationToken cancellationToken)
{
string lockName = $"statetransitions:{message.Id}";
if (!await _distributedLock.TryAcquireLock(lockName, cancellationToken))
{
return;
}
var processInstance = await _eventStoreRepository.GetLastAggregate <ProcessInstanceAggregate>(message.ProcessInstanceId, ProcessInstanceAggregate.GetStreamName(message.ProcessInstanceId));
try
{
if (processInstance == null || string.IsNullOrWhiteSpace(processInstance.AggregateId))
{
throw new InvalidOperationException($"process instance '{message.ProcessInstanceId}' doesn't exist");
}
processInstance.ConsumeStateTransition(message);
await _commitAggregateHelper.Commit(processInstance, processInstance.GetStreamName(), cancellationToken);
await MessageBroker.QueueProcessInstance(processInstance.AggregateId, false, cancellationToken);
_logger.LogInformation($"Make transition '{message.State}' on the user task instance '{message.FlowNodeInstanceId}'");
}
finally
{
await _distributedLock.ReleaseLock(lockName, cancellationToken);
}
}
public Task RegisterProcessInstance(ProcessInstanceAggregate processInstance, CancellationToken token)
{
return(_processJobServer.RegisterProcessInstance(processInstance, token));
}
public async Task <bool> Handle(MakeStateTransitionCommand request, CancellationToken cancellationToken)
{
var processInstance = await _eventStoreRepository.GetLastAggregate <ProcessInstanceAggregate>(request.FlowNodeInstanceId, ProcessInstanceAggregate.GetStreamName(request.FlowNodeInstanceId));
if (processInstance == null)
{
_logger.LogError($"unknown process instance '{request.FlowNodeInstanceId}'");
throw new UnknownFlowInstanceException(string.Format(Global.UnknownProcessInstance, request.FlowNodeInstanceId));
}
if (!processInstance.ElementInstances.Any(_ => _.Id == request.FlowNodeElementInstanceId))
{
_logger.LogError($"unknown process element instance '{request.FlowNodeElementInstanceId}'");
throw new UnknownFlowNodeElementInstanceException(string.Format(Global.UnknownProcessElementInstance, request.FlowNodeElementInstanceId));
}
await _messageBroker.QueueStateTransition(request.FlowNodeInstanceId, request.FlowNodeElementInstanceId, request.State, request.Parameters, cancellationToken);
return(true);
}
public async Task RegisterProcessInstance(ProcessInstanceAggregate processInstance, CancellationToken token)
{
await _commitAggregateHelper.Commit(processInstance, processInstance.GetStreamName(), token);
}
protected override async Task ProcessMessage(MessageNotification notification, CancellationToken cancellationToken)
{
string lockName = $"messages:{notification.Id}";
if (!await _distributedLock.TryAcquireLock(lockName, cancellationToken))
{
return;
}
var processInstance = await _eventStoreRepository.GetLastAggregate <ProcessInstanceAggregate>(notification.ProcessInstanceId, ProcessInstanceAggregate.GetStreamName(notification.ProcessInstanceId));
try
{
if (processInstance == null || string.IsNullOrWhiteSpace(processInstance.AggregateId))
{
throw new InvalidOperationException($"process instance '{notification.ProcessInstanceId}' doesn't exist");
}
processInstance.ConsumeMessage(new MessageToken
{
Name = notification.MessageName,
MessageContent = notification.Content
});
await _commitAggregateHelper.Commit(processInstance, processInstance.GetStreamName(), cancellationToken);
await MessageBroker.QueueProcessInstance(processInstance.AggregateId, false, cancellationToken);
}
finally
{
await _distributedLock.ReleaseLock(lockName, cancellationToken);
}
}
public async Task RegisterProcessInstance(ProcessInstanceAggregate processInstance, CancellationToken token)
{
await _processInstanceCommandRepository.Add(processInstance, token);
}
public override bool IsSatisfied(ProcessInstanceAggregate processInstance, MessageToken token)
{
return(processInstance.IsMessageCorrect(MessageRef, token));
}
public async Task Update(ProcessInstanceAggregate processInstance, CancellationToken token)
{
var result = await _dbContext.ProcessInstances
.Include(_ => _.ItemDefs)
.Include(_ => _.Interfaces).ThenInclude(_ => _.Operations)
.Include(_ => _.Messages)
.Include(_ => _.ElementDefs)
.Include(_ => _.SequenceFlows)
.Include(_ => _.ExecutionPathLst).ThenInclude(_ => _.Pointers).ThenInclude(_ => _.Tokens)
.Include(_ => _.StateTransitions)
.Include(_ => _.ElementInstances).ThenInclude(_ => _.ActivityStates)
.FirstOrDefaultAsync(_ => _.AggregateId == processInstance.AggregateId, token);
var rec = processInstance.ToModel();
result.Status = rec.Status;
result.NameIdentifier = rec.NameIdentifier;
result.Version = rec.Version;
result.UpdateDateTime = rec.UpdateDateTime;
result.ItemDefs.Clear();
result.Interfaces.Clear();
result.Messages.Clear();
result.ElementDefs.Clear();
result.SequenceFlows.Clear();
result.ElementInstances.Clear();
result.ExecutionPathLst.Clear();
result.StateTransitions.Clear();
foreach (var itemDef in rec.ItemDefs)
{
result.ItemDefs.Add(itemDef);
}
foreach (var inter in rec.Interfaces)
{
result.Interfaces.Add(inter);
}
foreach (var msg in rec.Messages)
{
result.Messages.Add(msg);
}
foreach (var eltDef in rec.ElementDefs)
{
result.ElementDefs.Add(eltDef);
}
foreach (var sequenceFlow in rec.SequenceFlows)
{
result.SequenceFlows.Add(sequenceFlow);
}
foreach (var eltInstance in rec.ElementInstances)
{
result.ElementInstances.Add(eltInstance);
}
foreach (var executionPath in rec.ExecutionPathLst)
{
result.ExecutionPathLst.Add(executionPath);
}
foreach (var stateTransition in rec.StateTransitions)
{
result.StateTransitions.Add(stateTransition);
}
}
