/// <inheritdoc />
public async Task SendAsync <TCommand, TAggregate>(TCommand command)
where TCommand : IDomainCommand
where TAggregate : IAggregateRoot
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var handler = _handlerResolver.ResolveHandler <IDomainCommandHandlerAsync <TCommand> >();
var aggregateTask = _aggregateStore.SaveAggregateAsync <TAggregate>(command.AggregateRootId);
var commandTask = _commandStore.SaveCommandAsync <TAggregate>(command);
var eventsTask = handler.HandleAsync(command);
await Task.WhenAll(aggregateTask, commandTask, eventsTask);
var publishEvents = PublishEvents(command);
var events = await eventsTask;
foreach (var @event in events)
{
@event.Update(command);
var concreteEvent = _eventFactory.CreateConcreteEvent(@event);
await _eventStore.SaveEventAsync <TAggregate>((IDomainEvent)concreteEvent, command.ExpectedVersion);
if (publishEvents)
{
await _eventPublisher.PublishAsync(concreteEvent);
}
}
}
/// <inheritdoc />
public void Send <TCommand, TAggregate>(TCommand command) where TCommand : IDomainCommand where TAggregate : IAggregateRoot
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
_commandStore.SaveCommand <TAggregate>(command);
var handler = _resolver.Resolve <ICommandHandlerWithAggregate <TCommand> >();
if (handler == null)
{
throw new ApplicationException($"No handler of type WeapsyCqrs.Commands.ICommandHandlerWithAggregate<TCommand> found for command '{command.GetType().FullName}'");
}
var aggregateRoot = handler.Handle(command);
foreach (var @event in aggregateRoot.Events)
{
@event.CommandId = command.Id;
var concreteEvent = _eventFactory.CreateConcreteEvent(@event);
_eventStore.SaveEvent <TAggregate>((IDomainEvent)concreteEvent);
}
}
public async Task <ICommandHandlerAggregateAnswer> Send <TCommand, TAggregate>(TCommand command)
where TCommand : IDomainCommand
where TAggregate : IAggregateRoot
{
Guard.AgainstNull <ArgumentNullException>(command);
await commandStore.SaveCommandAsync <TAggregate>(command);
var commandHandler = resolver.Resolve <ICommandHandlerWithResultAsync <TCommand> >();
Guard.AgainstNull <ApplicationException>(commandHandler,
$"No handler of type ICommandHandlerWithAggregateAsync<TCommand> found for command '" +
$"{command.GetType().FullName}'");
var commandHanderAnswer = await commandHandler.HandleAsync(command);
if (commandHanderAnswer.ValidationResult.IsValid)
{
foreach (var @event in commandHanderAnswer.AggregateRoot.Events)
{
@event.CommandId = command.Id;
var concreteEvent = eventFactory.CreateConcreteEvent(@event);
await eventStore.SaveEventAsync <TAggregate>((IDomainEvent)concreteEvent);
await eventPublisherAsync.PublishAsync(concreteEvent);
}
}
return(commandHanderAnswer);
}
/// <inheritdoc />
public async Task SendAsync<TCommand>(TCommand command) where TCommand : ICommand
{
if (command == null)
throw new ArgumentNullException(nameof(command));
var handler = _handlerResolver.ResolveHandler<ICommandHandlerAsync<TCommand>>();
var events = await handler.HandleAsync(command);
if (PublishEvents(command))
{
foreach (var @event in events)
{
var concreteEvent = _eventFactory.CreateConcreteEvent(@event);
await _eventPublisher.PublishAsync(concreteEvent);
}
}
}
public async Task SendAndPublishAsync <TCommand>(TCommand command) where TCommand : ICommand
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var commandHandler = _resolver.Resolve <ICommandHandlerWithEventsAsync <TCommand> >();
if (commandHandler == null)
{
throw new ApplicationException($"No handler of type ICommandHandlerWithEventsAsync<TCommand> found for command '{command.GetType().FullName}'");
}
var events = await commandHandler.HandleAsync(command);
foreach (var @event in events)
{
var concreteEvent = _eventFactory.CreateConcreteEvent(@event);
await _eventPublisher.PublishAsync(concreteEvent);
}
}
/// <inheritdoc />
public async Task SendAsync <TCommand, TAggregate>(TCommand command)
where TCommand : IDomainCommand
where TAggregate : IAggregateRoot
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var handler = _handlerResolver.ResolveHandler <ICommandHandlerWithDomainEventsAsync <TCommand> >();
await _commandStore.SaveCommandAsync <TAggregate>(command);
var events = await handler.HandleAsync(command);
foreach (var @event in events)
{
@event.CommandId = command.Id;
var concreteEvent = _eventFactory.CreateConcreteEvent(@event);
await _eventStore.SaveEventAsync <TAggregate>((IDomainEvent)concreteEvent);
}
}
