{

#region Constants and Fields

/// <summary>

/// The sync root.

/// </summary>

private static readonly object SyncRoot = new object();

/// <summary>

/// The categories.

/// </summary>

private readonly StateList<Category> categories;

/// <summary>

/// All comments, including deleted

/// </summary>

private readonly List<Comment> allcomments;

/// <summary>

/// The notification emails.

/// </summary>

private readonly StateList<string> notificationEmails;

/// <summary>

/// The post tags.

/// </summary>

private readonly StateList<string> tags;

/// <summary>

/// The posts.

/// </summary>

private static Dictionary<Guid, List<Post>> posts = new Dictionary<Guid, List<Post>>();

/// <summary>

/// The deleted posts.

/// </summary>

private static Dictionary<Guid, List<Post>> deletedposts = new Dictionary<Guid, List<Post>>();

/// <summary>

/// The author.

/// </summary>

private string author;

/// <summary>

/// The content.

/// </summary>

private string content;

/// <summary>

/// The description.

/// </summary>

private string description;

/// <summary>

/// Whether the post is comments enabled.

/// </summary>

private bool hasCommentsEnabled;

/// <summary>

/// The nested comments.

/// </summary>

private List<Comment> nestedComments;

/// <summary>

/// Whether the post is published.

/// </summary>

private bool isPublished;

/// <summary>

/// Whether the post is deleted.

/// </summary>

private bool isDeleted;

/// <summary>

/// The raters.

/// </summary>

private int raters;

/// <summary>

/// The rating.

/// </summary>

private float rating;

/// <summary>

/// The slug of the post.

/// </summary>

private string slug;

/// <summary>

/// The title.

/// </summary>

private string title;

#endregion

#region Constructors and Destructors

/// <summary>

/// Initializes a new instance of the <see cref = "Post" /> class.

/// The default contstructor assign default values.

/// </summary>

public Post()

{

this.Id = Guid.NewGuid();

this.allcomments = new List<Comment>();

this.categories = new StateList<Category>();

this.tags = new StateList<string>();

this.notificationEmails = new StateList<string>();

this.DateCreated = DateTime.Now;

this.isPublished = true;

this.hasCommentsEnabled = true;

}

static Post()

{

Blog.Saved += (s, e) =>

{

if (e.Action == SaveAction.Delete)

{

Blog blog = s as Blog;

if (blog != null)

{

RefreshPostLists(blog);

}

}

};

}

#endregion

#region Events

/// <summary>

/// Occurs before a new comment is added.

/// </summary>

public static event EventHandler<CancelEventArgs> AddingComment;

/// <summary>

/// Occurs when a comment is added.

/// </summary>

public static event EventHandler<EventArgs> CommentAdded;

/// <summary>

/// Occurs when a comment has been removed.

/// </summary>

public static event EventHandler<EventArgs> CommentRemoved;

/// <summary>

/// Occurs when a comment has been purged.

/// </summary>

public static event EventHandler<EventArgs> CommentPurged;

/// <summary>

/// Occurs when a comment has been restored.

/// </summary>

public static event EventHandler<EventArgs> CommentRestored;

/// <summary>

/// Occurs when a comment is updated.

/// </summary>

public static event EventHandler<EventArgs> CommentUpdated;

/// <summary>

/// Occurs when a visitor rates the post.

/// </summary>

public static event EventHandler<EventArgs> Rated;

/// <summary>

/// Occurs before comment is removed.

/// </summary>

public static event EventHandler<CancelEventArgs> RemovingComment;

/// <summary>

/// Occurs before comment is purged.

/// </summary>

public static event EventHandler<CancelEventArgs> PurgingComment;

/// <summary>

/// Occurs before comment is restored.

/// </summary>

public static event EventHandler<CancelEventArgs> RestoringComment;

/// <summary>

/// Occurs when the post is being served to the output stream.

/// </summary>

public static event EventHandler<ServingEventArgs> Serving;

/// <summary>

/// Occurs when the post is being published.

/// </summary>

public static event EventHandler<CancelEventArgs> Publishing;

/// <summary>

/// Occurs when a post is published.

/// </summary>

public static event EventHandler<EventArgs> Published;

/// <summary>

/// Occurs before a new comment is updated.

/// </summary>

public static event EventHandler<CancelEventArgs> UpdatingComment;

#endregion

#region Post Properties

/// <summary>

/// Gets a sorted collection of all undeleted posts in the blog.

/// Sorted by date.

/// </summary>

public static List<Post> Posts

{

get

{

Blog blog = Blog.CurrentInstance;

List<Post> blogPosts;

if (!posts.TryGetValue(blog.BlogId, out blogPosts))

{

lock (SyncRoot)

{

if (!posts.TryGetValue(blog.BlogId, out blogPosts))

{

posts[blog.Id] = blogPosts = BlogService.FillPosts().Where(p => p.IsDeleted == false).ToList();

blogPosts.TrimExcess();

AddRelations(blogPosts);

}

}

}

return blogPosts;

}

}

/// <summary>

/// Gets a sorted collection of all undeleted posts across all blogs.

/// Sorted by date.

/// </summary>

public static List<Post> AllBlogPosts

{

get

{

List<Blog> blogs = Blog.Blogs.Where(b => b.IsActive).ToList();

Guid originalBlogInstanceIdOverride = Blog.InstanceIdOverride;

List<Post> postsAcrossAllBlogs = new List<Post>();

// Posts are not loaded for a blog instance until that blog

// instance is first accessed. For blog instances where the

// posts have not yet been loaded, using InstanceIdOverride to

// temporarily switch the blog CurrentInstance blog so the Posts

// for that blog instance can be loaded.

//

for (int i = 0; i < blogs.Count; i++)

{

List<Post> blogPosts;

if (!posts.TryGetValue(blogs[i].Id, out blogPosts))

{

// temporarily override the Current BlogId to the

// blog Id we need posts to be loaded for.

Blog.InstanceIdOverride = blogs[i].Id;

blogPosts = Posts;

Blog.InstanceIdOverride = originalBlogInstanceIdOverride;

}

postsAcrossAllBlogs.AddRange(blogPosts);

}

postsAcrossAllBlogs.Sort();

// do not call AddRelations(). that will change the Next/Previous properties

// to point to posts in other blogs, which leads to the Next / Previous

// posts pointing to posts in other blog instances when viewing a single post

// (in post.aspx). If Next/Previous is needed for the posts returned

// here in AllBlogPosts, would be better to create new properties

// (e.g. AllBlogsNextPost, AllBlogsPreviousPost).

// AddRelations(postsAcrossAllBlogs);

return postsAcrossAllBlogs;

}

}

/// <summary>

/// Gets a sorted collection of all undeleted posts, taking into account the

/// current blog instance's Site Aggregation status in determining if posts

/// from just the current instance or all instances should be returned.

/// Sorted by date.

/// </summary>

/// <remarks>

/// This logic could be put into the normal 'Posts' property, however

/// there are times when a Site Aggregation blog instance may just need

/// its own posts. So ApplicablePosts can be called when data across

/// all blog instances may be needed, and Posts can be called when data

/// for just the current blog instance is needed.

/// </remarks>

public static List<Post> ApplicablePosts

{

get

{

if (Blog.CurrentInstance.IsSiteAggregation)

return AllBlogPosts;

else

return Posts;

}

}

/// <summary>

/// Gets a sorted collection of all deleted posts in the blog.

/// Sorted by date.

/// </summary>

public static List<Post> DeletedPosts

{

get

{

Blog blog = Blog.CurrentInstance;

List<Post> blogPosts;

if (!deletedposts.TryGetValue(blog.Id, out blogPosts))

{

lock (SyncRoot)

{

if (!deletedposts.TryGetValue(blog.Id, out blogPosts))

{

blogPosts = BlogService.FillPosts().Where(p => p.IsDeleted == true).ToList();

deletedposts[blog.Id] = blogPosts;

}

}

}

return blogPosts;

}

}

/// <summary>

/// Gets or sets the Author or the post.

/// </summary>

public string Author

{

get

{

return this.author;

}

set

{

base.SetValue("Author", value, ref this.author);

}

}

/// <summary>

/// Gets AuthorProfile.

/// </summary>

public AuthorProfile AuthorProfile

{

get

{

return AuthorProfile.GetProfile(this.Author);

}

}

/// <summary>

/// Gets an unsorted List of categories.

/// </summary>

public StateList<Category> Categories

{

get

{

return this.categories;

}

}

/// <summary>

/// Gets or sets the Content or the post.

/// </summary>

public string Content

{

get

{

return this.content;

}

set

{

base.SetValue("Content", value, ref this.content);

// This is commented out only because I can't find any reference to

// this cache item anywhere in the project. So it seems pretty obscure

// if it's supposed to be used by plugins or something else.

//if (base.SetValue("Content", value, ref this.content))

//{

// Blog.CurrentInstance.Cache.Remove("content_" + this.Id);

//}

}

}

/// <summary>

/// Gets or sets the Description or the post.

/// </summary>

public string Description

{

get

{

return this.description;

}

set

{

base.SetValue("Description", value, ref this.description);

}

}

/// <summary>

/// Gets if the Post have been changed.

/// </summary>

public override bool IsChanged

{

get

{

if (base.IsChanged)

{

return true;

}

if (this.Categories.IsChanged || this.Tags.IsChanged || this.NotificationEmails.IsChanged)

{

return true;

}

return false;

}

}

/// <summary>

/// Gets the next post relative to this one based on time.

/// <remarks>

/// If this post is the newest, then it returns null.

/// </remarks>

/// </summary>

public Post Next { get; private set; }

/// <summary>

/// Gets a collection of email addresses that is signed up for

/// comment notification on the specific post.

/// </summary>

public StateList<string> NotificationEmails

{

get

{

return this.notificationEmails;

}

}

/// <summary>

/// Gets the absolute permanent link to the post.

/// </summary>

public Uri PermaLink

{

get

{

return new Uri(string.Format("{0}post.aspx?id={1}", this.Blog.AbsoluteWebRoot, this.Id));

}

}

/// <summary>

/// Gets the previous post relative to this one based on time.

/// <remarks>

/// If this post is the oldest, then it returns null.

/// </remarks>

/// </summary>

public Post Previous { get; private set; }

/// <summary>

/// Gets or sets a value indicating whether or not the post is published.

/// </summary>

public bool IsPublished

{

get

{

return this.isPublished;

}

set

{

base.SetValue("IsPublished", value, ref this.isPublished);

}

}

/// <summary>

/// Gets or sets a value indicating whether or not the post is deleted.

/// </summary>

public bool IsDeleted

{

get

{

return this.isDeleted;

}

set

{

base.SetValue("IsDeleted", value, ref this.isDeleted);

}

}

/// <summary>

/// Gets or sets the number of raters or the object.

/// </summary>

public int Raters

{

get

{

return this.raters;

}

set

{

base.SetValue("Raters", value, ref this.raters);

}

}

/// <summary>

/// Gets or sets the rating or the post.

/// </summary>

public float Rating

{

get

{

return this.rating;

}

set

{

base.SetValue("Rating", value, ref this.rating);

}

}

/// <summary>

/// Gets the absolute link to the post.

/// </summary>

public Uri AbsoluteLink

{

get

{

return new Uri(this.Blog.AbsoluteWebRootAuthority + this.RelativeLink);

}

}

/// <summary>

/// Gets a relative-to-the-site-root path to the post.

/// Only for in-site use.

/// </summary>

public string RelativeLink

{

get

{

// taking into account aggregated posts

var settings = BlogSettings.GetInstanceSettings(Blog);

var ext = string.IsNullOrEmpty(BlogConfig.FileExtension) ? ".aspx" : BlogConfig.FileExtension;

var theslug = Utils.RemoveIllegalCharacters(this.Slug);

if (!settings.RemoveExtensionsFromUrls)

theslug += ext;

var BlogUrl = "";

if (this.BlogId != Blog.CurrentInstance.Id)

{

// point it to child blog

BlogUrl = this.Blog.Name + "/";

}

return settings.TimeStampPostLinks

? string.Format("{0}{1}post/{2}{3}", Blog.RelativeWebRoot, BlogUrl, DateCreated.ToString("yyyy/MM/dd/", CultureInfo.InvariantCulture), theslug)

: string.Format("{0}{1}post/{2}", Utils.RelativeWebRoot, BlogUrl, theslug);

}

}

/// <summary>

/// Returns a relative link if possible if the hostname of this blog instance matches the

/// hostname of the site aggregation blog. If the hostname is different, then the

/// absolute link is returned.

/// </summary>

public string RelativeOrAbsoluteLink

{

get

{

return Blog.DoesHostnameDifferFromSiteAggregationBlog ? AbsoluteLink.ToString() : RelativeLink;

}

}

/// <summary>

/// Gets or sets the Slug of the Post.

/// A Slug is the relative URL used by the posts.

/// </summary>

public string Slug

{

get

{

return string.IsNullOrEmpty(this.slug) ? GetUniqueSlug(this.title, this.Id) : this.slug;

}

set

{

base.SetValue("Slug", value, ref this.slug);

}

}

/// <summary>

/// Gets an unsorted collection of tags.

/// </summary>

public StateList<string> Tags

{

get

{

return this.tags;

}

}

/// <summary>

/// Gets or sets the Title or the post.

/// </summary>

public string Title

{

get

{

return this.title;

}

set

{

base.SetValue("Title", value, ref this.title);

}

}

/// <summary>

/// Gets the trackback link to the post.

/// </summary>

public Uri TrackbackLink

{

get

{

return new Uri(string.Format("{0}trackback.axd?id={1}", this.Blog.AbsoluteWebRoot, this.Id));

}

}

/// <summary>

/// Gets a value indicating whether or not the post is visible or not.

/// </summary>

public bool IsVisible

{

get

{

if (this.IsDeleted)

return false;

else if (this.IsPublished && this.DateCreated <= DateTime.Now.AddHours(BlogSettings.Instance.Timezone))

return true;

else if (Security.IsAuthorizedTo(Rights.ViewUnpublishedPosts))

return true;

return false;

}

}

/// <summary>

/// Gets a value indicating whether a post is available to visitors not logged into the blog.

/// </summary>

public bool IsVisibleToPublic

{

get

{

return (this.IsPublished && this.DateCreated <= DateTime.Now.AddHours(BlogSettings.Instance.Timezone)) &&

this.IsDeleted == false;

}

}

#endregion

#region Comment Properties

/// <summary>

/// Gets a Collection of All Comments for the post

/// </summary>

public List<Comment> Comments

{

get

{

return this.AllComments.FindAll(c => !c.IsDeleted);

}

}

/// <summary>

/// Gets a Collection of All Comments for the post

/// </summary>

public List<Comment> AllComments

{

get

{

return this.allcomments;

}

}

/// <summary>

/// Gets a collection of Approved comments for the post sorted by date.

/// When moderation is enabled, unapproved comments go to pending.

/// Whith moderation off, they shown as approved.

/// </summary>

public List<Comment> ApprovedComments

{

get

{

if (BlogSettings.Instance.EnableCommentsModeration)

{

return this.Comments.FindAll(c => c.IsApproved && !c.IsSpam && !c.IsPingbackOrTrackback);

}

else

{

return this.Comments.FindAll(c => !c.IsSpam && !c.IsPingbackOrTrackback);

}

}

}

/// <summary>

/// Gets a collection of comments waiting for approval for the post, sorted by date

/// excluding comments rejected as spam

/// </summary>

public List<Comment> NotApprovedComments

{

get

{

return this.Comments.FindAll(c => !c.IsApproved && !c.IsSpam && !c.IsPingbackOrTrackback);

}

}

/// <summary>

/// Gets a collection of pingbacks and trackbacks for the post, sorted by date

/// </summary>

public List<Comment> Pingbacks

{

get

{

return this.Comments.FindAll(c => c.IsApproved && !c.IsSpam && c.IsPingbackOrTrackback);

}

}

/// <summary>

/// Gets a collection of comments marked as spam for the post, sorted by date.

/// </summary>

public List<Comment> SpamComments

{

get

{

return this.Comments.FindAll(c => c.IsSpam && !c.IsDeleted);

}

}

/// <summary>

/// Gets a collection of comments marked as deleted for the post, sorted by date.

/// </summary>

public List<Comment> DeletedComments

{

get

{

return this.allcomments.FindAll(c => c.IsDeleted);

}

}

/// <summary>

/// Gets a collection of the comments that are nested as replies

/// </summary>

public List<Comment> NestedComments

{

get

{

if (this.nestedComments == null)

{

this.CreateNestedComments();

}

return this.nestedComments;

}

}

/// <summary>

/// Gets or sets a value indicating whether this instance has comments enabled.

/// </summary>

/// <value>

/// <c>true</c> if this instance has comments enabled; otherwise, <c>false</c>.

/// </value>

public bool HasCommentsEnabled

{

get

{

return this.hasCommentsEnabled;

}

set

{

base.SetValue("HasCommentsEnabled", value, ref this.hasCommentsEnabled);

}

}

#endregion

#region Post Public Methods

/// <summary>

/// Gets whether the current user can publish this post.

/// </summary>

/// <param name="author">The author of the post without needing to assign it to the Author property.</param>

/// <returns></returns>

public bool CanPublish(string author)

{

bool isOwnPost = Security.CurrentUser.Identity.Name.Equals(author, StringComparison.OrdinalIgnoreCase);

if (isOwnPost && !Security.IsAuthorizedTo(Rights.PublishOwnPosts))

{

return false;

}

else if (!isOwnPost && !Security.IsAuthorizedTo(Rights.PublishOtherUsersPosts))

{

return false;

}

return true;

}

/// <summary>

/// Gets whether or not the current user owns this post.

/// </summary>

/// <returns></returns>

public override bool CurrentUserOwns

{

get

{

return Security.CurrentUser.Identity.Name.Equals(this.Author, StringComparison.OrdinalIgnoreCase);

}

}

/// <summary>

/// Gets whether the current user can delete this post.

/// </summary>

/// <returns></returns>

public override bool CanUserDelete

{

get

{

if (CurrentUserOwns && Security.IsAuthorizedTo(Rights.DeleteOwnPosts))

return true;

else if (!CurrentUserOwns && Security.IsAuthorizedTo(Rights.DeleteOtherUsersPosts))

return true;

return false;

}

}

/// <summary>

/// Gets whether the current user can edit this post.

/// </summary>

/// <returns></returns>

public override bool CanUserEdit

{

get

{

if (CurrentUserOwns && Security.IsAuthorizedTo(Rights.EditOwnPosts))

return true;

else if (!CurrentUserOwns && Security.IsAuthorizedTo(Rights.EditOtherUsersPosts))

return true;

return false;

}

}

/// <summary>

/// Returns a post based on the specified id.

/// </summary>

/// <param name="id">

/// The post id.

/// </param>

/// <returns>

/// The selected post.

/// </returns>

public static Post GetPost(Guid id)

{

return Posts.Find(p => p.Id == id);

}

/// <summary>

/// Returns all posts written by the specified author.

/// </summary>

/// <param name="author">

/// The author.

/// </param>

/// <returns>

/// A list of Post.

/// </returns>

public static List<Post> GetPostsByAuthor(string author)

{

var legalAuthor = Utils.RemoveIllegalCharacters(author);

var list = ApplicablePosts.FindAll(

p =>

{

var legalTitle = Utils.RemoveIllegalCharacters(p.Author);

return legalAuthor.Equals(legalTitle, StringComparison.OrdinalIgnoreCase);

});

return list;

}

/// <summary>

/// Get blog by author

/// </summary>

/// <param name="author">Post author</param>

/// <returns>Blog if author wrote any posts there</returns>

public static Blog GetBlogByAuthor(string author)

{

var legalAuthor = Utils.RemoveIllegalCharacters(author);

var post = ApplicablePosts.FirstOrDefault(

p =>

{

var legalTitle = Utils.RemoveIllegalCharacters(p.Author);

return legalAuthor.Equals(legalTitle, StringComparison.OrdinalIgnoreCase);

});

return post == null ? null : post.Blog;

}

/// <summary>

/// Returns all posts in the specified category

/// </summary>

/// <param name="categoryId">

/// The category Id.

/// </param>

/// <returns>

/// A list of Post.

/// </returns>

public static List<Post> GetPostsByCategory(Guid categoryId)

{

var cat = Category.GetCategory(categoryId, Blog.CurrentInstance.IsSiteAggregation);

return GetPostsByCategory(cat);

}

/// <summary>

/// Returns all posts in the specified category

/// </summary>

/// <param name="cat">Category objuect</param>

/// <returns>A list of posts</returns>

public static List<Post> GetPostsByCategory(Category cat)

{

if (cat == null)

{

return null;

}

var col = new List<Post>();

foreach (var p in Post.ApplicablePosts)

{

foreach (var c in p.Categories)

{

if (Blog.CurrentInstance.IsSiteAggregation)

{

if (c.Title == cat.Title) col.Add(p);

}

else

{

if (c.Title == cat.Title && c.Id == cat.Id) col.Add(p);

}

}

}

//var col = Post.ApplicablePosts.Where(p => p.Categories.Contains(cat)).ToList();

col.Sort();

return col;

}

/// <summary>

/// Returns all posts published between the two dates.

/// </summary>

/// <param name="dateFrom">

/// The date From.

/// </param>

/// <param name="dateTo">

/// The date To.