public FriendshipAllFriendsPaginatedSpecification(FriendshipFilterDto friendshipFilter)
: base(x => (x.ReceiverId == friendshipFilter.UserId || x.SenderId == friendshipFilter.UserId) &&
x.StatusId == (int)FriendshipStatus.Accepted)
{
AddInclude($"{nameof(Domain.Entities.Friendship.Receiver)}");
AddInclude($"{nameof(Domain.Entities.Friendship.Sender)}");
ApplyPaging(friendshipFilter.Skip, friendshipFilter.Take, friendshipFilter.PageNumber);
}
public async Task ApplyWhereClause_EmptyFilter_ReturnsNull()
{
var mockManager = new QueryMockManager();
var mapperMock = mockManager.ConfigureMapperMock <Friendship, FriendshipDto, FriendshipFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Friendship>();
var friendshipQueryObject = new FriendshipQueryObject(mapperMock.Object, queryMock.Object);
var filter = new FriendshipFilterDto();
var temp = await friendshipQueryObject.ExecuteQuery(filter);
Assert.AreEqual(null, mockManager.CapturedPredicate);
}
private async Task <UserFriendsListViewModel> GetUserFriendsModel(UserDto user, int page)
{
var filter = new FriendshipFilterDto
{
PageSize = FriendsPageSize,
RequestedPageNumber = page
};
var friends = await UserFacade.GetFriendsOfUser(user.Id, filter);
return(new UserFriendsListViewModel
{
Friends = await InitializeFriendsListViewModel(friends),
Filter = friends.Filter
});
}
public async Task <FriendshipDto> GetFriendshipBetweenUsers(Guid userAId, Guid userBId)
{
var filter = new FriendshipFilterDto
{
UserA = userAId,
UserB = userBId
};
using (UnitOfWorkProvider.Create())
{
var result = await friendshipService.ListFriendshipAsync(filter);
return(result.Items.FirstOrDefault());
}
}
public async Task <QueryResultDto <FriendshipDto, FriendshipFilterDto> > PendingFriendshipRequests(Guid userId)
{
using (UnitOfWorkProvider.Create())
{
var filter = new FriendshipFilterDto
{
UserA = userId,
IsConfirmed = false
};
var friendships = await friendshipService.ListFriendshipAsync(filter);
friendships.Items = friendships.Items.Where(friendship => friendship.RecipientId == userId);
return(friendships);
}
}
public async Task <bool> CanSendFriendshipRequest(UserDto applicant, UserDto recipient)
{
using (UnitOfWorkProvider.Create())
{
var filter = new FriendshipFilterDto
{
// We can swap those, doesn't really matter the order
UserA = applicant.Id,
UserB = recipient.Id
};
var allFriendships = await friendshipService.ListFriendshipAsync(filter);
filter.IsConfirmed = false;
var allFriendshipRequests = await friendshipService.ListFriendshipAsync(filter);
return(allFriendships.TotalItemsCount == 0 && allFriendshipRequests.TotalItemsCount == 0);
}
}
public async Task <ActionResult> Index(int userId = 0)
{
var authUser = await BasicUserFacade.GetUserByNickNameAsync(User.Identity.Name);
var filter = new FriendshipFilterDto()
{
UserId = authUser.Id
};
var friendsWithChat = await FriendsWithChatFacade.GetFriendsWithChatAsync(filter);
return(View("Chat", new ChatModel
{
AuthenticatedUser = authUser,
FriendWithChat = friendsWithChat.Items,
Filter = filter
}));
}
public async Task <IEnumerable <FriendDto> > GetAllFriends(FriendshipFilterDto friendshipFilter)
{
friendshipFilter.UserId = _currentUserService.UserId;
var friendshipSpec = new FriendshipAllFriendsPaginatedSpecification(friendshipFilter);
var friendships = await _uow.Repository <Domain.Entities.Friendship>().FindAsyncWithPagination(friendshipSpec);
_context.HttpContext.Response.AddPagination(friendships.CurrentPage, friendships.PageSize, friendships.TotalCount, friendships.TotalPages);
var result = new List <FriendDto>();
foreach (var friendship in friendships)
{
if ((int)_currentUserService.UserId == friendship.SenderId)
{
result.Add(new FriendDto
{
Id = friendship.ReceiverId,
Username = friendship.Receiver.Username,
FirstName = friendship.Receiver.FirstName,
LastName = friendship.Receiver.LastName,
Interests = friendship.Receiver.Interests
});
}
else
{
result.Add(new FriendDto
{
Id = friendship.SenderId,
Username = friendship.Sender.Username,
FirstName = friendship.Sender.FirstName,
LastName = friendship.Sender.LastName,
Interests = friendship.Sender.Interests
});
}
}
await _photoService.IncludeMainPhoto(result, (int)EntityTypes.User);
return(result);
}
public async Task ApplyWhereClause_FilterByUserBId_ReturnsCorrectPredicate()
{
Guid filteredUserId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Friendship.ApplicantId), ValueComparingOperator.Equal, filteredUserId),
new SimplePredicate(nameof(Friendship.RecipientId), ValueComparingOperator.Equal, filteredUserId)
}, LogicalOperator.OR);
var mapperMock = mockManager.ConfigureMapperMock <Friendship, FriendshipDto, FriendshipFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Friendship>();
var friendshipQueryObject = new FriendshipQueryObject(mapperMock.Object, queryMock.Object);
var filter = new FriendshipFilterDto {
UserB = filteredUserId
};
var temp = await friendshipQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
private async Task <FriendListViewModel> GetFriendsModel(Guid userId, int page)
{
if (userId == Guid.Empty)
{
return(new FriendListViewModel
{
Friends = new StaticPagedList <UserDto>(new List <UserDto>(), page, 0, 0)
});
}
var filter = new FriendshipFilterDto()
{
IsConfirmed = true,
PageSize = FriendsPageSize,
RequestedPageNumber = page,
UserA = userId
};
var friends = await UserFacade.GetFriendsOfUser(userId, filter);
return(InitializeFriendListViewModel(friends));
}
private IPredicate CreateCompositePredicateFromFilter(FriendshipFilterDto filter)
{
// Filter confirmed friendships or pending friend requests
SimplePredicate confirmedFriendshipsPredicate = new SimplePredicate(nameof(Friendship.IsConfirmed), ValueComparingOperator.Equal, filter.IsConfirmed);
CompositePredicate result = new CompositePredicate(new List <IPredicate> {
confirmedFriendshipsPredicate
}, LogicalOperator.AND);
if (filter.UserA == Guid.Empty)
{
result.Predicates.Add(CreatePredicateForOneUser(filter.UserB));
return(result);
}
if (filter.UserB == Guid.Empty)
{
result.Predicates.Add(CreatePredicateForOneUser(filter.UserA));
return(result);
}
// Both users must be in frienship structure, doesn't matter who is sender or recipient
result.Predicates.Add(CreatePredicateForBothUsers(filter.UserA, filter.UserB));
return(result);
}
protected override IQuery <Friendship> ApplyWhereClause(IQuery <Friendship> query, FriendshipFilterDto filter)
{
var wherePredicate = new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Friendship.User1Id), ValueComparingOperator.Equal, filter.UserId),
new SimplePredicate(nameof(Friendship.User2Id), ValueComparingOperator.Equal, filter.UserId)
}, LogicalOperator.OR);
var compositePredicate = new CompositePredicate(new List <IPredicate>()
{
wherePredicate,
new SimplePredicate(nameof(Friendship.IsAccepted), ValueComparingOperator.Equal, true)
});
wherePredicate = compositePredicate;
return(filter.UserId.Equals(null)
? query
: query.Where(wherePredicate));
}
public async Task <QueryResultDto <FriendsWithChatDto, FriendshipFilterDto> > GetFriendsWithChatAsync(FriendshipFilterDto filter)
{
using (UnitOfWorkProvider.Create())
{
var friends = await _friendsWithChatService.GetFriendsAsync(filter);
foreach (var friendship in friends.Items)
{
friendship.Chat = await _messageService.GetMessagesByFriendshipIdAsync(friendship.Id);
}
return(friends);
}
}
protected override IQuery <Friendship> ApplyWhereClause(IQuery <Friendship> query, FriendshipFilterDto filter)
{
return(filter.UserA == Guid.Empty &&
filter.UserB == Guid.Empty
? query
: query.Where(CreateCompositePredicateFromFilter(filter)));
}
public async Task <IActionResult> GetAllFriends([FromQuery] FriendshipFilterDto friendshipFilter)
{
return(Ok(await _friendshipService.GetAllFriends(friendshipFilter)));
}
public async Task <QueryResultDto <UserDto, FriendshipFilterDto> > GetFriendsOfUser(Guid userId, FriendshipFilterDto filter)
{
filter.UserA = userId;
filter.IsConfirmed = true;
using (UnitOfWorkProvider.Create())
{
return(await friendshipService.GetFriendsOfUserAsync(userId, filter));
}
}
