/// <summary>
    /// Executes the pings from the new thread.
    /// </summary>
    /// <param name="item">
    /// The publishable item.
    /// </param>
    /// <param name="itemUrl">
    /// The item Url.
    /// </param>
    private static void Ping(IPublishable item, Uri itemUrl)
    {
        try
        {
            Thread.Sleep(2000);

            // Ping the specified ping services.
            PingService.Send(itemUrl);

            // Send trackbacks and pingbacks.
            if (!BlogSettings.Instance.EnableTrackBackSend && !BlogSettings.Instance.EnablePingBackSend)
            {
                return;
            }

            if (item.Content.ToUpperInvariant().Contains("\"HTTP"))
            {
                Manager.Send(item, itemUrl);
            }
        }
        catch (Exception)
        {
            // We need to catch this exception so the application doesn't get killed.
        }
    }

        /// <summary>
        /// Sends the trackback or pingback message.
        ///     <remarks>
        /// It will try to send a trackback message first, and if the refered web page
        ///         doesn't support trackbacks, a pingback is sent.
        ///     </remarks>
        /// </summary>
        /// <param name="item">
        /// The publishable item.
        /// </param>
        /// <param name="itemUrl">
        /// The item Url.
        /// </param>
        public static void Send(IPublishable item, Uri itemUrl)
        {
            foreach (var url in GetUrlsFromContent(item.Content))
            {
                var trackbackSent = false;

                if (BlogSettings.Instance.EnableTrackBackSend)
                {
                    // ignoreRemoteDownloadSettings should be set to true
                    // for backwards compatibilty with Utils.DownloadWebPage.
                    var remoteFile = new RemoteFile(url, true);
                    var pageContent = remoteFile.GetFileAsString(); // ReadFromWeb(url);
                    var trackbackUrl = GetTrackBackUrlFromPage(pageContent);

                    if (trackbackUrl != null)
                    {
                        var message = new TrackbackMessage(item, trackbackUrl, itemUrl);
                        trackbackSent = Trackback.Send(message);
                    }
                }

                if (!trackbackSent && BlogSettings.Instance.EnablePingBackSend)
                {
                    Pingback.Send(itemUrl, url);
                }
            }
        }

        public static void Send(IPublishable item, Uri itemUrl)
        {
            foreach (var url in GetUrlsFromContent(item.Content))
            {
                var trackbackSent = false;

                if (BlogSettings.Instance.EnableTrackBackSend)
                {
                    var remoteFile = new RemoteFile(url, true);
                    var pageContent = remoteFile.GetFileAsString();
                    var trackbackUrl = GetTrackBackUrlFromPage(pageContent);

                    if (trackbackUrl != null)
                    {
                        var message = new TrackbackMessage(item, trackbackUrl, itemUrl);
                        trackbackSent = Trackback.Send(message);
                    }
                }

                if (!trackbackSent && BlogSettings.Instance.EnablePingBackSend)
                {
                    Pingback.Send(itemUrl, url);
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TrackbackMessage"/> class.
        /// </summary>
        /// <param name="item">
        /// The publishable item.
        /// </param>
        /// <param name="urlToNotifyTrackback">
        /// The URL to notify trackback.
        /// </param>
        /// <param name="itemUrl">
        /// The item Url.
        /// </param>
        public TrackbackMessage(IPublishable item, Uri urlToNotifyTrackback, Uri itemUrl)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            this.Title = item.Title;
            this.PostUrl = itemUrl;
            this.Excerpt = item.Title;
            this.BlogName = GetBlogName();
            this.UrlToNotifyTrackback = urlToNotifyTrackback;
        }

        public void InstanceSend(IPublishable item, Uri itemUrl = null)
        {
            foreach (var url in GetUrlsFromContent(item.Content))
            {
                var trackbackSent = false;

                if (IsTrackbackSendEnabled())
                {
                    var trackbackUrl = GetTrackbackUrl(url);

                    if (trackbackUrl != null)
                    {
                        var message = GetTrackbackMessage(item, itemUrl, trackbackUrl);
                        trackbackSent = GetTrackbackSent(message);
                    }
                }

                if (!trackbackSent && IsPingbackEnabled())
                {
                    SendPingback(itemUrl, url);
                }
            }
        }

        /// <summary>
        /// Sends the trackback or pingback message.
        /// <remarks>
        /// It will try to send a trackback message first, and if the refered web page
        /// doesn't support trackbacks, a pingback is sent.
        /// </remarks>
        /// </summary>
        public static void Send(IPublishable item, Uri itemUrl)
        {
            foreach (Uri url in GetUrlsFromContent(item.Content))
            {
                bool isTrackbackSent = false;

                if (BlogSettings.Instance.EnableTrackBackSend)
                {
                    string pageContent = Utils.DownloadWebPage(url);// ReadFromWeb(url);
                    Uri trackbackUrl = GetTrackBackUrlFromPage(pageContent);

                    if (trackbackUrl != null)
                    {
                        TrackbackMessage message = new TrackbackMessage(item, trackbackUrl, itemUrl);
                        isTrackbackSent = Trackback.Send(message);
                    }
                }

                if (!isTrackbackSent && BlogSettings.Instance.EnablePingBackSend)
                {
                    Pingback.Send(itemUrl, url);
                }
            }
        }

 /// <summary>
 /// Send emails to newsletter subscribers
 /// </summary>
 public static void SendEmails(IPublishable publishable)
 {
     var emails = LoadEmails();
     if (emails != null && emails.Count > 0)
     {
         foreach (var email in emails)
         {
             if (!Utils.StringIsNullOrWhitespace(email) && Utils.IsEmailValid(email))
             {
                 MailMessage message = CreateEmail(publishable);
                 message.To.Add(email);
                 try
                 {
                     Utils.SendMailMessage(message);
                     //Utils.Log("sent to " + email + " on - " + publishable.Title);
                 }
                 catch (Exception ex)
                 {
                     Utils.Log("Custom.Widgets.Newsletter.SendEmails", ex);
                 }
             }
         }
     }
 }

 /// <summary>
 /// Creates the email.
 /// </summary>
 /// <param name="publishable">
 /// The publishable to mail.
 /// </param>
 /// <returns>
 /// The email.
 /// </returns>
 private static MailMessage CreateEmail(IPublishable publishable)
 {
     var mail = new MailMessage
         {
             Subject = publishable.Title,
             Body = FormatBodyMail(publishable),
             From = new MailAddress(BlogSettings.Instance.Email, BlogSettings.Instance.Name)
         };
     return mail;
 }

 /// <summary>
 /// A converter delegate used for converting Results to Posts.
 /// </summary>
 /// <param name="item">
 /// The publishable item.
 /// </param>
 /// <returns>
 /// Converts to publishable interface.
 /// </returns>
 private static IPublishable ConvertToIPublishable(IPublishable item)
 {
     return item;
 }

        string GetDescription(IPublishable post)
        {
            var description = Utils.StripHtml(post.Description);
            if (description != null && description.Length > this.DescriptionMaxLength)
            {
                description = string.Format("{0}...", description.Substring(0, this.DescriptionMaxLength));
            }

            if (String.IsNullOrEmpty(description))
            {
                var content = Utils.StripHtml(post.Content);
                description = content.Length > this.DescriptionMaxLength
                    ? string.Format("{0}...", content.Substring(0, this.DescriptionMaxLength))
                    : content;
            }
            return description;
        }

        /// <summary>
        /// Creates a <see cref="Uri"/> that represents the peramlink for the supplied <see cref="IPublishable"/>.
        /// </summary>
        /// <param name="publishable">The <see cref="IPublishable"/> used to generate the permalink for.</param>
        /// <returns>A <see cref="Uri"/> that represents the peramlink for the supplied <see cref="IPublishable"/>.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="publishable"/> is a null reference (Nothing in Visual Basic).</exception>
        private static Uri GetPermaLink(IPublishable publishable)
        {
            Training post = publishable as Training;
            if (post != null)
            {
                return post.PermaLink;
            }

            return publishable.AbsoluteLink;
        }

        /// <summary>
        /// Writes the Atom feed entry element information to the specified <see cref="XmlWriter"/> using the supplied <see cref="Page"/>.
        /// </summary>
        /// <param name="writer">
        /// The <see cref="XmlWriter"/> to write feed entry element information to.
        /// </param>
        /// <param name="publishable">
        /// The <see cref="IPublishable"/> used to generate feed entry content.
        /// </param>
        private static void WriteAtomEntry(XmlWriter writer, IPublishable publishable)
        {
            var post = publishable as Post;

            // var comment = publishable as Comment;

            // ------------------------------------------------------------
            // Raise serving event
            // ------------------------------------------------------------
            var arg = new ServingEventArgs(publishable.Content, ServingLocation.Feed);
            publishable.OnServing(arg);
            if (arg.Cancel)
            {
                return;
            }

            // ------------------------------------------------------------
            // Modify publishable content to make references absolute
            // ------------------------------------------------------------
            var content = Utils.ConvertPublishablePathsToAbsolute(arg.Body, publishable);

            writer.WriteStartElement("entry");

            // ------------------------------------------------------------
            // Write required entry elements
            // ------------------------------------------------------------
            writer.WriteElementString("id", publishable.AbsoluteLink.ToString());
            writer.WriteElementString("title", publishable.Title);
            writer.WriteElementString("updated", ToW3CDateTime(publishable.DateCreated.ToUniversalTime()));

            // ------------------------------------------------------------
            // Write recommended entry elements
            // ------------------------------------------------------------
            writer.WriteStartElement("link");
            writer.WriteAttributeString("rel", "self");
            writer.WriteAttributeString("href", GetPermaLink(publishable).ToString());
            writer.WriteEndElement();

            writer.WriteStartElement("link");
            writer.WriteAttributeString("href", publishable.AbsoluteLink.ToString());
            writer.WriteEndElement();

            writer.WriteStartElement("author");
            writer.WriteElementString("name", publishable.Author);
            writer.WriteEndElement();

            writer.WriteStartElement("summary");
            writer.WriteAttributeString("type", "html");
            writer.WriteString(content);
            writer.WriteEndElement();

            // ------------------------------------------------------------
            // Write optional entry elements
            // ------------------------------------------------------------
            writer.WriteElementString("published", ToW3CDateTime(publishable.DateCreated.ToUniversalTime()));

            writer.WriteStartElement("link");
            writer.WriteAttributeString("rel", "related");
            writer.WriteAttributeString("href", String.Concat(publishable.AbsoluteLink.ToString(),
                BlogSettings.Instance.ModerationType == BlogSettings.Moderation.Disqus ? "#disqus_thread" : "#comment"));
            writer.WriteEndElement();

            // ------------------------------------------------------------
            // Write enclosure tag for podcasting support
            // ------------------------------------------------------------
            if (BlogSettings.Instance.EnableEnclosures)
            {
                var encloser = GetEnclosure(content, publishable);
                if (!string.IsNullOrEmpty(encloser))
                {
                    writer.WriteRaw(encloser);
                }
            }

            // ------------------------------------------------------------
            // Write entry category elements
            // ------------------------------------------------------------
            if (publishable.Categories != null)
            {
                foreach (var category in publishable.Categories)
                {
                    writer.WriteStartElement("category");
                    writer.WriteAttributeString("term", category.Title);
                    writer.WriteEndElement();
                }
            }

            // ------------------------------------------------------------
            // Write Dublin Core syndication extension elements
            // ------------------------------------------------------------
            if (!String.IsNullOrEmpty(publishable.Author))
//.........这里部分代码省略.........

 /// <summary>
 /// Creates a <see cref="Uri"/> that represents the peramlink for the supplied <see cref="IPublishable"/>.
 /// </summary>
 /// <param name="publishable">
 /// The <see cref="IPublishable"/> used to generate the permalink for.
 /// </param>
 /// <returns>
 /// A <see cref="Uri"/> that represents the peramlink for the supplied <see cref="IPublishable"/>.
 /// </returns>
 /// <exception cref="ArgumentNullException">
 /// The <paramref name="publishable"/> is a null reference (Nothing in Visual Basic).
 /// </exception>
 private static Uri GetPermaLink(IPublishable publishable)
 {
     var post = publishable as Post;
     return post != null ? post.PermaLink : publishable.AbsoluteLink;
 }

        /// <summary>
        /// Gets enclosure for supported media type
        /// </summary>
        /// <param name="content">The content.</param>
        /// <param name="publishable">The publishable instance.</param>
        /// <returns>The enclosure.</returns>
        private static string GetEnclosure(string content, IPublishable publishable)
        {
            var enclosure = string.Empty;
            fileSize = 0;
            fileExists = false;

            foreach (var media in SupportedMedia)
            {
                enclosure = GetMediaEnclosure(publishable, content, media.Key, media.Value);
                if (enclosure.Length > 0)
                {
                    break;
                }
            }

            return enclosure;
        }

 protected virtual TrackbackMessage GetTrackbackMessage(IPublishable item, Uri itemUrl, Uri trackbackUrl)
 {
     return new TrackbackMessage(item, trackbackUrl, itemUrl);
 }

        private void UpdateFields(IPublishable parent, DbConnection conn, DbProviderFactory provider)
        {
            string table = "CurriculaField";
            string key = "CurriculaID";
            if (parent is Training)
            {

                table = "TrainingField";
                key = "TrainingID";
            }
            string sqlQuery = "DELETE FROM " + tablePrefix + table + " WHERE " + key + " = " + parmPrefix + "id";
            using (DbCommand cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                DbParameter dpID = provider.CreateParameter();
                dpID.ParameterName = parmPrefix + "id";
                dpID.Value = parent.Id.ToString();
                cmd.Parameters.Add(dpID);
                cmd.ExecuteNonQuery();

                foreach (Field fld in parent.Fields)
                {
                    cmd.CommandText = "INSERT INTO " + tablePrefix + table + " (" + key + ", FieldID) " +
                        "VALUES (" + parmPrefix + "id, " + parmPrefix + "fld)";
                    cmd.Parameters.Clear();
                    DbParameter dpPostID = provider.CreateParameter();
                    dpPostID.ParameterName = parmPrefix + "id";
                    dpPostID.Value = parent.Id.ToString();
                    cmd.Parameters.Add(dpPostID);
                    DbParameter dpfld = provider.CreateParameter();
                    dpfld.ParameterName = parmPrefix + "fld";
                    dpfld.Value = fld.Id.ToString();
                    cmd.Parameters.Add(dpfld);

                    cmd.ExecuteNonQuery();
                }
            }
        }

 /// <summary>
 /// Sends the trackback or pingback message.
 ///     <remarks>
 /// It will try to send a trackback message first, and if the refered web page
 ///         doesn't support trackbacks, a pingback is sent.
 ///     </remarks>
 /// </summary>
 /// <param name="item">
 /// The publishable item.
 /// </param>
 /// <param name="itemUrl">
 /// The item Url.
 /// </param>
 public static void Send(IPublishable item, Uri itemUrl)
 {
     new Manager().InstanceSend(item, itemUrl);
 }

        /// <summary>
        /// Adds the categories.
        /// </summary>
        /// <param name="categories">
        /// The categories.
        /// </param>
        /// <param name="post">
        /// The post to add to.
        /// </param>
        private static void AddCategories(IEnumerable<string> categories, IPublishable post)
        {
            try
            {
                foreach (var category in categories)
                {
                    var added = false;
                    var category1 = category;
                    foreach (var cat in
                        Category.Categories.Where(
                            cat => cat.Title.Equals(category1, StringComparison.OrdinalIgnoreCase)))
                    {
                        post.Categories.Add(cat);
                        added = true;
                    }

                    if (added)
                    {
                        continue;
                    }

                    var newCat = new Category(category, string.Empty);
                    newCat.Save();
                    post.Categories.Add(newCat);
                }
            }
            catch (Exception ex)
            {
                Utils.Log("BlogImporter.AddCategories(): " + ex.Message);
            }
        }

        /// <summary>
        /// Creates a <see cref="Uri"/> that represents the peramlink for the supplied <see cref="IPublishable"/>.
        /// </summary>
        /// <param name="publishable">The <see cref="IPublishable"/> used to generate the permalink for.</param>
        /// <returns>A <see cref="Uri"/> that represents the peramlink for the supplied <see cref="IPublishable"/>.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="publishable"/> is a null reference (Nothing in Visual Basic).</exception>
        private static Uri GetPermaLink(IPublishable publishable)
        {
            Post post = publishable as Post;
            if (post != null)
            {
                return post.PermaLink;
            }

            return publishable.AbsoluteLink;
        }

        private static MailMessage CreateEmail(IPublishable publishable)
        {
            var subject = publishable.Title;
            //var settings = GetSettings();

            //if (settings["subjectPrefix"] != null)
            //    subject = settings["subjectPrefix"] + subject;

            var mail = new MailMessage
            {
                Subject = subject,
                Body = FormatBodyMail(publishable),
                From = new MailAddress(BlogSettings.Instance.Email, BlogSettings.Instance.Name)
            };
            return mail;
        }