public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(user => new LikeDto
{
UserName = user.UserName,
AppUserType = user.AppUserType,
FirstName = user.FirstName,
Major = user.Major,
Position = user.Position,
Company = user.Company,
StudentUrl = user.Photos.FirstOrDefault(p => p.IsMain).StudentUrl,
LogoUrl = user.Photos.FirstOrDefault(p => p.IsMainLogo).LogoUrl,
// Athletics = user.CollegePreps.FirstOrDefault(p => p.IsActive).Athletics,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers,
likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDTO> > GetUserLikes(LikesParams likesParams)
{
var usersQuery = _context.Users.OrderBy(x => x.UserName).AsQueryable();
var likesQuery = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likesQuery = likesQuery.Where(x => x.SourceUserId == likesParams.UserId);
usersQuery = likesQuery.Select(x => x.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likesQuery = likesQuery.Where(x => x.LikedUserId == likesParams.UserId);
usersQuery = likesQuery.Select(x => x.SourceUser);
}
var likedUsers = usersQuery.Select(x => new LikeDTO
{
Id = x.Id,
Username = x.UserName,
KnownAs = x.KnownAs,
Age = x.DateOfBirth.CalculateAge(),
PhotoUrl = x.Photos.FirstOrDefault(x => x.IsMain).Url,
City = x.City,
});
return(await PagedList <LikeDTO> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(user => user.UserName).AsQueryable(); // We use the AsQueryable so that we can build up our queries below
var likes = _context.Likes.AsQueryable(); // We need to query both the users table and the likes table
if (likesParams.Predicate == "liked") // This is the users that the currently logged in user has liked
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId); // Here we are returning each like where the sourceUserId matches the userId that is passed into this method.
users = likes.Select(like => like.LikedUser); // Here we are returning the LikedUser (AppUser) from each of the likes that we have filtered above
}
if (likesParams.Predicate == "likedBy") // This is the users that the currently logged in user has been liked by
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId); // Here we are returning each like where the LikedUserId matches the userId that is passed into this method.
users = likes.Select(like => like.SourceUser); // Here we are returning the SourceUser (AppUser) from each of the likes that we have filtered above
}
var likedUsers = users.Select(user => new LikeDto // We don't use automapper here. We project directly into our Like Dto
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(user => new LikeDto
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers,
likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
// Here we will have 2 posibilities
// First: To show the users that sourceUser likes
// Second: Who likes the source user
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked") // users that currently logged in user likes
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser); // Users from liked table
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser); // Users that liked currently logged in user
}
var likedUsers = users.Select(user => new LikeDto {
UserName = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(x => x.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(x => x.SourceUserId == likesParams.UserId);
users = likes.Select(x => x.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(x => x.LikedUserId == likesParams.UserId);
users = likes.Select(x => x.SourceUser);
}
var likedUsers =
users
.Select(user =>
new LikeDto {
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = PhotosHelper.GetMainPhoto(user.Photos),
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto>
.CreateAsync(likedUsers,
likesParams.PageNumber,
likesParams.PageSize));
}
public async Task <PageList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var qUsers = _context.Users.OrderBy(x => x.UserName).AsQueryable();
var qLikes = _context.Likes.AsQueryable();
switch (likesParams.Predicate.ToLower())
{
case "liked":
qLikes = qLikes.Where(x => x.SourceUserId == likesParams.UserId);
qUsers = qLikes.Select(x => x.LikedUser);
break;
case "likedby":
qLikes = qLikes.Where(x => x.LikedUserId == likesParams.UserId);
qUsers = qLikes.Select(x => x.SourceUser);
break;
default:
break;
}
var likedUsers = qUsers.Select(x => new LikeDto {
Id = x.Id,
UserName = x.UserName,
Age = x.DateOfBirth.CalculateAge(),
KnownAs = x.KnownAs,
City = x.City,
PhotoUrl = x.Photos.FirstOrDefault(x => x.IsMain == true).Url
});
return(await PageList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = context.Users.AsQueryable();
var likes = context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
//var user = users.FirstOrDefaultAsync(u => u.Id == userId);
var likesOfUser = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likesOfUser.Select(x => x.LikedAppUser);
}
else if (likesParams.Predicate == "likedBy")
{
var likesOfUser = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likesOfUser.Select(x => x.SourceAppUser);
}
var source = users.Select(user => new LikeDto
{
Id = user.Id,
UserName = user.UserName,
Age = user.GetAge(),
KnownAs = user.KnownAs,
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain == true).Url,
City = user.City
}).AsQueryable();
return(await API.Helpers.PagedList <LikeDto> .CreateAsync(source, likesParams.PageNumber,
likesParams.PageSize));
}
public async Task <PageList <LikesDTO> > GetLikes(LikesParams likesParams)
{
IQueryable <LikesDTO> result = null;
if (likesParams.Predicate == "like")
{
result = _context.Users
.Include(x => x.Photos)
.Where(x => _context.Likes.Where(x => x.likedByUserId == likesParams.UserId).Select(x => x.likedUserId).Contains(x.Id))
.Select(u => new LikesDTO {
UserName = u.UserName,
Country = u.Country,
photoUrl = u.Photos.FirstOrDefault(x => x.isMain).Url,
Age = u.Age,
KnownAs = u.KnownAs,
}).OrderBy(x => x.KnownAs);
}
if (likesParams.Predicate == "likeBy")
{
result = _context.Users
.Include(x => x.Photos)
.Where(x => _context.Likes.Where(x => x.likedUserId == likesParams.UserId).Select(x => x.likedByUserId).Contains(x.Id))
.Select(u => new LikesDTO {
UserName = u.UserName,
Country = u.Country,
photoUrl = u.Photos.FirstOrDefault(x => x.isMain).Url,
Age = u.Age,
KnownAs = u.KnownAs,
}).OrderBy(x => x.KnownAs);
}
return(await PageList <LikesDTO> .CreateAsync(result, likesParams.PageSize, likesParams.PageNumber));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(user => user.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(user => new LikeDto
{
UserName = user.UserName,
Name = user.Name,
Id = user.Id,
PhotoUrl = user.Photo.Url,
Location = user.Location
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <AppUserLikesResponse> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
switch (likesParams.Predicate)
{
case "liked":
{
likes = likes.Where(l => l.SourceUserId == likesParams.UserId);
users = likes.Select(l => l.LikedUser);
}
break;
case "likedBy":
{
likes = likes.Where(l => l.LikedUserId == likesParams.UserId);
users = likes.Select(l => l.SourceUser);
}
break;
}
var likedUsers = users.Select(u => new AppUserLikesResponse
{
UserName = u.UserName,
KnownAs = u.KnownAs,
Age = u.DateOfBirth.CalculateAge(),
PhotoUrl = u.Photos.FirstOrDefault(p => p.Enabled).Url,
City = u.City,
Id = u.Id
});
return(await PagedList <AppUserLikesResponse> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
// get list of users user has liked -> user id is source user
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
// users have liked user
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser); // users from likes table, liked user is app user
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser); // users from liked table, source user is app user
}
var likedUsers = users.Select(user => new LikeDto
{
// not enough props to need AutoMapper
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
//public async Task<IEnumerable<LikeDto>> GetUserLikes(string predicate, int userId) { // our predicate means we add our queryables here
// public async Task<PagedList<LikeDto>> GetUserLikes(string predicate, int userId) { // our predicate means we add our queryables here
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams) // our predicate means we add our queryables here
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable(); // this is our join query that Entity Framework Works out for us
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(user => new LikeDto {
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
//}).ToListAsync();
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
/*By writing like this it internally writes the query in such a way that it join two table and gives the App-user list who is liked by me*/
users = likes.Select(like => like.LikedUser);
}
//List of user which has liked currently loggedIn user
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
/*By writing like this it internally writes the query in such a way that it join two table and gives the App-user list who liked me*/
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(user => new LikeDto
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDTO> > GetUserLikes(LikesParams likesParams)
{
var users = this.Context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = this.Context.UserLikes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(l => l.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(l => l.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(u => new LikeDTO()
{
Id = u.Id,
UserName = u.UserName,
//Age = u.age
KnownAs = u.KnownAs,
PhotoUrl = u.Photos.FirstOrDefault(x => x.IsMain).Url,
City = u.City,
});
return(await PagedList <LikeDTO> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = Context.Users.OrderBy(user => user.UserName).AsQueryable();
var likes = Context.Likes.AsQueryable();
if (likesParams.predicate == "liked") //users that were liked by currently logged user
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId); //likes that were liked by current user
users = likes.Select(like => like.LikedUser); //users that were liked
}
if (likesParams.predicate == "likedBy") //users that have liked currently logged user
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId); //likes that were given to currently logger user
users = likes.Select(like => like.SourceUser); //users that liked someone
}
var likedUsers = users.Select(user => new LikeDto //in this case we didnt use automapper, we mapped user to LikedDto
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(photo => photo.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
var users = await _likesRepository.GetUserLikes(predicate, User.GetUserId());
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
// gives us likes where our logged in user is the source id. (where they clicked liked on these profiles)
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
// gives us our users from our user's likes. And our liked user is an AppUser and we are selecting that.
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
// gives us a list of users that have liked the currently logged in user.
}
var likedUsers = users.Select(user => new LikeDto
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(l => l.SourceUserId == likesParams.UserId);
users = likes.Select(l => l.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(l => l.LikedUserId == likesParams.UserId);
users = likes.Select(l => l.SourceUser);
}
// return await users.Select(u => new LikeDto
// {
// Username = u.Username,
// KnownAs = u.KnownAs,
// Age = u.DateOfBirth.CalculateAge(),
// PhotoUrl = u.Photos.FirstOrDefault(p => p.IsMain).Url,
// City = u.City,
// Id = u.Id
// }).ToListAsync();
var likedUsers = users.ProjectTo <LikeDto>(_mapper.ConfigurationProvider);
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likesParams.PageNumber,
likesParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked") // the users that the currently login user has liked
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId); // so here you use where to filter and returns the likeUser filters but all its props.
users = likes.Select(like => like.LikedUser); // instead select of linQ is for select a spesific field of the table in this case the LikedUser (of type AppUser) prop.
}
if (likesParams.Predicate == "likedBy")// the users that has liked the currently login user
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUser = users.Select(user =>
new LikeDto {
Id = user.Id,
UserName = user.UserName,
Age = user.DateOfBirth.CalculateAge(),
KnownAs = user.KnownAs,
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City
}
);
return(await PagedList <LikeDto> .CreateAsync(likedUser, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier)?.Value);
var users = await _unitOfWork.likesService.GetUserLikes(likesParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikesDTO> > > GetLikes([FromQuery] LikesParams likesParmas)
{
likesParmas.UserId = User.GetUserId();
var user = await _mainRepositories.UserLikesRespository.GetLikes(likesParmas);
Response.addPaginationHeader(user.CurrentPage, user.PageSize, user.TotalCount, user.TotalPages);
return(Ok(user));
}
public async Task <ActionResult <PagedList <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = User.GetUserId();
var users = await _likesRepository.GetUserLikes(likesParams);
Response.AddPaginationHeader <LikesHeader, LikeDto, LikesParams>(users, _mapper, likesParams);
return(Ok(users));
}
public async Task <ActionResult <PagedList <LikeDto> > > GetUseLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = User.GetUserId();
var users = await _unitOfWork.LikesRepository.GetUserLikes(likesParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = User.GetUserId();
//var sourceUserId = User.GetUserId();
var users = await _unitOfWork.LikesRepository.GetUserLikes(likesParams); //.GetUserLikes(predicate, sourceUserId);
Response.AddPaginationHeader(likesParams.PageNumber, likesParams.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = User.GetUserId();
//Action result doesn't work so well with IEnumerables, so we need to return OK(IEnumerable)
var users = await _unitOfWork.LikesRepository.GetUserLikes(likesParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = User.GetUserId();
var users = await _unitOfWork.LikesRepository.GetUserLikes(likesParams);
//Adding the Pagination Information in the response to be used in the next request
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams)
{
likesParams.UserId = User.GetUserId();
var users = await this.unitOfWork.LikesRepository.GetUserLikes(likesParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
// Cannot return directly, ActionResult does not work well with IEnumerable
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikesParams likesParams) // => CONFIGURED FOR PAGINATION
{
likesParams.UserId = User.GetUserId(); // => CONFIGURED FOR PAGINATION
var users = await _likesRepository.GetUserLikes(likesParams); // => CONFIGURED FOR PAGINATION
Response.AddPaginationHeader(users.CurrentPage,
users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLike([FromQuery] LikesParams likedParams)
{
likedParams.UserId = User.GetUserId();
var result = await _unitOfWork.LikesRepository.GetUserLikesAsync(likedParams);
Response.AddPaginationHeader(result.PaginationProperties);
return(Ok(await _unitOfWork.LikesRepository.GetUserLikesAsync(likedParams)));
}
