示例#1
0
        /**
         * Import Comments
         *
         * Comments aren't as involved as Posts, so the loop to import can be self-contained. This function
         * imports the comments associated with the given post.
         *
         * The Wordpress export doesn't distinguish between spam comments and comments that simply haven't yet
         * been approved, so we can't explicitly mark them as spam in Kentico. We can, though, retain Wordpress'
         * behavior and just not approve them, thus retaining the same look on the Kentico blog as we had in WP.
         *
         * Wordpress also tracks ping/trackbacks differently than Kentico. Kentico just keeps a simple boolean value
         * for "IsTrackBack" and doesn't appear to distinguish between trackback and pingback, while Wordpress uses a
         * string value with null, Comment, Pingback, and Trackback as potential values
         *
         * @param entity context
         * @param CMS_Document postDoc
         */
        protected static void ImportComments(kenticofreeEntities context, CMS_Document postDoc)
        {
            // Get the comments from the XML
            var comments = (from c in wpxml.Descendants("item").Where(x => x.Element(wpns + "post_id").Value == postDoc.DocumentForeignKeyValue.ToString()).Descendants(wpns + "comment")
                            select new Blog_Comment {
                CommentID = Int32.Parse(c.Element(wpns + "comment_id").Value),
                CommentUserName = c.Element(wpns + "comment_author").Value,
                CommentEmail = c.Element(wpns + "comment_author_email").Value,
                CommentUrl = c.Element(wpns + "comment_author_url").Value,
                CommentApproved = (c.Element(wpns + "comment_approved").Value != "0"),                                                 // Convert "0"/"1" to false/true
                CommentDate = DateTime.Parse(c.Element(wpns + "comment_date").Value),
                CommentText = c.Element(wpns + "comment_content").Value,
                CommentIsTrackBack = (!String.IsNullOrEmpty(c.Element(wpns + "comment_type").Value) && c.Element(wpns + "comment_type").Value != "Comment"),                                                 // if comment_type has a value (not NullOrEmpty), AND that value is not "Comment", then it's a ping/trackback; otherwise it's just a comment
                CommentPostDocumentID = postDoc.DocumentID
            }
                            );

            // Insert them into the database
            foreach (Blog_Comment comment in comments)
            {
                context.Blog_Comment.AddObject(comment);
            }

            context.SaveChanges();
        }
示例#2
0
        /**
         * Link categories and tags to a post.
         *
         * This is combined into one function, because the Wordpress XML uses the same "category" tag
         * for both categories and tags for a post, and just uses the "domain" attribute to distinguish
         * between them.
         *
         * @param entity context
         * @param CMS_Document postDoc
         * @param CONTENT_BlogPost post
         */
        protected static void LinkCategoriesAndTags(kenticofreeEntities context, CMS_Document postDoc, CONTENT_BlogPost post)
        {
            var xml = (from c in wpxml.Descendants("item")
                       where Int32.Parse(c.Element(wpns + "post_id").Value) == post.BlogPostID
                       select c
                       ).Single();
            var categories = (from c in xml.Descendants("category")
                              select new {
                Domain = c.Attribute("domain").Value,
                Nicename = c.Attribute("nicename").Value
            }
                              );

            foreach (var cat in categories)
            {
                if (cat.Domain == "post_tag")
                {
                    CMS_TagGroup tg  = GetTagGroup(context);
                    CMS_Tag      tag = (from t in context.CMS_Tag
                                        where t.TagName == cat.Nicename && t.TagGroupID == tg.TagGroupID
                                        select t
                                        ).SingleOrDefault();
                    postDoc.CMS_Tag.Add(tag);
                    if (String.IsNullOrEmpty(postDoc.DocumentTags))
                    {
                        postDoc.DocumentTags = tag.TagName;
                    }
                    else
                    {
                        postDoc.DocumentTags = postDoc.DocumentTags + ", " + tag.TagName;
                    }
                    tag.TagCount++;
                }
                else if (cat.Domain == "category")
                {
                    CMS_Category category = (from c in context.CMS_Category
                                             where c.CategoryName == cat.Nicename
                                             select c
                                             ).SingleOrDefault();
                    postDoc.CMS_Category.Add(category);
                    category.CategoryCount++;
                }
            }
            context.SaveChanges();
        }
