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);
}
public async Task HandleAsync(CreateTrainingCommand command, CancellationToken cancellationToken = default)
{
Guid.TryParse(httpContext.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier)?.Value,
out Guid coachId);
var coach = await repository.GetByAsync(p => p.Id == coachId, new[] { "Runners" }, cancellationToken);
if (coach.Runners.Capacity == 0)
{
throw new ArgumentNullException("Coach does not have this runner!");
}
var runner = coach.Runners.Find(r => r.Id == command.RunnerId);
if (runner == null)
{
throw new ArgumentNullException("Coach does not have this runner!");
}
var trainingDetails = TraningDetails.Create(command.Details, command.Comments);
var training = Training.Create(command.TimeToDo, trainingDetails);
coach.AddTrainigForRunner(runner, training);
var coachName = $"{coach.FirstName} {coach.LastName}";
await eventPublisher.PublishAsync <TrainingCreated>
(new TrainingCreated(training.Id, DateTime.Now, coachName, runner.Email.EmailAdress));
await repository.SaveAsync(coach);
}
/// <inheritdoc />
public async Task SendAndPublishAsync <TCommand>(TCommand command) where TCommand : ICommand
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var handler = _handlerResolver.ResolveHandler <ICommandHandlerWithEventsAsync <TCommand> >();
var events = await handler.HandleAsync(command);
foreach (var @event in events)
{
var concreteEvent = _eventFactory.CreateConcreteEvent(@event);
await _eventPublisherAsync.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);
}
}
public void PublishAsync_ThrowsException_WhenEventIsNull()
{
_somethingCreated = null;
Assert.ThrowsAsync <ArgumentNullException>(async() => await _sut.PublishAsync(_somethingCreated));
}
public async Task PublishAsync <TEvent>(TEvent @event) where TEvent : IEvent
{
await _eventPublisherAsync.PublishAsync(@event);
}
/// <inheritdoc />
public Task PublishAsync <TEvent>(TEvent @event) where TEvent : IEvent
{
return(_eventPublisherAsync.PublishAsync(@event));
}
