/// <summary>
        /// Creates the specified entry in the back end data store attaching 
        /// the specified category ids.
        /// </summary>
        /// <param name="entry">Entry.</param>
        /// <param name="categoryIds">Category I ds.</param>
        /// <returns></returns>
        public override int Create(Entry entry, IEnumerable<int> categoryIds)
        {
            ValidateEntry(entry);

            entry.DateCreatedUtc = entry.DateCreatedUtc.IsNull() ? CurrentDateTimeUtc : entry.DateCreatedUtc;

            entry.Id = _procedures.InsertEntry(entry.Title
                , entry.Body.NullIfEmpty()
                , (int)entry.PostType
                , entry.Author.NullIfEmpty()
                , entry.Email.NullIfEmpty()
                , entry.Description.NullIfEmpty()
                , BlogId
                , entry.DateCreatedUtc
                , (int)entry.PostConfig
                , entry.EntryName.NullIfEmpty()
                , entry.DatePublishedUtc.NullIfEmpty());

            if (categoryIds != null)
            {
                SetEntryCategoryList(entry.Id, categoryIds);
            }

            if (entry.Id > -1)
            {
                Config.CurrentBlog.DateModifiedUtc = entry.DateCreatedUtc;
            }

            return entry.Id;
        }

        /// <summary>
        /// Posts trackbacks and pingbacks for the specified entry.
        /// </summary>
        public static void Run(Entry entry, Blog blog, BlogUrlHelper urlHelper)
        {
            if (!blog.TrackbacksEnabled)
            {
                return;
            }

            if (!Config.Settings.Tracking.EnablePingBacks && !Config.Settings.Tracking.EnableTrackBacks)
            {
                return;
            }

            if (entry != null)
            {
                VirtualPath blogUrl = urlHelper.BlogUrl();
                Uri fullyQualifiedUrl = blogUrl.ToFullyQualifiedUrl(blog);

                var notify = new Notifier
                {
                    FullyQualifiedUrl = fullyQualifiedUrl.AbsoluteUri,
                    BlogName = blog.Title,
                    Title = entry.Title,
                    PostUrl = urlHelper.EntryUrl(entry).ToFullyQualifiedUrl(blog),
                    Description = entry.HasDescription ? entry.Description : entry.Title,
                    Text = entry.Body
                };

                //This could take a while, do it on another thread
                ThreadHelper.FireAndForget(notify.Notify, "Exception occured while attempting trackback notification");
            }
        }

        public Entry ConvertBlogPost(BlogMLPost post, BlogMLBlog blogMLBlog, Blog blog)
        {
            DateTime dateModified = blog != null ? blog.TimeZone.FromUtc(post.DateModified) : post.DateModified;
            DateTime dateCreated = blog != null ? blog.TimeZone.FromUtc(post.DateCreated) : post.DateCreated;

            var newEntry = new Entry((post.PostType == BlogPostTypes.Article) ? PostType.Story : PostType.BlogPost)
            {
                Title = GetTitleFromPost(post).Left(BlogPostTitleMaxLength),
                DateCreated = dateCreated,
                DateModified = dateModified,
                DateSyndicated = post.Approved ? dateModified : DateTime.MaxValue,
                Body = post.Content.UncodedText,
                IsActive = post.Approved,
                DisplayOnHomePage = post.Approved,
                IncludeInMainSyndication = post.Approved,
                IsAggregated = post.Approved,
                AllowComments = true,
                Description = post.HasExcerpt ? post.Excerpt.UncodedText: null
            };

            if(!string.IsNullOrEmpty(post.PostName))
            {
                newEntry.EntryName = post.PostName;
            }
            else
            {
                SetEntryNameForBlogspotImport(post, newEntry);
            }

            SetEntryAuthor(post, newEntry, blogMLBlog);

            SetEntryCategories(post, newEntry, blogMLBlog);
            return newEntry;
        }

        public void editPost_WithEntryHavingEnclosure_UpdatesEntryEnclosureWithNewEnclosure()
        {
            //arrange
            var entry = new Entry(PostType.BlogPost) { Title = "Title 1", Body = "Blah", IsActive = true };
            entry.DateCreatedUtc = entry.DatePublishedUtc = entry.DateModifiedUtc = DateTime.ParseExact("1975/01/23", "yyyy/MM/dd", CultureInfo.InvariantCulture);
            entry.Categories.Add("TestCategory");
            var blog = new Blog { Id = 123, Host = "localhost", AllowServiceAccess = true, UserName = "username", Password = "password" };
            var subtextContext = new Mock<ISubtextContext>();
            subtextContext.Setup(c => c.Blog).Returns(blog);
            subtextContext.Setup(c => c.Repository.GetEntry(It.IsAny<Int32>(), false, true)).Returns(entry);
            var entryPublisher = new Mock<IEntryPublisher>();
            Entry publishedEntry = null;
            entryPublisher.Setup(p => p.Publish(It.IsAny<Entry>())).Callback<Entry>(e => publishedEntry = e);
            FrameworkEnclosure enclosure = UnitTestHelper.BuildEnclosure("<Digital Photography Explained (for Geeks) with Aaron Hockley/>",
                                              "http://perseus.franklins.net/hanselminutes_0107.mp3", "audio/mp3", 123, 26707573, true, true);
            entry.Enclosure = enclosure;
            var post = new Post { title = "Title 2", description = "Blah", dateCreated = DateTime.UtcNow };

            var postEnclosure = new Enclosure
            {
                url = "http://codeclimber.net.nz/podcast/mypodcastUpdated.mp3",
                type = "audio/mp3",
                length = 123456789
            };
            post.enclosure = postEnclosure;
            var metaWeblog = new MetaWeblog(subtextContext.Object, entryPublisher.Object);

            // act
            bool result = metaWeblog.editPost("123", "username", "password", post, true);

            // assert
            Assert.IsTrue(result);
            Assert.IsNotNull(publishedEntry.Enclosure);
            Assert.AreEqual("http://codeclimber.net.nz/podcast/mypodcastUpdated.mp3", entry.Enclosure.Url);
        }

        /// <summary>
        /// Creates the specified entry in the back end data store attaching 
        /// the specified category ids.
        /// </summary>
        /// <param name="entry">Entry.</param>
        /// <param name="categoryIds">Category I ds.</param>
        /// <returns></returns>
        public override int Create(Entry entry, IEnumerable<int> categoryIds)
        {
            ValidateEntry(entry);

            entry.Id = _procedures.InsertEntry(entry.Title
                , entry.Body.NullIfEmpty()
                , (int)entry.PostType
                , entry.Author.NullIfEmpty()
                , entry.Email.NullIfEmpty()
                , entry.Description.NullIfEmpty()
                , BlogId
                , entry.DateCreated
                , (int)entry.PostConfig
                , entry.EntryName.NullIfEmpty()
                , entry.DateSyndicated.NullIfEmpty()
                , CurrentDateTime);

            if(categoryIds != null)
            {
                SetEntryCategoryList(entry.Id, categoryIds);
            }

            if(entry.Id > -1)
            {
                Config.CurrentBlog.LastUpdated = entry.DateCreated;
            }

            return entry.Id;
        }

        public void CreateSetsDateCreated()
        {
            //arrange
            var blog = new Mock<Blog>();
            DateTime dateCreatedUtc = DateTime.UtcNow;
            blog.Object.Id = 1;
            var entry = new Entry(PostType.BlogPost, blog.Object) { Id = 123, BlogId = 1, CommentingClosed = false };
            var repository = new Mock<ObjectRepository>();
            repository.Setup(r => r.GetEntry(It.IsAny<int>(), true, true)).Returns(entry);
            var context = new Mock<ISubtextContext>();
            context.SetupGet(c => c.Repository).Returns(repository.Object);
            context.SetupGet(c => c.Blog).Returns(blog.Object);
            context.SetupGet(c => c.HttpContext.Items).Returns(new Hashtable());
            context.SetupGet(c => c.Cache).Returns(new TestCache());

            var service = new CommentService(context.Object, null);
            var comment = new FeedbackItem(FeedbackType.Comment) { EntryId = 123, BlogId = 1, Body = "test", Title = "title" };

            //act
            service.Create(comment, true/*runFilters*/);

            //assert
            Assert.GreaterEqualThan(comment.DateCreatedUtc, dateCreatedUtc);
            Assert.GreaterEqualThan(DateTime.UtcNow, comment.DateCreatedUtc);
        }

        public void CanUpdatePostWithCategories()
        {
            string hostname = UnitTestHelper.GenerateRandomString();
            Assert.IsTrue(Config.CreateBlog("", "username", "password", hostname, ""));
            UnitTestHelper.SetHttpContextWithBlogRequest(hostname, "");
            Config.CurrentBlog.AllowServiceAccess = true;

            string category1Name = UnitTestHelper.GenerateRandomString();
            string category2Name = UnitTestHelper.GenerateRandomString();
            UnitTestHelper.CreateCategory(Config.CurrentBlog.Id, category1Name);
            UnitTestHelper.CreateCategory(Config.CurrentBlog.Id, category2Name);

            Entry entry = new Entry(PostType.BlogPost);
            entry.Title = "Title 1";
            entry.Body = "Blah";
            entry.IsActive = true;
            entry.DateCreated = entry.DateSyndicated = entry.DateModified = DateTime.ParseExact("1975/01/23", "yyyy/MM/dd", CultureInfo.InvariantCulture);
            entry.Categories.Add(category1Name);
            int entryId = Entries.Create(entry);

            MetaWeblog api = new MetaWeblog();
            Post post = new Post();
            post.title = "Title 2";
            post.description = "Blah";
            post.categories = new string[] { category2Name };
            post.dateCreated = DateTime.Now;

            bool result = api.editPost(entryId.ToString(CultureInfo.InvariantCulture), "username", "password", post, true);

            entry = Entries.GetEntry(entryId, PostConfig.None, true);
            Assert.AreEqual(1, entry.Categories.Count, "We expected one category. We didn't get what we expected.");
            Assert.AreEqual(category2Name, entry.Categories[0], "Category has not been updated correctly.");
        }

        /// <summary>
        /// Creates the specified entry in the back end data store attaching 
        /// the specified category ids.
        /// </summary>
        /// <param name="entry">Entry.</param>
        /// <param name="categoryIds">Category I ds.</param>
        /// <returns></returns>
        public override int Create(Entry entry, int[] categoryIds)
        {
            if(!FormatEntry(entry,true))
            {
                throw new BlogFailedPostException("Failed post exception");
            }

            entry.Id = DbProvider.Instance().InsertEntry(entry);

            if(categoryIds != null)
            {
                DbProvider.Instance().SetEntryCategoryList(entry.Id, categoryIds);
            }

            if(entry.Id > -1 && Config.Settings.Tracking.UseTrackingServices)
            {
                entry.Url = Config.CurrentBlog.UrlFormats.EntryUrl(entry);
            }

            if(entry.Id > -1)
            {
                Config.CurrentBlog.LastUpdated = entry.DateCreated;
            }

            return entry.Id;
        }

        public void CreateDoesNotChangeDateCreatedAndDateModifiedIfAlreadySpecified()
        {
            //arrange
            var blog = new Mock<Blog>();
            DateTime dateCreated = DateTime.Now;
            blog.Object.Id = 1;
            blog.Setup(b => b.TimeZone.Now).Returns(dateCreated);
            var entry = new Entry(PostType.BlogPost, blog.Object) {Id = 123, BlogId = 1, CommentingClosed = false};
            var repository = new Mock<ObjectProvider>();
            repository.Setup(r => r.GetEntry(It.IsAny<int>(), true, true)).Returns(entry);
            var context = new Mock<ISubtextContext>();
            context.SetupGet(c => c.Repository).Returns(repository.Object);
            context.SetupGet(c => c.Blog).Returns(blog.Object);
            context.SetupGet(c => c.HttpContext.Items).Returns(new Hashtable());
            context.SetupGet(c => c.Cache).Returns(new TestCache());

            var service = new CommentService(context.Object, null);
            var comment = new FeedbackItem(FeedbackType.Comment)
            {
                EntryId = 123,
                BlogId = 1,
                Body = "test",
                Title = "title",
                DateCreated = dateCreated.AddDays(-2),
                DateModified = dateCreated.AddDays(-1)
            };

            //act
            service.Create(comment, true/*runFilters*/);

            //assert
            Assert.AreEqual(dateCreated.AddDays(-2), comment.DateCreated);
            Assert.AreEqual(dateCreated.AddDays(-1), comment.DateModified);
        }

        /// <summary>
        /// Posts trackbacks and pingbacks for the specified entry.
        /// </summary>
        /// <param name="entry">The entry.</param>
        public static void Run(Entry entry)
        {
            if(entry != null)
            {
                Notifier notify = new Notifier();

                notify.FullyQualifiedUrl = Config.CurrentBlog.RootUrl.ToString();
                notify.BlogName = Config.CurrentBlog.Title;

                notify.Title = entry.Title;

                notify.PostUrl = entry.FullyQualifiedUrl;

                if(entry.HasDescription)
                {
                    notify.Description = entry.Description;
                }
                else
                {
                    notify.Description = entry.Title;
                }

                notify.Text = entry.Body;

                //This could take a while, do it on another thread
                ManagedThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(notify.Notify));
            }
        }

        //Body of text to insert into a post with Trackback
        public static string TrackBackTag(Entry entry)
        {
            if (entry == null)
            {
                throw new ArgumentNullException("entry", Resources.ArgumentNull_Generic);
            }

            return String.Format(CultureInfo.InvariantCulture, Resources.TrackbackTag, entry.FullyQualifiedUrl, entry.FullyQualifiedUrl, entry.Title, Config.CurrentBlog.RootUrl, entry.Id.ToString(CultureInfo.InvariantCulture));
        }

 public EntryViewModel(Entry entry, ISubtextContext context)
 {
     if (entry == null)
     {
         throw new ArgumentNullException("entry");
     }
     Entry = entry;
     SubtextContext = context;
 }

        //Text to insert into a file with pingback service location
        public static string GetPingbackTag(BlogUrlHelper urlHelper, Entry entry)
        {
            VirtualPath blogUrl = urlHelper.BlogUrl();
            Uri absoluteUrl = blogUrl.ToFullyQualifiedUrl(entry.Blog);

            return string.Format(CultureInfo.InvariantCulture,
                "<link rel=\"pingback\" href=\"{0}Services/Pingback/{1}.aspx\"></link>",
                absoluteUrl.AbsoluteUri,
                entry.Id);
        }

        public void EntryExtensionMethodsTest_ConvertToSearchEngineEntry_WithTags_ConvertsTagsToString()
        {
            Entry post = new Entry(PostType.BlogPost)
                             {
                                 Blog = new  Blog(){ Title="MyTitle", BlogGroupId=1},
                             };
            IList<String> tags = new List<string>() {"tag1","tag2"};
            SearchEngineEntry searchEntry = post.ConvertToSearchEngineEntry(tags);

            Assert.AreEqual("tag1,tag2", searchEntry.Tags);
        }

        public void EntryExtensionMethodsTest_ConvertToSearchEngineEntry_WithOutTags_ConvertsTagsToString()
        {
            Entry post = new Entry(PostType.BlogPost)
            {
                Blog = new Blog() { Title = "MyTitle", BlogGroupId = 1 },
                Body = "<a href=\"http://blah.com/subdir/tag1/\" rel=\"tag\">tag1</a><a href=\"http://blah.com/another-dir/tag2/\" rel=\"tag\">tag2</a>"
            };
            SearchEngineEntry searchEntry = post.ConvertToSearchEngineEntry();

            Assert.AreEqual("tag1,tag2", searchEntry.Tags);
        }

        public void EntryExtensionMethodsTest_ConvertToSearchEngineEntry_StripsHtmlTags()
        {
            Entry post = new Entry(PostType.BlogPost)
            {
                Blog = new Blog() { Title = "MyTitle", BlogGroupId = 1 },
                Body = "this is <b>bold</b> text"
            };
            SearchEngineEntry searchEntry = post.ConvertToSearchEngineEntry();

            Assert.AreEqual("this is bold text", searchEntry.Body);
        }

        //Body of text to insert into a post with Trackback
        public static string TrackBackTag(Entry entry, Blog blog, BlogUrlHelper urlHelper)
        {
            if (entry == null)
            {
                throw new ArgumentNullException("entry");
            }

            Uri entryUrl = urlHelper.EntryUrl(entry).ToFullyQualifiedUrl(blog);
            return String.Format(CultureInfo.InvariantCulture, Resources.TrackbackTag, entryUrl, entryUrl, entry.Title,
                                 urlHelper.BlogUrl(), entry.Id.ToString(CultureInfo.InvariantCulture));
        }

        public void ConvertTitleToSlug_WithAllNumericTitle_PrependsLetterNToAvoidConflicts()
        {
            //arrange
            var generator = new SlugGenerator(null);
            var entry = new Entry(PostType.BlogPost) {Title = @"1234"};

            //act
            string slug = generator.GetSlugFromTitle(entry);

            //act
            Assert.AreEqual("n_1234", slug);
        }

 protected static void BindCurrentEntryControls(Entry entry, Control root)
 {
     foreach(Control control in root.Controls)
     {
         CurrentEntryControl currentEntryControl = control as CurrentEntryControl;
         if(currentEntryControl != null)
         {
             currentEntryControl.Entry = entry;
             currentEntryControl.DataBind();
         }
     }
 }

        public void CommentRssWriterProducesValidEmptyFeed()
        {
            UnitTestHelper.SetHttpContextWithBlogRequest("localhost", "blog");

            BlogInfo blogInfo = new BlogInfo();
            blogInfo.Host = "localhost";
            blogInfo.Subfolder = "blog";
            blogInfo.Email = "[email protected]";
            blogInfo.RFC3229DeltaEncodingEnabled = true;
            blogInfo.Title = "My Blog Rulz";
            blogInfo.TimeZoneId = PacificTimeZoneId;

            HttpContext.Current.Items.Add("BlogInfo-", blogInfo);

            Entry entry = new Entry(PostType.None);
            entry.AllowComments = true;
            entry.Title = "Comments requiring your approval.";
            entry.Url = "/Admin/Feedback.aspx?status=2";
            entry.Body = "The following items are waiting approval.";
            entry.PostType = PostType.None;
            ModeratedCommentRssWriter writer = new ModeratedCommentRssWriter(new List<FeedbackItem>(), entry);

            string expected = @"<rss version=""2.0"" "
                                    + @"xmlns:dc=""http://purl.org/dc/elements/1.1/"" "
                                    + @"xmlns:trackback=""http://madskills.com/public/xml/rss/module/trackback/"" "
                                    + @"xmlns:wfw=""http://wellformedweb.org/CommentAPI/"" "
                                    + @"xmlns:slash=""http://purl.org/rss/1.0/modules/slash/"" "
                                    + @"xmlns:copyright=""http://blogs.law.harvard.edu/tech/rss"" "
                                    + @"xmlns:image=""http://purl.org/rss/1.0/modules/image/"">" + Environment.NewLine
                                + indent() + @"<channel>" + Environment.NewLine
                                        + indent(2) + @"<title>Comments requiring your approval.</title>" + Environment.NewLine
                                        + indent(2) + @"<link>http://localhost/blog/Admin/Feedback.aspx?status=2</link>" + Environment.NewLine
                                        + indent(2) + @"<description>The following items are waiting approval.</description>" + Environment.NewLine
                                        + indent(2) + @"<language>en-US</language>" + Environment.NewLine
                                        + indent(2) + @"<copyright>Subtext Weblog</copyright>" + Environment.NewLine
                                        + indent(2) + @"<generator>{0}</generator>" + Environment.NewLine
                                        + indent(2) + @"<image>" + Environment.NewLine
                                            + indent(3) + @"<title>Comments requiring your approval.</title>" + Environment.NewLine
                                            + indent(3) + @"<url>http://localhost/images/RSS2Image.gif</url>" + Environment.NewLine
                                            + indent(3) + @"<link>http://localhost/blog/Admin/Feedback.aspx?status=2</link>" + Environment.NewLine
                                            + indent(3) + @"<width>77</width>" + Environment.NewLine
                                            + indent(3) + @"<height>60</height>" + Environment.NewLine
                                        + indent(2) + @"</image>" + Environment.NewLine
                                + indent(1) + @"</channel>" + Environment.NewLine
                              + @"</rss>";

            expected = string.Format(expected, VersionInfo.VersionDisplayText);

            Console.WriteLine("EXPECTED: " + expected);
            Console.WriteLine("ACTUAL  : " + writer.Xml);
            Assert.AreEqual(expected, writer.Xml);
        }