/// <summary>
/// Returns all parent pages, when <paramref name="withChildren"/> is true their children are also returned.
/// </summary>
/// <param name="withChildren">True will return children with the parents.</param>
/// <returns></returns>
public async Task <IList <Page> > GetParentsAsync(bool withChildren = false)
{
var query = new PostListQuery(withChildren ? EPostListQueryType.PagesWithChildren : EPostListQueryType.Pages);
var(posts, totalCount) = await postRepository.GetListAsync(query);
// either all pages or just parents
var pages = mapper.Map <IList <Post>, IList <Page> >(posts);
if (!withChildren)
{
return(pages);
}
var parents = pages.Where(p => p.IsParent);
foreach (var parent in parents)
{
var children = pages.Where(p => p.ParentId == parent.Id);
foreach (var child in children)
{
child.Parent = parent;
parent.Children.Add(child);
}
}
return(parents.ToList());
}
private async Task <List <Page> > QueryPagesAsync(PostListQuery query)
{
var results = await _postRepo.GetListAsync(query);
var pages = _mapper.Map <List <Post>, List <Page> >(results.posts);
return(pages);
}
/// <summary>
/// Returns specified number of <see cref="BlogPost"/> used by metaweblog.
/// </summary>
/// <param name="numberOfPosts">"All" is int.MaxValue</param>
public async Task <BlogPostList> GetRecentPostsAsync(int numberOfPosts)
{
var query = new PostListQuery(EPostListQueryType.BlogPostsByNumber)
{
PageSize = numberOfPosts
};
return(await QueryPostsAsync(query));
}
public async Task <List <Page> > GetRecentPagesAsync(int numberOfPages)
{
PostListQuery query =
new PostListQuery(EPostListQueryType.PagesByNumber)
{
PageSize = numberOfPages
};
return(await this.QueryPagesAsync(query));
}
/// <summary>
/// Returns spcific number of published <see cref="BlogPost"/>.
/// </summary>
/// <param name="numberOfPosts"></param>
/// <returns></returns>
public async Task <BlogPostList> GetRecentPublishedPostsAsync(int numberOfPosts)
{
return(await cache.GetAsync(BlogCache.KEY_POSTS_RECENT, BlogCache.Time_Posts_Recent, async() =>
{
var query = new PostListQuery(EPostListQueryType.BlogPublishedPostsByNumber)
{
PageSize = numberOfPosts <= 0 ? 1 : numberOfPosts
};
return await QueryPostsAsync(query);
}));
}
public async Task <Page> GetParentPageWithChildrenAsync(int id)
{
var parentPage = await this.GetPageAsync(id);
var query = new PostListQuery(EPostListQueryType.ChildPagesForParent, id);
var pages = await this.QueryPagesAsync(query);
foreach (var page in pages)
{
parentPage.Children.Add(page);
}
return(parentPage);
}
public async void GetPostList_By_Drafts_Returns_All_Drafts()
{
// Arrange: 11 drafts
SeedTestPosts(23);
var query = new PostListQuery(EPostListQueryType.BlogDrafts); // draft returns all, so no need for page indx and size
// Act
var list = await _postRepo.GetListAsync(query);
// Assert
Assert.Equal(11, list.posts.Count); // only published posts are returned
Assert.Equal(11, list.totalCount);
}
/// <summary>
/// Returns a list of blog posts for archive.
/// </summary>
/// <param name="year"></param>
/// <param name="month"></param>
/// <param name="page"></param>
/// <returns></returns>
public async Task <BlogPostList> GetListForArchive(int?year, int?month, int page = 1)
{
if (!year.HasValue)
{
throw new FanException("Year must be provided.");
}
var query = new PostListQuery(EPostListQueryType.BlogPostsArchive)
{
Year = year.Value,
Month = month
};
return(await QueryPostsAsync(query));
}
/// <summary>
/// Returns a <see cref="BlogPostList"/> based on query from data source.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
private async Task <BlogPostList> QueryPostsAsync(PostListQuery query)
{
var(posts, totalCount) = await _postRepo.GetListAsync(query);
var blogPostList = new BlogPostList
{
PostCount = totalCount
};
foreach (var post in posts)
{
blogPostList.Posts.Add(await GetBlogPostAsync(post, parseShortcode: true));
}
return(blogPostList);
}
/// <summary>
/// Returns a list of blog posts for a tag.
/// </summary>
/// <param name="tagSlug"></param>
/// <param name="pageIndex"></param>
/// <returns></returns>
public async Task <BlogPostList> GetListForTagAsync(string tagSlug, int pageIndex)
{
if (tagSlug.IsNullOrEmpty())
{
throw new FanException("Tag does not exist.");
}
PostListQuery query = new PostListQuery(EPostListQueryType.BlogPostsByTag)
{
TagSlug = tagSlug,
PageIndex = (pageIndex <= 0) ? 1 : pageIndex,
PageSize = (await _settingSvc.GetSettingsAsync <BlogSettings>()).PostPerPage,
};
return(await QueryPostsAsync(query));
}
/// <summary>
/// Returns a list of blog posts for a category.
/// </summary>
/// <param name="categorySlug"></param>
/// <param name="pageIndex"></param>
/// <returns></returns>
public async Task <BlogPostList> GetListForCategoryAsync(string categorySlug, int pageIndex)
{
if (categorySlug.IsNullOrEmpty())
{
throw new FanException("Category does not exist.");
}
PostListQuery query = new PostListQuery(EPostListQueryType.BlogPostsByCategory)
{
CategorySlug = categorySlug,
PageIndex = (pageIndex <= 0) ? 1 : pageIndex,
PageSize = (await settingService.GetSettingsAsync <BlogSettings>()).PostPerPage,
};
return(await QueryPostsAsync(query));
}
public async void GetPostList_By_Number_Returns_All_Posts_Regardless_Status()
{
// Arrange: given 11 drafts, 12 published
SeedTestPosts(23);
// Act: when query Max number of post by MetaWeblog
var query = new PostListQuery(EPostListQueryType.BlogPostsByNumber)
{
PageSize = int.MaxValue
};
var list = await _postRepo.GetListAsync(query);
// Assert: then all posts are returned
Assert.Equal(23, list.posts.Count);
Assert.Equal(23, list.totalCount);
}
public async void GetPostList_By_Category_Returns_Posts_For_Category()
{
// Arrange
SeedTestPosts(11);
var query = new PostListQuery(EPostListQueryType.BlogPostsByCategory)
{
CategorySlug = CAT_SLUG,
PageIndex = 1,
PageSize = 10,
};
// Act
var list = await _postRepo.GetListAsync(query);
// Assert
Assert.Equal(6, list.posts.Count);
Assert.Equal(6, list.totalCount);
}
public async void GetPostList_By_Tag_Returns_Posts_For_Tag(string slug, int expectedPostCount)
{
// Arrange: given 11 posts
SeedTestPosts(11);
var query = new PostListQuery(EPostListQueryType.BlogPostsByTag)
{
TagSlug = slug,
PageIndex = 1,
PageSize = 10,
};
// Act: GetList
var list = await _postRepo.GetListAsync(query);
// Assert
Assert.Equal(expectedPostCount, list.posts.Count);
Assert.Equal(expectedPostCount, list.totalCount);
}
public async void GetPostList_By_BlogPosts_Returns_Only_Published_Posts()
{
// Arrange: 5 drafts, 6 published
SeedTestPosts(11);
var query = new PostListQuery(EPostListQueryType.BlogPosts)
{
PageIndex = 1,
PageSize = 10,
};
// Act
var list = await _postRepo.GetListAsync(query);
// Assert
Assert.Equal(6, list.posts.Count); // only published posts are returned
Assert.Equal(6, list.totalCount);
var tags = list.posts[0].PostTags;
}
/// <summary>
/// Returns a <see cref="BlogPostList"/> based on query from data source.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
private async Task <BlogPostList> QueryPostsAsync(PostListQuery query)
{
var(posts, totalCount) = await postRepository.GetListAsync(query);
var blogPostList = new BlogPostList
{
TotalPostCount = totalCount
};
foreach (var post in posts)
{
var blogPost = ConvertToBlogPost(post);
blogPost = await PreRenderAsync(blogPost);
blogPostList.Posts.Add(blogPost);
}
return(blogPostList);
}
/// <summary>
/// Returns a list of blog posts.
/// </summary>
/// <param name="pageIndex"></param>
/// <returns></returns>
/// <remarks>
/// For the blog index page, admin post page, main rss feed.
/// </remarks>
public async Task <BlogPostList> GetListAsync(int pageIndex, int pageSize, bool cacheable = true)
{
PostListQuery query = new PostListQuery(EPostListQueryType.BlogPosts)
{
PageIndex = (pageIndex <= 0) ? 1 : pageIndex,
PageSize = pageSize,
};
// cache only first page of the public site, not admin or rss
if (query.PageIndex == 1 && cacheable)
{
return(await _cache.GetAsync(BlogCache.KEY_POSTS_INDEX, BlogCache.Time_PostsIndex, async() =>
{
return await QueryPostsAsync(query);
}));
}
return(await QueryPostsAsync(query));
}
public async Task <Page> GetRootPageWithChildrenAsync(string slug)
{
var rootPages = await GetRootPagesAsync();
var rootPage = rootPages.SingleOrDefault(p => p.Slug.Equals(slug, StringComparison.CurrentCultureIgnoreCase));
var query = new PostListQuery(EPostListQueryType.ChildPagesForRoot, rootPage.Id);
var pages = await this.QueryPagesAsync(query);
foreach (var page in pages)
{
var childPages = pages.Where(p => p.ParentId == page.Id);
if (childPages != null)
{
page.Children = childPages.ToList();
pages.RemoveAll(p => p.ParentId == page.Id);
}
}
rootPage.Children = pages;
return(rootPage);
}
/// <summary>
/// Returns a list of posts and total post count by query or empty list if no posts found.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public async Task <(List <Post> posts, int totalCount)> GetListAsync(PostListQuery query)
{
List <Post> posts = null;
int skip = (query.PageIndex - 1) * query.PageSize;
int take = query.PageSize;
IQueryable <Post> q = _entities.Include(p => p.User).Include(p => p.Category).Include(p => p.PostTags).ThenInclude(p => p.Tag);
switch (query.QueryType)
{
case EPostListQueryType.BlogPosts:
q = q.Where(p => p.Status == EPostStatus.Published && p.Type == EPostType.BlogPost);
posts = await q.OrderByDescending(p => p.CreatedOn).Skip(skip).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogDrafts:
q = q.Where(p => p.Status == EPostStatus.Draft && p.Type == EPostType.BlogPost);
posts = await q.OrderByDescending(p => p.UpdatedOn).ToListAsync();
break;
case EPostListQueryType.BlogPostsByCategory:
var cat = await _db.Set <Category>().FirstAsync(t => t.Slug.Equals(query.CategorySlug, StringComparison.CurrentCultureIgnoreCase));
q = q.Where(p => p.CategoryId == cat.Id && p.Status == EPostStatus.Published && p.Type == EPostType.BlogPost);
posts = await q.OrderByDescending(p => p.CreatedOn).Skip(skip).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogPostsByTag:
var tag = await _db.Set <Tag>().FirstAsync(t => t.Slug.Equals(query.TagSlug, StringComparison.CurrentCultureIgnoreCase));
q = from p in q
from pt in p.PostTags
where p.Id == pt.PostId &&
pt.TagId == tag.Id && p.Status == EPostStatus.Published && p.Type == EPostType.BlogPost
select p;
posts = await q.OrderByDescending(p => p.CreatedOn).Skip(skip).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogPostsArchive:
q = (query.Month.HasValue && query.Month > 0) ?
q.Where(p => p.CreatedOn.Year == query.Year && p.CreatedOn.Month == query.Month && p.Status == EPostStatus.Published && p.Type == EPostType.BlogPost) :
q.Where(p => p.CreatedOn.Year == query.Year && p.Status == EPostStatus.Published && p.Type == EPostType.BlogPost);
posts = await q.OrderByDescending(p => p.CreatedOn).ToListAsync();
break;
case EPostListQueryType.BlogPostsByNumber:
q = q.Where(p => p.Type == EPostType.BlogPost);
posts = await q.OrderByDescending(p => p.CreatedOn).Take(take).ToListAsync();
break;
case EPostListQueryType.RootPages:
q = _entities.Where(p => p.RootId == 0 && p.Status == EPostStatus.Published && p.Type == EPostType.Page);
posts = await q.OrderByDescending(p => p.CreatedOn).ToListAsync();
break;
case EPostListQueryType.ChildPagesForRoot:
q = _entities.Where(p => p.RootId == query.RootId && p.Status == EPostStatus.Published && p.Type == EPostType.Page);
posts = await q.OrderByDescending(p => p.CreatedOn).ToListAsync();
break;
case EPostListQueryType.PageDrafts:
q = _entities.Where(p => p.Status == EPostStatus.Draft && p.Type == EPostType.Page);
posts = await q.OrderByDescending(p => p.UpdatedOn).ToListAsync();
break;
case EPostListQueryType.PagesByNumber:
q = _entities.Where(p => p.Type == EPostType.Page);
posts = await q.OrderByDescending(p => p.CreatedOn).Take(take).ToListAsync();
break;
}
int postCount = await q.CountAsync();
return(posts : posts, totalCount : postCount);
}
/// <summary>
/// Returns a list of posts and total post count by query or empty list if no posts found.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public async Task <(IList <Post> posts, int totalCount)> GetListAsync(PostListQuery query)
{
IList <Post> posts = null;
int skip = (query.PageIndex - 1) * query.PageSize;
int take = query.PageSize;
IQueryable <Post> q = (query.QueryType == EPostListQueryType.Pages || query.QueryType == EPostListQueryType.PagesWithChildren) ?
_entities.Include(p => p.User).Where(p => p.Type == EPostType.Page) :
_entities.Include(p => p.User).Include(p => p.Category).Include(p => p.PostTags).ThenInclude(p => p.Tag).Where(p => p.Type == EPostType.BlogPost);
switch (query.QueryType)
{
case EPostListQueryType.BlogPosts:
q = q.Where(p => p.Status == EPostStatus.Published);
posts = await q.OrderByDescending(p => p.CreatedOn).Skip(skip).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogDrafts:
q = q.Where(p => p.Status == EPostStatus.Draft);
posts = await q.OrderByDescending(p => p.UpdatedOn).ToListAsync();
break;
case EPostListQueryType.BlogPostsByCategory:
var cat = await _db.Set <Category>().FirstAsync(t => t.Slug == query.CategorySlug);
q = q.Where(p => p.CategoryId == cat.Id && p.Status == EPostStatus.Published);
posts = await q.OrderByDescending(p => p.CreatedOn).Skip(skip).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogPostsByTag:
var tag = await _db.Set <Tag>().FirstAsync(t => t.Slug == query.TagSlug);
q = from p in q
from pt in p.PostTags
where p.Id == pt.PostId &&
pt.TagId == tag.Id && p.Status == EPostStatus.Published
select p;
posts = await q.OrderByDescending(p => p.CreatedOn).Skip(skip).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogPostsArchive:
q = (query.Month.HasValue && query.Month > 0) ?
q.Where(p => p.CreatedOn.Year == query.Year && p.CreatedOn.Month == query.Month && p.Status == EPostStatus.Published) :
q.Where(p => p.CreatedOn.Year == query.Year && p.Status == EPostStatus.Published);
posts = await q.OrderByDescending(p => p.CreatedOn).ToListAsync();
break;
case EPostListQueryType.BlogPostsByNumber:
posts = await q.OrderByDescending(p => p.CreatedOn).Take(take).ToListAsync();
break;
case EPostListQueryType.BlogPublishedPostsByNumber:
q = q.Where(p => p.Status == EPostStatus.Published);
posts = await q.OrderByDescending(p => p.CreatedOn).Take(take).ToListAsync();
break;
case EPostListQueryType.Pages:
q = q.Where(p => p.ParentId == null || p.ParentId == 0);
posts = await q.OrderByDescending(p => p.CreatedOn).ToListAsync();
break;
case EPostListQueryType.PagesWithChildren:
posts = await q.OrderByDescending(p => p.CreatedOn).ToListAsync();
break;
}
int postCount = await q.CountAsync();
return(posts, totalCount : postCount);
}
public async Task <List <Page> > GetRootPagesAsync()
{
PostListQuery query = new PostListQuery(EPostListQueryType.RootPages);
return(await this.QueryPagesAsync(query));
}
/// <summary>
/// Returns a list of blog drafts.
/// </summary>
/// <returns></returns>
public async Task <BlogPostList> GetListForDraftsAsync()
{
PostListQuery query = new PostListQuery(EPostListQueryType.BlogDrafts);
return(await QueryPostsAsync(query));
}
