Пример #1
0
        public ActionResult Compose(string id)
        {
            DraftPost post = new DraftPost();

            if (!string.IsNullOrEmpty(id))
            {
                post = DraftComp.Load(id);
                this.Session["Post"] = post;
            }
            else
            {
                if (this.Session["Post"] == null)
                {
                    TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById(SettingsComp.GetSettings().Timezone);
                    post.Time = LocalTime.GetCurrentTime(tzi);
                    post.Type = PostType.New;
                    this.Session["Post"] = post;
                }
                else
                {
                    post = this.Session["Post"] as DraftPost;
                }
            }

            ComposePostModel model = new ComposePostModel();
            model.Title = post.Title;
            model.PublishDate = post.Time.ToString("MM/dd/yyyy", CultureInfo.InvariantCulture);
            List<string> catList = new List<string>();
            if (!string.IsNullOrEmpty(post.CatID))
            {
                string[] catIDs = post.CatID.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string catID in catIDs)
                {
                    catList.Add(catID);
                }
            }

            model.CatID = catList;
            model.Content = post.Contents;
            model.DraftID = post.DraftID;
            model.Post = post;

            this.Response.Cache.SetCacheability(HttpCacheability.NoCache);

            this.ViewData.Model = model;
            return this.View();
        }
Пример #2
0
        /// <summary>
        /// The publish.
        /// </summary>
        /// <param name="post">
        /// The post.
        /// </param>
        /// <returns>
        /// The System.Boolean.
        /// </returns>
        public static bool Publish(DraftPost post)
        {
            TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById(SettingsComp.GetSettings().Timezone);
            if (post.Time > LocalTime.GetCurrentTime(tzi))
            {
                ConfigHelper.DataContext.DraftData.AddSchedule(post.DraftID, post.Time);
                return false;
            }

            IDraftPostData postData = ConfigHelper.DataContext.DraftPostData;
            post.FileID = postData.Publish(post);

            UpdatePost(post);
            UpdateCategory(post.OldCatID, post.CatID);
            if (post.Type == PostType.New)
            {
                UpdateMonth(post.Time);
            }

            IDraftData draftData = ConfigHelper.DataContext.DraftData;
            draftData.Delete(post.DraftID);
            return true;
        }
Пример #3
0
        /// <summary>
        /// Creates a draft post
        /// Called when creating a new post
        /// </summary>
        /// <param name="title">
        /// The Title
        /// </param>
        /// <param name="author">
        /// The Author
        /// </param>
        /// <param name="time">
        /// The Time
        /// </param>
        /// <param name="catID">
        /// Category ID
        /// </param>
        /// <returns>
        /// Draft Post
        /// </returns>
        public DraftPost Create(string title, string author, DateTime time, string catID)
        {
            DraftPost post = new DraftPost();

            post.FileID = string.Empty;
            DateTime now = LocalTime.GetCurrentTime(SettingsData.TimeZoneInfo);
            post.DraftID = DraftPost.GetNewDraftID(this.GetUniqueFileID(title), now);
            post.Time = time;
            post.CatID = catID;
            post.Title = title;
            post.Author = author;
            post.Type = PostType.New;

            string xmlTime = post.Time.ToString(DataContext.DateTimeFormat, CultureInfo.InvariantCulture);

            string template = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
            template +=
                "<Post Title=\"{0}\" FileID=\"{1}\" Author=\"{2}\" Time=\"{3}\" CatID=\"{4}\" Comments=\"0\" Type=\"New\">";
            template += "<Documents></Documents>";
            template += "<Content></Content>";
            template += "<Comments></Comments></Post>";

            string xml = string.Format(template, title, post.FileID, author, xmlTime, catID);

            XElement postElem = XElement.Parse(xml);

            string path = this.GetFilePath(post.DraftID);
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            XmlWriter writer = XmlWriter.Create(path, settings);
            postElem.Save(writer);
            writer.Close();

            DraftData draft = new DraftData();
            draft.Insert(post.DraftID, title);
            return post;
        }
