public async Task <(IList <BlogPost> posts, int totalPosts)> GetPosts(PostsFilter filter)
{
// there are no posts w/o status
if (!filter.Drafted && !filter.Published && !filter.Removed)
{
return(null, 0);
}
var query = _context.Posts
.AsNoTracking();
query = QueryPostsByStatus(query, filter.Drafted, filter.Published, filter.Removed);
query = QueryPostsByAuthorId(query, filter.AuthorId);
query = QueryPostsBySearchText(query, filter.Search);
List <Post> posts = null;
var count = await query.CountAsync();
if (count != 0)
{
var skip = (filter.Page - 1) * filter.PageSize;
posts = await query
.Include(x => x.Author)
.OrderBy(x => x.Id)
.Skip(skip)
.Take(filter.PageSize)
.ToListAsync();
}
var dtoPosts = posts?.Select(x => Mapper.ConvertToModel(x))?.ToList();
return(dtoPosts, count);
}
/// <summary>
/// Get more items when filter posts by category
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public PartialViewResult ArchiveGetMore(PostsFilter model)
{
ArchiveId id = new ArchiveId(model.Id);
InitializeArchiveModel(model, id);
return(PartialView(FilterGetMoreView, model));
}
public Task <List <Post> > GetPosts(PostsFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
return(_postsRepository.GetPosts(filter));
}
/// <summary>
/// Get more items when filter posts by category
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public PartialViewResult CategoryGetMore(PostsFilter model)
{
// Filters have to share the id
if (Int32.TryParse(model.Id, out int id))
{
InitializeCategorymodel(model, id);
}
return(PartialView(FilterGetMoreView, model));
}
/// <summary>
/// Get more items when filter posts by category
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public PartialViewResult ArchiveGetMore(PostsFilter model)
{
ArchiveId id = new ArchiveId(model.Id);
using (var db = new DataService())
{
InitializeArchiveModel(db, model, id);
}
return(PartialView(FilterGetMoreView, model));
}
public void GetPosts_ExistingItems_ReturnsPosts(PostsFilter filter, IEnumerable <Post> expected, IEnumerable <Post> data)
{
// Arrange
var repository = new TestSetup().SetupRepository(list: data);
// Act
var result = repository.GetPosts(filter).Result;
// Assert
CollectionAssert.AreEquivalent(expected, result);
}
private static PostsFilter map(PostsFilterModel source)
{
var destination = new PostsFilter();
destination.PageSize = source.PageSize;
destination.PageIndex = source.PageNumber - 1;
destination.StartDate = source.StartDate;
destination.EndDate = source.EndDate;
return(destination);
}
/// <summary>
/// Get more items when filter posts by category
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public PartialViewResult CategoryGetMore(PostsFilter model)
{
// Filters have to share the id
if (Int32.TryParse(model.Id, out int id))
{
using (var db = new DataService())
{
InitializeCategorymodel(db, model, id);
}
}
return(PartialView(FilterGetMoreView, model));
}
private static void InitializeArchiveModel(DataService db, PostsFilter model, ArchiveId id)
{
// Archive
model.Action = "Archive";
// Gets posts
model.Items = db.GetPostsInArchive(id, model.Page * Settings.Current.PostQuantityPerSearch);
// Have more
Int32 count = db.CounPostsInArchive(id);
model.Available = count;
model.HaveMoreResults = count > (model.Page + 1) * Settings.Current.PostQuantityPerSearch;
// Update page index
model.NextPage = model.Page + 1;
}
public async Task <IActionResult> Posts([FromQuery] PostsFilter filter)
{
filter = filter ?? new PostsFilter();
filter.AuthorId = filter.Own ? User.GetId() : null as int?;
filter.Removed = User.IsAdmin() ? filter.Removed : false;
var result = await _postsService.GetPosts(filter);
var postsVM = result.Elements?.Select(x => (PostViewModel)x)?.ToList() ?? Enumerable.Empty <PostViewModel>();
var pagedPostsVM = new StaticPagedList <PostViewModel>(postsVM, filter.Page, filter.PageSize, result.TotalElements);
return(View(new PostsListViewModel
{
Filter = filter,
Posts = pagedPostsVM
}));
}
private void InitializeArchiveModel(PostsFilter model, ArchiveId id)
{
// Archive
model.Action = "Archive";
// Gets posts
model.Items = _dataService.GetPostsInArchive(id, model.Page * _options.Value.PostQuantityPerSearch);
// Have more
Int32 count = _dataService.CounPostsInArchive(id);
model.Available = count;
model.HaveMoreResults = count > (model.Page + 1) * _options.Value.PostQuantityPerSearch;
// Update page index
model.NextPage = model.Page + 1;
}
/// <summary>
/// Filter post by category
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ActionResult Archive(PostsFilter model)
{
ArchiveId id = new ArchiveId(model.Id);
// Title
model.Title = Resources.Archives;
// Get name
model.SubTitle = id.ToString();
model.Description = String.Format(
Resources.ArchivesDescription,
model.SubTitle);
// Initialize the data
InitializeArchiveModel(model, id);
return(View(FilterView, model));
}
/// <summary>
/// Filter post by category
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ActionResult Category(PostsFilter model)
{
// Filters have to share the id
if (Int32.TryParse(model.Id, out int id))
{
// Title
model.Title = Resources.Category;
// Get name
model.SubTitle = _dataService.GetCategoryName(id);
model.Description = String.Format(
Resources.CategoryDescription,
model.SubTitle);
// Initialize the data
InitializeCategorymodel(model, id);
}
return(View(FilterView, model));
}
public Task <List <Post> > GetPosts(PostsFilter filter)
{
IEnumerable <Post> result = _storage;
if (filter.StartDate.HasValue)
{
result = result.Where(p => p.CreationDate >= filter.StartDate.Value);
}
if (filter.EndDate.HasValue)
{
result = result.Where(p => p.CreationDate <= filter.EndDate.Value);
}
result = result
.OrderByDescending(p => p.CreationDate)
.Skip(filter.PageSize * filter.PageIndex)
.Take(filter.PageSize);
return(Task.FromResult(result.ToList()));
}
public Task <(IList <BlogPost> posts, int totalPosts)> GetPosts(PostsFilter filter)
{
return(_postRepository.GetPosts(filter));
}
public async Task <PagedResult <BlogPost> > GetPosts(PostsFilter filter)
{
var(posts, totalPosts) = await _postRepository.GetPosts(filter);
return(new PagedResult <BlogPost>(posts, totalPosts));
}
