public IPagedResult <PostDto> Search(string term, int pageIndex, int pageSize, ItemQueryFilter filters)
{
if (pageIndex < 1)
{
throw new ArgumentException("The page index must be greater than 0", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("The page size must be greater than 0", "pageSize");
}
if (filters == null)
{
filters = new ItemQueryFilter();
filters.MaxPublishAt = DateTime.Now;
filters.Status = ItemStatus.Published;
}
CancelEventArgsWithOneParameter <Tuple <string, int, int, ItemQueryFilter>, IPagedResult <PostDto> > e = new CancelEventArgsWithOneParameter <Tuple <string, int, int, ItemQueryFilter>, IPagedResult <PostDto> >(new Tuple <string, int, int, ItemQueryFilter>(term, pageIndex, pageSize, filters), null);
this.PostsSearchingWithFilters.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'Search' is overridden by the event 'PostsSearchingWithFilters'.");
return(e.Result);
}
IPagedResult <PostDto> result = this.postDataService.Search(term, pageIndex, pageSize, filters);
this.PostsSearchedWithFilters.Raise(this, new GenericEventArgs <IPagedResult <PostDto> >(result));
return(result);
}
public IPagedResult <PostDto> GetPostsByDate(int pageIndex, int pageSize, int year, int?month, int?day, ItemQueryFilter filters = null)
{
if (pageIndex < 1)
{
throw new ArgumentException("The page index must be greater than 0", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("The page size must be greater than 0", "pageSize");
}
if (year < 1700)
{
throw new ArgumentException("The year value must be greater than 1700. Internet did not exist in 1700!", "year");
}
if (month.HasValue && (month.Value < 1 || month.Value > 12))
{
throw new ArgumentException("The month value must be greater than 0 and lesser than 12", "month");
}
if (day.HasValue && (day.Value < 1 || day.Value > 31))
{
throw new ArgumentException("The day value must be greater than 0 and lesser than 31", "month");
}
if (filters == null)
{
filters = new ItemQueryFilter();
filters.MaxPublishAt = DateTimeOffset.Now.AsMinutes();
filters.Status = ItemStatus.Published;
}
Tuple <int, int, int, int?, int?, ItemQueryFilter> p = new Tuple <int, int, int, int?, int?, ItemQueryFilter>(pageIndex, pageSize, year, month, day, filters);
CancelEventArgsWithOneParameter <Tuple <int, int, int, int?, int?, ItemQueryFilter>, IPagedResult <PostDto> > e = new CancelEventArgsWithOneParameter <Tuple <int, int, int, int?, int?, ItemQueryFilter>, IPagedResult <PostDto> >(p, null);
this.PostsRetrievingByDates.Raise(this, e);
if (e.Cancel)
{
return(e.Result);
}
IPagedResult <PostDto> result = this.postDataService.GetPostsByDate(pageIndex, pageSize, year, month, day, filters);
this.PostsRetrievedByDates.Raise(this, new GenericEventArgs <IPagedResult <PostDto> >(result));
return(result);
}
public ActionResult PostList(int pageIndex, int pageSize, ItemQueryFilter filter)
{
if (filter == null)
{
filter = new ItemQueryFilter
{
MaxPublishAt = DateTimeOffset.Now.AddMonths(1).AsMinutes(),
MinPublishAt = DateTimeOffset.Now.AsMinutes(),
Status = ItemStatus.Scheduled
};
}
IPagedResult <PostDto> model = this.postService.GetPosts(1, 5, filter);
return(this.View(model));
}
public IPagedResult <PostDto> GetPostsByTag(int pageIndex, int pageSize, string tag, ItemQueryFilter filters = null)
{
if (pageIndex < 1)
{
throw new ArgumentException("The page index must be greater than 0", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("The page size must be greater than 0", "pageSize");
}
if (tag == null)
{
throw new ArgumentNullException("tag", "The string tag must contains a value");
}
if (tag == string.Empty)
{
throw new ArgumentException("The string tag must not be empty", "tag");
}
if (filters == null)
{
filters = new ItemQueryFilter();
filters.MaxPublishAt = DateTimeOffset.Now.AsMinutes();
filters.Status = ItemStatus.Published;
}
CancelEventArgsWithOneParameter <Tuple <int, int, string, ItemQueryFilter>, IPagedResult <PostDto> > e = new CancelEventArgsWithOneParameter <Tuple <int, int, string, ItemQueryFilter>, IPagedResult <PostDto> >(new Tuple <int, int, string, ItemQueryFilter>(pageIndex, pageSize, tag, filters), null);
this.PostsRetrievingByTag.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'GetPostsByTag' is overridden by the event 'PostsRetrievingByTag'.");
return(e.Result);
}
IPagedResult <PostDto> result = this.postDataService.GetPostsByTag(pageIndex, pageSize, tag, filters);
this.PostsRetrievedByTag.Raise(this, new GenericEventArgs <IPagedResult <PostDto> >(result));
return(result);
}
public static IQueryable <T> ApplyFilterItem <T>(this IQueryable <T> query, ItemQueryFilter filters) where T : Item
{
if (filters != null && filters.Status.HasValue)
{
query = query.Where(x => x.Status == filters.Status);
}
if (filters != null && filters.MinPublishAt.HasValue)
{
query = query.Where(x => x.PublishAt >= filters.MaxPublishAt);
}
if (filters != null && filters.MaxPublishAt.HasValue)
{
query = query.Where(x => x.PublishAt <= filters.MaxPublishAt);
}
return(query);
}
public IPagedResult <PageDto> GetPages(int pageIndex, int pageSize, ItemQueryFilter filter)
{
if (pageIndex < 1)
{
throw new ArgumentException("The page index must be greater than 0", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("The page size must be greater than 0", "pageSize");
}
RavenQueryStatistics stats;
return(this.Session.Query <Page>()
.Statistics(out stats)
.ApplyFilterItem(filter)
.OrderByDescending(post => post.PublishAt)
.ToPagedResult <Page, PageDto>(pageIndex, pageSize, stats));
}
public IList <CommentDto> GetRecentApprovedComments(int maxNumberOfComments, ItemQueryFilter filters)
{
IRavenQueryable <PostCommentsCreationDateIndex.ReduceResult> query = this.Session.Query <PostCommentsCreationDateIndex.ReduceResult, PostCommentsCreationDateIndex>();
if (filters != null && filters.Status.HasValue)
{
query.Where(x => x.Status == filters.Status);
}
if (filters != null && filters.MinPublishAt.HasValue)
{
query.Where(x => x.ItemPublishedAt > filters.MaxPublishAt);
}
if (filters != null && filters.MaxPublishAt.HasValue)
{
query.Where(x => x.ItemPublishedAt < filters.MaxPublishAt);
}
List <PostCommentsCreationDateIndex.ReduceResult> data = query.ThenByDescending(x => x.CreatedAt)
.AsProjection <PostCommentsCreationDateIndex.ReduceResult>()
.Take(maxNumberOfComments)
.ToList();
IList <CommentDto> list = new List <CommentDto>();
foreach (PostCommentsCreationDateIndex.ReduceResult commentIdentifier in data)
{
ItemComments comments = this.Session.Load <ItemComments>(commentIdentifier.PostCommentsId);
Comment comment = comments.Approved.FirstOrDefault(x => x.Id == commentIdentifier.CommentId);
Item item = this.Session.Load <Post>(commentIdentifier.ItemId);
CommentDto c = comment.MapTo <CommentDto>();
c.ItemInfo = item.MapTo <ItemBaseInfo>();
list.Add(c);
}
return(list);
}
public IPagedResult <PostDto> Search(string term, int pageIndex, int pageSize, ItemQueryFilter filters)
{
RavenQueryStatistics stats;
return(this.Session.Query <PostFullTextIndex.ReduceResult, PostFullTextIndex>()
.Customize(x => x.Highlight("SearchQuery", 128, 1, "Results"))
.Search(x => x.SearchQuery, term)
.OrderByDescending(post => post.PublishDate)
.Statistics(out stats)
.As <Post>()
.ApplyFilterItem(filters)
.ToPagedResult <Post, PostDto>(pageIndex, pageSize, stats));
}
public IPagedResult <PostDto> GetPostsByCategory(int pageIndex, int pageSize, string categoryName, ItemQueryFilter filters)
{
if (pageIndex < 1)
{
throw new ArgumentException("The page index must be greater than 0.", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("The page size must be greater than 0.", "pageSize");
}
if (string.IsNullOrEmpty(categoryName))
{
throw new ArgumentException("The category name must contains a valid value.", "categoryName");
}
RavenQueryStatistics stats;
return(this.Session.Query <Post>()
.Statistics(out stats)
.ApplyFilterItem(filters)
.Where(post => post.Categories.Any(postCategory => postCategory == categoryName))
.OrderByDescending(post => post.PublishAt)
.ToPagedResult <Post, PostDto>(pageIndex, pageSize, stats));
}
public IPagedResult <PostDto> GetPostsByDate(int pageIndex, int pageSize, int year, int?month, int?day, ItemQueryFilter filters)
{
if (pageIndex < 1)
{
throw new ArgumentException("The page index must be greater than 0", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("The page size must be greater than 0", "pageSize");
}
if (year < 1700)
{
throw new ArgumentException("The year value must be greater than 1700. Internet did not exist in 1700!", "year");
}
if (month.HasValue && (month.Value < 1 || month.Value > 12))
{
throw new ArgumentException("The month value must be greater than 0 and lesser than 12", "month");
}
if (day.HasValue && (day.Value < 1 || day.Value > 31))
{
throw new ArgumentException("The day value must be greater than 0 and lesser than 31", "month");
}
RavenQueryStatistics stats;
IQueryable <Post> query = this.Session.Query <Post>()
.Statistics(out stats)
.Where(post => post.PublishAt.Year == year)
.ApplyFilterItem(filters);
if (month.HasValue)
{
query = query.Where(post => post.PublishAt.Month == month.Value);
}
if (day.HasValue)
{
query = query.Where(post => post.PublishAt.Day == day.Value);
}
return(query
.OrderByDescending(post => post.PublishAt)
.ToPagedResult <Post, PostDto>(pageIndex, pageSize, stats));
}