public override BlogPost GetPost(string blogId, string postId)
{
// query for post
XmlNode postResult = CallMethod("blogger.getPost",
new XmlRpcString(APP_KEY),
new XmlRpcString(postId),
new XmlRpcString(Username),
new XmlRpcString(Password, true));
// parse results
try
{
// get the post struct
XmlNode postNode = postResult.SelectSingleNode("struct");
// create a post to return
BlogPost blogPost = new BlogPost();
// extract content
ExtractStandardPostFields(postNode, blogPost);
// return the post
return blogPost;
}
catch (Exception ex)
{
string response = postResult != null ? postResult.OuterXml : "(empty response)";
Trace.Fail("Exception occurred while parsing blogger.getPost response: " + response + "\r\n" + ex.ToString());
throw new BlogClientInvalidServerResponseException("blogger.getPost", ex.Message, response);
}
}
protected internal override void PreparePost(BlogPost blogPost, ref bool? publish)
{
foreach (PostTest test in tests)
{
test.PreparePost(blogPost, ref publish);
}
}
protected internal override void PreparePost(BlogPost blogPost, ref bool? publish)
{
guid1 = BlogUtil.ShortGuid;
guid2 = BlogUtil.ShortGuid;
blogPost.Title = guid1 + TEST_STRING + guid2;
blogPost.Contents = "foo";
}
private void CreateBlogPost(string blogId, string postId, string title)
{
BlogPost post = new BlogPost();
if (postId != null)
post.Id = postId;
post.Title = title;
BlogPostEditingContext ctx = new BlogPostEditingContext(blogId, post);
PostEditorFile file = PostEditorFile.CreateNew(tempDir);
file.SaveBlogPost(ctx);
}
public BlogPostEditingContext(string destinationBlogId, BlogPost blogPost, PostEditorFile localFile, PostEditorFile autoSaveLocalFile, string serverSupportingFileDirectory, BlogPostSupportingFileStorage supportingFileStorage, BlogPostImageDataList imageDataList, BlogPostExtensionDataList extensionDataList, ISupportingFileService supportingFileService)
: this(destinationBlogId, blogPost, localFile)
{
_serverSupportingFileDirectory = serverSupportingFileDirectory;
_supportingFileStorage = supportingFileStorage;
_imageDataList = imageDataList;
_extensionDataList = extensionDataList;
_fileService = supportingFileService;
_autoSaveLocalFile = autoSaveLocalFile;
}
protected internal override void HandleResult(OpenLiveWriter.Extensibility.BlogClient.BlogPost blogPost, ITestResults results)
{
if (blogPost.Categories.Length == 2)
{
results.AddResult("supportsMultipleCategories", YES);
}
else
{
results.AddResult("supportsMultipleCategories", NO);
}
}
public string NewPost(string title, string body, DateTime? dateTime)
{
BlogPost post = new BlogPost();
post.Title = title;
post.Contents = body;
if (dateTime != null)
post.DatePublishedOverride = dateTime.Value;
string eTag;
XmlDocument remotePost;
return client.NewPost(blog.BlogId, post, null, true, out eTag, out remotePost);
}
public override void DoTest(BlogRunner.Core.Config.Blog blog, OpenLiveWriter.Extensibility.BlogClient.IBlogClient blogClient, ITestResults results)
{
BlogPost post = new BlogPost();
post.Contents = "foo";
post.Title = "";
string etag;
XmlDocument remotePost;
try
{
string newPostId = blogClient.NewPost(blog.BlogId, post, null, true, out etag, out remotePost);
results.AddResult("supportsEmptyTitles", YES);
if (CleanUpPosts)
blogClient.DeletePost(blog.BlogId, newPostId, true);
}
catch
{
results.AddResult("supportsEmptyTitles", NO);
}
}
public bool EditPost(string blogId, BlogPost post, INewCategoryContext newCategoryContext, bool publish, out string etag, out XmlDocument remotePost)
{
etag = null;
remotePost = null;
return EditPost(blogId, post, newCategoryContext, publish);
}
/// <summary>
/// Overridable hook to allow custom handling of setting the post title (in plain text form).
/// This method is called when reading the post title out of an XML-RPC response. Most providers
/// represent the post title value as HTML, so the default implementation here unescapes the encoded HTML
/// back into plain text.
/// </summary>
/// <param name="post"></param>
/// <param name="blogPostTitle"></param>
protected void SetPostTitleFromXmlValue(BlogPost post, string blogPostTitle)
{
bool isHtml = (Options.ReturnsHtmlTitlesOnGet != SupportsFeature.Unknown)
? Options.ReturnsHtmlTitlesOnGet == SupportsFeature.Yes
: Options.RequiresHtmlTitles;
if (!isHtml)
post.Title = blogPostTitle;
else
post.Title = HtmlUtils.UnEscapeEntities(blogPostTitle, HtmlUtils.UnEscapeMode.Default);
}
public bool EditPage(string blogId, BlogPost page, bool publish, out string etag, out XmlDocument remotePost)
{
etag = null;
remotePost = null;
return EditPage(blogId, page, publish);
}
protected virtual XmlRpcArray GenerateCategoriesForPost(BlogPost post)
{
ArrayList categoryXmlValues = new ArrayList();
foreach (BlogPostCategory category in post.Categories)
categoryXmlValues.Add(new XmlRpcString(category.Name));
// if we support adding categories then add them too
if (Options.SupportsNewCategories)
foreach (BlogPostCategory category in post.NewCategories)
categoryXmlValues.Add(new XmlRpcString(category.Name));
return new XmlRpcArray((XmlRpcValue[])categoryXmlValues.ToArray(typeof(XmlRpcValue)));
}
protected virtual XmlRpcStruct GeneratePostStruct(string blogId, BlogPost post, bool publish)
{
ArrayList members = new ArrayList();
// title
members.Add(new XmlRpcMember("title", new XmlRpcString(GetPostTitleForXmlValue(post))));
// set the contents
if (Options.SupportsExtendedEntries && !post.IsPage)
{
//set the main and extended contents as separate fields
members.Add(new XmlRpcMember("description", new XmlRpcString(post.MainContents)));
members.Add(new XmlRpcMember("mt_text_more", new XmlRpcString(post.ExtendedContents)));
}
else
{
//merge the main and extended contents into a single field
string contents = post.MainContents;
if (post.ExtendedContents != null)
contents += post.ExtendedContents;
members.Add(new XmlRpcMember("description", new XmlRpcString(contents)));
}
// allow comments field
if (Options.SupportsCommentPolicy)
{
if (post.CommentPolicy != BlogCommentPolicy.Unspecified)
{
int policy = -1;
if (Options.CommentPolicyAsBoolean)
{
policy = post.CommentPolicy == BlogCommentPolicy.Open ? 1 : Options.AllowPolicyFalseValue;
}
else
{
switch (post.CommentPolicy)
{
case BlogCommentPolicy.None:
policy = 0;
break;
case BlogCommentPolicy.Open:
policy = 1;
break;
case BlogCommentPolicy.Closed:
policy = 2;
break;
default:
Trace.Fail("Unexpected blog comment policy: " + post.CommentPolicy.ToString());
break;
}
}
if (policy != -1)
members.Add(new XmlRpcMember("mt_allow_comments", new XmlRpcInt(policy)));
}
}
// trackback policy field
if (Options.SupportsPingPolicy)
{
if (post.TrackbackPolicy != BlogTrackbackPolicy.Unspecified)
{
members.Add(new XmlRpcMember("mt_allow_pings",
new XmlRpcInt((post.TrackbackPolicy == BlogTrackbackPolicy.Allow) ? 1 : Options.AllowPolicyFalseValue)));
}
}
// keywords field
if (Options.SupportsKeywords)
{
members.Add(new XmlRpcMember("mt_keywords", new XmlRpcString(post.Keywords)));
}
// slug field
if (Options.SupportsSlug)
{
members.Add(new XmlRpcMember("wp_slug", new XmlRpcString(post.Slug)));
members.Add(new XmlRpcMember("mt_basename", new XmlRpcString(post.Slug)));
}
// password field
if (Options.SupportsPassword)
{
members.Add(new XmlRpcMember("wp_password", new XmlRpcString(post.Password)));
}
// author field
if (Options.SupportsAuthor)
{
if (!post.Author.IsEmpty)
{
members.Add(new XmlRpcMember("wp_author_id", new XmlRpcString(post.Author.Id)));
}
}
// page specific fields
if (post.IsPage)
{
if (Options.SupportsPageParent)
{
string pageParentId = !post.PageParent.IsEmpty ? post.PageParent.Id : "0";
members.Add(new XmlRpcMember("wp_page_parent_id", new XmlRpcString(pageParentId)));
}
if (Options.SupportsPageOrder && (post.PageOrder != String.Empty))
{
members.Add(new XmlRpcMember("wp_page_order", new XmlRpcString(post.PageOrder)));
}
if (Options.SupportsPageTrackbacks)
{
AddTrackbacks(post, members);
}
}
// fields that don't apply to pages
else
{
// generate categories for the post
XmlRpcArray categories = GenerateCategoriesForPost(post);
if (categories != null)
members.Add(new XmlRpcMember("categories", categories));
// generate post date fields
GeneratePostDateFields(post, members);
if (Options.SupportsExcerpt)
{
members.Add(new XmlRpcMember("mt_excerpt", new XmlRpcString(post.Excerpt)));
}
// trackback field
if (Options.SupportsTrackbacks)
{
AddTrackbacks(post, members);
}
}
// return the struct
return new XmlRpcStruct((XmlRpcMember[])members.ToArray(typeof(XmlRpcMember)));
}
private bool MovableTypeEditPost(string blogId, BlogPost post, bool publish)
{
// add the categories to the post
MovableTypeSetPostCategories(post.Id, post.Categories);
// call the base to do the rest of the edit
return MetaweblogEditPost(blogId, post, publish);
}
/// <summary>
/// Edit an existing entry
/// </summary>
/// <param name="blog">blog</param>
/// <param name="postId">post id</param>
/// <param name="account">account to post to</param>
/// <param name="entry">entry to post</param>
/// <param name="publish">publish now?</param>
/// <returns>was the entry successfully edited</returns>
public override bool EditPost(string blogId, BlogPost post, INewCategoryContext newCategoryContext, bool publish)
{
if (!publish && !Options.SupportsPostAsDraft)
{
Trace.Fail("Post to draft not supported on this provider");
throw new BlogClientPostAsDraftUnsupportedException();
}
bool addCategoriesOutOfBand = AddCategoriesIfNecessary(blogId, post, newCategoryContext);
bool result;
if (Options.SupportsCategoriesInline)
{
result = MetaweblogEditPost(blogId, post, publish);
if (Options.SupportsHierarchicalCategories)
MovableTypeSetPostCategories(post.Id, ArrayHelper.Concat(post.Categories, post.NewCategories));
}
else
{
result = MovableTypeEditPost(blogId, post, publish);
}
// if we succeeded then note addition of categories if appropriate
if (!addCategoriesOutOfBand)
{
foreach (BlogPostCategory category in post.NewCategories)
newCategoryContext.NewCategoryAdded(category);
}
return result;
}
protected internal override void PreparePost(Blog blog, IBlogClient blogClient, OpenLiveWriter.Extensibility.BlogClient.BlogPost blogPost, ref bool?publish)
{
BlogPostCategory[] categories = blogClient.GetCategories(blog.BlogId);
if (categories.Length < 2)
{
throw new InvalidOperationException("Blog " + blog.HomepageUrl + " does not have enough categories for the SupportsMultipleCategories test to be performed");
}
BlogPostCategory[] newCategories = new BlogPostCategory[2];
newCategories[0] = categories[0];
newCategories[1] = categories[1];
blogPost.Categories = newCategories;
}
private string MovableTypeNewPost(string blogId, BlogPost post, bool publish)
{
// See http://www.jayallen.org/journey/2003/10/tip_xmlrpc_and_movable_type
// for explanation of MT's weird publish flag behavior and why it's
// a good idea to do the song and dance below.
// create the post (don't publish it yet because
// we need to add the categories)
string postId = MetaweblogNewPost(blogId, post, false);
// add the categories to the post
MovableTypeSetPostCategories(postId, post.Categories);
if (publish)
{
// call the metaweblog edit post for publishing
post.Id = postId;
MetaweblogEditPost(blogId, post, publish);
}
// return the post-id
return postId;
}
public string NewPost(string blogId, BlogPost post, INewCategoryContext newCategoryContext, bool publish, out string etag, out XmlDocument remotePost)
{
// The remote post is only meant to be used for blogs that use the Atom protocol.
remotePost = null;
if (!publish && !Options.SupportsPostAsDraft)
{
Trace.Fail("Post to draft not supported on this provider");
throw new BlogClientPostAsDraftUnsupportedException();
}
var bloggerPost = ConvertToGoogleBloggerPost(post);
var newPostRequest = GetService().Posts.Insert(bloggerPost, blogId);
newPostRequest.IsDraft = !publish;
var newPost = newPostRequest.Execute();
etag = newPost.ETag;
return newPost.Id;
}
private bool MetaweblogEditPost(string blogId, BlogPost post, bool publish)
{
// call the method
XmlNode result = CallMethod("metaWeblog.editPost",
new XmlRpcString(post.Id),
new XmlRpcString(Username),
new XmlRpcString(Password, true),
GeneratePostStruct(blogId, post, publish),
new XmlRpcBoolean(publish));
return (result.InnerText == "1");
}
public bool EditPage(string blogId, BlogPost page, bool publish, out string etag, out XmlDocument remotePost)
{
// The remote post is only meant to be used for blogs that use the Atom protocol.
remotePost = null;
if (!publish && !Options.SupportsPostAsDraft)
{
Trace.Fail("Post to draft not supported on this provider");
throw new BlogClientPostAsDraftUnsupportedException();
}
var bloggerPage = ConvertToGoogleBloggerPage(page);
var updatePostRequest = GetService().Pages.Update(bloggerPage, blogId, page.Id);
updatePostRequest.Publish = publish;
var updatedPage = updatePostRequest.Execute();
etag = updatedPage.ETag;
return true;
}
protected override bool EditPage(string blogId, BlogPost page, bool publish)
{
if (Options.SupportsPages)
{
// call the method
XmlNode result = CallMethod("wp.editPage",
new XmlRpcString(blogId),
new XmlRpcString(page.Id),
new XmlRpcString(Username),
new XmlRpcString(Password, true),
GeneratePostStruct(blogId, page, publish),
new XmlRpcBoolean(publish));
return (result.InnerText == "1");
}
else
{
throw new BlogClientMethodUnsupportedException("EditPage");
}
}
private static Page ConvertToGoogleBloggerPage(BlogPost page)
{
return new Page()
{
Content = page.Contents,
// TODO:OLW - DatePublishedOverride didn't work quite right. Either the date published override was off by several hours,
// needs to be normalized to UTC or the Blogger website thinks I'm in the wrong time zone.
Published = page.HasDatePublishedOverride ? page?.DatePublishedOverride : null,
Title = page.Title,
};
}
protected virtual void GeneratePostDateFields(BlogPost post, ArrayList members)
{
if (post.HasDatePublishedOverride && Options.SupportsCustomDate)
{
DateTime date = post.DatePublishedOverride;
DateTime utcDate = date;
if (Options.UseLocalTime)
date = DateTimeHelper.UtcToLocal(date);
string format = Options.PostDateFormat;
members.Add(new XmlRpcMember("dateCreated", new XmlRpcFormatTime(date, format)));
members.Add(new XmlRpcMember("date_created_gmt", new XmlRpcFormatTime(utcDate, format)));
}
}
public IBlogPostEditingContext Load(bool addToRecentDocs)
{
try
{
if (!IsSaved)
throw new InvalidOperationException("Attempted to load a PostEditorFile that has never been saved!");
// add to shell recent documents
if (addToRecentDocs)
Shell32.SHAddToRecentDocs(SHARD.PATHW, TargetFile.FullName);
using (Storage postStorage = new Storage(TargetFile.FullName, StorageMode.Open, false))
{
// meta-data
string destinationBlogId = ReadString(postStorage, DESTINATION_BLOG_ID);
string serverSupportingFileDirectory = ReadString(postStorage, SERVER_SUPPORTING_FILE_DIR);
// blog post
BlogPost blogPost = new BlogPost();
blogPost.Id = ReadString(postStorage, POST_ID);
blogPost.IsPage = SafeReadBoolean(postStorage, POST_ISPAGE, false);
blogPost.Title = ReadString(postStorage, POST_TITLE);
blogPost.Categories = (BlogPostCategory[])ReadXml(postStorage, POST_CATEGORIES, new XmlReadHandler(ReadCategories));
blogPost.NewCategories = (BlogPostCategory[])SafeReadXml(postStorage, POST_NEW_CATEGORIES, new XmlReadHandler(ReadCategories), new BlogPostCategory[] { });
blogPost.DatePublished = ReadDateTime(postStorage, POST_DATEPUBLISHED);
blogPost.DatePublishedOverride = ReadDateTime(postStorage, POST_DATEPUBLISHED_OVERRIDE);
blogPost.CommentPolicy = ReadCommentPolicy(postStorage);
blogPost.TrackbackPolicy = ReadTrackbackPolicy(postStorage);
blogPost.Keywords = ReadString(postStorage, POST_KEYWORDS);
blogPost.Excerpt = ReadString(postStorage, POST_EXCERPT);
blogPost.Permalink = SafeReadString(postStorage, POST_PERMALINK, String.Empty);
blogPost.PingUrlsPending = (string[])ReadXml(postStorage, POST_PINGURLS_PENDING, new XmlReadHandler(ReadPingUrls));
blogPost.PingUrlsSent = (string[])SafeReadXml(postStorage, POST_PINGURLS_SENT, new XmlReadHandler(ReadPingUrls), new string[0]);
blogPost.Slug = SafeReadString(postStorage, POST_SLUG, String.Empty);
blogPost.Password = SafeReadString(postStorage, POST_PASSWORD, String.Empty);
string authorId = SafeReadString(postStorage, POST_AUTHOR_ID, String.Empty);
string authorName = SafeReadString(postStorage, POST_AUTHOR_NAME, String.Empty);
blogPost.Author = new PostIdAndNameField(authorId, authorName);
string pageParentId = SafeReadString(postStorage, POST_PAGE_PARENT_ID, String.Empty);
string pageParentName = SafeReadString(postStorage, POST_PAGE_PARENT_NAME, String.Empty);
blogPost.PageParent = new PostIdAndNameField(pageParentId, pageParentName);
blogPost.PageOrder = SafeReadString(postStorage, POST_PAGE_ORDER, String.Empty);
blogPost.ETag = SafeReadString(postStorage, POST_ETAG, String.Empty);
blogPost.AtomRemotePost = (XmlDocument)SafeReadXml(postStorage, POST_ATOM_REMOTE_POST, new XmlReadHandler(XmlDocReadHandler), null);
try
{
blogPost.ContentsVersionSignature = ReadString(postStorage, POST_CONTENTS_VERSION_SIGNATURE);
}
catch (StorageFileNotFoundException) { } //BACKWARDS_COMPATABILITY: occurs if this file was created before the introduction of content signatures (pre-Beta2)
// post contents (must extract supporting files -- protect against leakage with try/catch
BlogPostSupportingFileStorage supportingFileStorage = new BlogPostSupportingFileStorage();
using (Storage postSupportStorage = postStorage.OpenStorage(POST_SUPPORTING_FILES, StorageMode.Open, false))
{
SupportingFilePersister supportingFilePersister = new SupportingFilePersister(postSupportStorage, supportingFileStorage);
//read the attached files
SupportingFileService supportingFileService = new SupportingFileService(supportingFileStorage);
try
{
ReadXml(postStorage, POST_ATTACHED_FILES, new XmlReadHandler(new AttachedFileListReader(supportingFileService, supportingFilePersister).ReadAttachedFileList));
}
catch (StorageFileNotFoundException) { } //occurs if this file was created before the introduction of extension data
//read in the image data (note: this must happen before fixing the file references)
BlogPostImageDataList imageDataList = (BlogPostImageDataList)ReadXml(postStorage, POST_IMAGE_FILES, new XmlReadHandler(new ImageListReader(supportingFilePersister, supportingFileService).ReadImageFiles));
//read the extension data settings
BlogPostExtensionDataList extensionDataList = new BlogPostExtensionDataList(supportingFileService);
try
{
ReadXml(postStorage, POST_EXTENSION_DATA_LIST, new XmlReadHandler(new ExtensionDataListReader(extensionDataList, supportingFilePersister, supportingFileService).ReadExtensionDataList));
}
catch (StorageFileNotFoundException) { } //occurs if this file was created before the introduction of extension data
//fix up the HTML content to reference the extracted files
blogPost.Contents = supportingFilePersister.FixupHtmlReferences(ReadStringUtf8(postStorage, POST_CONTENTS));
string originalSourcePath = SafeReadString(postStorage, ORIGINAL_SOURCE_PATH, null);
PostEditorFile autoSaveFile;
PostEditorFile file = GetFileFromSourcePath(originalSourcePath, out autoSaveFile);
// return init params
return new BlogPostEditingContext(destinationBlogId, blogPost, file, autoSaveFile, serverSupportingFileDirectory, supportingFileStorage, imageDataList, extensionDataList, supportingFileService);
}
}
}
catch (Exception ex)
{
Trace.Fail("Unexpected exception type in PostEditorFile.Load. It is critical that only IO exceptions occur at this level of the system so please check the code which threw the exeption and see if there is a way to behave more robustly!\r\n"
+ ex.ToString());
throw PostEditorStorageException.Create(ex);
}
}
private BlogPost ParseBlogPost(XmlNode postNode, bool includeCategories)
{
// create blog post
BlogPost blogPost = new BlogPost();
// get node values
blogPost.Id = NodeText(postNode.SelectSingleNode("member[name='postid']/value"));
if (blogPost.Id == String.Empty)
blogPost.Id = NodeText(postNode.SelectSingleNode("member[name='page_id']/value"));
SetPostTitleFromXmlValue(blogPost, NodeText(postNode.SelectSingleNode("member[name='title']/value")));
// attempt to discover the permalink
blogPost.Permalink = NodeText(postNode.SelectSingleNode("member[name='permaLink']/value"));
if (blogPost.Permalink == String.Empty)
blogPost.Permalink = NodeText(postNode.SelectSingleNode("member[name='permalink']/value"));
if (blogPost.Permalink == String.Empty)
blogPost.Permalink = NodeText(postNode.SelectSingleNode("member[name='link']/value"));
// contents and extended contents
string mainContents = NodeText(postNode.SelectSingleNode("member[name='description']/value"));
string extendedContents = NodeText(postNode.SelectSingleNode("member[name='mt_text_more']/value"));
blogPost.SetContents(mainContents, extendedContents);
// date published
XmlNode dateCreatedNode = postNode.SelectSingleNode("member[name='date_created_gmt']/value");
if (dateCreatedNode == null)
dateCreatedNode = postNode.SelectSingleNode("member[name='dateCreated']/value");
blogPost.DatePublished = ParseBlogDate(dateCreatedNode);
// extract comment field
if (Options.SupportsCommentPolicy)
{
string commentPolicy = NodeText(postNode.SelectSingleNode("member[name='mt_allow_comments']/value"));
if (commentPolicy != String.Empty)
{
switch (commentPolicy)
{
case "0":
blogPost.CommentPolicy = BlogCommentPolicy.None;
break;
case "1":
blogPost.CommentPolicy = BlogCommentPolicy.Open;
break;
case "2":
blogPost.CommentPolicy = BlogCommentPolicy.Closed;
break;
default:
Trace.Fail("Unexpected value for mt_allow_comments: " + commentPolicy);
break;
}
}
}
// extract trackback field
if (Options.SupportsPingPolicy)
{
string allowTrackbacks = NodeText(postNode.SelectSingleNode("member[name='mt_allow_pings']/value"));
if (allowTrackbacks != String.Empty)
blogPost.TrackbackPolicy = (allowTrackbacks == "1") ? BlogTrackbackPolicy.Allow : BlogTrackbackPolicy.Deny;
}
// extract keywords field
if (Options.SupportsKeywords)
{
string keywords = NodeText(postNode.SelectSingleNode("member[name='mt_keywords']/value"));
blogPost.Keywords = HtmlUtils.UnEscapeEntities(keywords, HtmlUtils.UnEscapeMode.Default);
}
// extract excerpt field
if (Options.SupportsExcerpt)
{
blogPost.Excerpt = NodeText(postNode.SelectSingleNode("member[name='mt_excerpt']/value"));
}
// extract ping url array
if (Options.SupportsTrackbacks)
{
XmlNode pingUrlsNode = postNode.SelectSingleNode("member[name='mt_tb_ping_urls']/value");
if (pingUrlsNode != null)
{
ArrayList sentPingUrls = new ArrayList();
if (Options.TrackbackDelimiter == TrackbackDelimiter.ArrayElement)
{
XmlNodeList pingUrlNodes = pingUrlsNode.SelectNodes("array/data/value");
foreach (XmlNode node in pingUrlNodes)
sentPingUrls.Add(node.InnerText.Trim());
}
else
{
string delimiter = null;
if (Options.TrackbackDelimiter == TrackbackDelimiter.Space)
delimiter = " ";
else if (Options.TrackbackDelimiter == TrackbackDelimiter.Comma)
delimiter = ",";
sentPingUrls.AddRange(StringHelper.Split(pingUrlsNode.InnerText, delimiter));
}
blogPost.PingUrlsSent = sentPingUrls.ToArray(typeof(string)) as string[];
}
}
// extract slug
if (Options.SupportsSlug)
{
blogPost.Slug = NodeText(postNode.SelectSingleNode("member[name='wp_slug']/value"));
if (blogPost.Slug == String.Empty)
blogPost.Slug = NodeText(postNode.SelectSingleNode("member[name='mt_basename']/value"));
}
// extract password
if (Options.SupportsPassword)
{
blogPost.Password = NodeText(postNode.SelectSingleNode("member[name='wp_password']/value"));
}
// extract author
if (Options.SupportsAuthor)
{
string authorId = NodeText(postNode.SelectSingleNode("member[name='wp_author_id']/value"));
// account for different display name syntax in various calls
string authorName = NodeText(postNode.SelectSingleNode("member[name='wp_author_display_name']/value"));
blogPost.Author = new PostIdAndNameField(authorId, authorName);
}
// extract page parent
if (Options.SupportsPageParent)
{
string pageParentId = NodeText(postNode.SelectSingleNode("member[name='wp_page_parent_id']/value"));
// convert 0 to empty string for parent-id
if (pageParentId == "0")
pageParentId = String.Empty;
string pageParentTitle = NodeText(postNode.SelectSingleNode("member[name='wp_page_parent_title']/value"));
blogPost.PageParent = new PostIdAndNameField(pageParentId, pageParentTitle);
}
// extract page order
if (Options.SupportsPageOrder)
{
blogPost.PageOrder = NodeText(postNode.SelectSingleNode("member[name='wp_page_order']/value"));
}
// extract categories
if (includeCategories && Options.SupportsCategories)
{
if (Options.SupportsCategoriesInline && !Options.SupportsHierarchicalCategories)
{
blogPost.Categories = MetaweblogExtractCategories(blogPost.Id, postNode);
}
else
{
blogPost.Categories = MovableTypeExtractCategories(blogPost.Id, postNode);
}
}
// allow post-processing of extracted blog post
BlogPostReadFilter(blogPost);
// return the post
return blogPost;
}
protected virtual void BlogPostReadFilter(BlogPost blogPost)
{
}
protected virtual bool EditPage(string blogId, BlogPost page, bool publish)
{
throw new BlogClientMethodUnsupportedException("EditPage");
}
private void AddTrackbacks(BlogPost post, ArrayList members)
{
if (post.PingUrlsPending.Length > 0)
{
if (Options.TrackbackDelimiter == TrackbackDelimiter.ArrayElement)
{
members.Add(new XmlRpcMember("mt_tb_ping_urls", ArrayFromStrings(post.PingUrlsPending)));
}
else
{
char delimiter;
switch (Options.TrackbackDelimiter)
{
case TrackbackDelimiter.Space:
delimiter = ' ';
break;
case TrackbackDelimiter.Comma:
default:
delimiter = ',';
break;
}
StringBuilder trackbackBuilder = new StringBuilder();
foreach (string pingUrl in post.PingUrlsPending)
trackbackBuilder.AppendFormat("{0}{1}", pingUrl, delimiter);
string trackbacks = trackbackBuilder.ToString().TrimEnd(delimiter);
members.Add(new XmlRpcMember("mt_tb_ping_urls", trackbacks));
}
}
}
/// <summary>
/// Overridable hook to allow custom handling of reading the post title for insertion into an XML-RPC request.
/// This method is called when reading the post title for insertion in an XML-RPC response. Most providers
/// represent the post title value as HTML, so the default implementation here escapes plain text post Title
/// into HTML format.
/// </summary>
/// <param name="post"></param>
/// <returns></returns>
protected string GetPostTitleForXmlValue(BlogPost post)
{
if (!this.Options.RequiresHtmlTitles)
return post.Title;
else
return HtmlUtils.EscapeEntities(post.Title);
}
private bool AddCategoriesIfNecessary(string blogId, BlogPost post, INewCategoryContext newCategoryContext)
{
// this blog doesn't support adding categories
if (!Options.SupportsNewCategories)
return false;
// no new categories to add
if (post.NewCategories.Length == 0)
return false;
// we support inline category addition and we don't require a special
// api for heirarchical categories (inline api can't handle parent specification)
if (Options.SupportsNewCategoriesInline && !Options.SupportsHierarchicalCategories)
return false;
// add the categories and update their ids
ArrayList newCategories = new ArrayList();
foreach (BlogPostCategory category in post.NewCategories)
{
string categoryId = AddCategory(blogId, category);
BlogPostCategory newCategory = new BlogPostCategory(categoryId, category.Name, category.Parent);
newCategories.Add(newCategory);
newCategoryContext.NewCategoryAdded(newCategory);
}
post.NewCategories = newCategories.ToArray(typeof(BlogPostCategory)) as BlogPostCategory[];
return true;
}
public abstract bool EditPost(string blogId, BlogPost post, INewCategoryContext newCategoryContext, bool publish);
private string MetaweblogNewPost(string blogId, BlogPost post, bool publish)
{
// call the method
XmlNode result = CallMethod("metaWeblog.newPost",
new XmlRpcString(blogId),
new XmlRpcString(Username),
new XmlRpcString(Password, true),
GeneratePostStruct(blogId, post, publish),
new XmlRpcBoolean(publish));
// return the blog id
return result.InnerText;
}
