1 <?php

     2 /**

     3  * XML-RPC protocol support for WordPress

     4  *

     5  * @package WordPress

     6  */

     7 

     8 /**

     9  * WordPress XMLRPC server implementation.

    10  *

    11  * Implements compatibility for Blogger API, MetaWeblog API, MovableType, and

    12  * pingback. Additional WordPress API for managing comments, pages, posts,

    13  * options, etc.

    14  *

    15  * As of WordPress 3.5.0, XML-RPC is enabled by default. It can be disabled

    16  * via the xmlrpc_enabled filter found in wp_xmlrpc_server::login().

    17  *

    18  * @package WordPress

    19  * @subpackage Publishing

    20  * @since 1.5.0

    21  */

    22 class wp_xmlrpc_server extends IXR_Server {

    23 

    24 	/**

    25 	 * Register all of the XMLRPC methods that XMLRPC server understands.

    26 	 *

    27 	 * Sets up server and method property. Passes XMLRPC

    28 	 * methods through the 'xmlrpc_methods' filter to allow plugins to extend

    29 	 * or replace XMLRPC methods.

    30 	 *

    31 	 * @since 1.5.0

    32 	 *

    33 	 * @return wp_xmlrpc_server

    34 	 */

    35 	function __construct() {

    36 		$this->methods = array(

    37 			// WordPress API

    38 			'wp.getUsersBlogs'		=> 'this:wp_getUsersBlogs',

    39 			'wp.newPost'			=> 'this:wp_newPost',

    40 			'wp.editPost'			=> 'this:wp_editPost',

    41 			'wp.deletePost'			=> 'this:wp_deletePost',

    42 			'wp.getPost'			=> 'this:wp_getPost',

    43 			'wp.getPosts'			=> 'this:wp_getPosts',

    44 			'wp.newTerm'			=> 'this:wp_newTerm',

    45 			'wp.editTerm'			=> 'this:wp_editTerm',

    46 			'wp.deleteTerm'			=> 'this:wp_deleteTerm',

    47 			'wp.getTerm'			=> 'this:wp_getTerm',

    48 			'wp.getTerms'			=> 'this:wp_getTerms',

    49 			'wp.getTaxonomy'		=> 'this:wp_getTaxonomy',

    50 			'wp.getTaxonomies'		=> 'this:wp_getTaxonomies',

    51 			'wp.getUser'			=> 'this:wp_getUser',

    52 			'wp.getUsers'			=> 'this:wp_getUsers',

    53 			'wp.getProfile'			=> 'this:wp_getProfile',

    54 			'wp.editProfile'		=> 'this:wp_editProfile',

    55 			'wp.getPage'			=> 'this:wp_getPage',

    56 			'wp.getPages'			=> 'this:wp_getPages',

    57 			'wp.newPage'			=> 'this:wp_newPage',

    58 			'wp.deletePage'			=> 'this:wp_deletePage',

    59 			'wp.editPage'			=> 'this:wp_editPage',

    60 			'wp.getPageList'		=> 'this:wp_getPageList',

    61 			'wp.getAuthors'			=> 'this:wp_getAuthors',

    62 			'wp.getCategories'		=> 'this:mw_getCategories',		// Alias

    63 			'wp.getTags'			=> 'this:wp_getTags',

    64 			'wp.newCategory'		=> 'this:wp_newCategory',

    65 			'wp.deleteCategory'		=> 'this:wp_deleteCategory',

    66 			'wp.suggestCategories'	=> 'this:wp_suggestCategories',

    67 			'wp.uploadFile'			=> 'this:mw_newMediaObject',	// Alias

    68 			'wp.getCommentCount'	=> 'this:wp_getCommentCount',

    69 			'wp.getPostStatusList'	=> 'this:wp_getPostStatusList',

    70 			'wp.getPageStatusList'	=> 'this:wp_getPageStatusList',

    71 			'wp.getPageTemplates'	=> 'this:wp_getPageTemplates',

    72 			'wp.getOptions'			=> 'this:wp_getOptions',

    73 			'wp.setOptions'			=> 'this:wp_setOptions',

    74 			'wp.getComment'			=> 'this:wp_getComment',

    75 			'wp.getComments'		=> 'this:wp_getComments',

    76 			'wp.deleteComment'		=> 'this:wp_deleteComment',

    77 			'wp.editComment'		=> 'this:wp_editComment',

    78 			'wp.newComment'			=> 'this:wp_newComment',

    79 			'wp.getCommentStatusList' => 'this:wp_getCommentStatusList',

    80 			'wp.getMediaItem'		=> 'this:wp_getMediaItem',

    81 			'wp.getMediaLibrary'	=> 'this:wp_getMediaLibrary',

    82 			'wp.getPostFormats'     => 'this:wp_getPostFormats',

    83 			'wp.getPostType'		=> 'this:wp_getPostType',

    84 			'wp.getPostTypes'		=> 'this:wp_getPostTypes',

    85 			'wp.getRevisions'		=> 'this:wp_getRevisions',

    86 			'wp.restoreRevision'	=> 'this:wp_restoreRevision',

    87 

    88 			// Blogger API

    89 			'blogger.getUsersBlogs' => 'this:blogger_getUsersBlogs',

    90 			'blogger.getUserInfo' => 'this:blogger_getUserInfo',

    91 			'blogger.getPost' => 'this:blogger_getPost',

    92 			'blogger.getRecentPosts' => 'this:blogger_getRecentPosts',

    93 			'blogger.newPost' => 'this:blogger_newPost',

    94 			'blogger.editPost' => 'this:blogger_editPost',

    95 			'blogger.deletePost' => 'this:blogger_deletePost',

    96 

    97 			// MetaWeblog API (with MT extensions to structs)

    98 			'metaWeblog.newPost' => 'this:mw_newPost',

    99 			'metaWeblog.editPost' => 'this:mw_editPost',

   100 			'metaWeblog.getPost' => 'this:mw_getPost',

   101 			'metaWeblog.getRecentPosts' => 'this:mw_getRecentPosts',

   102 			'metaWeblog.getCategories' => 'this:mw_getCategories',

   103 			'metaWeblog.newMediaObject' => 'this:mw_newMediaObject',

   104 

   105 			// MetaWeblog API aliases for Blogger API

   106 			// see http://www.xmlrpc.com/stories/storyReader$2460

   107 			'metaWeblog.deletePost' => 'this:blogger_deletePost',

   108 			'metaWeblog.getUsersBlogs' => 'this:blogger_getUsersBlogs',

   109 

   110 			// MovableType API

   111 			'mt.getCategoryList' => 'this:mt_getCategoryList',

   112 			'mt.getRecentPostTitles' => 'this:mt_getRecentPostTitles',

   113 			'mt.getPostCategories' => 'this:mt_getPostCategories',

   114 			'mt.setPostCategories' => 'this:mt_setPostCategories',

   115 			'mt.supportedMethods' => 'this:mt_supportedMethods',

   116 			'mt.supportedTextFilters' => 'this:mt_supportedTextFilters',

   117 			'mt.getTrackbackPings' => 'this:mt_getTrackbackPings',

   118 			'mt.publishPost' => 'this:mt_publishPost',

   119 

   120 			// PingBack

   121 			'pingback.ping' => 'this:pingback_ping',

   122 			'pingback.extensions.getPingbacks' => 'this:pingback_extensions_getPingbacks',

   123 

   124 			'demo.sayHello' => 'this:sayHello',

   125 			'demo.addTwoNumbers' => 'this:addTwoNumbers'

   126 		);

   127 

   128 		$this->initialise_blog_option_info();

   129 		$this->methods = apply_filters('xmlrpc_methods', $this->methods);

   130 	}

   131 

   132 	function serve_request() {

   133 		$this->IXR_Server($this->methods);

   134 	}

   135 

   136 	/**

   137 	 * Test XMLRPC API by saying, "Hello!" to client.

   138 	 *

   139 	 * @since 1.5.0

   140 	 *

   141 	 * @param array $args Method Parameters.

   142 	 * @return string

   143 	 */

   144 	function sayHello($args) {

   145 		return 'Hello!';

   146 	}

   147 

   148 	/**

   149 	 * Test XMLRPC API by adding two numbers for client.

   150 	 *

   151 	 * @since 1.5.0

   152 	 *

   153 	 * @param array $args Method Parameters.

   154 	 * @return int

   155 	 */

   156 	function addTwoNumbers($args) {

   157 		$number1 = $args[0];

   158 		$number2 = $args[1];

   159 		return $number1 + $number2;

   160 	}

   161 

   162 	/**

   163 	 * Log user in.

   164 	 *

   165 	 * @since 2.8.0

   166 	 *

   167 	 * @param string $username User's username.

   168 	 * @param string $password User's password.

   169 	 * @return mixed WP_User object if authentication passed, false otherwise

   170 	 */

   171 	function login( $username, $password ) {

   172 		// Respect any old filters against get_option() for 'enable_xmlrpc'.

   173 		$enabled = apply_filters( 'pre_option_enable_xmlrpc', false ); // Deprecated

   174 		if ( false === $enabled )

   175 			$enabled = apply_filters( 'option_enable_xmlrpc', true ); // Deprecated

   176 

   177 		// Proper filter for turning off XML-RPC. It is on by default.

   178 		$enabled = apply_filters( 'xmlrpc_enabled', $enabled );

   179 

   180 		if ( ! $enabled ) {

   181 			$this->error = new IXR_Error( 405, sprintf( __( 'XML-RPC services are disabled on this site.' ) ) );

   182 			return false;

   183 		}

   184 

   185 		$user = wp_authenticate($username, $password);

   186 

   187 		if (is_wp_error($user)) {

   188 			$this->error = new IXR_Error( 403, __( 'Incorrect username or password.' ) );

   189 			$this->error = apply_filters( 'xmlrpc_login_error', $this->error, $user );

   190 			return false;

   191 		}

   192 

   193 		wp_set_current_user( $user->ID );

   194 		return $user;

   195 	}

   196 

   197 	/**

   198 	 * Check user's credentials. Deprecated.

   199 	 *

   200 	 * @since 1.5.0

   201 	 * @deprecated 2.8.0

   202 	 * @deprecated use wp_xmlrpc_server::login

   203 	 * @see wp_xmlrpc_server::login

   204 	 *

   205 	 * @param string $username User's username.

   206 	 * @param string $password User's password.

   207 	 * @return bool Whether authentication passed.

   208 	 */

   209 	function login_pass_ok( $username, $password ) {

   210 		return (bool) $this->login( $username, $password );

   211 	}

   212 

   213 	/**

   214 	 * Escape string or array of strings for database.

   215 	 *

   216 	 * @since 1.5.2

   217 	 *

   218 	 * @param string|array $data Escape single string or array of strings.

   219 	 * @return string|array Type matches $data and sanitized for the database.

   220 	 */

   221 	function escape( &$data ) {

   222 		if ( ! is_array( $data ) )

   223 			return wp_slash( $data );

   224 

   225 		foreach ( $data as &$v ) {

   226 			if ( is_array( $v ) )

   227 				$this->escape( $v );

   228 			elseif ( ! is_object( $v ) )

   229 				$v = wp_slash( $v );

   230 		}

   231 	}

   232 

   233 	/**

   234 	 * Retrieve custom fields for post.

   235 	 *

   236 	 * @since 2.5.0

   237 	 *

   238 	 * @param int $post_id Post ID.

   239 	 * @return array Custom fields, if exist.

   240 	 */

   241 	function get_custom_fields($post_id) {

   242 		$post_id = (int) $post_id;

   243 

   244 		$custom_fields = array();

   245 

   246 		foreach ( (array) has_meta($post_id) as $meta ) {

   247 			// Don't expose protected fields.

   248 			if ( ! current_user_can( 'edit_post_meta', $post_id , $meta['meta_key'] ) )

   249 				continue;

   250 

   251 			$custom_fields[] = array(

   252 				"id"    => $meta['meta_id'],

   253 				"key"   => $meta['meta_key'],

   254 				"value" => $meta['meta_value']

   255 			);

   256 		}

   257 

   258 		return $custom_fields;

   259 	}

   260 

   261 	/**

   262 	 * Set custom fields for post.

   263 	 *

   264 	 * @since 2.5.0

   265 	 *

   266 	 * @param int $post_id Post ID.

   267 	 * @param array $fields Custom fields.

   268 	 */

   269 	function set_custom_fields($post_id, $fields) {

   270 		$post_id = (int) $post_id;

   271 

   272 		foreach ( (array) $fields as $meta ) {

   273 			if ( isset($meta['id']) ) {

   274 				$meta['id'] = (int) $meta['id'];

   275 				$pmeta = get_metadata_by_mid( 'post', $meta['id'] );

   276 				if ( isset($meta['key']) ) {

   277 					$meta['key'] = wp_unslash( $meta['key'] );

   278 					if ( $meta['key'] !== $pmeta->meta_key )

   279 						continue;

   280 					$meta['value'] = wp_unslash( $meta['value'] );

   281 					if ( current_user_can( 'edit_post_meta', $post_id, $meta['key'] ) )

   282 						update_metadata_by_mid( 'post', $meta['id'], $meta['value'] );

   283 				} elseif ( current_user_can( 'delete_post_meta', $post_id, $pmeta->meta_key ) ) {

   284 					delete_metadata_by_mid( 'post', $meta['id'] );

   285 				}

   286 			} elseif ( current_user_can( 'add_post_meta', $post_id, wp_unslash( $meta['key'] ) ) ) {

   287 				add_post_meta( $post_id, $meta['key'], $meta['value'] );

   288 			}

   289 		}

   290 	}

   291 

   292 	/**

   293 	 * Set up blog options property.

   294 	 *

   295 	 * Passes property through 'xmlrpc_blog_options' filter.

   296 	 *

   297 	 * @since 2.6.0

   298 	 */

   299 	function initialise_blog_option_info() {

   300 		global $wp_version;

   301 

   302 		$this->blog_options = array(

   303 			// Read only options

   304 			'software_name'     => array(

   305 				'desc'          => __( 'Software Name' ),

   306 				'readonly'      => true,

   307 				'value'         => 'WordPress'

   308 			),

   309 			'software_version'  => array(

   310 				'desc'          => __( 'Software Version' ),

   311 				'readonly'      => true,

   312 				'value'         => $wp_version

   313 			),

   314 			'blog_url'          => array(

   315 				'desc'          => __( 'WordPress Address (URL)' ),

   316 				'readonly'      => true,

   317 				'option'        => 'siteurl'

   318 			),

   319 			'home_url'          => array(

   320 				'desc'          => __( 'Site Address (URL)' ),

   321 				'readonly'      => true,

   322 				'option'        => 'home'

   323 			),

   324 			'login_url'          => array(

   325 				'desc'          => __( 'Login Address (URL)' ),

   326 				'readonly'      => true,

   327 				'value'         => wp_login_url( )

   328 			),

   329 			'admin_url'          => array(

   330 				'desc'          => __( 'The URL to the admin area' ),

   331 				'readonly'      => true,

   332 				'value'         => get_admin_url( )

   333 			),

   334 			'image_default_link_type' => array(

   335 				'desc'          => __( 'Image default link type' ),

   336 				'readonly'      => true,

   337 				'option'        => 'image_default_link_type'

   338 			),

   339 			'image_default_size' => array(

   340 				'desc'          => __( 'Image default size' ),

   341 				'readonly'      => true,

   342 				'option'        => 'image_default_size'

   343 			),

   344 			'image_default_align' => array(

   345 				'desc'          => __( 'Image default align' ),

   346 				'readonly'      => true,

   347 				'option'        => 'image_default_align'

   348 			),

   349 			'template'          => array(

   350 				'desc'          => __( 'Template' ),

   351 				'readonly'      => true,

   352 				'option'        => 'template'

   353 			),

   354 			'stylesheet'        => array(

   355 				'desc'          => __( 'Stylesheet' ),

   356 				'readonly'      => true,

   357 				'option'        => 'stylesheet'

   358 			),

   359 			'post_thumbnail'    => array(

   360 				'desc'          => __('Post Thumbnail'),

   361 				'readonly'      => true,

   362 				'value'         => current_theme_supports( 'post-thumbnails' )

   363 			),

   364 

   365 			// Updatable options

   366 			'time_zone'         => array(

   367 				'desc'          => __( 'Time Zone' ),

   368 				'readonly'      => false,

   369 				'option'        => 'gmt_offset'

   370 			),

   371 			'blog_title'        => array(

   372 				'desc'          => __( 'Site Title' ),

   373 				'readonly'      => false,

   374 				'option'        => 'blogname'

   375 			),

   376 			'blog_tagline'      => array(

   377 				'desc'          => __( 'Site Tagline' ),

   378 				'readonly'      => false,

   379 				'option'        => 'blogdescription'

   380 			),

   381 			'date_format'       => array(

   382 				'desc'          => __( 'Date Format' ),

   383 				'readonly'      => false,

   384 				'option'        => 'date_format'

   385 			),

   386 			'time_format'       => array(

   387 				'desc'          => __( 'Time Format' ),

   388 				'readonly'      => false,

   389 				'option'        => 'time_format'

   390 			),

   391 			'users_can_register' => array(

   392 				'desc'          => __( 'Allow new users to sign up' ),

   393 				'readonly'      => false,

   394 				'option'        => 'users_can_register'

   395 			),

   396 			'thumbnail_size_w'  => array(

   397 				'desc'          => __( 'Thumbnail Width' ),

   398 				'readonly'      => false,

   399 				'option'        => 'thumbnail_size_w'

   400 			),

   401 			'thumbnail_size_h'  => array(

   402 				'desc'          => __( 'Thumbnail Height' ),

   403 				'readonly'      => false,

   404 				'option'        => 'thumbnail_size_h'

   405 			),

   406 			'thumbnail_crop'    => array(

   407 				'desc'          => __( 'Crop thumbnail to exact dimensions' ),

   408 				'readonly'      => false,

   409 				'option'        => 'thumbnail_crop'

   410 			),

   411 			'medium_size_w'     => array(

   412 				'desc'          => __( 'Medium size image width' ),

   413 				'readonly'      => false,

   414 				'option'        => 'medium_size_w'

   415 			),

   416 			'medium_size_h'     => array(

   417 				'desc'          => __( 'Medium size image height' ),

   418 				'readonly'      => false,

   419 				'option'        => 'medium_size_h'

   420 			),

   421 			'large_size_w'      => array(

   422 				'desc'          => __( 'Large size image width' ),

   423 				'readonly'      => false,

   424 				'option'        => 'large_size_w'

   425 			),

   426 			'large_size_h'      => array(

   427 				'desc'          => __( 'Large size image height' ),

   428 				'readonly'      => false,

   429 				'option'        => 'large_size_h'

   430 			),

   431 			'default_comment_status' => array(

   432 				'desc'          => __( 'Allow people to post comments on new articles' ),

   433 				'readonly'      => false,

   434 				'option'        => 'default_comment_status'

   435 			),

   436 			'default_ping_status' => array(

   437 				'desc'          => __( 'Allow link notifications from other blogs (pingbacks and trackbacks)' ),

   438 				'readonly'      => false,

   439 				'option'        => 'default_ping_status'

   440 			)

   441 		);

   442 

   443 		$this->blog_options = apply_filters( 'xmlrpc_blog_options', $this->blog_options );

   444 	}

   445 

   446 	/**

   447 	 * Retrieve the blogs of the user.

   448 	 *

   449 	 * @since 2.6.0

   450 	 *

   451 	 * @param array $args Method parameters. Contains:

   452 	 *  - username

   453 	 *  - password

   454 	 * @return array. Contains:

   455 	 *  - 'isAdmin'

   456 	 *  - 'url'

   457 	 *  - 'blogid'

   458 	 *  - 'blogName'

   459 	 *  - 'xmlrpc' - url of xmlrpc endpoint

   460 	 */

   461 	function wp_getUsersBlogs( $args ) {

   462 		global $current_site;

   463 		// If this isn't on WPMU then just use blogger_getUsersBlogs

   464 		if ( !is_multisite() ) {

   465 			array_unshift( $args, 1 );

   466 			return $this->blogger_getUsersBlogs( $args );

   467 		}

   468 

   469 		$this->escape( $args );

   470 

   471 		$username = $args[0];

   472 		$password = $args[1];

   473 

   474 		if ( !$user = $this->login($username, $password) )

   475 			return $this->error;

   476 

   477 		do_action( 'xmlrpc_call', 'wp.getUsersBlogs' );

   478 

   479 		$blogs = (array) get_blogs_of_user( $user->ID );

   480 		$struct = array();

   481 

   482 		foreach ( $blogs as $blog ) {

   483 			// Don't include blogs that aren't hosted at this site

   484 			if ( $blog->site_id != $current_site->id )

   485 				continue;

   486 

   487 			$blog_id = $blog->userblog_id;

   488 

   489 			switch_to_blog( $blog_id );

   490 

   491 			$is_admin = current_user_can( 'manage_options' );

   492 

   493 			$struct[] = array(

   494 				'isAdmin'		=> $is_admin,

   495 				'url'			=> home_url( '/' ),

   496 				'blogid'		=> (string) $blog_id,

   497 				'blogName'		=> get_option( 'blogname' ),

   498 				'xmlrpc'		=> site_url( 'xmlrpc.php', 'rpc' ),

   499 			);

   500 

   501 			restore_current_blog();

   502 		}

   503 

   504 		return $struct;

   505 	}

   506 

   507 	/**

   508 	 * Checks if the method received at least the minimum number of arguments.

   509 	 *

   510 	 * @since 3.4.0

   511 	 *

   512 	 * @param string|array $args Sanitize single string or array of strings.

   513 	 * @param int $count Minimum number of arguments.

   514 	 * @return boolean if $args contains at least $count arguments.

   515 	 */

   516 	protected function minimum_args( $args, $count ) {

   517 		if ( count( $args ) < $count ) {

   518 			$this->error = new IXR_Error( 400, __( 'Insufficient arguments passed to this XML-RPC method.' ) );

   519 			return false;

   520 		}

   521 

   522 		return true;

   523 	}

   524 

   525 	/**

   526 	 * Prepares taxonomy data for return in an XML-RPC object.

   527 	 *

   528 	 * @access protected

   529 	 *

   530 	 * @param object $taxonomy The unprepared taxonomy data

   531 	 * @param array $fields The subset of taxonomy fields to return

   532 	 * @return array The prepared taxonomy data

   533 	 */

   534 	protected function _prepare_taxonomy( $taxonomy, $fields ) {

   535 		$_taxonomy = array(

   536 			'name' => $taxonomy->name,

   537 			'label' => $taxonomy->label,

   538 			'hierarchical' => (bool) $taxonomy->hierarchical,

   539 			'public' => (bool) $taxonomy->public,

   540 			'show_ui' => (bool) $taxonomy->show_ui,

   541 			'_builtin' => (bool) $taxonomy->_builtin,

   542 		);

   543 

   544 		if ( in_array( 'labels', $fields ) )

   545 			$_taxonomy['labels'] = (array) $taxonomy->labels;

   546 

   547 		if ( in_array( 'cap', $fields ) )

   548 			$_taxonomy['cap'] = (array) $taxonomy->cap;

   549 

   550 		if ( in_array( 'menu', $fields ) )

   551 			$_taxonomy['show_in_menu'] = (bool) $_taxonomy->show_in_menu;

   552 

   553 		if ( in_array( 'object_type', $fields ) )

   554 			$_taxonomy['object_type'] = array_unique( (array) $taxonomy->object_type );

   555 

   556 		return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy, $fields );

   557 	}

   558 

   559 	/**

   560 	 * Prepares term data for return in an XML-RPC object.

   561 	 *

   562 	 * @access protected

   563 	 *

   564 	 * @param array|object $term The unprepared term data

   565 	 * @return array The prepared term data

   566 	 */

   567 	protected function _prepare_term( $term ) {

   568 		$_term = $term;

   569 		if ( ! is_array( $_term) )

   570 			$_term = get_object_vars( $_term );

   571 

   572 		// For integers which may be larger than XML-RPC supports ensure we return strings.

   573 		$_term['term_id'] = strval( $_term['term_id'] );

   574 		$_term['term_group'] = strval( $_term['term_group'] );

   575 		$_term['term_taxonomy_id'] = strval( $_term['term_taxonomy_id'] );

   576 		$_term['parent'] = strval( $_term['parent'] );

   577 

   578 		// Count we are happy to return as an integer because people really shouldn't use terms that much.

   579 		$_term['count'] = intval( $_term['count'] );

   580 

   581 		return apply_filters( 'xmlrpc_prepare_term', $_term, $term );

   582 	}

   583 

   584 	/**

   585 	 * Convert a WordPress date string to an IXR_Date object.

   586 	 *

   587 	 * @access protected

   588 	 *

   589 	 * @param string $date

   590 	 * @return IXR_Date

   591 	 */

   592 	protected function _convert_date( $date ) {

   593 		if ( $date === '0000-00-00 00:00:00' ) {

   594 			return new IXR_Date( '00000000T00:00:00Z' );

   595 		}

   596 		return new IXR_Date( mysql2date( 'Ymd\TH:i:s', $date, false ) );

   597 	}

   598 

   599 	/**

   600 	 * Convert a WordPress GMT date string to an IXR_Date object.

   601 	 *

   602 	 * @access protected

   603 	 *

   604 	 * @param string $date_gmt

   605 	 * @param string $date

   606 	 * @return IXR_Date

   607 	 */

   608 	protected function _convert_date_gmt( $date_gmt, $date ) {

   609 		if ( $date !== '0000-00-00 00:00:00' && $date_gmt === '0000-00-00 00:00:00' ) {

   610 			return new IXR_Date( get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $date, false ), 'Ymd\TH:i:s' ) );

   611 		}

   612 		return $this->_convert_date( $date_gmt );

   613 	}

   614 

   615 	/**

   616 	 * Prepares post data for return in an XML-RPC object.

   617 	 *

   618 	 * @access protected

   619 	 *

   620 	 * @param array $post The unprepared post data

   621 	 * @param array $fields The subset of post type fields to return

   622 	 * @return array The prepared post data

   623 	 */

   624 	protected function _prepare_post( $post, $fields ) {

   625 		// holds the data for this post. built up based on $fields

   626 		$_post = array( 'post_id' => strval( $post['ID'] ) );

   627 

   628 		// prepare common post fields

   629 		$post_fields = array(

   630 			'post_title'        => $post['post_title'],

   631 			'post_date'         => $this->_convert_date( $post['post_date'] ),

   632 			'post_date_gmt'     => $this->_convert_date_gmt( $post['post_date_gmt'], $post['post_date'] ),

   633 			'post_modified'     => $this->_convert_date( $post['post_modified'] ),

   634 			'post_modified_gmt' => $this->_convert_date_gmt( $post['post_modified_gmt'], $post['post_modified'] ),

   635 			'post_status'       => $post['post_status'],

   636 			'post_type'         => $post['post_type'],

   637 			'post_name'         => $post['post_name'],

   638 			'post_author'       => $post['post_author'],

   639 			'post_password'     => $post['post_password'],

   640 			'post_excerpt'      => $post['post_excerpt'],

   641 			'post_content'      => $post['post_content'],

   642 			'post_parent'       => strval( $post['post_parent'] ),

   643 			'post_mime_type'    => $post['post_mime_type'],

   644 			'link'              => post_permalink( $post['ID'] ),

   645 			'guid'              => $post['guid'],

   646 			'menu_order'        => intval( $post['menu_order'] ),

   647 			'comment_status'    => $post['comment_status'],

   648 			'ping_status'       => $post['ping_status'],

   649 			'sticky'            => ( $post['post_type'] === 'post' && is_sticky( $post['ID'] ) ),

   650 		);

   651 

   652 		// Thumbnail

   653 		$post_fields['post_thumbnail'] = array();

   654 		$thumbnail_id = get_post_thumbnail_id( $post['ID'] );

   655 		if ( $thumbnail_id ) {

   656 			$thumbnail_size = current_theme_supports('post-thumbnail') ? 'post-thumbnail' : 'thumbnail';

   657 			$post_fields['post_thumbnail'] = $this->_prepare_media_item( get_post( $thumbnail_id ), $thumbnail_size );

   658 		}

   659 

   660 		// Consider future posts as published

   661 		if ( $post_fields['post_status'] === 'future' )

   662 			$post_fields['post_status'] = 'publish';

   663 

   664 		// Fill in blank post format

   665 		$post_fields['post_format'] = get_post_format( $post['ID'] );

   666 		if ( empty( $post_fields['post_format'] ) )

   667 			$post_fields['post_format'] = 'standard';

   668 

   669 		// Merge requested $post_fields fields into $_post

   670 		if ( in_array( 'post', $fields ) ) {

   671 			$_post = array_merge( $_post, $post_fields );

   672 		} else {

   673 			$requested_fields = array_intersect_key( $post_fields, array_flip( $fields ) );

   674 			$_post = array_merge( $_post, $requested_fields );

   675 		}

   676 

   677 		$all_taxonomy_fields = in_array( 'taxonomies', $fields );

   678 

   679 		if ( $all_taxonomy_fields || in_array( 'terms', $fields ) ) {

   680 			$post_type_taxonomies = get_object_taxonomies( $post['post_type'], 'names' );

   681 			$terms = wp_get_object_terms( $post['ID'], $post_type_taxonomies );

   682 			$_post['terms'] = array();

   683 			foreach ( $terms as $term ) {

   684 				$_post['terms'][] = $this->_prepare_term( $term );

   685 			}

   686 		}

   687 

   688 		if ( in_array( 'custom_fields', $fields ) )

   689 			$_post['custom_fields'] = $this->get_custom_fields( $post['ID'] );

   690 

   691 		if ( in_array( 'enclosure', $fields ) ) {

   692 			$_post['enclosure'] = array();

   693 			$enclosures = (array) get_post_meta( $post['ID'], 'enclosure' );

   694 			if ( ! empty( $enclosures ) ) {

   695 				$encdata = explode( "\n", $enclosures[0] );

   696 				$_post['enclosure']['url'] = trim( htmlspecialchars( $encdata[0] ) );

   697 				$_post['enclosure']['length'] = (int) trim( $encdata[1] );

   698 				$_post['enclosure']['type'] = trim( $encdata[2] );

   699 			}

   700 		}

   701 

   702 		return apply_filters( 'xmlrpc_prepare_post', $_post, $post, $fields );

   703 	}

   704 

   705 	/**

   706 	 * Prepares post data for return in an XML-RPC object.

   707 	 *

   708 	 * @access protected

   709 	 *

   710 	 * @param object $post_type Post type object

   711 	 * @param array $fields The subset of post fields to return

   712 	 * @return array The prepared post type data

   713 	 */

   714 	protected function _prepare_post_type( $post_type, $fields ) {

   715 		$_post_type = array(

   716 			'name' => $post_type->name,

   717 			'label' => $post_type->label,

   718 			'hierarchical' => (bool) $post_type->hierarchical,

   719 			'public' => (bool) $post_type->public,

   720 			'show_ui' => (bool) $post_type->show_ui,

   721 			'_builtin' => (bool) $post_type->_builtin,

   722 			'has_archive' => (bool) $post_type->has_archive,

   723 			'supports' => get_all_post_type_supports( $post_type->name ),

   724 		);

   725 

   726 		if ( in_array( 'labels', $fields ) ) {

   727 			$_post_type['labels'] = (array) $post_type->labels;

   728 		}

   729 

   730 		if ( in_array( 'cap', $fields ) ) {

   731 			$_post_type['cap'] = (array) $post_type->cap;

   732 			$_post_type['map_meta_cap'] = (bool) $post_type->map_meta_cap;

   733 		}

   734 

   735 		if ( in_array( 'menu', $fields ) ) {

   736 			$_post_type['menu_position'] = (int) $post_type->menu_position;

   737 			$_post_type['menu_icon'] = $post_type->menu_icon;

   738 			$_post_type['show_in_menu'] = (bool) $post_type->show_in_menu;

   739 		}

   740 

   741 		if ( in_array( 'taxonomies', $fields ) )

   742 			$_post_type['taxonomies'] = get_object_taxonomies( $post_type->name, 'names' );

   743 

   744 		return apply_filters( 'xmlrpc_prepare_post_type', $_post_type, $post_type );

   745 	}

   746 

   747 	/**

   748 	 * Prepares media item data for return in an XML-RPC object.

   749 	 *

   750 	 * @access protected

   751 	 *

   752 	 * @param object $media_item The unprepared media item data

   753 	 * @param string $thumbnail_size The image size to use for the thumbnail URL

   754 	 * @return array The prepared media item data

   755 	 */

   756 	protected function _prepare_media_item( $media_item, $thumbnail_size = 'thumbnail' ) {

   757 		$_media_item = array(

   758 			'attachment_id'    => strval( $media_item->ID ),

   759 			'date_created_gmt' => $this->_convert_date_gmt( $media_item->post_date_gmt, $media_item->post_date ),

   760 			'parent'           => $media_item->post_parent,

   761 			'link'             => wp_get_attachment_url( $media_item->ID ),

   762 			'title'            => $media_item->post_title,

   763 			'caption'          => $media_item->post_excerpt,

   764 			'description'      => $media_item->post_content,

   765 			'metadata'         => wp_get_attachment_metadata( $media_item->ID ),

   766 		);

   767 

   768 		$thumbnail_src = image_downsize( $media_item->ID, $thumbnail_size );

   769 		if ( $thumbnail_src )

   770 			$_media_item['thumbnail'] = $thumbnail_src[0];

   771 		else

   772 			$_media_item['thumbnail'] = $_media_item['link'];

   773 

   774 		return apply_filters( 'xmlrpc_prepare_media_item', $_media_item, $media_item, $thumbnail_size );

   775 	}

   776 

   777 	/**

   778 	 * Prepares page data for return in an XML-RPC object.

   779 	 *

   780 	 * @access protected

   781 	 *

   782 	 * @param object $page The unprepared page data

   783 	 * @return array The prepared page data

   784 	 */

   785 	protected function _prepare_page( $page ) {

   786 		// Get all of the page content and link.

   787 		$full_page = get_extended( $page->post_content );

   788 		$link = post_permalink( $page->ID );

   789 

   790 		// Get info the page parent if there is one.

   791 		$parent_title = "";

   792 		if ( ! empty( $page->post_parent ) ) {

   793 			$parent = get_post( $page->post_parent );

   794 			$parent_title = $parent->post_title;

   795 		}

   796 

   797 		// Determine comment and ping settings.

   798 		$allow_comments = comments_open( $page->ID ) ? 1 : 0;

   799 		$allow_pings = pings_open( $page->ID ) ? 1 : 0;

   800 

   801 		// Format page date.

   802 		$page_date = $this->_convert_date( $page->post_date );

   803 		$page_date_gmt = $this->_convert_date_gmt( $page->post_date_gmt, $page->post_date );

   804 

   805 		// Pull the categories info together.

   806 		$categories = array();

   807 		foreach ( wp_get_post_categories( $page->ID ) as $cat_id ) {

   808 			$categories[] = get_cat_name( $cat_id );

   809 		}

   810 

   811 		// Get the author info.

   812 		$author = get_userdata( $page->post_author );

   813 

   814 		$page_template = get_page_template_slug( $page->ID );

   815 		if ( empty( $page_template ) )

   816 			$page_template = 'default';

   817 

   818 		$_page = array(

   819 			'dateCreated'            => $page_date,

   820 			'userid'                 => $page->post_author,

   821 			'page_id'                => $page->ID,

   822 			'page_status'            => $page->post_status,

   823 			'description'            => $full_page['main'],

   824 			'title'                  => $page->post_title,

   825 			'link'                   => $link,

   826 			'permaLink'              => $link,

   827 			'categories'             => $categories,

   828 			'excerpt'                => $page->post_excerpt,

   829 			'text_more'              => $full_page['extended'],

   830 			'mt_allow_comments'      => $allow_comments,

   831 			'mt_allow_pings'         => $allow_pings,

   832 			'wp_slug'                => $page->post_name,

   833 			'wp_password'            => $page->post_password,

   834 			'wp_author'              => $author->display_name,

   835 			'wp_page_parent_id'      => $page->post_parent,

   836 			'wp_page_parent_title'   => $parent_title,

   837 			'wp_page_order'          => $page->menu_order,

   838 			'wp_author_id'           => (string) $author->ID,

   839 			'wp_author_display_name' => $author->display_name,

   840 			'date_created_gmt'       => $page_date_gmt,

   841 			'custom_fields'          => $this->get_custom_fields( $page->ID ),

   842 			'wp_page_template'       => $page_template

   843 		);

   844 

   845 		return apply_filters( 'xmlrpc_prepare_page', $_page, $page );

   846 	}

   847 

   848 	/**

   849 	 * Prepares comment data for return in an XML-RPC object.

   850 	 *

   851 	 * @access protected

   852 	 *

   853 	 * @param object $comment The unprepared comment data

   854 	 * @return array The prepared comment data

   855 	 */

   856 	protected function _prepare_comment( $comment ) {

   857 		// Format page date.

   858 		$comment_date = $this->_convert_date( $comment->comment_date );

   859 		$comment_date_gmt = $this->_convert_date_gmt( $comment->comment_date_gmt, $comment->comment_date );

   860 

   861 		if ( '0' == $comment->comment_approved )

   862 			$comment_status = 'hold';

   863 		else if ( 'spam' == $comment->comment_approved )

   864 			$comment_status = 'spam';

   865 		else if ( '1' == $comment->comment_approved )

   866 			$comment_status = 'approve';

   867 		else

   868 			$comment_status = $comment->comment_approved;

   869 

   870 		$_comment = array(

   871 			'date_created_gmt' => $comment_date_gmt,

   872 			'user_id'          => $comment->user_id,

   873 			'comment_id'       => $comment->comment_ID,

   874 			'parent'           => $comment->comment_parent,

   875 			'status'           => $comment_status,

   876 			'content'          => $comment->comment_content,

   877 			'link'             => get_comment_link($comment),

   878 			'post_id'          => $comment->comment_post_ID,

   879 			'post_title'       => get_the_title($comment->comment_post_ID),

   880 			'author'           => $comment->comment_author,

   881 			'author_url'       => $comment->comment_author_url,

   882 			'author_email'     => $comment->comment_author_email,

   883 			'author_ip'        => $comment->comment_author_IP,

   884 			'type'             => $comment->comment_type,

   885 		);

   886 

   887 		return apply_filters( 'xmlrpc_prepare_comment', $_comment, $comment );

   888 	}

   889 

   890 	/**

   891 	 * Prepares user data for return in an XML-RPC object.

   892 	 *

   893 	 * @access protected

   894 	 *

   895 	 * @param WP_User $user The unprepared user object

   896 	 * @param array $fields The subset of user fields to return

   897 	 * @return array The prepared user data

   898 	 */

   899 	protected function _prepare_user( $user, $fields ) {

   900 		$_user = array( 'user_id' => strval( $user->ID ) );

   901 

   902 		$user_fields = array(

   903 			'username'          => $user->user_login,

   904 			'first_name'        => $user->user_firstname,

   905 			'last_name'         => $user->user_lastname,

   906 			'registered'        => $this->_convert_date( $user->user_registered ),

   907 			'bio'               => $user->user_description,

   908 			'email'             => $user->user_email,

   909 			'nickname'          => $user->nickname,

   910 			'nicename'          => $user->user_nicename,

   911 			'url'               => $user->user_url,

   912 			'display_name'      => $user->display_name,

   913 			'roles'             => $user->roles,

   914 		);

   915 

   916 		if ( in_array( 'all', $fields ) ) {

   917 			$_user = array_merge( $_user, $user_fields );

   918 		} else {

   919 			if ( in_array( 'basic', $fields ) ) {

   920 				$basic_fields = array( 'username', 'email', 'registered', 'display_name', 'nicename' );

   921 				$fields = array_merge( $fields, $basic_fields );

   922 			}

   923 			$requested_fields = array_intersect_key( $user_fields, array_flip( $fields ) );

   924 			$_user = array_merge( $_user, $requested_fields );

   925 		}

   926 

   927 		return apply_filters( 'xmlrpc_prepare_user', $_user, $user, $fields );

   928 	}

   929 

   930 	/**

   931 	 * Create a new post for any registered post type.

   932 	 *

   933 	 * @since 3.4.0

   934 	 *

   935 	 * @param array $args Method parameters. Contains:

   936 	 *  - int     $blog_id

   937 	 *  - string  $username

   938 	 *  - string  $password

   939 	 *  - array   $content_struct

   940 	 *      $content_struct can contain:

   941 	 *      - post_type (default: 'post')

   942 	 *      - post_status (default: 'draft')

   943 	 *      - post_title

   944 	 *      - post_author

   945 	 *      - post_excerpt

   946 	 *      - post_content

   947 	 *      - post_date_gmt | post_date

   948 	 *      - post_format

   949 	 *      - post_password

   950 	 *      - comment_status - can be 'open' | 'closed'

   951 	 *      - ping_status - can be 'open' | 'closed'

   952 	 *      - sticky

   953 	 *      - post_thumbnail - ID of a media item to use as the post thumbnail/featured image

   954 	 *      - custom_fields - array, with each element containing 'key' and 'value'

   955 	 *      - terms - array, with taxonomy names as keys and arrays of term IDs as values

   956 	 *      - terms_names - array, with taxonomy names as keys and arrays of term names as values

   957 	 *      - enclosure

   958 	 *      - any other fields supported by wp_insert_post()

   959 	 * @return string post_id

   960 	 */

   961 	function wp_newPost( $args ) {

   962 		if ( ! $this->minimum_args( $args, 4 ) )

   963 			return $this->error;

   964 

   965 		$this->escape( $args );

   966 

   967 		$blog_id        = (int) $args[0];

   968 		$username       = $args[1];

   969 		$password       = $args[2];

   970 		$content_struct = $args[3];

   971 

   972 		if ( ! $user = $this->login( $username, $password ) )

   973 			return $this->error;

   974 

   975 		do_action( 'xmlrpc_call', 'wp.newPost' );

   976 

   977 		unset( $content_struct['ID'] );

   978 

   979 		return $this->_insert_post( $user, $content_struct );

   980 	}

   981 

   982 	/**

   983 	 * Helper method for filtering out elements from an array.

   984 	 *

   985 	 * @since 3.4.0

   986 	 *

   987 	 * @param int $count Number to compare to one.

   988 	 */

   989 	private function _is_greater_than_one( $count ) {

   990 		return $count > 1;

   991 	}

   992 

   993 	/**

   994 	 * Helper method for wp_newPost and wp_editPost, containing shared logic.

   995 	 *

   996 	 * @since 3.4.0

   997 	 * @uses wp_insert_post()

   998 	 *

   999 	 * @param WP_User $user The post author if post_author isn't set in $content_struct.

  1000 	 * @param array $content_struct Post data to insert.

  1001 	 */

  1002 	protected function _insert_post( $user, $content_struct ) {

  1003 		$defaults = array( 'post_status' => 'draft', 'post_type' => 'post', 'post_author' => 0,

  1004 			'post_password' => '', 'post_excerpt' => '', 'post_content' => '', 'post_title' => '' );

  1005 

  1006 		$post_data = wp_parse_args( $content_struct, $defaults );

  1007 

  1008 		$post_type = get_post_type_object( $post_data['post_type'] );

  1009 		if ( ! $post_type )

  1010 			return new IXR_Error( 403, __( 'Invalid post type' ) );

  1011 

  1012 		$update = ! empty( $post_data['ID'] );

  1013 

  1014 		if ( $update ) {

  1015 			if ( ! get_post( $post_data['ID'] ) )

  1016 				return new IXR_Error( 401, __( 'Invalid post ID.' ) );

  1017 			if ( ! current_user_can( 'edit_post', $post_data['ID'] ) )

  1018 				return new IXR_Error( 401, __( 'Sorry, you are not allowed to edit this post.' ) );

  1019 			if ( $post_data['post_type'] != get_post_type( $post_data['ID'] ) )

  1020 				return new IXR_Error( 401, __( 'The post type may not be changed.' ) );

  1021 		} else {

  1022 			if ( ! current_user_can( $post_type->cap->create_posts ) || ! current_user_can( $post_type->cap->edit_posts ) )

  1023 				return new IXR_Error( 401, __( 'Sorry, you are not allowed to post on this site.' ) );

  1024 		}

  1025 

  1026 		switch ( $post_data['post_status'] ) {

  1027 			case 'draft':

  1028 			case 'pending':

  1029 				break;

  1030 			case 'private':

  1031 				if ( ! current_user_can( $post_type->cap->publish_posts ) )

  1032 					return new IXR_Error( 401, __( 'Sorry, you are not allowed to create private posts in this post type' ) );

  1033 				break;

  1034 			case 'publish':

  1035 			case 'future':

  1036 				if ( ! current_user_can( $post_type->cap->publish_posts ) )

  1037 					return new IXR_Error( 401, __( 'Sorry, you are not allowed to publish posts in this post type' ) );

  1038 				break;

  1039 			default:

  1040 				if ( ! get_post_status_object( $post_data['post_status'] ) )

  1041 					$post_data['post_status'] = 'draft';

  1042 			break;

  1043 		}

  1044 

  1045 		if ( ! empty( $post_data['post_password'] ) && ! current_user_can( $post_type->cap->publish_posts ) )

  1046 			return new IXR_Error( 401, __( 'Sorry, you are not allowed to create password protected posts in this post type' ) );

  1047 

  1048 		$post_data['post_author'] = absint( $post_data['post_author'] );

  1049 		if ( ! empty( $post_data['post_author'] ) && $post_data['post_author'] != $user->ID ) {

  1050 			if ( ! current_user_can( $post_type->cap->edit_others_posts ) )

  1051 				return new IXR_Error( 401, __( 'You are not allowed to create posts as this user.' ) );

  1052 

  1053 			$author = get_userdata( $post_data['post_author'] );

  1054 

  1055 			if ( ! $author )

  1056 				return new IXR_Error( 404, __( 'Invalid author ID.' ) );

  1057 		} else {

  1058 			$post_data['post_author'] = $user->ID;

  1059 		}

  1060 

  1061 		if ( isset( $post_data['comment_status'] ) && $post_data['comment_status'] != 'open' && $post_data['comment_status'] != 'closed' )

  1062 			unset( $post_data['comment_status'] );

  1063 

  1064 		if ( isset( $post_data['ping_status'] ) && $post_data['ping_status'] != 'open' && $post_data['ping_status'] != 'closed' )

  1065 			unset( $post_data['ping_status'] );

  1066 

  1067 		// Do some timestamp voodoo

  1068 		if ( ! empty( $post_data['post_date_gmt'] ) ) {

  1069 			// We know this is supposed to be GMT, so we're going to slap that Z on there by force

  1070 			$dateCreated = rtrim( $post_data['post_date_gmt']->getIso(), 'Z' ) . 'Z';

  1071 		} elseif ( ! empty( $post_data['post_date'] ) ) {

  1072 			$dateCreated = $post_data['post_date']->getIso();

  1073 		}

  1074 

  1075 		if ( ! empty( $dateCreated ) ) {

  1076 			$post_data['post_date'] = get_date_from_gmt( iso8601_to_datetime( $dateCreated ) );

  1077 			$post_data['post_date_gmt'] = iso8601_to_datetime( $dateCreated, 'GMT' );

  1078 		}

  1079 

  1080 		if ( ! isset( $post_data['ID'] ) )

  1081 			$post_data['ID'] = get_default_post_to_edit( $post_data['post_type'], true )->ID;

  1082 		$post_ID = $post_data['ID'];

  1083 

  1084 		if ( $post_data['post_type'] == 'post' ) {

  1085 			// Private and password-protected posts cannot be stickied.

  1086 			if ( $post_data['post_status'] == 'private' || ! empty( $post_data['post_password'] ) ) {

  1087 				// Error if the client tried to stick the post, otherwise, silently unstick.

  1088 				if ( ! empty( $post_data['sticky'] ) )

  1089 					return new IXR_Error( 401, __( 'Sorry, you cannot stick a private post.' ) );

  1090 				if ( $update )

  1091 					unstick_post( $post_ID );

  1092 			} elseif ( isset( $post_data['sticky'] ) )  {

  1093 				if ( ! current_user_can( $post_type->cap->edit_others_posts ) )

  1094 					return new IXR_Error( 401, __( 'Sorry, you are not allowed to stick this post.' ) );

  1095 				if ( $post_data['sticky'] )

  1096 					stick_post( $post_ID );

  1097 				else

  1098 					unstick_post( $post_ID );

  1099 			}

  1100 		}

  1101 

  1102 		if ( isset( $post_data['post_thumbnail'] ) ) {

  1103 			// empty value deletes, non-empty value adds/updates

  1104 			if ( ! $post_data['post_thumbnail'] )

  1105 				delete_post_thumbnail( $post_ID );

  1106 			elseif ( ! get_post( absint( $post_data['post_thumbnail'] ) ) )

  1107 				return new IXR_Error( 404, __( 'Invalid attachment ID.' ) );

  1108 			set_post_thumbnail( $post_ID, $post_data['post_thumbnail'] );

  1109 			unset( $content_struct['post_thumbnail'] );

  1110 		}

  1111 

  1112 		if ( isset( $post_data['custom_fields'] ) )

  1113 			$this->set_custom_fields( $post_ID, $post_data['custom_fields'] );

  1114 

  1115 		if ( isset( $post_data['terms'] ) || isset( $post_data['terms_names'] ) ) {

  1116 			$post_type_taxonomies = get_object_taxonomies( $post_data['post_type'], 'objects' );

  1117 

  1118 			// accumulate term IDs from terms and terms_names

  1119 			$terms = array();

  1120 

  1121 			// first validate the terms specified by ID

  1122 			if ( isset( $post_data['terms'] ) && is_array( $post_data['terms'] ) ) {

  1123 				$taxonomies = array_keys( $post_data['terms'] );

  1124 

  1125 				// validating term ids

  1126 				foreach ( $taxonomies as $taxonomy ) {

  1127 					if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) )

  1128 						return new IXR_Error( 401, __( 'Sorry, one of the given taxonomies is not supported by the post type.' ) );

  1129 

  1130 					if ( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) )

  1131 						return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) );

  1132 

  1133 					$term_ids = $post_data['terms'][$taxonomy];

  1134 					foreach ( $term_ids as $term_id ) {

  1135 						$term = get_term_by( 'id', $term_id, $taxonomy );