Пример #4
0
        /// <summary>
        /// Save draft post
        /// Called while creating / editing post
        /// </summary>
        /// <param name="post">
        /// Draft Post
        /// </param>
        public void Save(DraftPost post)
        {
            XElement root = null;
            string path = this.GetFilePath(post.DraftID);

            string template = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
            template +=
                "<Post Title=\"{0}\" FileID=\"{1}\" Author=\"{2}\" Time=\"{3}\" CatID=\"{4}\" Comments=\"{5}\" Type=\"{6}\">";
            template += "<Documents></Documents>";
            template += "<Content></Content>";
            template += "<Comments></Comments></Post>";

            template = string.Format(
                template,
                post.Title,
                post.FileID,
                post.Author,
                post.Time.ToString(DataContext.DateTimeFormat, CultureInfo.InvariantCulture),
                post.CatID,
                post.Comments.Count,
                post.Type.ToString());

            try
            {
                root = XElement.Parse(template);
            }
            catch (Exception ex)
            {
                Logger.Log(XML_FORMAT_ERROR, ex);
                throw new ApplicationException(XML_FORMAT_ERROR, ex);
            }

            XElement postElem = root;

            try
            {
                XElement docsElem = postElem.Element("Documents");

                foreach (Document document in post.Documents)
                {
                    XElement docElem = new XElement("Document", new XAttribute("Path", document.Path));
                    docsElem.Add(docElem);
                }

                // string contents2 = HttpContext.Current.Server.HtmlEncode(post.Contents);
                // postElem.Element("Content").Value = contents2;
                postElem.Element("Content").Value = post.Contents;

                XElement commentsElem = postElem.Element("Comments");
                foreach (Comment comment in post.Comments)
                {
                    XElement commentElem = new XElement(
                        "Comment",
                        new XAttribute("ID", comment.ID),
                        new XAttribute("Name", comment.Name),
                        new XAttribute("Url", comment.Url),
                        new XAttribute(
                            "Time", comment.Time.ToString(DataContext.DateTimeFormat, CultureInfo.InvariantCulture)),
                        new XAttribute("Ip", comment.Ip));

                    // commentElem.Value = HttpContext.Current.Server.HtmlEncode(comment.Text);
                    commentElem.Value = comment.Text;
                    commentsElem.Add(commentElem);
                }

                if (post.Type == PostType.Draft)
                {
                    // Save the old CatID attribute
                    postElem.SetAttributeValue("OldCatID", post.OldCatID);
                }

                if (!File.Exists(path))
                {
                    FileStream fs2 = File.Create(path);
                    fs2.Close();
                }

                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent = true;
                using (FileStream fs = File.Open(path, FileMode.Truncate, FileAccess.Write, FileShare.None))
                {
                    using (XmlWriter writer = XmlWriter.Create(fs, settings))
                    {
                        root.Save(writer);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Log(XML_FORMAT_ERROR, ex);
                throw new ApplicationException(XML_FORMAT_ERROR, ex);
            }
        }
Пример #5
0
        /// <summary>
        /// Publish the post
        /// Draft posts will merge the comments
        /// New posts will get a unique file id
        /// OldCatID, DraftType etc will be removed
        /// </summary>
        /// <param name="post">
        /// Draft Post
        /// </param>
        /// <returns>
        /// Post ID
        /// </returns>
        public string Publish(DraftPost post)
        {
            if (post.Type == PostType.Draft)
            {
                string draftPath = this.GetFilePath(post.DraftID);
                XElement root = null;
                root = XElement.Load(draftPath);
                XAttribute attr = root.Attribute("OldCatID");
                if (attr != null)
                {
                    attr.Remove();
                }

                XAttribute attr2 = root.Attribute("Type");
                if (attr2 != null)
                {
                    attr2.Remove();
                }

                // Get a copy of the post to merge comments
                PostData data = new PostData();
                Post existPost = data.Load(post.FileID);

                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent = true;
                string publishPath = this.GetFilePath(post.FileID);
                XmlWriter writer = XmlWriter.Create(publishPath, settings);
                root.Save(writer);
                writer.Close();

                // Merge comments
                Post publishPost = data.Load(post.FileID);
                publishPost.Comments = existPost.Comments;
                data.Save(publishPost);

                System.IO.File.Delete(draftPath);
            }

            if (post.Type == PostType.New)
            {
                string filePath = this.GetFilePath(post.DraftID);
                XElement root = null;
                root = XElement.Load(filePath);

                XAttribute attr2 = root.Attribute("Type");
                if (attr2 != null)
                {
                    attr2.Remove();
                }

                post.FileID = this.GetUniqueFileID(post.Title);

                root.Attribute("FileID").Value = post.FileID;

                string publishPath = this.GetFilePath(post.FileID);
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent = true;
                XmlWriter writer = XmlWriter.Create(publishPath, settings);
                root.Save(writer);
                writer.Close();
                System.IO.File.Delete(filePath);
            }

            // Newly published posts will get their file ID here.
            return post.FileID;
        }
Пример #6
0
        /// <summary>
        /// Loads draft
        /// Called when creating a post
        /// </summary>
        /// <param name="draftID">
        /// Draft ID
        /// </param>
        /// <returns>
        /// Draft Post
        /// </returns>
        public DraftPost Load(string draftID)
        {
            string path = this.GetFilePath(draftID);

            XElement root = null;
            try
            {
                root = XElement.Load(path);
            }
            catch (Exception ex)
            {
                Logger.Log(NO_FILE_ERROR, ex);
                throw new ApplicationException(NO_FILE_ERROR, ex);
            }

            XElement postElem = root;
            DraftPost post = new DraftPost();

            try
            {
                post.FileID = postElem.Attribute("FileID").Value;
                post.DraftID = draftID;
                post.Title = postElem.Attribute("Title").Value;
                post.Author = postElem.Attribute("Author").Value;
                post.CatID = postElem.Attribute("CatID").Value;
                XAttribute attr = postElem.Attribute("Type");
                if (attr != null)
                {
                    post.Type = (PostType)Enum.Parse(typeof(PostType), attr.Value, true);
                }

                // Load draft data, if we are loading a draft
                if (post.Type == PostType.Draft)
                {
                    if (postElem.Attribute("OldCatID") != null)
                    {
                        post.OldCatID = postElem.Attribute("OldCatID").Value;
                    }
                }

                try
                {
                    post.Time = DateTime.ParseExact(
                        postElem.Attribute("Time").Value, DataContext.DateTimeFormat, CultureInfo.InvariantCulture);
                }
                catch (Exception ex)
                {
                    string msg = string.Format(DATE_FORMAT_ERROR, draftID);
                    Logger.Log(msg, ex);
                    post.Time = DateTime.MinValue;
                }

                XElement docsElem = postElem.Element("Documents");
                if (docsElem != null)
                {
                    foreach (XElement docElem in docsElem.Elements("Document"))
                    {
                        Document document = new Document();
                        document.Path = docElem.Attribute("Path").Value;
                        post.Documents.Add(document);
                    }
                }

                // string contents = HttpContext.Current.Server.HtmlDecode(postElem.Element("Content").Value);
                string contents = HttpContext.Current.Server.HtmlDecode(GetInnerXml(postElem.Element("Content")));
                post.Contents = contents;

                XElement commentsElem = postElem.Element("Comments");
                if (commentsElem != null)
                {
                    foreach (XElement commentElem in commentsElem.Elements("Comment"))
                    {
                        Comment comment = new Comment();
                        comment.FileID = post.FileID;
                        comment.ID = commentElem.Attribute("ID").Value;
                        comment.Name = commentElem.Attribute("Name").Value;
                        comment.Text = HttpContext.Current.Server.HtmlDecode(GetInnerXml(commentElem));
                        comment.Url = commentElem.Attribute("Url").Value;
                        comment.Time = DateTime.ParseExact(
                            commentElem.Attribute("Time").Value,
                            DataContext.DateTimeFormat,
                            CultureInfo.InvariantCulture);
                        comment.Ip = commentElem.Attribute("Ip").Value;

                        post.Comments.Add(comment);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Log(XML_FORMAT_ERROR, ex);
                throw new ApplicationException(XML_FORMAT_ERROR, ex);
            }

            return post;
        }
Пример #7
0
 /// <summary>
 /// Creates draft post
 /// Called when editing a published post
 /// </summary>
 /// <param name="fileID">
 /// Post ID
 /// </param>
 /// <returns>
 /// Draft Post
 /// </returns>
 public DraftPost Create(string fileID)
 {
     PostData data = new PostData();
     Post post = data.Load(fileID);
     DraftPost draft = new DraftPost(post);
     DateTime now = LocalTime.GetCurrentTime(SettingsData.TimeZoneInfo);
     draft.DraftID = DraftPost.GetNewDraftID(fileID, now);
     this.Save(draft);
     DraftData data2 = new DraftData();
     data2.Insert(draft.DraftID, draft.Title);
     return draft;
 }
Пример #8
0
        /// <summary>
        /// Strange method, got to look into it
        /// </summary>
        /// <param name="model">
        /// The model
        /// </param>
        private void UpdatePost(ComposePostModel model)
        {
            DraftPost post = new DraftPost();
            if (this.Session["Post"] != null)
            {
                post = this.Session["Post"] as DraftPost;
            }

            model.Title = model.Title ?? string.Empty;
            post.Title = model.Title;
            post.CatID = string.Empty;
            if (model.CatID != null)
            {
                foreach (string catID in model.CatID)
                {
                    post.CatID += catID + ",";
                }

                post.CatID = post.CatID.Substring(0, post.CatID.Length - 1);
            }

            if (post.Type == PostType.New)
            {
                try
                {
                    if (!string.IsNullOrEmpty(model.PublishDate))
                    {
                        post.Time = DateTime.ParseExact(model.PublishDate, "MM/dd/yyyy", CultureInfo.InvariantCulture);
                        TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById(SettingsComp.GetSettings().Timezone);
                        DateTime now = LocalTime.GetCurrentTime(tzi);
                        post.Time = post.Time.AddHours(now.Hour);
                        post.Time = post.Time.AddMinutes(now.Minute);
                    }
                }
                catch
                {
                }
            }

            // To avoid exception in syntax highlighter
            post.Contents = model.Content ?? string.Empty;
            post.Author = this.User.Identity.Name;
            model.Post = post;

            this.Session["Post"] = post;
        }
Пример #9
0
        /// <summary>
        /// The save post.
        /// </summary>
        /// <param name="post">
        /// The post.
        /// </param>
        /// <returns>
        /// The LiteBlog.Common.DraftPost.
        /// </returns>
        private DraftPost SavePost(DraftPost post)
        {
            if (string.IsNullOrEmpty(post.DraftID))
            {
                if (post.Type == PostType.New)
                {
                    post.DraftID = DraftComp.Create(post.Title, post.Time, post.CatID);
                }
                else
                {
                    post.DraftID = DraftComp.Create(post.FileID);
                }
            }

            // post.Contents = post.Contents.Replace("&nbsp;", " ");
            DraftComp.Save(post);

            this.Session["Post"] = post;

            return post;
        }
Пример #10
0
 /// <summary>
 /// The update post.
 /// </summary>
 /// <param name="post">
 /// The post.
 /// </param>
 private static void UpdatePost(DraftPost post)
 {
     if (post.Type == PostType.New)
     {
         PostInfo postInfo = new PostInfo();
         postInfo.FileID = post.FileID;
         postInfo.Author = post.Author;
         postInfo.Title = post.Title;
         postInfo.CatID = post.CatID;
         postInfo.Time = post.Time;
         BlogComp.Create(postInfo);
     }
     else
     {
         BlogComp.Update(post.FileID, post.Title, post.CatID);
     }
 }
Пример #11
0
 /// <summary>
 /// The save.
 /// </summary>
 /// <param name="post">
 /// The post.
 /// </param>
 public static void Save(DraftPost post)
 {
     IDraftPostData data = ConfigHelper.DataContext.DraftPostData;
     data.Save(post);
 }
Пример #12
0
        /// <summary>
        /// The load.
        /// </summary>
        /// <param name="draftID">
        /// The draft id.
        /// </param>
        /// <returns>
        /// The LiteBlog.Common.DraftPost.
        /// </returns>
        public static DraftPost Load(string draftID)
        {
            IDraftPostData data = ConfigHelper.DataContext.DraftPostData;
            DraftPost post;
            if (DraftPost.IsDraft(draftID))
            {
                post = data.Load(draftID);
            }
            else
            {
                Post post2 = PostComp.Load(draftID);
                post = new DraftPost(post2);

                // post.GetCode();
                // post.RestoreCode();
            }

            //// for earlier versions!
            // post.GetCode();
            // post.RestoreCode();
            return post;
        }