public PostDto GetPostBySlug(string slug)
{
if (slug == null)
{
throw new ArgumentNullException("slug");
}
if (slug == string.Empty)
{
throw new ArgumentException("The string must have a value.", "slug");
}
CancelEventArgsWithOneParameter <string, PostDto> e = new CancelEventArgsWithOneParameter <string, PostDto>(slug, null);
this.PostRetrievingBySlug.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'PostRetrievingBySlug' is overridden by the event 'PostRetrievingBySlug'.");
return(e.Result);
}
PostDto result = this.postDataService.GetPostBySlug(slug);
this.PostRetrievedBySlug.Raise(this, new GenericEventArgs <PostDto>(result));
return(result);
}
public IList <CommentDto> GetCommentForSpecificItem(int itemId, CommentQueryFilter queryFilter)
{
if (itemId < 1)
{
throw new ArgumentException("The item id must be greater than 0", "itemId");
}
if (queryFilter == null)
{
queryFilter = new CommentQueryFilter();
queryFilter.CommentStatus = CommentStatus.IsApproved;
}
CancelEventArgsWithOneParameter <int, IList <CommentDto> > e = new CancelEventArgsWithOneParameter <int, IList <CommentDto> >(itemId, null);
this.CommentsRetrievingByItemId.Raise(this, e);
if (e.Cancel)
{
return(e.Result);
}
IList <CommentDto> result = this.commentDataService.GetCommentForSpecificItem(itemId, queryFilter);
this.CommentsRetrievedByItemId(this, new GenericEventArgs <IList <CommentDto> >(result));
return(result);
}
public IList <TagDto> GetTopTagsForPublishedPosts(int maxNumberOfTags)
{
if (maxNumberOfTags < 1)
{
throw new ArgumentException("The number of tags to retrieve must be greater than 0", "maxNumberOfTags");
}
CancelEventArgsWithOneParameter <int, IList <TagDto> > e = new CancelEventArgsWithOneParameter <int, IList <TagDto> >(maxNumberOfTags, null);
this.TagsRetrievingForPublishedPosts.Raise(this, e);
if (e.Cancel)
{
return(e.Result);
}
IList <TagDto> data = this.postDataService.GetTopTagsForPublishedPosts(maxNumberOfTags);
this.TagsRetrievedForPublishedPosts.Raise(this, new GenericEventArgs <IList <TagDto> >(data));
return(data);
}
public PostDto GetPostByKey(int key)
{
if (key < 1)
{
throw new ArgumentException("The Key must be greater than 0", "key");
}
CancelEventArgsWithOneParameter <int, PostDto> e = new CancelEventArgsWithOneParameter <int, PostDto>(key, null);
this.PostRetrievingById.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'GetPostByKey' is overridden by the event 'PostRetrievingById'.");
return(e.Result);
}
PostDto result = this.postDataService.GetPostByKey(key);
this.PostRetrievedById.Raise(this, new GenericEventArgs <PostDto>(result));
return(result);
}
public IList<CommentDto> GetCommentForSpecificItem(int itemId, CommentQueryFilter queryFilter)
{
if (itemId < 1)
{
throw new ArgumentException("The item id must be greater than 0", "itemId");
}
if (queryFilter == null)
{
queryFilter = new CommentQueryFilter();
queryFilter.CommentStatus = CommentStatus.IsApproved;
}
CancelEventArgsWithOneParameter<int, IList<CommentDto>> e = new CancelEventArgsWithOneParameter<int, IList<CommentDto>>(itemId, null);
this.CommentsRetrievingByItemId.Raise(this, e);
if (e.Cancel)
{
return e.Result;
}
IList<CommentDto> result = this.commentDataService.GetCommentForSpecificItem(itemId, queryFilter);
this.CommentsRetrievedByItemId(this, new GenericEventArgs<IList<CommentDto>>(result));
return result;
}
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> 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 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 IPagedResult<PageDto> GetPages(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<int, int, ItemQueryFilter>, IPagedResult<PageDto>> e = new CancelEventArgsWithOneParameter<Tuple<int, int, ItemQueryFilter>, IPagedResult<PageDto>>(new Tuple<int, int, ItemQueryFilter>(pageIndex, pageSize, filters), null);
this.PagesRetrievingWithFilters.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'GetPages' is overridden by the event 'PagesRetrievingWithFilters'.");
return e.Result;
}
IPagedResult<PageDto> result = this.pageDataService.GetPages(pageIndex, pageSize, filters);
this.PagesRetrievedWithFilters.Raise(this, new GenericEventArgs<IPagedResult<PageDto>>(result));
return result;
}
public PageDto GetPageBySlug(string slug)
{
if (slug == null)
{
throw new ArgumentNullException("slug");
}
if (slug == string.Empty)
{
throw new ArgumentException("The string must have a value.", "slug");
}
CancelEventArgsWithOneParameter<string, PageDto> e = new CancelEventArgsWithOneParameter<string, PageDto>(slug, null);
this.PageRetrievingBySlug.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'PageRetrievingBySlug' is overridden by the event 'PageRetrievingBySlug'.");
return e.Result;
}
PageDto result = this.pageDataService.GetPageBySlug(slug);
this.PageRetrievedBySlug.Raise(this, new GenericEventArgs<PageDto>(result));
return result;
}
public PageDto GetPageByKey(int key)
{
if (key < 1)
{
throw new ArgumentException("The Key must be greater than 0", "key");
}
CancelEventArgsWithOneParameter<int, PageDto> e = new CancelEventArgsWithOneParameter<int, PageDto>(key, null);
this.PageRetrievingById.Raise(this, e);
if (e.Cancel)
{
this.logger.DebugAsync("The result of the method 'GetPageByKey' is overridden by the event 'PageRetrievingById'.");
return e.Result;
}
PageDto result = this.pageDataService.GetPageByKey(key);
this.PageRetrievedById.Raise(this, new GenericEventArgs<PageDto>(result));
return result;
}
