/// <inheritdoc/>
public async Task <ProcessResponse> Execute(ProcessRequest <TState> request, ProcessMiddlewareDelegate next, CancellationToken token)
{
var response = await next();
foreach (var message in response.ProcessMessages
.Where(s => !s.IsPublished)
.Select(s => s.Message))
{
var executionResult = await PublishMessageAsync(message);
if (executionResult.Success)
{
await store.MarkMessageAsPublishedAsync(request.Id, message);
}
}
return(response);
Task <IExecutionResult> PublishMessageAsync(IMessage msg) =>
msg switch
{
ICommand cmd => commandBus.PublishAsync(cmd),
Notification notification => notificationBus.PublishAsync(notification),
_ => throw new ArgumentException($"Invalid message type '{msg.GetType()}'."),
};
}
/// <inheritdoc />
public async Task <ProcessResponse> Execute(ProcessRequest <TState> request, ProcessMiddlewareDelegate next, CancellationToken token)
{
var response = await next();
var correlationId = request.State is IIntegrationEvent @event
? @event.CorrelationId
: Unified.NewCode();
var processMessages = response.ProcessMessages
.Select(m =>
{
m.Message.CorrelationId = correlationId;
EnrichWithUserId(m.Message, options.ActorId);
EnrichWithRoles(m.Message, "[]");
var principal = new Principal
{
IdentityId = options.ActorId,
UserId = options.ActorId,
IsProcessManager = true,
};
m.Message.Actor = principal.AsActor();
if (m.Message is Command cmd)
{
cmd.Principal = principal;
}
return(new ProcessMessage(m.Message, m.IsPublished));
})
.ToArray();
return(new ProcessResponse(response.Id, processMessages, response.IsPersisted));
}
/// <inheritdoc/>
public async Task <ProcessResponse> Execute(ProcessRequest <TState> request, ProcessMiddlewareDelegate next, CancellationToken token)
{
var messages = await store.GetMessagesAsync(request.Id);
return(messages.Count > 0
? new ProcessResponse(request.Id, messages, true)
: await next());
}
/// <inheritdoc/>
public async Task <ProcessResponse> Execute(ProcessRequest <TState> request, ProcessMiddlewareDelegate next, CancellationToken token)
{
var response = await next();
if (!response.IsPersisted && response.ProcessMessages.Count > 0)
{
await store.PersistMessagesAsync(request.Id, response.ProcessMessages.Select(s => s.Message).ToArray());
}
return(new ProcessResponse(response.Id, response.ProcessMessages, true));
}
/// <summary>
/// Execute process pipeline.
/// </summary>
/// <param name="request">Process request.</param>
/// <param name="handler">Process handler.</param>
/// <param name="token">Cancellation token.</param>
/// <returns>Task.</returns>
public Task ExecutePipline(ProcessRequest <TState> request, IProcessHandler <TState> handler, CancellationToken token)
{
var delegates = new List <Func <ProcessMiddlewareDelegate, ProcessMiddlewareDelegate> >();
foreach (var middleware in middlewares)
{
delegates.Add(next =>
{
return(() => middleware.Execute(request, next, token));
});
}
ProcessMiddlewareDelegate execute = () => handler.Handle(request, token);
foreach (var @delegate in delegates)
{
execute = @delegate(execute);
}
return(execute());
}
