// 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())); }