示例#3
0
        /**
         * Add a document based on the given treeNode and related item
         *
         * @param entity context
         * @param CMS_Tree treeNode
         * @param int itemId
         * @param bool hasTags
         * @return CMS_Document
         */
        protected static CMS_Document AddDocument(kenticofreeEntities context, CMS_Tree treeNode, int itemId, int tagGroupId = 0)
        {
            // Create the document and add it into the database
            CMS_Document doc = new CMS_Document()
            {
                DocumentName                     = treeNode.NodeName,
                DocumentNamePath                 = treeNode.NodeAliasPath,
                DocumentForeignKeyValue          = itemId,
                DocumentCulture                  = "en-US",
                DocumentShowInSiteMap            = true,
                DocumentMenuItemHideInNavigation = false,
                DocumentUseNamePathForUrlPath    = false,
                DocumentStylesheetID             = -1,
                DocumentNodeID                   = treeNode.NodeID,
                DocumentGUID                     = Guid.NewGuid(),
                DocumentWorkflowCycleGUID        = Guid.NewGuid(),
                DocumentCreatedByUserID          = treeNode.NodeOwner,
                DocumentCreatedWhen              = DateTime.Now,
                DocumentModifiedWhen             = DateTime.Now,
                DocumentModifiedByUserID         = treeNode.NodeOwner,
                DocumentUrlPath                  = "",
                DocumentContent                  = "",
                DocumentIsArchived               = false
            };

            // Include the TagGroupID that the documents belong to. Used largely for blog entries.
            if (tagGroupId > 0)
            {
                doc.DocumentTagGroupID = tagGroupId;
            }

            context.CMS_Document.AddObject(doc);
            context.SaveChanges();

            return(doc);
        }
示例#4
0
        /**
         * Import Post
         *
         * Imports a given post into the database, creating the necessary dependencies,
         * including BlogMonth (if it doesn't already exist), TreeNode, and Document.
         * Returns the newly-created document that represents the post.
         *
         * @param entities context
         * @param CMS_Tree blog
         * @param CONTENT_BlogPost post
         * @return CMS_Document
         */
        protected static CMS_Document ImportPost(kenticofreeEntities context, CMS_Tree blog, CONTENT_BlogPost post)
        {
            Regex forbidden         = new Regex(forbiddenChars);
            Regex consolidateDashes = new Regex("[-]{2}");

            /* We want to preserve the IDs of the Posts for linking, but EF won't let us turn on IDENTITY_INSERT
             * with its available methods (ExecuteStoreCommand and SaveChanges are different connections, it seems).
             * So we have to do it the old fashioned way.
             */
            object[] values = new object[] {
                post.BlogPostID.ToString(),
                     post.BlogPostTitle,
                     post.BlogPostDate.Date.ToString("yyyy-MM-dd HH:mm:ss"),
                post.BlogPostSummary,
                post.BlogPostAllowComments,
                post.BlogPostBody,
                post.BlogLogActivity
            };

            /* We'll use MERGE here, so that we can handle existing entries.
             * The "xmlTrumpsDb" config switch will allow a choice between nuking what's in the DB
             * or preserving it.
             */
            string cmd = "SET IDENTITY_INSERT CONTENT_BlogPost ON; ";

            cmd += "MERGE CONTENT_BlogPost ";
            cmd += "USING (VALUES ({0},{1},{2},{3},{4},{5},{6})) as temp(BlogPostID, BlogPostTitle, BlogPostDate, BlogPostSummary, BlogPostAllowComments, BlogPostBody, BlogLogActivity) ";
            cmd += "ON CONTENT_BlogPost.BlogPostID = temp.BlogPostID ";
            // To nuke or not to nuke, that is the question...
            if (config.Get("xmlTrumpsDb") == "true")
            {
                cmd += "WHEN MATCHED THEN ";
                cmd += "UPDATE SET CONTENT_BlogPost.BlogPostTitle = temp.BlogPostTitle, CONTENT_BlogPost.BlogPostDate = temp.BlogPostDate, CONTENT_BlogPost.BlogPostSummary = temp.BlogPostSummary, CONTENT_BlogPost.BlogPostAllowComments = temp.BlogPostAllowComments, CONTENT_BlogPost.BlogPostBody = temp.BlogPostBody, CONTENT_BlogPost.BlogLogActivity = temp.BlogLogActivity ";
            }
            cmd += "WHEN NOT MATCHED THEN ";
            cmd += "INSERT (BlogPostId, BlogPostTitle, BlogPostDate, BlogPostSummary, BlogPostAllowComments, BlogPostBody, BlogLogActivity) VALUES ({0},{1},{2},{3},{4},{5},{6}); ";
            cmd += "SET IDENTITY_INSERT CONTENT_BlogPost OFF;";
            context.ExecuteStoreCommand(cmd, values);

            // See if there's a BlogMonth entry for the month this post is for
            CMS_Tree month = GetBlogMonth(context, post, blog);

            CMS_Class blogClass = context.CMS_Class.Where(x => x.ClassName == "CMS.BlogPost").First();

            CMS_Tree treeNode = (from t in context.CMS_Tree
                                 join d in context.CMS_Document on t.NodeID equals d.DocumentNodeID
                                 where d.DocumentForeignKeyValue == post.BlogPostID && t.NodeClassID == 3423
                                 select t).FirstOrDefault();

            // Add a new node only if one doesn't already exist
            if (treeNode == null)
            {
                string nodeAlias = consolidateDashes.Replace(forbidden.Replace(post.BlogPostTitle, "-"), "-");
                nodeAlias = (nodeAlias.Length > 50 ? nodeAlias.Substring(0, 50) : nodeAlias);                 // Truncate the alias to avoid SQL Server errors

                // Create the Tree Node for the post and add it in
                treeNode = new CMS_Tree()
                {
                    NodeAliasPath              = string.Format("{0}/{1}", month.NodeAliasPath, forbidden.Replace(post.BlogPostTitle, "-")),
                    NodeName                   = post.BlogPostTitle,
                    NodeAlias                  = nodeAlias,
                    NodeClassID                = blogClass.ClassID,
                    NodeParentID               = month.NodeID,
                    NodeLevel                  = Int32.Parse(config.Get("kenticoBlogLevel")) + 2,
                    NodeACLID                  = 1,    // Default ACL ID
                    NodeSiteID                 = siteId,
                    NodeGUID                   = Guid.NewGuid(),
                    NodeInheritPageLevels      = "",
                    NodeTemplateForAllCultures = true,
                    NodeChildNodesCount        = 0
                };

                CMS_User author = GetAuthor(context, post);
                treeNode.NodeOwner = author.UserID;

                context.CMS_Tree.AddObject(treeNode);
                treeNode.NodeOrder = GetNodeOrder(context, treeNode);
                month.NodeChildNodesCount++;                // Increment the child nodes count, so the new post will display in the CMS
                blog.NodeChildNodesCount++;                 // Increment the blog's child nodes count, too.
                context.SaveChanges();
            }

            CMS_TagGroup tagGroup = GetTagGroup(context);

            // Create the document and add it into the database
            CMS_Document postDoc = AddDocument(context, treeNode, post.BlogPostID, tagGroup.TagGroupID);

            return(postDoc);
        }
