private async Task <bool> DoesUserExist(Guid id)
{
var userExistsQuery = new UserExistsQuery(id);
var exists = await _mediator.Send(userExistsQuery);
return(exists);
}
public UserExistsQueryTests()
{
_user = new User()
{
EmailAddress = "*****@*****.**"
};
_factory = new Mock <IUserFactory>();
_factory.Setup(c => c.Create(It.IsAny <string>())).Returns(_user);
_dbCommand = new Mock <IUserExistsDbQuery>();
_dbCommand.Setup(c => c.Execute(It.IsAny <User>())).Returns(false);
_subject = new UserExistsQuery(_factory.Object, _dbCommand.Object);
}
public async Task UserExistsQueryHandler_ShouldReturnFalse_WhenUserDoesNotExist()
{
// Arrange
UserExistsQuery request = new UserExistsQuery {
UserId = 124311
};
_unitOfWorkMock
.Setup(m => m.Users.Exists(request.UserId, It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
UserExistsQuery.Handler handler = new UserExistsQuery.Handler(_unitOfWorkMock.Object);
// Act
bool exists = await handler.Handle(request);
// Assert
Assert.False(exists);
}
public CreateUser_should()
{
query = new UserExistsQuery(Db);
sut = new CreateUserCommand(Db.Users, query);
}
public async Task <ActionResult <FriendshipResource> > RequestFriendship([FromBody] RequestFriendshipBody body, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Get the current user id
int requesterId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
// Check if requester + addressee id are the same
if (requesterId == body.AddresseeId)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "You cannot create a friendship with yourself"
}));
}
// Check if the addressed user exists
UserExistsQuery existsQuery = new UserExistsQuery {
UserId = body.AddresseeId
};
bool userExists = await _mediator.Send(existsQuery, cancellationToken);
if (!userExists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"User with ID '{body.AddresseeId}' does not exist"
}));
}
// Check if there is already a friendship with the given user combination
FriendshipCombinationExistsQuery combinationExistsQuery = new FriendshipCombinationExistsQuery
{
RequesterId = requesterId,
AddresseeId = body.AddresseeId
};
bool combinationExists = await _mediator.Send(combinationExistsQuery, cancellationToken);
if (combinationExists)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = $"There is already a friendship with user {body.AddresseeId}"
}));
}
// Create friendship
RequestFriendshipCommand command = _mapper.Map <RequestFriendshipBody, RequestFriendshipCommand>(body);
FriendshipResource friendship = await _mediator.Send(command, cancellationToken);
return(CreatedAtAction(nameof(GetFriendshipById), new { friendshipId = friendship.FriendshipId }, friendship));
}
public async Task <ActionResult <GroupMembershipResource> > CreateMembership([FromBody] CreateMembershipBody body, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Check if the provided group exists
GroupExistsQuery groupExistsQuery = new GroupExistsQuery {
GroupId = body.GroupId
};
bool groupExists = await _mediator.Send(groupExistsQuery, cancellationToken);
if (!groupExists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Group with ID '{body.GroupId}' does not exist"
}));
}
// Check if the provided user exists
UserExistsQuery userExistsQuery = new UserExistsQuery {
UserId = body.UserId
};
bool userExists = await _mediator.Send(userExistsQuery, cancellationToken);
if (!userExists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"User with ID '{body.UserId}' does not exist"
}));
}
// Check if the current user is permitted to create memberships in this group
CanCreateMembershipQuery canCreateQuery = new CanCreateMembershipQuery {
GroupId = body.GroupId
};
bool canCreate = await _mediator.Send(canCreateQuery, cancellationToken);
if (!canCreate)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "You are not permitted to add users to this group. This privilege is only granted to administrators of the group"
}));
}
// Check if such a membership does not already exist
MembershipCombinationExistsQuery membershipExistsQuery = _mapper.Map <CreateMembershipBody, MembershipCombinationExistsQuery>(body);
bool membershipExists = await _mediator.Send(membershipExistsQuery, cancellationToken);
if (membershipExists)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "This user is already a member of this group"
}));
}
CreateMembershipCommand createCommand = _mapper.Map <CreateMembershipBody, CreateMembershipCommand>(body);
GroupMembershipResource membership = await _mediator.Send(createCommand, cancellationToken);
return(CreatedAtAction(nameof(GetMembershipById), new { membershipId = membership.GroupMembershipId }, membership));
}
