/// <inheritdoc />
public async Task <Result> Handle(CancelGroupEventCommand request, CancellationToken cancellationToken)
{
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(request.GroupEventId);
if (maybeGroupEvent.HasNoValue)
{
return(Result.Failure(DomainErrors.GroupEvent.NotFound));
}
GroupEvent groupEvent = maybeGroupEvent.Value;
if (groupEvent.UserId != _userIdentifierProvider.UserId)
{
return(Result.Failure(DomainErrors.User.InvalidPermissions));
}
Result result = groupEvent.Cancel(_dateTime.UtcNow);
if (result.IsFailure)
{
return(result);
}
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
/// <inheritdoc />
public async Task <Result> Handle(InviteFriendToGroupEventCommand request, CancellationToken cancellationToken)
{
// TODO: Consider moving this into domain service? Potential for some interesting business rules.
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(request.GroupEventId);
if (maybeGroupEvent.HasNoValue)
{
return(Result.Failure(DomainErrors.GroupEvent.NotFound));
}
GroupEvent groupEvent = maybeGroupEvent.Value;
if (groupEvent.UserId != _userIdentifierProvider.UserId)
{
return(Result.Failure(DomainErrors.User.InvalidPermissions));
}
Maybe <User> maybeUser = await _userRepository.GetByIdAsync(groupEvent.UserId);
if (maybeUser.HasNoValue)
{
return(Result.Failure(DomainErrors.GroupEvent.UserNotFound));
}
Maybe <User> maybeFriend = await _userRepository.GetByIdAsync(request.FriendId);
if (maybeFriend.HasNoValue)
{
return(Result.Failure(DomainErrors.GroupEvent.FriendNotFound));
}
User user = maybeUser.Value;
User friend = maybeFriend.Value;
if (!await _friendshipRepository.CheckIfFriendsAsync(user, friend))
{
return(Result.Failure(DomainErrors.GroupEvent.NotFriends));
}
Result <Invitation> invitationResult = await groupEvent.InviteAsync(friend, _invitationRepository);
if (invitationResult.IsFailure)
{
return(Result.Failure(invitationResult.Error));
}
Invitation invitation = invitationResult.Value;
_invitationRepository.Insert(invitation);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
/// <inheritdoc />
public async Task Handle(GroupEventDateAndTimeChangedIntegrationEvent notification, CancellationToken cancellationToken)
{
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(notification.GroupEventId);
if (maybeGroupEvent.HasNoValue)
{
throw new DomainException(DomainErrors.GroupEvent.NotFound);
}
GroupEvent groupEvent = maybeGroupEvent.Value;
(string Email, string Name)[] attendeeEmailsAndNames = await _attendeeRepository.GetEmailsAndNamesForGroupEvent(groupEvent);
/// <inheritdoc />
public async Task Handle(InvitationAcceptedIntegrationEvent notification, CancellationToken cancellationToken)
{
Maybe <Invitation> maybeInvitation = await _invitationRepository.GetByIdAsync(notification.InvitationId);
if (maybeInvitation.HasNoValue)
{
throw new DomainException(DomainErrors.Invitation.NotFound);
}
Invitation invitation = maybeInvitation.Value;
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(invitation.EventId);
if (maybeGroupEvent.HasNoValue)
{
throw new DomainException(DomainErrors.Invitation.EventNotFound);
}
GroupEvent groupEvent = maybeGroupEvent.Value;
Maybe <User> maybeUser = await _userRepository.GetByIdAsync(groupEvent.UserId);
if (maybeUser.HasNoValue)
{
throw new DomainException(DomainErrors.Invitation.UserNotFound);
}
Maybe <User> maybeFriend = await _userRepository.GetByIdAsync(invitation.UserId);
if (maybeFriend.HasNoValue)
{
throw new DomainException(DomainErrors.Invitation.FriendNotFound);
}
User user = maybeUser.Value;
User friend = maybeFriend.Value;
var invitationAcceptedEmail = new InvitationAcceptedEmail(
user.Email,
user.FullName,
friend.FullName,
groupEvent.Name,
groupEvent.DateTimeUtc.ToString(CultureInfo.InvariantCulture));
await _emailNotificationService.SendInvitationAcceptedEmail(invitationAcceptedEmail);
}
/// <inheritdoc />
public async Task Handle(AttendeeCreatedIntegrationEvent notification, CancellationToken cancellationToken)
{
Maybe <Attendee> maybeAttendee = await _attendeeRepository.GetByIdAsync(notification.AttendeeId);
if (maybeAttendee.HasNoValue)
{
throw new DomainException(DomainErrors.Attendee.NotFound);
}
Attendee attendee = maybeAttendee.Value;
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(attendee.EventId);
if (maybeGroupEvent.HasNoValue)
{
throw new DomainException(DomainErrors.GroupEvent.NotFound);
}
Maybe <User> maybeUser = await _userRepository.GetByIdAsync(attendee.UserId);
if (maybeUser.HasNoValue)
{
throw new DomainException(DomainErrors.User.NotFound);
}
GroupEvent groupEvent = maybeGroupEvent.Value;
User user = maybeUser.Value;
var attendeeCreatedEmail = new AttendeeCreatedEmail(
user.Email,
user.FullName,
groupEvent.Name,
groupEvent.DateTimeUtc.ToString(CultureInfo.InvariantCulture));
await _emailNotificationService.SendAttendeeCreatedEmail(attendeeCreatedEmail);
}
/// <inheritdoc />
public async Task <Result> Handle(UpdateGroupEventCommand request, CancellationToken cancellationToken)
{
if (request.DateTimeUtc <= _dateTime.UtcNow)
{
return(Result.Failure(DomainErrors.GroupEvent.DateAndTimeIsInThePast));
}
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(request.GroupEventId);
if (maybeGroupEvent.HasNoValue)
{
return(Result.Failure(DomainErrors.GroupEvent.NotFound));
}
GroupEvent groupEvent = maybeGroupEvent.Value;
if (groupEvent.UserId != _userIdentifierProvider.UserId)
{
return(Result.Failure(DomainErrors.User.InvalidPermissions));
}
Result <Name> nameResult = Name.Create(request.Name);
if (nameResult.IsFailure)
{
return(Result.Failure(nameResult.Error));
}
groupEvent.ChangeName(nameResult.Value);
groupEvent.ChangeDateAndTime(request.DateTimeUtc);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
