public async Task Perform(ReadOnlyMemory <byte> elevatorAction)
{
var action = JsonSerializer.Deserialize <ElevatorCommandBase>(elevatorAction.Span);
var elevator = await _aggregateRepository.LoadAsync <Elevator>(action.ElevatorId);
switch (action.ActionType)
{
case ElevatorCommandType.CloseDoor:
await CloseDoors(action.ElevatorId);
break;
case ElevatorCommandType.OpenDoor:
await OpenDoors(action.ElevatorId);
break;
case ElevatorCommandType.GoToFloor:
var goToFloor = JsonSerializer.Deserialize <GoToFloorCommand>(elevatorAction.Span);
await GoToFloor(goToFloor);
break;
}
await _aggregateRepository.SaveAsync(elevator);
}
public async Task CreateAsync(string emailAddress)
{
var user = new User(Guid.NewGuid(), emailAddress);
_subscriber.Subscribe <UserSubmittedEvent>(async domainEvent => await HandleAsync(_userSubmittedEventHandlers, domainEvent));
await _userRepository.SaveAsync(user);
}
public async Task HandleAsync(CreateProductCommand command, CancellationToken cancellationToken = new CancellationToken())
{
var aggregate = new ProductAggregate(command);
IsHandled = true;
await _repo.SaveAsync(aggregate, cancellationToken);
}
public async Task SaveAsync <AR>(AR aggregateRoot) where AR : IAggregateRoot
{
await aggregateRepository.SaveAsync <AR>(aggregateRoot).ConfigureAwait(false);
if (ReferenceEquals(null, aggregateRoot.UncommittedEvents) || aggregateRoot.UncommittedEvents.Any() == false)
{
return;
}
var events = aggregateRoot.UncommittedEvents.ToList();
for (int i = 0; i < events.Count; i++)
{
var theEvent = events[i];
var entityEvent = theEvent as EntityEvent;
if (ReferenceEquals(null, entityEvent) == false)
{
theEvent = entityEvent.Event;
}
eventPublisher.Publish(theEvent, BuildHeaders(aggregateRoot, i));
}
var publicEvents = aggregateRoot.UncommittedPublicEvents.ToList();
for (int i = 0; i < publicEvents.Count; i++)
{
publicEventPublisher.Publish(publicEvents[i], BuildHeaders(aggregateRoot, i));
}
}
public async Task ProcessAsync(string aggregateId, Action <TAggregate> command, CancellationToken cancellationToken = default)
{
var aggregate = await _aggregateRepository.GetAsync(aggregateId, cancellationToken);
command?.Invoke(aggregate);
await _aggregateRepository.SaveAsync(aggregate, cancellationToken);
}
public async Task ExecuteAsync(LogoutCommand command, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (cancellationToken.IsCancellationRequested)
{
_logger.LogInformation($"{nameof(LogoutCommandHandler)}.{nameof(ExecuteAsync)} was cancelled before execution");
cancellationToken.ThrowIfCancellationRequested();
}
await _signInManager.SignOutAsync();
var logout = await _interaction.GetLogoutContextAsync(command.LogoutId);
await _persistedGrantService.RemoveAllGrantsAsync(command.Subject, logout?.ClientId);
var aggregate = await _aggregateRepository.GetAsync <User, UserState>(command.Subject, cancellationToken);
var expectedVersion = aggregate.Version;
if (aggregate == null)
{
throw new ArgumentNullException(nameof(aggregate));
}
aggregate.Logout();
await _aggregateRepository.SaveAsync(aggregate, command, expectedVersion, cancellationToken);
}
public async Task <Guid> Handle(RegisterUserCommand request, CancellationToken cancellationToken)
{
var user = User.Initialize(_userChecker, _passwordService, request.Email, request.Password,
request.Name);
await _aggregateRepository.SaveAsync(user);
return(user.Id);
}
public async Task <Guid> Handle(AddNoteCommentCommand request, CancellationToken cancellationToken)
{
var note = await _aggregateRepository.LoadAsync <Note>(request.NoteId);
var comment = note.AddComment(_currentUser.Id, request.Text);
await _aggregateRepository.SaveAsync(comment);
return(comment.Id);
}
public async Task <Unit> Handle(UpdateProfileCommand request, CancellationToken cancellationToken)
{
var user = await _aggregateRepository.LoadAsync <User>(_currentUser.Id);
user.UpdateProfile(request.Name, request.Avatar, request.Bio);
await _aggregateRepository.SaveAsync(user);
return(Unit.Value);
}
public async Task <Unit> Handle(JoinMeetupCommand request, CancellationToken cancellationToken)
{
var aggregate = await _aggregateRepository.LoadAsync <Meetup>(request.MeetupId.ToString(), cancellationToken);
aggregate.Join(request.ParticipantId);
await _aggregateRepository.SaveAsync(aggregate);
return(Unit.Value);
}
public async Task <Unit> Handle(EditNoteCommand request, CancellationToken cancellationToken)
{
var note = await _aggregateRepository.LoadAsync <Note>(request.NoteId);
note.Edit(_currentUser.Id, request.Title, request.Content, request.Comment);
await _aggregateRepository.SaveAsync(note);
return(Unit.Value);
}
public async Task <Unit> Handle(UpdateUserRolesCommand request, CancellationToken cancellationToken)
{
var user = await _aggregateRepository.LoadAsync <User>(request.UserId);
user.UpdateRoles(request.Roles);
await _aggregateRepository.SaveAsync(user);
return(Unit.Value);
}
public async Task <Unit> Handle(CancelMeetupCommand request, CancellationToken cancellationToken)
{
var aggregate = await _aggregateRepository.LoadAsync <Meetup>(request.MeetupId.ToString(), cancellationToken);
aggregate.Cancel(request.OrganizerId);
await _aggregateRepository.SaveAsync(aggregate);
return(Unit.Value);
}
public async Task <Guid> Handle(AddCommentReplyCommand request, CancellationToken cancellationToken)
{
var comment = await _aggregateRepository.LoadAsync <Comment>(request.CommentId);
var replyComment = comment.Reply(_currentUser.Id, request.Text);
await _aggregateRepository.SaveAsync(replyComment);
return(replyComment.Id);
}
public async Task <Unit> Handle(CreateMeetupCommand request, CancellationToken cancellationToken)
{
var aggregate = await _aggregateRepository.LoadAsync <Meetup>(request.MeetupId.ToString(), cancellationToken);
await aggregate.Register(request.MeetupId, request.OrganizerId, request.Subject, request.When, request.Description, request.Address, _meetupPolicy);
await _aggregateRepository.SaveAsync(aggregate);
return(Unit.Value);
}
public async Task <Unit> Handle(AddCommentCommand request, CancellationToken cancellationToken)
{
var aggregate = await _aggregateRepository.LoadAsync <Meetup>(request.MeetupId.ToString(), cancellationToken);
aggregate.AddComment(request.CommentatorId, request.Comment);
await _aggregateRepository.SaveAsync(aggregate);
return(Unit.Value);
}
public async Task <Guid> Handle(CloneNoteCommand request, CancellationToken cancellationToken)
{
var note = await _aggregateRepository.LoadAsync <Note>(request.NoteId);
var cloneNote = note.Clone(_currentUser.Id, request.SpaceId);
await _aggregateRepository.SaveAsync(cloneNote);
return(cloneNote.Id);
}
public async Task <Unit> Handle(ChangePasswordCommand request, CancellationToken cancellationToken)
{
var user = await _aggregateRepository.LoadAsync <User>(_currentUser.Id);
user.ChangePassword(_passwordService, request.OldPassword, request.NewPassword);
await _aggregateRepository.SaveAsync(user);
return(Unit.Value);
}
public async Task <Unit> Handle(CloseMergeRequestCommand request, CancellationToken cancellationToken)
{
var mergeRequest = await _aggregateRepository.LoadAsync <MergeRequest>(request.MergeRequestId);
mergeRequest.Close(_currentUser.Id);
await _aggregateRepository.SaveAsync(mergeRequest);
return(Unit.Value);
}
public async Task <Unit> Handle(MergeNoteCommand request, CancellationToken cancellationToken)
{
var note = await _aggregateRepository.LoadAsync <Note>(request.NoteId);
note.Merge(request.SourceNoteId, request.Title, request.Content);
await _aggregateRepository.SaveAsync(note);
return(Unit.Value);
}
public async Task <Unit> Handle(UpdateNoteTagsCommand request, CancellationToken cancellationToken)
{
var note = await _aggregateRepository.LoadAsync <Note>(request.NoteId);
note.UpdateTags(request.Tags);
await _aggregateRepository.SaveAsync(note);
return(Unit.Value);
}
public async Task <Guid> Handle(AddMergeRequestCommentCommand request, CancellationToken cancellationToken)
{
var mergeRequest = await _aggregateRepository.LoadAsync <MergeRequest>(request.MergeRequestId);
var comment = mergeRequest.AddComment(_currentUser.Id, request.Text);
await _aggregateRepository.SaveAsync(comment);
return(comment.Id);
}
public async Task SaveAsync <AR>(AR aggregateRoot) where AR : IAggregateRoot
{
using (logger.BeginScope(s => s
.AddScope(Log.AggregateName, typeof(AR).Name)
.AddScope(Log.AggregateId, aggregateRoot.State.Id.Value)))
{
await realDeal.SaveAsync <AR>(aggregateRoot).ConfigureAwait(false);
logger.Debug(() => "Aggregate has been saved.");
}
}
public async Task <Guid> Handle(CreateMergeRequestCommand request, CancellationToken cancellationToken)
{
var note = await _aggregateRepository.LoadAsync <Note>(request.NoteId);
var mergeRequest = note.CreateMergeRequest(_noteChecker, _mergeRequestChecker, _currentUser.Id, request.Title,
request.Description);
await _aggregateRepository.SaveAsync(mergeRequest);
return(mergeRequest.Id);
}
public async Task <Unit> Handle(StartToDo request, CancellationToken cancellationToken)
{
var toDo = await _aggregateRepository.LoadAsync(request.ToDoId);
var @event = new ToDoStartedV1(toDo.Id, toDo.State.ToDoListId);
toDo.When(@event);
await _aggregateRepository.SaveAsync(toDo);
return(Unit.Value);
}
public async Task <Unit> Handle(EditCommentCommand request, CancellationToken cancellationToken)
{
var comment = await _aggregateRepository.LoadAsync <Comment>(request.CommentId);
await _resourceAuthorizationService.CheckAsync(comment, CommonOperations.Update);
comment.Edit(request.Text);
await _aggregateRepository.SaveAsync(comment);
return(Unit.Value);
}
public async Task <Unit> Handle(AddToDo request, CancellationToken cancellationToken)
{
var toDo = await _aggregateRepository.LoadAsync(null);
var @event = new ToDoAddedV1(toDo.Id, request.ToDoListId, request.Label, request.Description);
toDo.When(@event);
await _aggregateRepository.SaveAsync(toDo);
return(Unit.Value);
}
public async Task <Unit> Handle(DeleteToDoList request, CancellationToken cancellationToken)
{
var toDoList = await _aggregateRepository.LoadAsync(request.ToDoListId);
var @event = new ToDoListDeletedV1(toDoList.Id);
toDoList.When(@event);
await _aggregateRepository.SaveAsync(toDoList);
return(Unit.Value);
}
public async Task <Unit> Handle(DeleteSpaceCommand request, CancellationToken cancellationToken)
{
var space = await _aggregateRepository.LoadAsync <Space>(request.SpaceId);
await _resourceAuthorizationService.CheckAsync(space, CommonOperations.Delete);
space.Delete();
await _aggregateRepository.SaveAsync(space);
return(Unit.Value);
}
public async Task <Guid> Handle(CreateNoteCommand request, CancellationToken cancellationToken)
{
var space = await _aggregateRepository.LoadAsync <Space>(request.SpaceId);
var note = space.CreateNote(
request.Title,
request.Content,
request.Status);
await _aggregateRepository.SaveAsync(note);
return(note.Id);
}