public void Export(
string fileName,
int blogRootNode)
{
var root = _applicationContext.Services.ContentService.GetById(blogRootNode);
if (root == null)
{
throw new InvalidOperationException("No node found with id " + blogRootNode);
}
if (!root.ContentType.Alias.InvariantEquals("Articulate"))
{
throw new InvalidOperationException("The node with id " + blogRootNode + " is not an Articulate root node");
}
var postType = _applicationContext.Services.ContentTypeService.GetContentType("ArticulateRichText");
if (postType == null)
{
throw new InvalidOperationException("Articulate is not installed properly, the ArticulateRichText doc type could not be found");
}
var children = root.Children().ToArray();
var archiveNode = children.FirstOrDefault(x => x.ContentType.Alias.InvariantEquals("ArticulateArchive"));
var authorsNode = children.FirstOrDefault(x => x.ContentType.Alias.InvariantEquals("ArticulateAuthors"));
if (archiveNode == null)
{
throw new InvalidOperationException("No ArticulateArchive found under the blog root node");
}
if (authorsNode == null)
{
throw new InvalidOperationException("No ArticulateAuthors found under the blog root node");
}
var categoryDataType = _applicationContext.Services.DataTypeService.GetDataTypeDefinitionByName("Articulate Categories");
if (categoryDataType == null)
{
throw new InvalidOperationException("No Articulate Categories data type found");
}
var categoryDtPreVals = _applicationContext.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(categoryDataType.Id);
if (categoryDtPreVals == null)
{
throw new InvalidOperationException("No pre values for Articulate Categories data type found");
}
var tagGroup = categoryDtPreVals.PreValuesAsDictionary["group"];
//TODO: See: http://argotic.codeplex.com/wikipage?title=Generating%20portable%20web%20log%20content&referringTitle=Home
var blogMlDoc = new BlogMLDocument();
blogMlDoc.RootUrl = new Uri(_umbracoContext.UrlProvider.GetUrl(root.Id), UriKind.RelativeOrAbsolute);
blogMlDoc.GeneratedOn = DateTime.Now;
blogMlDoc.Title = new BlogMLTextConstruct(root.GetValue<string>("blogTitle"));
blogMlDoc.Subtitle = new BlogMLTextConstruct(root.GetValue<string>("blogDescription"));
AddBlogAuthors(authorsNode, blogMlDoc);
AddBlogCategories(blogMlDoc, tagGroup.Value);
AddBlogPosts(archiveNode, blogMlDoc, tagGroup.Value);
WriteFile(blogMlDoc);
}
public async Task Import(
int userId,
string fileName,
int blogRootNode,
bool overwrite,
string regexMatch,
string regexReplace,
bool publishAll,
bool exportDisqusXml = false)
{
try
{
if (!File.Exists(fileName))
{
throw new FileNotFoundException("File not found: " + fileName);
}
var root = _applicationContext.Services.ContentService.GetById(blogRootNode);
if (root == null)
{
throw new InvalidOperationException("No node found with id " + blogRootNode);
}
if (!root.ContentType.Alias.InvariantEquals("Articulate"))
{
throw new InvalidOperationException("The node with id " + blogRootNode + " is not an Articulate root node");
}
using (var stream = File.OpenRead(fileName))
{
var document = new BlogMLDocument();
document.Load(stream);
stream.Position = 0;
var xdoc = XDocument.Load(stream);
var authorIdsToName = ImportAuthors(userId, root, document.Authors);
var imported = await ImportPosts(userId, xdoc, root, document.Posts, document.Authors.ToArray(), document.Categories.ToArray(), authorIdsToName, overwrite, regexMatch, regexReplace, publishAll);
if (exportDisqusXml)
{
var exporter = new DisqusXmlExporter();
var xDoc = exporter.Export(imported, document);
using (var memStream = new MemoryStream())
{
xDoc.Save(memStream);
_fileSystem.AddFile("DisqusXmlExport.xml", memStream, true);
}
}
}
}
catch (Exception ex)
{
HasErrors = true;
LogHelper.Error<BlogMlImporter>("Importing failed with errors", ex);
}
}
private BlogMLDocument GetDocument(string fileName)
{
if (!File.Exists(fileName))
{
throw new FileNotFoundException("File not found: " + fileName);
}
using (var stream = File.OpenRead(fileName))
{
var document = new BlogMLDocument();
document.Load(stream);
return document;
}
}
public XDocument Export(IEnumerable<IContent> posts, BlogMLDocument document)
{
var nsContent = XNamespace.Get("http://purl.org/rss/1.0/modules/content/");
var nsDsq = XNamespace.Get("http://www.disqus.com/");
var nsDc = XNamespace.Get("http://purl.org/dc/elements/1.1/");
var nsWp = XNamespace.Get("http://wordpress.org/export/1.0/");
var xChannel = new XElement("channel");
var xDoc = new XDocument(
new XElement("rss",
new XAttribute("version", "2.0"),
new XAttribute(XNamespace.Xmlns + "content", nsContent),
new XAttribute(XNamespace.Xmlns + "dsq", nsDsq),
new XAttribute(XNamespace.Xmlns + "dc", nsDc),
new XAttribute(XNamespace.Xmlns + "wp", nsWp),
xChannel));
var umbHelper = new UmbracoHelper(UmbracoContext.Current);
var markDown = new MarkdownDeep.Markdown();
foreach (var post in posts)
{
var blogMlPost = document.Posts.FirstOrDefault(x => x.Title.Content == post.Name);
//TODO: Add logging here if we cant find it
if (blogMlPost == null) continue;
//no comments to import
if (blogMlPost.Comments.Any() == false) continue;
var body = post.GetValue<string>("richText");
if (body.IsNullOrWhiteSpace())
{
body = markDown.Transform(post.GetValue<string>("markdown"));
}
var xItem = new XElement("item",
new XElement("title", post.Name),
new XElement("link", umbHelper.NiceUrlWithDomain(post.Id)),
new XElement(nsContent + "encoded", new XCData(body)),
new XElement(nsDsq + "thread_identifier", post.Key.ToString()),
new XElement(nsWp + "post_date_gmt", post.GetValue<DateTime>("publishedDate").ToUniversalTime().ToIsoString()),
new XElement(nsWp + "comment_status", "open"));
foreach (var comment in blogMlPost.Comments)
{
string commentText = comment.Content.Content;
if (comment.Content.ContentType == BlogMLContentType.Base64)
commentText = Encoding.UTF8.GetString(Convert.FromBase64String(comment.Content.Content));
var xComment = new XElement(nsWp + "comment",
new XElement(nsWp + "comment_id", comment.Id),
new XElement(nsWp + "comment_author", comment.UserName),
new XElement(nsWp + "comment_author_email", comment.UserEmailAddress),
new XElement(nsWp + "comment_author_url", comment.UserUrl == null ? string.Empty : comment.UserUrl.ToString()),
new XElement(nsWp + "comment_date_gmt", comment.CreatedOn.ToUniversalTime().ToIsoString()),
new XElement(nsWp + "comment_content", commentText),
new XElement(nsWp + "comment_approved", comment.ApprovalStatus == BlogMLApprovalStatus.Approved ? 1 : 0));
xItem.Add(xComment);
}
xChannel.Add(xItem);
}
return xDoc;
}
private void AddBlogAuthors(IContent authorsNode, BlogMLDocument blogMlDoc)
{
foreach (var author in _applicationContext.Services.ContentService.GetChildren(authorsNode.Id))
{
var blogMlAuthor = new BlogMLAuthor();
blogMlAuthor.Id = author.Key.ToString();
blogMlAuthor.CreatedOn = author.CreateDate;
blogMlAuthor.LastModifiedOn = author.UpdateDate;
blogMlAuthor.ApprovalStatus = BlogMLApprovalStatus.Approved;
blogMlAuthor.Title = new BlogMLTextConstruct(author.Name);
blogMlDoc.Authors.Add(blogMlAuthor);
}
}
private void WriteFile(BlogMLDocument blogMlDoc)
{
using (var stream = new MemoryStream())
{
blogMlDoc.Save(stream, new SyndicationResourceSaveSettings()
{
CharacterEncoding = Encoding.UTF8
});
stream.Position = 0;
_fileSystem.AddFile("BlogMlExport.xml", stream, true);
}
}
private void AddBlogPosts(IContent archiveNode, BlogMLDocument blogMlDoc, string tagGroup)
{
const int pageSize = 1000;
var pageIndex = 0;
IContent[] posts;
do
{
long total;
posts = _applicationContext.Services.ContentService.GetPagedChildren(archiveNode.Id, pageIndex, pageSize, out total, "createDate").ToArray();
foreach (var child in posts)
{
string content = "";
if (child.ContentType.Alias.InvariantEquals("ArticulateRichText"))
{
//TODO: this would also need to export all macros
content = child.GetValue<string>("richText");
}
else if (child.ContentType.Alias.InvariantEquals("ArticulateMarkdown"))
{
content = child.GetValue<string>("markdown");
var markdown = new MarkdownDeep.Markdown();
content = markdown.Transform(content);
}
var blogMlPost = new BlogMLPost()
{
Id = child.Key.ToString(),
Name = new BlogMLTextConstruct(child.Name),
Title = new BlogMLTextConstruct(child.Name),
ApprovalStatus = BlogMLApprovalStatus.Approved,
PostType = BlogMLPostType.Normal,
CreatedOn = child.CreateDate,
LastModifiedOn = child.UpdateDate,
Content = new BlogMLTextConstruct(content, BlogMLContentType.Html),
Excerpt = new BlogMLTextConstruct(child.GetValue<string>("excerpt")),
Url = new Uri(_umbracoContext.UrlProvider.GetUrl(child.Id), UriKind.RelativeOrAbsolute)
};
var author = blogMlDoc.Authors.FirstOrDefault(x => x.Title != null && x.Title.Content.InvariantEquals(child.GetValue<string>("author")));
if (author != null)
{
blogMlPost.Authors.Add(author.Id);
}
var categories = _applicationContext.Services.TagService.GetTagsForEntity(child.Id, tagGroup);
foreach (var category in categories)
{
blogMlPost.Categories.Add(category.Id.ToString());
}
//TODO: Tags isn't natively supported
blogMlDoc.AddPost(blogMlPost);
}
pageIndex++;
} while (posts.Length == pageSize);
}
private void AddBlogCategories(BlogMLDocument blogMlDoc, string tagGroup)
{
var categories = _applicationContext.Services.TagService.GetAllContentTags(tagGroup);
foreach (var category in categories)
{
if (category.NodeCount == 0) continue;
var blogMlCategory = new BlogMLCategory();
blogMlCategory.Id = category.Id.ToString();
blogMlCategory.CreatedOn = category.CreateDate;
blogMlCategory.LastModifiedOn = category.UpdateDate;
blogMlCategory.ApprovalStatus = BlogMLApprovalStatus.Approved;
blogMlCategory.ParentId = "0";
blogMlCategory.Title = new BlogMLTextConstruct(category.Text);
blogMlDoc.Categories.Add(blogMlCategory);
}
}
/// <summary>
/// Modifies the <see cref="BlogMLDocument"/> to match the data source.
/// </summary>
/// <param name="resource">The <see cref="BlogMLDocument"/> to be filled.</param>
/// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
public void Fill(BlogMLDocument resource)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Create namespace resolver
//------------------------------------------------------------
XmlNamespaceManager manager = BlogMLUtility.CreateNamespaceManager(this.Navigator.NameTable);
//------------------------------------------------------------
// Attempt to fill syndication resource
//------------------------------------------------------------
XPathNavigator blogNavigator = this.Navigator.SelectSingleNode("blog:blog", manager);
if (blogNavigator != null)
{
if(blogNavigator.HasAttributes)
{
string dateCreatedAttribute = blogNavigator.GetAttribute("date-created", String.Empty);
string rootUrlAttribute = blogNavigator.GetAttribute("root-url", String.Empty);
if (!String.IsNullOrEmpty(dateCreatedAttribute))
{
DateTime createdOn;
if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(dateCreatedAttribute, out createdOn))
{
resource.GeneratedOn = createdOn;
}
}
if (!String.IsNullOrEmpty(rootUrlAttribute))
{
Uri rootUrl;
if (Uri.TryCreate(rootUrlAttribute, UriKind.RelativeOrAbsolute, out rootUrl))
{
resource.RootUrl = rootUrl;
}
}
}
if (blogNavigator.HasChildren)
{
XPathNavigator titleNavigator = blogNavigator.SelectSingleNode("blog:title", manager);
XPathNavigator subtitleNavigator = blogNavigator.SelectSingleNode("blog:sub-title", manager);
if (titleNavigator != null)
{
BlogMLTextConstruct title = new BlogMLTextConstruct();
if (title.Load(titleNavigator))
{
resource.Title = title;
}
}
if (subtitleNavigator != null)
{
BlogMLTextConstruct subtitle = new BlogMLTextConstruct();
if (subtitle.Load(subtitleNavigator))
{
resource.Subtitle = subtitle;
}
}
BlogML20SyndicationResourceAdapter.FillDocumentCollections(resource, blogNavigator, manager, this.Settings);
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(blogNavigator, this.Settings);
adapter.Fill(resource, manager);
}
}
/// <summary>
/// Modifies the <see cref="BlogMLDocument"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="document">The <see cref="BlogMLDocument"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="BlogMLDocument"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="document"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillDocumentCollections(BlogMLDocument document, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(document, "document");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator authorsIterator = source.Select("blog:authors/blog:author", manager);
XPathNodeIterator extendedPropertiesIterator = source.Select("blog:extended-properties/blog:property", manager);
XPathNodeIterator categoriesIterator = source.Select("blog:categories/blog:category", manager);
XPathNodeIterator postsIterator = source.Select("blog:posts/blog:post", manager);
if (authorsIterator != null && authorsIterator.Count > 0)
{
while (authorsIterator.MoveNext())
{
BlogMLAuthor author = new BlogMLAuthor();
if (author.Load(authorsIterator.Current, settings))
{
document.Authors.Add(author);
}
}
}
if (extendedPropertiesIterator != null && extendedPropertiesIterator.Count > 0)
{
while (extendedPropertiesIterator.MoveNext())
{
if (extendedPropertiesIterator.Current.HasAttributes)
{
string propertyName = extendedPropertiesIterator.Current.GetAttribute("name", String.Empty);
string propertyValue = extendedPropertiesIterator.Current.GetAttribute("value", String.Empty);
if (!String.IsNullOrEmpty(propertyName) && !document.ExtendedProperties.ContainsKey(propertyName))
{
document.ExtendedProperties.Add(propertyName, propertyValue);
}
}
}
}
if (categoriesIterator != null && categoriesIterator.Count > 0)
{
while (categoriesIterator.MoveNext())
{
BlogMLCategory category = new BlogMLCategory();
if (category.Load(categoriesIterator.Current, settings))
{
document.Categories.Add(category);
}
}
}
if (postsIterator != null && postsIterator.Count > 0)
{
int counter = 0;
while (postsIterator.MoveNext())
{
BlogMLPost post = new BlogMLPost();
counter++;
if (post.Load(postsIterator.Current, settings))
{
if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit)
{
break;
}
((Collection<BlogMLPost>)document.Posts).Add(post);
}
}
}
}
//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the BlogMLPost class.
/// </summary>
public static void ClassExample()
{
#region BlogMLPost
BlogMLDocument document = new BlogMLDocument();
document.RootUrl = new Uri("/blogs/default.aspx");
document.GeneratedOn = new DateTime(2006, 9, 5, 18, 22, 10);
document.Title = new BlogMLTextConstruct("BlogML 2.0 Example");
document.Subtitle = new BlogMLTextConstruct("This is some sample blog content for BlogML 2.0");
BlogMLAuthor administrator = new BlogMLAuthor();
administrator.Id = "2100";
administrator.CreatedOn = new DateTime(2006, 8, 10, 8, 44, 35);
administrator.LastModifiedOn = new DateTime(2006, 9, 4, 13, 46, 38);
administrator.ApprovalStatus = BlogMLApprovalStatus.Approved;
administrator.EmailAddress = "*****@*****.**";
administrator.Title = new BlogMLTextConstruct("admin");
document.Authors.Add(administrator);
document.ExtendedProperties.Add("CommentModeration", "Anonymous");
document.ExtendedProperties.Add("SendTrackback", "yes");
BlogMLCategory category1 = new BlogMLCategory();
category1.Id = "1018";
category1.CreatedOn = new DateTime(2006, 9, 5, 17, 54, 58);
category1.LastModifiedOn = new DateTime(2006, 9, 5, 17, 54, 58);
category1.ApprovalStatus = BlogMLApprovalStatus.Approved;
category1.Description = "Sample Category 1";
category1.ParentId = "0";
category1.Title = new BlogMLTextConstruct("Category 1");
document.Categories.Add(category1);
BlogMLCategory category2 = new BlogMLCategory();
category2.Id = "1019";
category2.CreatedOn = new DateTime(2006, 9, 5, 17, 54, 59);
category2.LastModifiedOn = new DateTime(2006, 9, 5, 17, 54, 59);
category2.ApprovalStatus = BlogMLApprovalStatus.Approved;
category2.Description = "Sample Category 2";
category2.ParentId = "0";
category2.Title = new BlogMLTextConstruct("Category 2");
document.Categories.Add(category2);
BlogMLCategory category3 = new BlogMLCategory();
category3.Id = "1020";
category3.CreatedOn = new DateTime(2006, 9, 5, 17, 55, 0);
category3.LastModifiedOn = new DateTime(2006, 9, 5, 17, 55, 0);
category3.ApprovalStatus = BlogMLApprovalStatus.NotApproved;
category3.Description = "Sample Category 3";
category3.ParentId = "0";
category3.Title = new BlogMLTextConstruct("Category 3");
document.Categories.Add(category3);
// Create a blog entry
BlogMLPost post = new BlogMLPost();
post.Id = "34";
post.CreatedOn = new DateTime(2006, 9, 5, 3, 19, 0);
post.LastModifiedOn = new DateTime(2006, 9, 5, 3, 19, 0);
post.ApprovalStatus = BlogMLApprovalStatus.Approved;
post.Url = new Uri("/blogs/archive/2006/09/05/Sample-Blog-Post.aspx");
post.PostType = BlogMLPostType.Normal;
post.Views = "0";
post.Title = new BlogMLTextConstruct("Sample Blog Post");
post.Content = new BlogMLTextConstruct("<p>This is <b>HTML encoded</b> content. </p>", BlogMLContentType.Html);
post.Name = new BlogMLTextConstruct("Sample Blog Post");
post.Categories.Add("1018");
post.Categories.Add("1020");
post.Authors.Add("2100");
BlogMLComment comment = new BlogMLComment();
comment.Id = "35";
comment.CreatedOn = new DateTime(2006, 9, 5, 11, 36, 50);
comment.LastModifiedOn = new DateTime(2006, 9, 5, 11, 36, 50);
comment.Title = new BlogMLTextConstruct("re: Sample Blog Post");
comment.Content = new BlogMLTextConstruct("This is a test comment.");
post.Comments.Add(comment);
#endregion
}
/// <summary>
/// Instantiates a <see cref="ISyndicationResource"/> that conforms to the specified <see cref="SyndicationContentFormat"/> using the supplied <see cref="Stream"/>.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> used to load the syndication resource.</param>
/// <param name="format">A <see cref="SyndicationContentFormat"/> enumeration value that indicates the type syndication resource the <paramref name="stream"/> represents.</param>
/// <returns>
/// An <see cref="ISyndicationResource"/> object that conforms to the specified <paramref name="format"/>, initialized using the supplied <paramref name="stream"/>.
/// If the <paramref name="format"/> is not supported by the provider, returns a <b>null</b> reference.
/// </returns>
/// <exception cref="ArgumentNullException">The <paramref name="stream"/> is a null reference (Nothing in Visual Basic).</exception>
private static ISyndicationResource BuildResource(SyndicationContentFormat format, Stream stream)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(stream, "stream");
//------------------------------------------------------------
// Create syndication resource based on content format
//------------------------------------------------------------
if (format == SyndicationContentFormat.Apml)
{
ApmlDocument document = new ApmlDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Atom)
{
XPathDocument document = new XPathDocument(stream);
XPathNavigator navigator = document.CreateNavigator();
navigator.MoveToRoot();
navigator.MoveToChild(XPathNodeType.Element);
if(String.Compare(navigator.LocalName, "entry", StringComparison.OrdinalIgnoreCase) == 0)
{
AtomEntry entry = new AtomEntry();
entry.Load(navigator);
return entry;
}
else if (String.Compare(navigator.LocalName, "feed", StringComparison.OrdinalIgnoreCase) == 0)
{
AtomFeed feed = new AtomFeed();
feed.Load(navigator);
return feed;
}
else
{
return null;
}
}
else if (format == SyndicationContentFormat.BlogML)
{
BlogMLDocument document = new BlogMLDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Opml)
{
OpmlDocument document = new OpmlDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Rsd)
{
RsdDocument document = new RsdDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Rss)
{
RssFeed feed = new RssFeed();
feed.Load(stream);
return feed;
}
else
{
return null;
}
}
/// <summary>
/// Creates a new <see cref="BlogMLDocument"/> instance using the specified <see cref="Uri"/>, <see cref="ICredentials"/>, <see cref="IWebProxy"/>, and <see cref="SyndicationResourceLoadSettings"/> object.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="BlogMLDocument"/> instance. This value can be <b>null</b>.</param>
/// <returns>An <see cref="BlogMLDocument"/> object loaded using the <paramref name="source"/> data.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the document remains empty.</exception>
public static BlogMLDocument Create(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
BlogMLDocument syndicationResource = new BlogMLDocument();
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Create new instance using supplied parameters
//------------------------------------------------------------
syndicationResource.Load(source, options, settings);
return syndicationResource;
}