public void GetFollowersNotBeingFollowedUserNames_ReturnsNullReferenceException_WhenUserIsNull()
{
// Act & Assert
var ex = Assert.Throws <NullReferenceException>(() => UserNetworkHelpers.GetFollowersNotBeingFollowedUserNames(null));
Assert.Equal("The user is null", ex.Message);
}
public void GetFollowingUserNames_ReturnsNullReferenceException_WhenArgumentIsNull()
{
// Act & Assert
var ex = Assert.Throws <NullReferenceException>(() => UserNetworkHelpers.GetFollowingUserNames(null));
Assert.Equal("The following collection is null", ex.Message);
}
public void UpdateIsFollowingProperty_ReturnsNullReferenceException_WhenUsernameIsNull()
{
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => UserNetworkHelpers.UpdateIsFollowingProperty(null, new List <Network>()));
Assert.Equal("The requestingUsername is null (Parameter 'requestingUsername')", ex.Message);
}
public async Task <IActionResult> GetSearchNetworkAsync(string searchCriterion)
{
try
{
if (string.IsNullOrEmpty(searchCriterion))
{
_logger.LogError(LoggingEvents.GetListNotFound, "The search criterion is null or empty");
return(BadRequest("No search criterion"));
}
var requestingUser = await _userManager.GetUserWithNetworkAsync(User.Identity.Name);
if (requestingUser is null)
{
_logger.LogError(LoggingEvents.GetItemNotFound, "The user was not found");
return(StatusCode(500, $"requesting user not found"));
}
var followingUsernamesList = UserNetworkHelpers.GetFollowingUserNames(requestingUser.Following);
followingUsernamesList.Add(requestingUser.UserName);
//var users = await _SearchBirdersToFollowAsync(searchCriterion, followingUsernamesList);
var users = await _userManager.GetUsersAsync(user => user.NormalizedUserName.Contains(searchCriterion.ToUpper()) && !followingUsernamesList.Contains(user.UserName));
return(Ok(_mapper.Map <IEnumerable <ApplicationUser>, IEnumerable <NetworkUserViewModel> >(users)));
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.Exception, ex, $"an unexpected error occurred");
return(StatusCode(500, "an unexpected error occurred"));
}
}
public async Task <IActionResult> GetFollowersAsync(string requestedUsername)
{
if (string.IsNullOrEmpty(requestedUsername))
{
_logger.LogError(LoggingEvents.GetListNotFound, "The search criterion is null or empty");
return(BadRequest("No search criterion"));
}
try
{
var requestedUser = await _userManager.GetUserWithNetworkAsync(requestedUsername);
if (requestedUser is null)
{
_logger.LogError(LoggingEvents.GetItem, $"Username '{requestedUsername}' not found at GetUserProfileAsync action");
return(StatusCode(500, $"requested user not found"));
}
var model = _mapper.Map <ICollection <Network>, IEnumerable <FollowerViewModel> >(requestedUser.Followers);
var requesterUsername = User.Identity.Name;
if (requestedUser is null)
{
_logger.LogError(LoggingEvents.GetItem, $"Username '{requestedUsername}' not found at GetUserProfileAsync action");
return(StatusCode(500, $"requested user not found"));
}
if (requesterUsername.Equals(requestedUsername))
{
// Own profile requested...
UserNetworkHelpers.SetupFollowersCollection(requestedUser, model);
return(Ok(model));
}
else
{
// Other user's profile requested...
var requestingUser = await _userManager.GetUserWithNetworkAsync(requesterUsername);
if (requestingUser is null)
{
_logger.LogError(LoggingEvents.GetItem, $"Username '{requesterUsername}' not found at GetUserProfileAsync action");
return(StatusCode(500, $"requesting user not found"));
}
UserNetworkHelpers.SetupFollowersCollection(requestingUser, model);
return(Ok(model));
}
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.Exception, ex, $"an unexpected error occurred");
return(StatusCode(500, "an unexpected error occurred"));
}
}
public void SetupFollowingCollection_ReturnsArgumentNullException_WhenUserIsNull()
{
ApplicationUser requestingUser = null;
IEnumerable <FollowingViewModel> following = new List <FollowingViewModel>();
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => UserNetworkHelpers.SetupFollowingCollection(requestingUser, following));
Assert.Equal("The requesting user is null (Parameter 'requestingUser')", ex.Message);
}
public void SetupFollowersCollection_ReturnsArgumentNullException_WhenFollowersIsNull()
{
ApplicationUser requestingUser = new ApplicationUser();
IEnumerable <FollowerViewModel> followers = null;
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => UserNetworkHelpers.SetupFollowersCollection(requestingUser, followers));
Assert.Equal("The followers collection is null (Parameter 'followers')", ex.Message);
}
public void GetFollowingUserNames_ReturnsEmptyCollection_WhenInputCollectionIsEmpty()
{
// Arrange
var emptyInputCollection = new List <Network>();
// Act
var result = UserNetworkHelpers.GetFollowingUserNames(emptyInputCollection);
// Assert
Assert.IsType <List <String> >(result);
Assert.Empty(result);
}
public void UpdateIsFollowing_ReturnsNullReferenceException_WhenUsernameIsNull()
{
// Arrange
var viewModel = new NetworkUserViewModel()
{
UserName = "******"
};
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => UserNetworkHelpers.UpdateIsFollowing(null, new List <Network>()));
Assert.Equal("The requestingUsername is null (Parameter 'requestingUsername')", ex.Message);
}
public void UpdateIsFollowingProperty_ReturnsNullReferenceException_WhenFollowingCollectionIsNull()
{
// Arrange
var viewModel = new NetworkUserViewModel()
{
UserName = "******"
};
// Act & Assert
var ex = Assert.Throws <ArgumentNullException>(() => UserNetworkHelpers.UpdateIsFollowingProperty(viewModel.UserName, null));
Assert.Equal("The followers collection is null (Parameter 'requestedUsersFollowers')", ex.Message);
}
public void GetFollowingUserNames_ReturnsCollection_WhenInputCollectionLengthIsGreaterThan0(int length)
{
// Arrange
var testCollection = GetDynamicNetworkCollection(length);
// Act
var result = UserNetworkHelpers.GetFollowingUserNames(testCollection);
// Assert
Assert.IsType <List <String> >(result);
Assert.NotEmpty(result);
Assert.Equal(length, result.Count);
Assert.Equal("Test 1", result[0]);
Assert.Equal("Test " + length.ToString(), result[length - 1]);
}
public void GetFollowersNotBeingFollowedUserNames_ReturnsNullReferenceException_WhenFollowingCollectionIsNull()
{
// Arrange
var user = new ApplicationUser()
{
UserName = "******"
};
user.Following = null;
user.Followers = new List <Network>();
// Act & Assert
var ex = Assert.Throws <NullReferenceException>(() => UserNetworkHelpers.GetFollowersNotBeingFollowedUserNames(user));
Assert.Equal("The following collection is null", ex.Message);
}
public async Task <IActionResult> GetNetworkSummaryAsync()
{
try
{
var requestingUser = await _userManager.GetUserWithNetworkAsync(User.Identity.Name);
if (requestingUser is null)
{
_logger.LogError(LoggingEvents.GetItemNotFound, "requesting user not found");
return(StatusCode(500, "requesting user not found"));
}
var model = new NetworkSummaryDto
{
FollowersCount = requestingUser.Followers.Count,
FollowingCount = requestingUser.Following.Count
};
var followersNotBeingFollowed = UserNetworkHelpers.GetFollowersNotBeingFollowedUserNames(requestingUser);
if (followersNotBeingFollowed.Any())
{
// ToDo: needs to be paged or Take(x)
var users = await _userManager.GetUsersAsync(user => followersNotBeingFollowed.Contains(user.UserName));
model.SuggestedUsersToFollow = _mapper.Map <IEnumerable <ApplicationUser>, IEnumerable <NetworkUserViewModel> >(users);
return(Ok(model));
}
else
{
// ToDo: needs to be paged or Take(x)
var followingUsernamesList = UserNetworkHelpers.GetFollowingUserNames(requestingUser.Following);
var users = await _userManager.GetUsersAsync(user => !followingUsernamesList.Contains(user.UserName) && user.UserName != requestingUser.UserName);
model.SuggestedUsersToFollow = _mapper.Map <IEnumerable <ApplicationUser>, IEnumerable <NetworkUserViewModel> >(users);
return(Ok(model));
}
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.Exception, ex, $"an unexpected error occurred");
return(StatusCode(500, "an unexpected error occurred"));
}
}
public async Task <IActionResult> GetUserProfileAsync(string requestedUsername)
{
// add properties for no. of species / observations
// build new query object
if (string.IsNullOrEmpty(requestedUsername))
{
_logger.LogError(LoggingEvents.GetItem, "requestedUsername argument is null or empty at GetUserProfileAsync action");
return(BadRequest($"{nameof(requestedUsername)} argument is null or empty"));
}
try
{
var requestedUser = await _userManager.GetUserWithNetworkAsync(requestedUsername);
if (requestedUser is null)
{
_logger.LogError(LoggingEvents.GetItem, $"Username '{requestedUsername}' not found at GetUserProfileAsync action");
return(StatusCode(500, "userManager returned null"));
}
var requestedUserProfileViewModel = _mapper.Map <ApplicationUser, UserProfileViewModel>(requestedUser);
requestedUserProfileViewModel.FollowersCount = requestedUser.Followers.Count;
requestedUserProfileViewModel.FollowingCount = requestedUser.Following.Count;
if (requestedUsername.Equals(User.Identity.Name))
{
// Own profile requested...
requestedUserProfileViewModel.IsOwnProfile = true;
}
else
{
// Other user's profile requested...
requestedUserProfileViewModel.IsFollowing = UserNetworkHelpers.UpdateIsFollowingProperty(User.Identity.Name, requestedUser.Followers);
}
return(Ok(requestedUserProfileViewModel));
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.Exception, ex, "Error at GetUserProfileAsync");
return(StatusCode(500, "There was an error getting the user profile"));
}
}
public void GetFollowersNotBeingFollowedUserNames_ReturnsEmptyCollection_WhenInputCollectionIsEmpty(int length)
{
// Arrange
var user = new ApplicationUser()
{
UserName = "******"
};
user.Following = GetDynamicNetworkCollection(length);
user.Followers = new List <Network>();
// Act
var result = UserNetworkHelpers.GetFollowersNotBeingFollowedUserNames(user);
// Assert
Assert.IsAssignableFrom <IEnumerable <String> >(result);
Assert.Empty(result);
}
public void UpdateIsFollowingProperty_ReturnsIsFollowEqualsFalse_WhenViewModelUserIsNotInFollowingCollection(int length)
{
// Arrange
var viewModel = new NetworkUserViewModel()
{
UserName = "******"
};
var followers = GetDynamicNetworkCollection(length);
// Act
var result = UserNetworkHelpers.UpdateIsFollowingProperty(viewModel.UserName, followers);
// Assert
var returnModel = Assert.IsType <bool>(result);
//Assert.Equal(viewModel.UserName, returnModel.UserName);
Assert.False(result);
}
public void UpdateIsFollowing_ReturnsIsFollowEqualsTrue_WhenViewModelUserIsInFollowingCollection()
{
// Arrange
var viewModel = new NetworkUserViewModel()
{
UserName = "******"
};
var following = GetDynamicNetworkCollection(8);
// Act
var result = UserNetworkHelpers.UpdateIsFollowing(viewModel.UserName, following);
// Assert
var returnModel = Assert.IsType <bool>(result);
//Assert.Equal(viewModel.UserName, returnModel.UserName);
Assert.True(result);
}
public void GetFollowersNotBeingFollowedUserNames_ReturnsCollection_WhenCollectionsAreGreaterThanOne()
{
// Arrange
var user = new ApplicationUser()
{
UserName = "******"
};
user.Following = GetDynamicNetworkCollection(3);
user.Followers = GetDynamicNetworkCollection(6);
// Act
var result = UserNetworkHelpers.GetFollowersNotBeingFollowedUserNames(user);
// Assert
var t = Assert.IsAssignableFrom <IEnumerable <String> >(result);
Assert.Equal(3, t.Count());
}
public async Task <IActionResult> PostUnfollowUserAsync(NetworkUserViewModel userToUnfollowDetails) //, int currentPage)
{
try
{
var requestingUser = await _userManager.GetUserWithNetworkAsync(User.Identity.Name);
if (requestingUser is null)
{
_logger.LogError(LoggingEvents.UpdateItem, "Requesting user not found");
return(NotFound("Requesting user not found"));
}
var userToUnfollow = await _userManager.GetUserWithNetworkAsync(userToUnfollowDetails.UserName);
if (userToUnfollow is null)
{
_logger.LogError(LoggingEvents.UpdateItem, "User to Unfollow not found");
return(NotFound("User to Unfollow not found"));
}
if (requestingUser == userToUnfollow)
{
return(BadRequest("Trying to unfollow yourself"));
}
_networkRepository.UnFollow(requestingUser, userToUnfollow);
await _unitOfWork.CompleteAsync();
var viewModel = _mapper.Map <ApplicationUser, NetworkUserViewModel>(userToUnfollow);
viewModel.IsFollowing = UserNetworkHelpers.UpdateIsFollowing(viewModel.UserName, requestingUser.Following);
return(Ok(viewModel));
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.Exception, ex, $"an unexpected error occurred");
return(StatusCode(500, "an unexpected error occurred"));
}
}
public async Task <IActionResult> GetObservationsFeedAsync(int pageIndex, ObservationFeedFilter filter)
{
try
{
if (filter == ObservationFeedFilter.Own)
{
var userObservations = await _observationQueryService.GetPagedObservationsFeedAsync(o => o.ApplicationUser.UserName == User.Identity.Name, pageIndex, pageSize);
if (userObservations is null)
{
_logger.LogWarning(LoggingEvents.GetListNotFound, "User Observations list was null at GetObservationsFeedAsync()");
return(StatusCode(500, $"User observations object is null"));
}
if (userObservations.TotalItems > 0 || pageIndex > 1)
{
// _profilePhotosService.GetThumbnailUrl(userObservations.Items);
userObservations.ReturnFilter = ObservationFeedFilter.Own;
return(Ok(userObservations));
}
}
/*
* if network observations is requested, or
* if user's own observations is request BUT user has no observations
*/
if (filter == ObservationFeedFilter.Network || filter == ObservationFeedFilter.Own)
{
var requestingUserAndNetwork = await _userManager.GetUserWithNetworkAsync(User.Identity.Name);
if (requestingUserAndNetwork is null)
{
_logger.LogWarning(LoggingEvents.GetItemNotFound, "Requesting user not found");
return(StatusCode(500, $"requesting user not found"));
}
var followingUsernamesList = UserNetworkHelpers.GetFollowingUserNames(requestingUserAndNetwork.Following);
followingUsernamesList.Add(requestingUserAndNetwork.UserName);
var networkObservations = await _observationQueryService.GetPagedObservationsFeedAsync(o => followingUsernamesList.Contains(o.ApplicationUser.UserName), pageIndex, pageSize);
if (networkObservations is null)
{
_logger.LogWarning(LoggingEvents.GetListNotFound, "Network observations list is null");
return(StatusCode(500, $"Network observations object is null"));
}
if (networkObservations.TotalItems > 0 || pageIndex > 1)
{
// move to ObservationQueryService?
//_profilePhotosService.GetThumbnailUrl(networkObservations.Items);
networkObservations.ReturnFilter = ObservationFeedFilter.Network;
return(Ok(networkObservations));
}
}
/*
* if public observations is requested, or
* if user's own or network observations is request BUT user/network has no observations
*/
var publicObservations = await _observationQueryService.GetPagedObservationsFeedAsync(pl => pl.SelectedPrivacyLevel == PrivacyLevel.Public, pageIndex, pageSize);
if (publicObservations is null)
{
_logger.LogWarning(LoggingEvents.GetListNotFound, "Observations list is null");
return(StatusCode(500, $"Public observations object is null"));
}
//_profilePhotosService.GetThumbnailUrl(publicObservations.Items);
publicObservations.ReturnFilter = ObservationFeedFilter.Public;
return(Ok(publicObservations));
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.GetListNotFound, ex, "An error occurred getting the observations feed");
return(StatusCode(500, "An unexpected error occurred"));
}
}
