public async Task <PagedList <LikeDto> > GetUserLikes(LikeParams likeParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likeParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likeParams.UserId);
users = likes.Select(like => like.LikeUser); // it will provide the user who liked multiple users
}
if (likeParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikeUserId == likeParams.UserId);
users = likes.Select(like => like.SourceUser);
// this should give us a list of users that have 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, likeParams.PageNumber,
likeParams.PageSize));
}
public async Task <PagedList <LikeDTO> > GetUserLikes(LikeParams likeParams)
{
var users = _dataContext.Users.OrderBy(user => user.UserName).AsQueryable();
var likes = _dataContext.Likes.AsQueryable();
// Joining the tables
if (likeParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likeParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likeParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likeParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUser = users.Select(user => new LikeDTO // Project the user data to DTO
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalcAge(),
PhotoUrl = user.Photos.FirstOrDefault(photo => photo.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PagedList <LikeDTO> .CreateAsync(likedUser, likeParams.PageNumber, likeParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikeParams likeParams)
{
var users = this._context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = this._context.Likes.AsQueryable();
if (likeParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likeParams.UserId);
users = likes.Select(like => like.LikedUser); // chi lay cot likeUser
}
if (likeParams.Predicate == "likedBy") // lay danh sach like ma user đang log like
{
likes = likes.Where(like => like.LikedUserId == likeParams.UserId);
users = likes.Select(like => like.SourceUser);
}
// return await users.Select(user => new LikeDto{
// Username = user.UserName,
// KnownAs = user.KnownAs,
// Age = user.DateOfBirth.CalculateAge(),
// PhotoUrl = user.Photos.SingleOrDefault(p => p.IsMain).Url,// select photo in AppUser
// City = user.City,
// Id = user.Id
// }).ToListAsync<LikeDto>();
var likeUsers = users.ProjectTo <LikeDto>(this._mapper.ConfigurationProvider);
return(await PagedList <LikeDto> .CreateAysnc(likeUsers,
likeParams.PageNumber,
likeParams.PageSize));
}
public async Task <PageList <LikeDto> > GetUserLikes(LikeParams likeParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likeParams.predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likeParams.UserId);
users = likes.Select(likes => likes.LikedUser);
}
if (likeParams.predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likeParams.UserId);
users = likes.Select(likes => likes.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 PageList <LikeDto> .CreateAsync(likedUsers, likeParams.PageNumber, likeParams.PageSize));
}
public async Task <PagedList <LikeDTO> > GetUserLikes(LikeParams likeParams)
{
var users = _context.Users.OrderBy(u => u.Username).AsQueryable();
var likes = _context.Likes.AsQueryable();
//currently loggedin user liked
if (likeParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likeParams.UserId);
users = likes.Select(like => like.LikedUser);
}
// users liked currently loggedin user
if (likeParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likeParams.UserId);
users = likes.Select(like => like.SourceUser);
}
var likedUsers = users.Select(user => new LikeDTO
{
// mapping to LikeDTO
Id = user.Id,
Username = user.Username,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City
});
return(await PagedList <LikeDTO> .CreateAsync(likedUsers, likeParams.PageNumber, likeParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikeParams likeParams)
{
var users = _context.Users.OrderBy(o => o.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likeParams.Predicate == "liked")
{
likes = likes.Where(w => w.SourceUserId == likeParams.UserId);
users = likes.Select(s => s.LikedUser);
}
if (likeParams.Predicate == "likedBy")
{
likes = likes.Where(w => w.LikedUserId == likeParams.UserId);
users = likes.Select(s => s.SourceUser);
}
var likedUsers = users.Select(s => new LikeDto
{
Id = s.Id,
Username = s.UserName,
KnownAs = s.KnownAs,
PhotoUrl = s.Photos.FirstOrDefault(f => f.IsMain).Url,
Age = s.DateOfBirth.CalculateAge(),
City = s.City
});
return(await PagedList <LikeDto> .CreateAsync(likedUsers, likeParams.PageNumber,
likeParams.PageSize));
}
public async Task <PagedList <LikeDto> > GetUserLikes(LikeParams likeParams)
{
var users = _context.Users.AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likeParams.Predicate == "Liked")
{
likes = likes.Where(xx => xx.SourceUserId == likeParams.UserId);
users = likes.Select(likes => likes.LikedUser);
}
if (likeParams.Predicate == "LikedBy")
{
likes = likes.Where(xx => xx.LikedUserId == likeParams.UserId);
users = likes.Select(likes => likes.SourceUser);
}
var usersToReturn = users.Select(user => new LikeDto
{
Id = user.Id,
City = user.City,
Username = user.UserName,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(xx => xx.IsMain).Url,
KnownAs = user.KnownAs
});
return(await PagedList <LikeDto> .CreateAsync(usersToReturn
, likeParams.PageNumber, likeParams.PageSize));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikeParams likeParams)
{
likeParams.UserId = User.GetUserId();
var users = await _likeRepository.GetUserLikes(likeParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <LikeDTO> > > GetUserLikes([FromQuery] LikeParams likeParams)
{
var userId = User.GetUserId();
var userLikes = await _likesRepository.GetUserLikes(likeParams, userId);
Response.AddPaginationHeaders(userLikes.PageNumber, userLikes.TotalPages, userLikes.PageSize, userLikes.TotalCount);
return(Ok(userLikes));
}
public async Task <ActionResult <IEnumerable <LikeDto> > > GetUserLikes([FromQuery] LikeParams likeParams)
{
likeParams.userId = User.GetUserId();
var likes = await _unitOfWork.LikesRepository.GetUserLikes(likeParams);
Response.AddPaginationHeader(likes.CurrentPage, likes.TotalPages, likes.TotalCount, likes.PageSize);
return(Ok(likes));
}
public async Task <ActionResult <PagedList <LikeDto> > > GetUserLikes([FromQuery] LikeParams likeParams)
{
likeParams.UserId = User.GetUserId();
var users = await _unitOfWork.LikesRepository.GetUserLikes(likeParams);
Response.AddPaginationHeader(likeParams.PageNumber, likeParams.PageSize,
users.TotalCount, users.TotalPages);
return(Ok(users));
}
/// <summary>
/// EvaluateIsLike
/// </summary>
/// <param name="MatchValue">The value to evaluate</param>
/// <param name="Pattern">The pattern to use</param>
/// <returns>Whether the pattern matches the value to evaluate</returns>
public static bool EvaluateIsLike(string MatchValue, string Pattern, char Wildcard = '%', char Placeholder = '_', char Escape = '!')
{
LikeParams l = new LikeParams() {
MatchValue = MatchValue.ToLowerInvariant(),
Pattern = Pattern.ToLowerInvariant(),
Wildcard = Wildcard,
PlaceHolder = Placeholder,
Escape = Escape
};
return EvaluateIsLike(l, 0, 0);
}
/// <summary>
/// EvaluateIsNotLike
/// </summary>
/// <param name="MatchValue">The value to evaluate</param>
/// <param name="Pattern">The pattern to use</param>
/// <returns>Whether the pattern matches the value to evaluate</returns>
public static bool EvaluateIsNotLike(string MatchValue, string Pattern, char Wildcard = '%', char Placeholder = '_', char Escape = '!')
{
LikeParams l = new LikeParams()
{
MatchValue = MatchValue.ToLowerInvariant(),
Pattern = Pattern.ToLowerInvariant(),
Wildcard = Wildcard,
PlaceHolder = Placeholder,
Escape = Escape
};
return(!EvaluateIsLike(l, 0, 0));
}
public async Task <ActionResult <PagedList <LikeDto> > > GetUserLikes([FromQuery] LikeParams likeParams)
{
// sử dụng 2 tham số nen tao 2 property trong likeParam la predicate , UserId
likeParams.UserId = User.getUserId();
// tra ve 1 page list cho user
var users = await this._unitOfWork.LikeRepository.GetUserLikes(likeParams);
// add vài Header là một Extension để client lấy ra
Response.AddPaginationHeader(users.CurrentPage,
users.PageSize,
users.TotalCount,
users.TotalPages);
return(Ok(users));
}
public async Task <PageList <LikeDto> > GetUserLikes(LikeParams likeParams)
{
IQueryable <LikeDto> query = null;
switch (likeParams.predicate)
{
case "liked":
query = _context.UserLikes
.Where(u => u.SourceUserId == likeParams.userId)
.Select(u => u.LikedUser).ProjectTo <LikeDto>(_mapper.ConfigurationProvider)
.AsQueryable();
break;
default: //likedby
query = _context.UserLikes
.Where(u => u.LikedUserId == likeParams.userId)
.Select(u => u.SourceUser).ProjectTo <LikeDto>(_mapper.ConfigurationProvider)
.AsQueryable();
break;
}
return(await PageList <LikeDto> .CreateAsync(query, likeParams.PageNumber, likeParams.PageSize));
}
public async Task <PagedList <LikeDTO> > GetUserLikes(LikeParams likeParams, int userId)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likeParams.Predicate == "likedBy")
{
likes = likes.Where(ul => ul.LikedUserId == userId);
users = likes.Include(ul => ul.SourceUser.Photos).Select(ul => ul.SourceUser);
}
else if (likeParams.Predicate == "liked" || string.IsNullOrEmpty(likeParams.Predicate))
{
likes = likes.Where(ul => ul.SourceUserId == userId);
users = likes.Include(ul => ul.LikedUser.Photos).Select(ul => ul.LikedUser);
}
var source = users
.ProjectTo <LikeDTO>(_mapper.ConfigurationProvider)
.AsNoTracking();
return(await PagedList <LikeDTO>
.CreateAsync(source, likeParams.PageNumber, likeParams.PageSize));
}
private static bool EvaluateIsLike(LikeParams l, int ValuePosition, int PatternPosition)
{
bool IsOnEscape = false;
while (true)
{
IsOnEscape = false;
if (l.Pattern[PatternPosition] == l.Escape)
{
IsOnEscape = true;
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
{
IsOnEscape = false;
PatternPosition--;
//throw new Exception("Escape character found at end of string - can't use that"); //Run out of characters
}
}
if (!IsOnEscape && l.Pattern[PatternPosition] == l.Wildcard)
{
PatternPosition++; //Look at the next character from now on
if (PatternPosition == l.Pattern.Length) //Wildcard at the end of the pattern, requires no further processing
return true;
//Find the first case of a character we can match (escaped or otherwise, fast forwarding past placeholders and other wildcards along the way)
while (true)
{
IsOnEscape = false;
if (l.Pattern[PatternPosition] == l.Escape)
{
IsOnEscape = true;
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
throw new Exception("Escape character found at end of string - can't use that"); //Run out of characters
}
if (!IsOnEscape && l.Pattern[PatternPosition] == l.PlaceHolder)
{
ValuePosition++; //Requires at least 1 character before search text
if (ValuePosition == l.MatchValue.Length)
return false; //Run out of characters
}
else if (!IsOnEscape && l.Pattern[PatternPosition] == l.Wildcard)
{
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
return true; //Run out of characters
}
else
{
char SearchCharacter = l.Pattern[PatternPosition];
if (IsOnEscape && SearchCharacter != l.Wildcard && SearchCharacter != l.PlaceHolder && SearchCharacter != l.Escape)
throw new Exception("Invalid escape sequence (wildcard scan) - " + PatternPosition);
int start = ValuePosition;
while (true)
{
//Now we can find a starting position for continued Evaluation
start = l.MatchValue.IndexOf(SearchCharacter, start);
if (start == -1)
return false; //Match could not be found
if (!IsOnEscape)
{
if (EvaluateIsLike(l, start, PatternPosition))
return true; //Pop the true up the stack
}
else
{
if (EvaluateIsLike(l, start, PatternPosition - 1)) //Substract 1 so the recursed function can re-evaluate
return true; //Pop the true up the stack
}
start++; //Try to find another match
}
}
}
}
else if (!IsOnEscape && l.Pattern[PatternPosition] == l.PlaceHolder)
{
if (ValuePosition == l.MatchValue.Length) //MatchValue is too short - we've reached the end
return false;
}
else
{
if (ValuePosition == l.MatchValue.Length)
return false; //Characters left over in value, without wildcard in pattern on last character
char ValueCharacter = l.MatchValue[ValuePosition];
char PatternCharacter = l.Pattern[PatternPosition];
if (IsOnEscape && PatternCharacter != l.Wildcard && PatternCharacter != l.PlaceHolder && PatternCharacter != l.Escape)
throw new Exception(String.Format("Invalid escape sequence - {0} - {1}", PatternPosition, ValueCharacter));
if (ValueCharacter != PatternCharacter) //Characters don't match - fail
return false;
}
ValuePosition++;
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
{
if (ValuePosition == l.MatchValue.Length)
return true; //Run out of characters
else
return false; //Left over characters in Value without % in pattern
}
}
}
private static bool EvaluateIsLike(LikeParams l, int ValuePosition, int PatternPosition)
{
bool IsOnEscape = false;
while (true)
{
IsOnEscape = false;
if (l.Pattern[PatternPosition] == l.Escape)
{
IsOnEscape = true;
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
{
IsOnEscape = false;
PatternPosition--;
//throw new Exception("Escape character found at end of string - can't use that"); //Run out of characters
}
}
if (!IsOnEscape && l.Pattern[PatternPosition] == l.Wildcard)
{
PatternPosition++; //Look at the next character from now on
if (PatternPosition == l.Pattern.Length) //Wildcard at the end of the pattern, requires no further processing
{
return(true);
}
//Find the first case of a character we can match (escaped or otherwise, fast forwarding past placeholders and other wildcards along the way)
while (true)
{
IsOnEscape = false;
if (l.Pattern[PatternPosition] == l.Escape)
{
IsOnEscape = true;
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
{
throw new Exception("Escape character found at end of string - can't use that"); //Run out of characters
}
}
if (!IsOnEscape && l.Pattern[PatternPosition] == l.PlaceHolder)
{
ValuePosition++; //Requires at least 1 character before search text
if (ValuePosition == l.MatchValue.Length)
{
return(false); //Run out of characters
}
}
else if (!IsOnEscape && l.Pattern[PatternPosition] == l.Wildcard)
{
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
{
return(true); //Run out of characters
}
}
else
{
char SearchCharacter = l.Pattern[PatternPosition];
if (IsOnEscape && SearchCharacter != l.Wildcard && SearchCharacter != l.PlaceHolder && SearchCharacter != l.Escape)
{
throw new Exception("Invalid escape sequence (wildcard scan) - " + PatternPosition);
}
int start = ValuePosition;
while (true)
{
//Now we can find a starting position for continued Evaluation
start = l.MatchValue.IndexOf(SearchCharacter, start);
if (start == -1)
{
return(false); //Match could not be found
}
if (!IsOnEscape)
{
if (EvaluateIsLike(l, start, PatternPosition))
{
return(true); //Pop the true up the stack
}
}
else
{
if (EvaluateIsLike(l, start, PatternPosition - 1)) //Substract 1 so the recursed function can re-evaluate
{
return(true); //Pop the true up the stack
}
}
start++; //Try to find another match
}
}
}
}
else if (!IsOnEscape && l.Pattern[PatternPosition] == l.PlaceHolder)
{
if (ValuePosition == l.MatchValue.Length) //MatchValue is too short - we've reached the end
{
return(false);
}
}
else
{
if (ValuePosition == l.MatchValue.Length)
{
return(false); //Characters left over in value, without wildcard in pattern on last character
}
char ValueCharacter = l.MatchValue[ValuePosition];
char PatternCharacter = l.Pattern[PatternPosition];
if (IsOnEscape && PatternCharacter != l.Wildcard && PatternCharacter != l.PlaceHolder && PatternCharacter != l.Escape)
{
throw new Exception(String.Format("Invalid escape sequence - {0} - {1}", PatternPosition, ValueCharacter));
}
if (ValueCharacter != PatternCharacter) //Characters don't match - fail
{
return(false);
}
}
ValuePosition++;
PatternPosition++;
if (PatternPosition == l.Pattern.Length)
{
if (ValuePosition == l.MatchValue.Length)
{
return(true); //Run out of characters
}
else
{
return(false); //Left over characters in Value without % in pattern
}
}
}
}
