public async Task ApplyWhereClause_FilterByGenderRestriction_ReturnsCorrectPredicate()
{
const Gender filteredGenderRestriction = Gender.Female;
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, filteredGenderRestriction),
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, Gender.NoInformation)
}, LogicalOperator.OR)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
GenderRestriction = filteredGenderRestriction
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
private IPredicate CreatePostUsernameRestrictionsPredicate(PostFilterDto filter)
{
var predicates = new List <IPredicate>();
foreach (Guid userId in filter.PostUserIds)
{
predicates.Add(new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, userId));
}
return(new CompositePredicate(predicates, LogicalOperator.OR));
}
protected override IQuery <Post> ApplyWhereClause(IQuery <Post> query, PostFilterDto filter)
{
var simplePredicate = filter.GroupId.Equals(null)
? new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filter.UserId)
: new SimplePredicate(nameof(Post.GroupId), ValueComparingOperator.Equal, filter.GroupId);
return(filter.UserId.Equals(null) && filter.GroupId.Equals(null)
? query
: query.Where(simplePredicate));
}
private Gender GetGenderRetrictionEnumFromFilter(PostFilterDto filter)
{
switch (filter.GenderRestriction)
{
case DataTransferObjects.Gender.Male: return(Gender.Male);
case DataTransferObjects.Gender.Female: return(Gender.Female);
default: return(Gender.NoInformation);
}
}
public async Task ApplyWhereClause_ComplexFilterByAllParameters_ReturnsCorrectPredicate()
{
const int filteredUserAge = 30;
Gender filteredGenderRestriction = Gender.Female;
PostVisibility filteredPostVisibility = PostVisibility.FriendsOnly;
Guid filteredUserId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var agePredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.HasAgeRestriction), ValueComparingOperator.Equal, false)
};
var innerAgePredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.AgeRestrictionTo), ValueComparingOperator.LessThanOrEqual, filteredUserAge),
new SimplePredicate(nameof(Post.AgeRestrictionFrom), ValueComparingOperator.GreaterThanOrEqual, filteredUserAge)
};
agePredicates.Add(new CompositePredicate(innerAgePredicates, LogicalOperator.AND));
var genderPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, filteredGenderRestriction),
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, Gender.NoInformation)
}, LogicalOperator.OR);
var userIdPredicate = new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filteredUserId);
var visibilityPredicate = new SimplePredicate(nameof(Post.Visibility), ValueComparingOperator.Equal, filteredPostVisibility);
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new CompositePredicate(agePredicates, LogicalOperator.OR),
genderPredicate,
userIdPredicate,
visibilityPredicate
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto
{
UserAge = filteredUserAge,
GenderRestriction = filteredGenderRestriction,
UserId = filteredUserId
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task <UserProfileUserDto> GetUserProfile(PostFilterDto postFilter, CommentFilterDto commentFilter)
{
using (UnitOfWorkProvider.Create())
{
var user = await _userProfileUserService.GetUserProfileUserByIdAsync(postFilter.UserId);
user.Friends = (await _friendshipService.GetFriendsByUserIdAsync(user.Id, true)).ToList();
user.Posts = await GetPostsWithUsersNicknamesAndCommentsByFilters(postFilter, commentFilter);
return(user);
}
}
public async Task ApplyWhereClause_EmptyFilter_ReturnsNull()
{
var mockManager = new QueryMockManager();
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto();
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(null, mockManager.CapturedPredicate);
}
private IPredicate CreateGenderRestrictionPredicate(PostFilterDto filter)
{
var predicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, GetGenderRetrictionEnumFromFilter(filter)), // filter by user's gender
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, Gender.NoInformation) // and add posts with no gender restriction
};
if (filter.LoggedUserId != Guid.Empty)
{
predicates.Add(new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filter.LoggedUserId)); // Display own posts reggardless of restrictions
}
return(new CompositePredicate(predicates, LogicalOperator.OR));
}
public async Task ApplyWhereClause_FilterByVisibility_ReturnsCorrectPredicate()
{
const PostVisibility filteredVisibility = PostVisibility.FriendsOnly;
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.Visibility), ValueComparingOperator.Equal, filteredVisibility)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
private IPredicate CreateVisibilityRestrictionPostPredicates(PostFilterDto filter)
{
var friendsOnlyPostsPredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.Visibility), ValueComparingOperator.Equal, PostVisibility.FriendsOnly)
};
if (filter.PostUserIds != null && filter.PostUserIds.Count > 0)
{
friendsOnlyPostsPredicates.Add(CreatePostUsernameRestrictionsPredicate(filter));
}
var predicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.Visibility), ValueComparingOperator.Equal, PostVisibility.Public),
new CompositePredicate(friendsOnlyPostsPredicates, LogicalOperator.AND)
};
return(new CompositePredicate(predicates, LogicalOperator.OR));
}
private IPredicate CreateAgeRestrictionPredicate(PostFilterDto filter)
{
var predicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.HasAgeRestriction), ValueComparingOperator.Equal, false) // add posts who has no age restriction
};
var innerPredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.AgeRestrictionTo), ValueComparingOperator.LessThanOrEqual, filter.UserAge),
new SimplePredicate(nameof(Post.AgeRestrictionFrom), ValueComparingOperator.GreaterThanOrEqual, filter.UserAge)
};
predicates.Add(new CompositePredicate(innerPredicates, LogicalOperator.AND));
if (filter.LoggedUserId != Guid.Empty)
{
predicates.Add(new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filter.LoggedUserId)); // Display own posts reggardless of restrictions
}
return(new CompositePredicate(predicates, LogicalOperator.OR));
}
public async Task ApplyWhereClause_FilterByUserId_ReturnsCorrectPredicate()
{
Guid filteredUserId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filteredUserId)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
UserId = filteredUserId
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
private async Task <PostFilterDto> CreateFilterForUserDetailPosts(bool isFriend)
{
var result = new PostFilterDto
{
PageSize = PostsPageSize,
};
var loggedUser = await GetLoggedUser();
if (loggedUser != null)
{
var age = (int)((DateTime.Now - loggedUser.Birthdate).TotalDays / 365.2425);
result.UserAge = age;
result.GenderRestriction = loggedUser.Gender;
result.LoggedUserId = loggedUser.Id;
}
if (isFriend)
{
result.IncludePrivatePosts = true;
}
return(result);
}
// GET: Posts
public async Task <ActionResult> Index(PostFilterDto postFilter)
{
//defaultni hodnota pagesize je 50 - zvysuje se po lichych cislech, takze je to v poho (y)
if (postFilter.PageSize == 50)
{
postFilter = new PostFilterDto()
{
SortCriteria = nameof(Post.PostedAt),
PageSize = Posts
};
}
//priprava na pagination
Session[PostFilterSessionKey] = postFilter;
var commentFilter = Session[CommentFilterSessionKey] as CommentFilterDto ?? new CommentFilterDto()
{
PageSize = Comments
};
var posts = await UserProfileFacade.GetPostsWithUsersNicknamesAndCommentsByFilters(postFilter, commentFilter);
BasicUserDto userWithFriends = null;
if (Request.IsAuthenticated)
{
var user = await BasicUserFacade.GetUserByNickNameAsync(User.Identity.Name);
userWithFriends = await BasicUserFacade.GetBasicUserWithFriends(user.Id);
}
return(View("Index", new PostListModel()
{
PostFilter = postFilter,
AuthenticatedUser = userWithFriends,
Posts = posts
}));
}
public async Task <QueryResultDto <PostDto, PostFilterDto> > GetPostsByUserIdForLoggedUser(PostFilterDto filter,
Guid userId, Guid loggedUserId)
{
using (UnitOfWorkProvider.Create())
{
if (userId != Guid.Empty)
{
var friendships = await friendshipService.GetFriendsOfUserAsync(loggedUserId, new FriendshipFilterDto());
if (friendships.Items.Any(friend => friend.Id == userId))
{
filter.PostUserIds = new List <Guid>
{
userId
};
}
filter.LoggedUserId = loggedUserId;
filter.UserId = userId;
filter.SortCriteria = "Time";
filter.IncludePrivatePosts = true;
return(await postService.ListPostAsync(filter));
}
throw new ArgumentException("Cannot display posts of not existing user");
}
}
public async Task <QueryResultDto <PostDto, PostFilterDto> > GetPostsByUserId(PostFilterDto filter, Guid userId)
{
using (UnitOfWorkProvider.Create())
{
if (userId != Guid.Empty)
{
filter.UserId = userId;
filter.SortCriteria = "Time";
return(await postService.ListPostAsync(filter));
}
throw new ArgumentException("Cannot display posts of not existing user");
}
}
public async Task <QueryResultDto <PostDto, PostFilterDto> > GetPostFeedAsync(PostFilterDto filter, Guid userId, string hashtagFilter)
{
using (UnitOfWorkProvider.Create())
{
filter.SortCriteria = "Time";
if (hashtagFilter != null)
{
filter.PostIdsWithHashtag = (await hashtagService.ListHashtagAsync(new HashtagFilterDto {
Tag = hashtagFilter
}))
.Items
.Select(h => h.PostId)
.ToList();
}
if (userId != Guid.Empty)
{
filter.LoggedUserId = userId;
return(await postService.ListPostsAvailableForUser(userId, filter));
}
return(await postService.ListPostAsync(filter));
}
}
//Get posts by filter, when is commentFilter not null then load also comments
public async Task <QueryResultDto <UserProfilePostDto, PostFilterDto> > GetPostsWithUsersNicknamesAndCommentsByFilters(PostFilterDto postFilter, CommentFilterDto commentFilter)
{
using (UnitOfWorkProvider.Create())
{
postFilter.SortCriteria = nameof(Post.PostedAt);
var posts = await _userProfilePostService.GetPostsByFilterAsync(postFilter);
foreach (var post in posts.Items)
{
if (postFilter.UserId == null && post.UserId != null)
{
//Add Nicknames
post.NickName = (await _basicUsersService.GetAsync((int)post.UserId)).NickName;
}
if (commentFilter != null)
{
commentFilter.PostId = post.Id;
post.Comments = await GetCommentsByFilter(commentFilter);
}
}
return(posts);
}
}
protected override IQuery <Post> ApplyWhereClause(IQuery <Post> query, PostFilterDto filter)
{
return(query.Where(CreatePredicateFromFilter(filter)));
}