示例#5
0
        /**
         * The main function for importing the posts.
         *
         * @param entity context
         */
        protected static void ProcessPosts(kenticofreeEntities context)
        {
            Console.WriteLine("Adding posts to database.");
            // Gather list of Posts and make them each Entities
            var posts = (from i in wpxml.Descendants("item")
                         where i.Element(wpns + "post_type").Value == "post" && i.Element(wpns + "status").Value == "publish"
                         select new CONTENT_BlogPost {
                BlogPostID = Int32.Parse(i.Element(wpns + "post_id").Value),
                BlogPostTitle = i.Element("title").Value,
                BlogPostDate = DateTime.Parse(i.Element(wpns + "post_date").Value),
                BlogPostSummary = (String.IsNullOrEmpty(i.Element("description").Value) ? i.Element("title").Value : i.Element("description").Value),
                BlogPostAllowComments = true,
                BlogPostBody = i.Element(encoded + "encoded").Value.Replace("\n", "<br/>"),                                                 // CDATA element
                BlogLogActivity = true
            });

            // Get the blog by the ID set in the settings
            CMS_Tree blog = (from b in context.CONTENT_Blog
                             join d in context.CMS_Document on b.BlogID equals d.DocumentForeignKeyValue
                             join t in context.CMS_Tree on d.DocumentNodeID equals t.NodeID
                             where b.BlogID == blogId && t.NodeClassID == 3423                                    //Blog class ID, otherwise we end up with a bunch of stuff that aren't blogs
                             select t).FirstOrDefault();

            if (blog == null)
            {
                Console.WriteLine("No blog with the ID of " + blogId + " detected. Adding new blog.");
                CONTENT_Blog b = new CONTENT_Blog()
                {
                    BlogName             = "BlogImport",
                    BlogDescription      = "The Imported Blog",
                    BlogOpenCommentsFor  = "-1",
                    BlogEnableTrackbacks = true
                };

                CMS_Class blogClass = context.CMS_Class.Where(x => x.ClassName == "CMS.BlogPost").First();
                CMS_Tree  root      = context.CMS_Tree.Where(x => x.NodeClassID == 1095).Where(x => x.NodeSiteID == siteId).First();

                blog = new CMS_Tree()
                {
                    NodeAliasPath              = "/" + b.BlogName,
                    NodeName                   = b.BlogName,
                    NodeAlias                  = b.BlogName,
                    NodeClassID                = blogClass.ClassID,
                    NodeLevel                  = Int32.Parse(config.Get("kenticoBlogLevel")),
                    NodeACLID                  = 1,    // Default ACL ID
                    NodeSiteID                 = siteId,
                    NodeOwner                  = nodeOwnerId,
                    NodeOrder                  = 100,
                    NodeGUID                   = Guid.NewGuid(),
                    NodeInheritPageLevels      = "",
                    NodeTemplateForAllCultures = true,
                    NodeChildNodesCount        = 0,
                    NodeParentID               = (root != null ? root.NodeID : 0)
                };

                context.CONTENT_Blog.AddObject(b);
                context.CMS_Tree.AddObject(blog);
                context.SaveChanges();

                AddDocument(context, blog, b.BlogID);
            }

            Console.WriteLine("Connecting categories, tags, and comments to posts. This may take a while.");
            foreach (CONTENT_BlogPost post in posts)
            {
                CMS_Document postDoc = ImportPost(context, blog, post);
                LinkCategoriesAndTags(context, postDoc, post);
                ImportComments(context, postDoc);
            }

            OrderPosts(context, blog);
        }