// posts filtered on status (all, draft or published) and categories
public Task <List <PostListItem> > ByFilter(string status, List <string> categories, string blog, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = _db.BlogPosts.Where(p => p.Profile.Slug == blog);
if (status == "P")
{
posts = posts.Where(p => p.Published > DateTime.MinValue);
}
if (status == "D")
{
posts = posts.Where(p => p.Published == DateTime.MinValue);
}
if (categories.Count > 0)
{
posts = posts.Where(p => p.PostCategories.Any(pc => pc.BlogPostId == p.Id && categories.Contains(pc.CategoryId.ToString())));
}
pager.Configure(posts.Count());
var postPage = posts.OrderByDescending(pc => pc.Published).Skip(skip).Take(pager.ItemsPerPage).ToList();
return(Task.Run(() => GetPostItems(postPage)));
}
public IEnumerable <ProfileListItem> ProfileList(Expression <Func <Profile, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var all = _db.Profiles.Include(p => p.Assets).Include(p => p.BlogPosts).Where(predicate);
pager.Configure(all.Count());
var posts = all.OrderBy(p => p.Id).Skip(skip).Take(pager.ItemsPerPage).ToList();
return(posts.Select(p => new ProfileListItem
{
ProfileId = p.Id,
Title = p.Title,
Email = p.AuthorEmail,
Url = ApplicationSettings.BlogRoute + "/" + p.Slug,
IdentityName = p.IdentityName,
AuthorName = p.AuthorName,
IsAdmin = p.IsAdmin,
PostCount = p.BlogPosts.Count,
PostViews = _db.BlogPosts.Where(bp => bp.Profile.Id == p.Id).Sum(bp => bp.PostViews),
DbUsage = _db.BlogPosts.Where(bp => bp.Profile.Id == p.Id).Sum(bp => Convert.ToInt32(bp.Content.Length)),
AssetCount = p.Assets.Count,
DownloadCount = _db.Assets.Where(a => a.ProfileId == p.Id).Sum(a => a.DownloadCount),
DiskUsage = _db.Assets.Where(a => a.ProfileId == p.Id).Sum(a => a.Length),
LastUpdated = p.LastUpdated
}));
}
public async Task <IEnumerable <PostItem> > GetListByCategory(string category, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = _db.BlogPosts
.Where(p => p.Published > DateTime.MinValue)
.OrderByDescending(p => p.Published).ToList();
var items = new List <BlogPost>();
foreach (var item in posts)
{
if (!string.IsNullOrEmpty(item.Categories))
{
var cats = item.Categories.ToLower().Split(',');
if (cats.Contains(category.ToLower()))
{
items.Add(item);
}
}
}
pager.Configure(items.Count);
var postPage = items.Skip(skip).Take(pager.ItemsPerPage).ToList();
return(await Task.FromResult(PostListToItems(postPage)));
}
private async Task <IEnumerable <Post> > GetPagedListAsync(IEnumerable <Expression <Func <Post, bool> > > predicates, Pager pager, string pagingUrlPartFormat, CancellationToken cancellationToken)
{
var skip = (pager.CurrentPage - 1) * pager.ItemsPerPage;
var countQuery = _context.Posts.Where(_ => true);
foreach (var predicate in predicates)
{
countQuery = countQuery.Where(predicate);
}
var count = await countQuery.CountAsync(cancellationToken);
pager.Configure(count, pagingUrlPartFormat);
var query = _context.Posts.Where(_ => true);
foreach (var predicate in predicates)
{
query = query.Where(predicate);
}
query = query.Include(p => p.Author)
.OrderByDescending(p => p.Published)
.Skip(skip)
.Take(pager.ItemsPerPage);
return(await query.ToListAsync(cancellationToken));
}
public async Task <IEnumerable <Author> > GetList(Expression <Func <Author, bool> > predicate, Pager pager, bool sanitize = false)
{
var take = pager.ItemsPerPage == 0 ? 10 : pager.ItemsPerPage;
var skip = pager.CurrentPage * take - take;
var users = _db.Authors.Where(predicate)
.OrderBy(u => u.DisplayName).ToList();
pager.Configure(users.Count);
var list = users.Skip(skip).Take(take).ToList();
foreach (var item in list)
{
if (string.IsNullOrEmpty(item.Avatar))
{
item.Avatar = Constants.DefaultAvatar;
}
if (sanitize)
{
item.Email = Constants.DummyEmail;
}
}
if (sanitize)
{
foreach (var item in list)
{
item.Email = Constants.DummyEmail;
}
}
return(await Task.FromResult(list));
}
public async Task <IEnumerable <AssetItem> > Find(Func <AssetItem, bool> predicate, Pager pager, string path = "", bool sanitize = false)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var files = GetAssets(path);
var items = MapFilesToAssets(files);
if (predicate != null)
{
items = items.Where(predicate).ToList();
}
pager.Configure(items.Count);
var page = items.Skip(skip).Take(pager.ItemsPerPage).ToList();
if (sanitize)
{
foreach (var p in page)
{
p.Path = p.Path.Replace(Location, "");
}
}
return(await Task.FromResult(page));
}
private async Task <IEnumerable <FileModel> > GetPagedListAsync(
Pager pager,
CloudBlobContainer cloudBlobContainer,
string directoryPath,
FileType fileType,
CancellationToken cancellationToken)
{
var directory = cloudBlobContainer.GetDirectoryReference(directoryPath);
var blobs = await _azureBlobHelper.ListAsync(directory, cancellationToken);
var files = blobs.Select(b => b.Uri.AbsoluteUri);
var skip = (pager.CurrentPage - 1) * pager.ItemsPerPage;
if (fileType != FileType.All)
{
files = files.Where(f => fileType.IsFileTypeSupported(f.GetMimeType()));
}
var count = files.Count();
pager.Configure(count, _blogOptions.Value.PagingUrlPartFormat);
return(files
.OrderBy(f => f)
.Skip(skip)
.Take(pager.ItemsPerPage)
.Select(f => new FileModel {
Url = f, FileName = Path.GetFileName(f), MimeType = f.GetMimeType()
}));
}
public async Task <IEnumerable <PostItem> > GetPopular(Pager pager, int author = 0)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = new List <Post>();
if (author > 0)
{
posts = _db.Posts.AsNoTracking().Where(p => p.Published > DateTime.MinValue && p.AuthorId == author)
.OrderByDescending(p => p.PostViews).ThenByDescending(p => p.Published).ToList();
}
else
{
posts = _db.Posts.AsNoTracking().Where(p => p.Published > DateTime.MinValue)
.OrderByDescending(p => p.PostViews).ThenByDescending(p => p.Published).ToList();
}
pager.Configure(posts.Count);
var items = new List <PostItem>();
foreach (var p in posts.Skip(skip).Take(pager.ItemsPerPage).ToList())
{
items.Add(await PostToItem(p, true));
}
return(await Task.FromResult(items));
}
public Task <List <PostListItem> > ByCategory(string slug, Pager pager, string blog = "")
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = _db.PostCategories.Include(pc => pc.BlogPost).Include(pc => pc.Category)
.Where(pc => pc.BlogPost.Published > DateTime.MinValue && pc.Category.Slug == slug)
.Select(pc => new PostListItem
{
BlogPostId = pc.BlogPostId,
Slug = pc.BlogPost.Slug,
Title = pc.BlogPost.Title,
Image = string.IsNullOrEmpty(pc.BlogPost.Image) ? ApplicationSettings.PostImage : pc.BlogPost.Image,
Content = pc.BlogPost.Description,
Published = pc.BlogPost.Published,
AuthorName = pc.BlogPost.Profile.AuthorName,
AuthorEmail = pc.BlogPost.Profile.AuthorEmail,
BlogSlug = pc.BlogPost.Profile.Slug,
PostViews = pc.BlogPost.PostViews
}).ToList();
if (!string.IsNullOrEmpty(blog))
{
posts = posts.Where(p => p.BlogSlug == blog).ToList();
}
pager.Configure(posts.Count);
return(Task.Run(() => posts.Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
public async Task <IEnumerable <PostItem> > GetList(Pager pager, int author = 0, string category = "", string include = "", bool sanitize = true)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = new List <BlogPost>();
foreach (var p in GetPosts(include, author))
{
if (string.IsNullOrEmpty(category))
{
posts.Add(p);
}
else
{
if (!string.IsNullOrEmpty(p.Categories))
{
var cats = p.Categories.ToLower().Split(',');
if (cats.Contains(category.ToLower()))
{
posts.Add(p);
}
}
}
}
pager.Configure(posts.Count);
var items = new List <PostItem>();
foreach (var p in posts.Skip(skip).Take(pager.ItemsPerPage).ToList())
{
items.Add(PostToItem(p, sanitize));
}
return(await Task.FromResult(items));
}
public IEnumerable <Asset> Find(Expression <Func <Asset, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var items = _db.Assets.AsNoTracking().Where(predicate).OrderByDescending(a => a.LastUpdated).ToList();
pager.Configure(items.Count);
return(items.Skip(skip).Take(pager.ItemsPerPage));
}
private async Task <IEnumerable <Post> > GetPagedListAsync(IEnumerable <Expression <Func <Post, bool> > > predicates, Pager pager, string pagingUrlPartFormat, CancellationToken cancellationToken)
{
var skip = (pager.CurrentPage - 1) * pager.ItemsPerPage;
var count = await _uow.Posts.CountAsync(predicates, cancellationToken);
pager.Configure(count, pagingUrlPartFormat);
return(await _uow.Posts.GetAsync(predicates, skip, pager.ItemsPerPage, cancellationToken));
}
public IEnumerable <ProfileListItem> ProfileList(Expression <Func <Profile, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var all = _db.Profiles.Include(p => p.Assets).Include(p => p.BlogPosts);
pager.Configure(all.Count());
var posts = all.Where(predicate).Skip(skip).Take(pager.ItemsPerPage).ToList();
// this is work around EF 1.1 not handling "count" fields
// and can be simplified when moved to EF 2
var p2 = posts.Select(p => new
{
ProfileId = p.Id,
Title = p.Title,
Email = p.AuthorEmail,
Url = ApplicationSettings.BlogRoute + "/" + p.Slug,
IdentityName = p.IdentityName,
AuthorName = p.AuthorName,
IsAdmin = p.IsAdmin,
PostCount = p.BlogPosts.Count,
PostViews = _db.BlogPosts.Where(bp => bp.Profile.Id == p.Id).Sum(bp => bp.PostViews),
DbUsage = _db.BlogPosts.Where(bp => bp.Profile.Id == p.Id).Sum(bp => (System.Int64)bp.Content.Length),
AssetCount = p.Assets.Count,
DownloadCount = _db.Assets.Where(a => a.ProfileId == p.Id).Sum(a => a.DownloadCount),
DiskUsage = _db.Assets.Where(a => a.ProfileId == p.Id).Sum(a => a.Length),
LastUpdated = p.LastUpdated
}).ToList();
return(p2.Select(p => new ProfileListItem
{
ProfileId = p.ProfileId,
Title = p.Title,
Email = p.Email,
Url = p.Url,
IdentityName = p.IdentityName,
AuthorName = p.AuthorName,
IsAdmin = p.IsAdmin,
PostCount = p.PostCount,
PostViews = p.PostViews,
DbUsage = p.DbUsage,
AssetCount = p.AssetCount,
DownloadCount = p.DownloadCount,
DiskUsage = p.DiskUsage,
LastUpdated = p.LastUpdated
}));
}
public async Task <IEnumerable <PostItem> > GetList(Expression <Func <BlogPost, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var items = _blogUnitOfWork.PostRepository.Get(predicate).OrderByDescending(x => x.CreationTime).ToList();
pager.Configure(items.Count);
var postPage = items.Skip(skip).Take(pager.ItemsPerPage).ToList();
return(await Task.FromResult(PostListToItems(postPage)));
}
public IEnumerable <Blog> Query(Expression <Func <Blog, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var drafts = _db.Blogs
.Where(predicate)
.OrderByDescending(p => p.CreationTime).ToList();
var items = drafts.ToList();
pager.Configure(items.Count);
return(items.Skip(skip).Take(pager.ItemsPerPage).ToList());
}
public async Task <List <PostListItem> > Find(Pager pager, string term, string blogSlug = "")
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var results = new List <Result>();
var list = new List <PostListItem>();
IEnumerable <BlogPost> posts;
if (string.IsNullOrEmpty(blogSlug))
{
posts = _db.BlogPosts.AllIncluded(p => p.Published > DateTime.MinValue).ToList();
}
else
{
posts = _db.BlogPosts.AllIncluded(p => p.Published > DateTime.MinValue && p.Profile.Slug == blogSlug).ToList();
}
foreach (var item in posts)
{
var rank = 0;
var hits = 0;
term = term.ToLower();
if (item.Title.ToLower().Contains(term))
{
hits = Regex.Matches(item.Title.ToLower(), term).Count;
rank += hits * 10;
}
if (item.Description.ToLower().Contains(term))
{
hits = Regex.Matches(item.Description.ToLower(), term).Count;
rank += hits * 3;
}
if (item.Content.ToLower().Contains(term))
{
rank += Regex.Matches(item.Content.ToLower(), term).Count;
}
if (rank > 0)
{
results.Add(new Result {
Rank = rank, Item = GetItem(item)
});
}
}
results = results.OrderByDescending(r => r.Rank).ToList();
for (int i = 0; i < results.Count; i++)
{
list.Add(results[i].Item);
}
pager.Configure(list.Count);
return(await Task.Run(() => list.Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
// search always returns only published posts
// for a search term and optional blog author
public async Task <IEnumerable <PostItem> > Search(Pager pager, string term, int author = 0)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var results = new List <SearchResult>();
var list = new List <PostItem>();
IEnumerable <BlogPost> posts;
if (author == 0)
{
posts = _db.BlogPosts.Where(p => p.Published > DateTime.MinValue).ToList();
}
else
{
posts = _db.BlogPosts.Where(p => p.Published > DateTime.MinValue && p.AuthorId == author).ToList();
}
foreach (var item in posts)
{
var rank = 0;
var hits = 0;
term = term.ToLower();
if (item.Title.ToLower().Contains(term))
{
hits = Regex.Matches(item.Title.ToLower(), term).Count;
rank += hits * 10;
}
if (item.Description.ToLower().Contains(term))
{
hits = Regex.Matches(item.Description.ToLower(), term).Count;
rank += hits * 3;
}
if (item.Content.ToLower().Contains(term))
{
rank += Regex.Matches(item.Content.ToLower(), term).Count;
}
if (rank > 0)
{
results.Add(new SearchResult {
Rank = rank, Item = PostToItem(item)
});
}
}
results = results.OrderByDescending(r => r.Rank).ToList();
for (int i = 0; i < results.Count; i++)
{
list.Add(results[i].Item);
}
pager.Configure(list.Count);
return(await Task.Run(() => list.Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
public async Task <IEnumerable <Newsletter> > GetList(Expression <Func <Newsletter, bool> > predicate, Pager pager)
{
var take = pager.ItemsPerPage == 0 ? 10 : pager.ItemsPerPage;
var skip = pager.CurrentPage * take - take;
var emails = _db.Newsletters.Where(predicate)
.OrderByDescending(e => e.Id).ToList();
pager.Configure(emails.Count);
var list = emails.Skip(skip).Take(take).ToList();
return(await Task.FromResult(list));
}
public async Task <IEnumerable <Author> > GetList(Expression <Func <Author, bool> > predicate, Pager pager)
{
var take = pager.ItemsPerPage == 0 ? 10 : pager.ItemsPerPage;
var skip = pager.CurrentPage * take - take;
var users = _db.Authors.Where(predicate)
.OrderBy(u => u.DisplayName).ToList();
pager.Configure(users.Count);
var list = users.Skip(skip).Take(take).ToList();
return(await Task.FromResult(list));
}
public IEnumerable <PostListItem> Find(Expression <Func <BlogPost, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var drafts = _db.BlogPosts.AsNoTracking().Where(p => p.Published == DateTime.MinValue)
.Where(predicate).OrderByDescending(p => p.LastUpdated).Include(p => p.Profile).ToList();
var pubs = _db.BlogPosts.AsNoTracking().Where(p => p.Published > DateTime.MinValue)
.Where(predicate).OrderByDescending(p => p.Published).Include(p => p.Profile).ToList();
var items = drafts.Concat(pubs).ToList();
pager.Configure(items.Count);
return(GetItems(items).Skip(skip).Take(pager.ItemsPerPage));
}
public async Task <IEnumerable <AssetItem> > Find(Func <AssetItem, bool> predicate, Pager pager, string path = "")
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var files = GetAssets(path);
var items = MapFilesToAssets(files);
if (predicate != null)
{
items = items.Where(predicate).ToList();
}
pager.Configure(items.Count);
var page = items.Skip(skip).Take(pager.ItemsPerPage).ToList();
return(await Task.FromResult(page));
}
public async Task <IEnumerable <PostItem> > Search(Pager pager, string term, int author = 0, string include = "", bool sanitize = false)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var results = new List <SearchResult>();
foreach (var p in GetPosts(include, author))
{
var rank = 0;
var hits = 0;
term = term.ToLower();
if (p.Title.ToLower().Contains(term))
{
hits = Regex.Matches(p.Title.ToLower(), term).Count;
rank += hits * 10;
}
if (p.Description.ToLower().Contains(term))
{
hits = Regex.Matches(p.Description.ToLower(), term).Count;
rank += hits * 3;
}
if (p.Content.ToLower().Contains(term))
{
rank += Regex.Matches(p.Content.ToLower(), term).Count;
}
if (rank > 0)
{
results.Add(new SearchResult {
Rank = rank, Item = PostToItem(p, sanitize)
});
}
}
results = results.OrderByDescending(r => r.Rank).ToList();
var posts = new List <PostItem>();
for (int i = 0; i < results.Count; i++)
{
posts.Add(results[i].Item);
}
pager.Configure(posts.Count);
return(await Task.Run(() => posts.Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
public async Task <IEnumerable <PostItem> > GetList(Pager pager, int author = 0, string category = "", string include = "", bool sanitize = true)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = new List <Post>();
foreach (var p in GetPosts(include, author))
{
if (string.IsNullOrEmpty(category))
{
posts.Add(p);
}
else
{
if (p.PostCategories != null && p.PostCategories.Count > 0)
{
Category cat = _db.Categories.Single(c => c.Content.ToLower() == category.ToLower());
if (cat == null)
{
continue;
}
foreach (var pc in p.PostCategories)
{
if (pc.CategoryId == cat.Id)
{
posts.Add(p);
}
}
}
}
}
pager.Configure(posts.Count);
var items = new List <PostItem>();
foreach (var p in posts.Skip(skip).Take(pager.ItemsPerPage).ToList())
{
items.Add(await PostToItem(p, sanitize));
}
return(await Task.FromResult(items));
}
public async Task <IList <PostItem> > GetList(Expression <Func <BlogPost, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = new List <PostItem>();
var blogs = await _blogService.GetList(predicate, pager);
foreach (var p in blogs)
{
posts.Add(p);
}
pager.Configure(posts.Count);
var items = new List <PostItem>();
foreach (var p in posts.Skip(skip).Take(pager.ItemsPerPage).ToList())
{
items.Add(p);
}
return(await Task.FromResult(items));
}
public async Task <IEnumerable <PostItem> > GetList(Expression <Func <BlogPost, bool> > predicate, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var drafts = _db.BlogPosts
.Where(p => p.Published == DateTime.MinValue).Where(predicate)
.OrderByDescending(p => p.Published).ToList();
var pubs = _db.BlogPosts
.Where(p => p.Published > DateTime.MinValue).Where(predicate)
.OrderByDescending(p => p.IsFeatured)
.ThenByDescending(p => p.Published).ToList();
var items = drafts.Concat(pubs).ToList();
pager.Configure(items.Count);
var postPage = items.Skip(skip).Take(pager.ItemsPerPage).ToList();
return(await Task.FromResult(PostListToItems(postPage)));
}
public IEnumerable <Category> Find(Expression <Func <Category, bool> > predicate, Pager pager)
{
if (pager == null)
{
return(this.db.Categories.AsNoTracking()
.Include(c => c.PostCategories)
.Where(predicate)
.OrderBy(c => c.Title));
}
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var categories = this.db.Categories.AsNoTracking()
.Include(c => c.PostCategories)
.Where(predicate)
.OrderBy(c => c.Title)
.ToList();
pager.Configure(categories.Count());
return(categories.Skip(skip).Take(pager.ItemsPerPage));
}
// posts filtered on status (all, draft or published) and categories
public Task <List <PostListItem> > ByFilter(string status, List <string> categories, string blog, Pager pager)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = _db.PostCategories.Include(pc => pc.BlogPost).Include(pc => pc.Category)
.Where(pc => pc.BlogPost.Profile.Slug == blog);
if (status == "P")
{
posts = posts.Where(p => p.BlogPost.Published > DateTime.MinValue);
}
if (status == "D")
{
posts = posts.Where(p => p.BlogPost.Published == DateTime.MinValue);
}
if (categories.Count > 0)
{
posts = posts.Where(p => categories.Contains(p.CategoryId.ToString()));
}
var postItems = posts.Select(pc => new PostListItem
{
BlogPostId = pc.BlogPostId,
Slug = pc.BlogPost.Slug,
Title = pc.BlogPost.Title,
Image = string.IsNullOrEmpty(pc.BlogPost.Image) ? ApplicationSettings.PostImage : pc.BlogPost.Image,
Content = pc.BlogPost.Description,
Published = pc.BlogPost.Published,
AuthorName = pc.BlogPost.Profile.AuthorName,
AuthorEmail = pc.BlogPost.Profile.AuthorEmail,
BlogSlug = pc.BlogPost.Profile.Slug,
PostViews = pc.BlogPost.PostViews
}).Distinct().ToList();
pager.Configure(postItems.Count);
return(Task.Run(() => postItems.OrderByDescending(pc => pc.Published).Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
public async Task <List <PostListItem> > ByCategory(string slug, Pager pager, string blog = "")
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var postsList = await _db.PostCategories
.Include(pc => pc.BlogPost)
.Include(pc => pc.Category)
.Include(pc => pc.BlogPost.Profile)
.Where(pc => pc.BlogPost.Published > DateTime.MinValue && pc.Category.Slug == slug)
.ToListAsync();
var posts = postsList.Select(pc => new PostListItem
{
BlogPostId = pc.BlogPostId,
Slug = pc.BlogPost.Slug,
Title = pc.BlogPost.Title,
Avatar = string.IsNullOrEmpty(pc.BlogPost.Profile.Avatar) ? ApplicationSettings.ProfileAvatar : pc.BlogPost.Profile.Avatar,
Image = string.IsNullOrEmpty(pc.BlogPost.Image) ? BlogSettings.PostCover : pc.BlogPost.Image,
Content = pc.BlogPost.Description,
Published = pc.BlogPost.Published,
LastUpdated = pc.LastUpdated,
AuthorName = pc.BlogPost.Profile.AuthorName,
AuthorEmail = pc.BlogPost.Profile.AuthorEmail,
BlogSlug = pc.BlogPost.Profile.Slug,
PostViews = pc.BlogPost.PostViews,
Rating = pc.BlogPost.Rating,
IsFeatured = pc.BlogPost.IsFeatured,
PostCategories = pc.BlogPost.PostCategories.Select(c => c.Category.Slug).ToList()
}).Distinct().ToList();
if (!string.IsNullOrEmpty(blog))
{
posts = posts.Where(p => p.BlogSlug == blog).ToList();
}
pager.Configure(posts.Count);
return(await Task.Run(() => posts.Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
public async Task <(IList <BlogPost>, int)> GetList(Pager pager, string category = "", bool sanitize = true)
{
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var posts = new List <BlogPost>();
var blogs = await _blogService.GetPosts();
var cnt = blogs.Count;
foreach (var p in blogs)
{
posts.Add(p);
}
pager.Configure(posts.Count);
var items = new List <BlogPost>();
foreach (var p in posts.Skip(skip).Take(pager.ItemsPerPage).ToList())
{
items.Add(p);
}
return(await Task.FromResult((items, cnt)));
}
public async Task <IEnumerable <PostItem> > Search(Pager pager, string term, int author = 0, string include = "", bool sanitize = false)
{
term = term.ToLower();
var skip = pager.CurrentPage * pager.ItemsPerPage - pager.ItemsPerPage;
var results = new List <SearchResult>();
var termList = term.ToLower().Split(' ').ToList();
var categories = await _db.Categories.ToListAsync();
foreach (var p in GetPosts(include, author))
{
var rank = 0;
var hits = 0;
foreach (var termItem in termList)
{
if (termItem.Length < 4 && rank > 0)
{
continue;
}
//var postCategories = categories.Where(c => c.)
if (p.PostCategories != null && p.PostCategories.Count > 0)
{
foreach (var pc in p.PostCategories)
{
if (pc.Category.Content.ToLower() == termItem)
{
rank += 10;
}
}
}
if (p.Title.ToLower().Contains(termItem))
{
hits = Regex.Matches(p.Title.ToLower(), termItem).Count;
rank += hits * 10;
}
if (p.Description.ToLower().Contains(termItem))
{
hits = Regex.Matches(p.Description.ToLower(), termItem).Count;
rank += hits * 3;
}
if (p.Content.ToLower().Contains(termItem))
{
rank += Regex.Matches(p.Content.ToLower(), termItem).Count;
}
}
if (rank > 0)
{
results.Add(new SearchResult {
Rank = rank, Item = await PostToItem(p, sanitize)
});
}
}
results = results.OrderByDescending(r => r.Rank).ToList();
var posts = new List <PostItem>();
for (int i = 0; i < results.Count; i++)
{
posts.Add(results[i].Item);
}
pager.Configure(posts.Count);
return(await Task.Run(() => posts.Skip(skip).Take(pager.ItemsPerPage).ToList()));
}
