public async Task <IEnumerable <UserViewModel> > FilterUser(Models.Request.FilterUserRequest request)
{
var builder = Builders <User> .Filter;
var filter = builder.Regex(FirstName, request.KeyWord)
| builder.Regex(LastName, request.KeyWord)
| builder.Regex(Email, request.KeyWord)
| builder.Regex(PhoneNumber, request.KeyWord);
var users = (await userRepository.FindListAsync(filter)).AsQueryable();
var user = new List <User>();
foreach (var item in users)
{
if (IsUserMatchField(item, request.FieldFilter) == true)
{
user.Add(item);
}
}
var userViewModel = mapper.Map <List <UserViewModel> >(user);
if (request.FilterType.HasValue && request.OrderType.HasValue)
{
switch (request.FilterType.Value)
{
case UserFilterType.PostCount:
{
if (request.OrderType.Value == Models.Request.OrderTypeUser.Descending)
{
userViewModel = userViewModel.OrderByDescending(x => x.PostCount).ToList();
}
else
{
userViewModel = userViewModel.OrderBy(x => x.PostCount).ToList();
}
break;
}
case UserFilterType.Follower:
{
if (request.OrderType.Value == Models.Request.OrderTypeUser.Descending)
{
userViewModel = userViewModel.OrderByDescending(x => x.Followers).ToList();
}
else
{
userViewModel = userViewModel.OrderBy(x => x.Followers).ToList();
}
break;
}
}
}
var currentUser = Feature.CurrentUser(_httpContextAccessor, userRepository);
var historyModel = new SearchHistory()
{
HistoryType = HistoryType.User,
UserId = currentUser.OId,
UserValue = request
};
await searchHistoryRepository.AddAsync(historyModel);
if (request.Skip.HasValue && request.Count.HasValue)
{
userViewModel = userViewModel.Skip(request.Skip.Value).Take(request.Count.Value).ToList();
}
return(userViewModel);
}
public async Task <PostFilterResponse> Filter(Models.Request.FilterRequest filterRequest)
{
var posts = postRepository.GetAll().Where(x => x.PostType == filterRequest.PostType);
var builders = Builders <Post> .Filter;
var filterParam = builders.Eq(Status, ItemStatus.Active);
if (filterRequest.ContentFilter != null)
{
filterParam = filterParam & (builders.Regex(PostStringContent, filterRequest.ContentFilter)
| builders.Regex(Title, filterRequest.ContentFilter));
}
if (filterRequest.FromDate != null && filterRequest.ToDate != null)
{
filterParam = filterParam
& builders.Gt(CreatedDate, filterRequest.FromDate)
& builders.Lt(CreatedDate, filterRequest.ToDate);
}
filterParam = filterParam & builders.Eq("post_type", filterRequest.PostType);
posts = (await postRepository.FindListAsync(filterParam)).AsQueryable();
var vm = mapper.Map <IEnumerable <PostViewModel> >(posts);
if (filterRequest.SortObject.HasValue && filterRequest.SortType.HasValue)
{
switch (filterRequest.SortObject.Value)
{
case Models.Request.SortObject.Upvote:
{
var sortType = filterRequest.SortType.Value;
vm = sortType switch
{
Models.Request.SortType.Ascending => vm.OrderBy(x => x.Upvote),
Models.Request.SortType.Descending => vm.OrderByDescending(x => x.Upvote),
_ => vm
};
break;
}
case Models.Request.SortObject.Comment:
{
var sortType = filterRequest.SortType.Value;
vm = sortType switch
{
Models.Request.SortType.Ascending => vm.OrderBy(x => x.CommentCount),
Models.Request.SortType.Descending => vm.OrderByDescending(x => x.CommentCount),
_ => vm
};
break;
}
case SortObject.CreatedDate:
{
var sortType = filterRequest.SortType.Value;
vm = sortType switch
{
SortType.Ascending => vm.OrderBy(x => x.CreatedDate),
SortType.Descending => vm.OrderByDescending(x => x.CreatedDate),
_ => vm
};
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
var currentUser = Feature.CurrentUser(httpContextAccessor, userRepository);
var historyBuilder = Builders <SearchHistory> .Filter;
var historyFilter = historyBuilder.Eq("user_id", currentUser.OId) & historyBuilder.Eq("history_type", HistoryType.Post);
var existHistoryModels = await searchHistoryRepository.FindListAsync(historyFilter);
var historyModel = new SearchHistory()
{
HistoryType = HistoryType.Post,
UserId = currentUser.OId,
PostValue = filterRequest
};
await searchHistoryRepository.AddAsync(historyModel);
var response = new PostFilterResponse();
if (filterRequest.LevelFilter != null && filterRequest.LevelFilter.FilterItems.Any())
{
var result = new List <PostViewModel>();
foreach (var post in vm)
{
if (IsMatch(post, filterRequest.LevelFilter) == true)
{
result.Add(post);
}
}
return(new PostFilterResponse
{
Data = result.Skip(filterRequest.Skip.Value).Take(filterRequest.Count.Value),
RecordFiltered = result.Count,
RecordRemain = (result.Count - filterRequest.Skip.Value - filterRequest.Count.Value) >= 0
? (result.Count - filterRequest.Skip.Value - filterRequest.Count.Value) : 0
});
}
var rp = mapper.Map <List <PostViewModel> >(posts.ToList());
return(new PostFilterResponse
{
Data = rp.Skip(filterRequest.Skip.Value).Take(filterRequest.Count.Value),
RecordFiltered = rp.Count,
RecordRemain = (rp.Count - filterRequest.Skip.Value - filterRequest.Count.Value) >= 0
? (rp.Count - filterRequest.Skip.Value - filterRequest.Count.Value) : 0
});
}