diff options
Diffstat (limited to 'srcs/wordpress/wp-includes/class-wp-xmlrpc-server.php')
| -rw-r--r-- | srcs/wordpress/wp-includes/class-wp-xmlrpc-server.php | 7047 |
1 files changed, 7047 insertions, 0 deletions
diff --git a/srcs/wordpress/wp-includes/class-wp-xmlrpc-server.php b/srcs/wordpress/wp-includes/class-wp-xmlrpc-server.php new file mode 100644 index 0000000..5b3d514 --- /dev/null +++ b/srcs/wordpress/wp-includes/class-wp-xmlrpc-server.php @@ -0,0 +1,7047 @@ +<?php +/** + * XML-RPC protocol support for WordPress + * + * @package WordPress + * @subpackage Publishing + */ + +/** + * WordPress XMLRPC server implementation. + * + * Implements compatibility for Blogger API, MetaWeblog API, MovableType, and + * pingback. Additional WordPress API for managing comments, pages, posts, + * options, etc. + * + * As of WordPress 3.5.0, XML-RPC is enabled by default. It can be disabled + * via the {@see 'xmlrpc_enabled'} filter found in wp_xmlrpc_server::login(). + * + * @since 1.5.0 + * + * @see IXR_Server + */ +class wp_xmlrpc_server extends IXR_Server { + /** + * Methods. + * + * @var array + */ + public $methods; + + /** + * Blog options. + * + * @var array + */ + public $blog_options; + + /** + * IXR_Error instance. + * + * @var IXR_Error + */ + public $error; + + /** + * Flags that the user authentication has failed in this instance of wp_xmlrpc_server. + * + * @var bool + */ + protected $auth_failed = false; + + /** + * Registers all of the XMLRPC methods that XMLRPC server understands. + * + * Sets up server and method property. Passes XMLRPC + * methods through the {@see 'xmlrpc_methods'} filter to allow plugins to extend + * or replace XML-RPC methods. + * + * @since 1.5.0 + */ + public function __construct() { + $this->methods = array( + // WordPress API + 'wp.getUsersBlogs' => 'this:wp_getUsersBlogs', + 'wp.newPost' => 'this:wp_newPost', + 'wp.editPost' => 'this:wp_editPost', + 'wp.deletePost' => 'this:wp_deletePost', + 'wp.getPost' => 'this:wp_getPost', + 'wp.getPosts' => 'this:wp_getPosts', + 'wp.newTerm' => 'this:wp_newTerm', + 'wp.editTerm' => 'this:wp_editTerm', + 'wp.deleteTerm' => 'this:wp_deleteTerm', + 'wp.getTerm' => 'this:wp_getTerm', + 'wp.getTerms' => 'this:wp_getTerms', + 'wp.getTaxonomy' => 'this:wp_getTaxonomy', + 'wp.getTaxonomies' => 'this:wp_getTaxonomies', + 'wp.getUser' => 'this:wp_getUser', + 'wp.getUsers' => 'this:wp_getUsers', + 'wp.getProfile' => 'this:wp_getProfile', + 'wp.editProfile' => 'this:wp_editProfile', + 'wp.getPage' => 'this:wp_getPage', + 'wp.getPages' => 'this:wp_getPages', + 'wp.newPage' => 'this:wp_newPage', + 'wp.deletePage' => 'this:wp_deletePage', + 'wp.editPage' => 'this:wp_editPage', + 'wp.getPageList' => 'this:wp_getPageList', + 'wp.getAuthors' => 'this:wp_getAuthors', + 'wp.getCategories' => 'this:mw_getCategories', // Alias + 'wp.getTags' => 'this:wp_getTags', + 'wp.newCategory' => 'this:wp_newCategory', + 'wp.deleteCategory' => 'this:wp_deleteCategory', + 'wp.suggestCategories' => 'this:wp_suggestCategories', + 'wp.uploadFile' => 'this:mw_newMediaObject', // Alias + 'wp.deleteFile' => 'this:wp_deletePost', // Alias + 'wp.getCommentCount' => 'this:wp_getCommentCount', + 'wp.getPostStatusList' => 'this:wp_getPostStatusList', + 'wp.getPageStatusList' => 'this:wp_getPageStatusList', + 'wp.getPageTemplates' => 'this:wp_getPageTemplates', + 'wp.getOptions' => 'this:wp_getOptions', + 'wp.setOptions' => 'this:wp_setOptions', + 'wp.getComment' => 'this:wp_getComment', + 'wp.getComments' => 'this:wp_getComments', + 'wp.deleteComment' => 'this:wp_deleteComment', + 'wp.editComment' => 'this:wp_editComment', + 'wp.newComment' => 'this:wp_newComment', + 'wp.getCommentStatusList' => 'this:wp_getCommentStatusList', + 'wp.getMediaItem' => 'this:wp_getMediaItem', + 'wp.getMediaLibrary' => 'this:wp_getMediaLibrary', + 'wp.getPostFormats' => 'this:wp_getPostFormats', + 'wp.getPostType' => 'this:wp_getPostType', + 'wp.getPostTypes' => 'this:wp_getPostTypes', + 'wp.getRevisions' => 'this:wp_getRevisions', + 'wp.restoreRevision' => 'this:wp_restoreRevision', + + // Blogger API + 'blogger.getUsersBlogs' => 'this:blogger_getUsersBlogs', + 'blogger.getUserInfo' => 'this:blogger_getUserInfo', + 'blogger.getPost' => 'this:blogger_getPost', + 'blogger.getRecentPosts' => 'this:blogger_getRecentPosts', + 'blogger.newPost' => 'this:blogger_newPost', + 'blogger.editPost' => 'this:blogger_editPost', + 'blogger.deletePost' => 'this:blogger_deletePost', + + // MetaWeblog API (with MT extensions to structs) + 'metaWeblog.newPost' => 'this:mw_newPost', + 'metaWeblog.editPost' => 'this:mw_editPost', + 'metaWeblog.getPost' => 'this:mw_getPost', + 'metaWeblog.getRecentPosts' => 'this:mw_getRecentPosts', + 'metaWeblog.getCategories' => 'this:mw_getCategories', + 'metaWeblog.newMediaObject' => 'this:mw_newMediaObject', + + // MetaWeblog API aliases for Blogger API + // see http://www.xmlrpc.com/stories/storyReader$2460 + 'metaWeblog.deletePost' => 'this:blogger_deletePost', + 'metaWeblog.getUsersBlogs' => 'this:blogger_getUsersBlogs', + + // MovableType API + 'mt.getCategoryList' => 'this:mt_getCategoryList', + 'mt.getRecentPostTitles' => 'this:mt_getRecentPostTitles', + 'mt.getPostCategories' => 'this:mt_getPostCategories', + 'mt.setPostCategories' => 'this:mt_setPostCategories', + 'mt.supportedMethods' => 'this:mt_supportedMethods', + 'mt.supportedTextFilters' => 'this:mt_supportedTextFilters', + 'mt.getTrackbackPings' => 'this:mt_getTrackbackPings', + 'mt.publishPost' => 'this:mt_publishPost', + + // PingBack + 'pingback.ping' => 'this:pingback_ping', + 'pingback.extensions.getPingbacks' => 'this:pingback_extensions_getPingbacks', + + 'demo.sayHello' => 'this:sayHello', + 'demo.addTwoNumbers' => 'this:addTwoNumbers', + ); + + $this->initialise_blog_option_info(); + + /** + * Filters the methods exposed by the XML-RPC server. + * + * This filter can be used to add new methods, and remove built-in methods. + * + * @since 1.5.0 + * + * @param array $methods An array of XML-RPC methods. + */ + $this->methods = apply_filters( 'xmlrpc_methods', $this->methods ); + } + + /** + * Make private/protected methods readable for backward compatibility. + * + * @since 4.0.0 + * + * @param string $name Method to call. + * @param array $arguments Arguments to pass when calling. + * @return array|IXR_Error|false Return value of the callback, false otherwise. + */ + public function __call( $name, $arguments ) { + if ( '_multisite_getUsersBlogs' === $name ) { + return $this->_multisite_getUsersBlogs( ...$arguments ); + } + return false; + } + + /** + * Serves the XML-RPC request. + * + * @since 2.9.0 + */ + public function serve_request() { + $this->IXR_Server( $this->methods ); + } + + /** + * Test XMLRPC API by saying, "Hello!" to client. + * + * @since 1.5.0 + * + * @return string Hello string response. + */ + public function sayHello() { + return 'Hello!'; + } + + /** + * Test XMLRPC API by adding two numbers for client. + * + * @since 1.5.0 + * + * @param array $args { + * Method arguments. Note: arguments must be ordered as documented. + * + * @type int $number1 A number to add. + * @type int $number2 A second number to add. + * } + * @return int Sum of the two given numbers. + */ + public function addTwoNumbers( $args ) { + $number1 = $args[0]; + $number2 = $args[1]; + return $number1 + $number2; + } + + /** + * Log user in. + * + * @since 2.8.0 + * + * @param string $username User's username. + * @param string $password User's password. + * @return WP_User|bool WP_User object if authentication passed, false otherwise + */ + public function login( $username, $password ) { + /* + * Respect old get_option() filters left for back-compat when the 'enable_xmlrpc' + * option was deprecated in 3.5.0. Use the 'xmlrpc_enabled' hook instead. + */ + $enabled = apply_filters( 'pre_option_enable_xmlrpc', false ); + if ( false === $enabled ) { + $enabled = apply_filters( 'option_enable_xmlrpc', true ); + } + + /** + * Filters whether XML-RPC methods requiring authentication are enabled. + * + * Contrary to the way it's named, this filter does not control whether XML-RPC is *fully* + * enabled, rather, it only controls whether XML-RPC methods requiring authentication - such + * as for publishing purposes - are enabled. + * + * Further, the filter does not control whether pingbacks or other custom endpoints that don't + * require authentication are enabled. This behavior is expected, and due to how parity was matched + * with the `enable_xmlrpc` UI option the filter replaced when it was introduced in 3.5. + * + * To disable XML-RPC methods that require authentication, use: + * + * add_filter( 'xmlrpc_enabled', '__return_false' ); + * + * For more granular control over all XML-RPC methods and requests, see the {@see 'xmlrpc_methods'} + * and {@see 'xmlrpc_element_limit'} hooks. + * + * @since 3.5.0 + * + * @param bool $enabled Whether XML-RPC is enabled. Default true. + */ + $enabled = apply_filters( 'xmlrpc_enabled', $enabled ); + + if ( ! $enabled ) { + $this->error = new IXR_Error( 405, sprintf( __( 'XML-RPC services are disabled on this site.' ) ) ); + return false; + } + + if ( $this->auth_failed ) { + $user = new WP_Error( 'login_prevented' ); + } else { + $user = wp_authenticate( $username, $password ); + } + + if ( is_wp_error( $user ) ) { + $this->error = new IXR_Error( 403, __( 'Incorrect username or password.' ) ); + + // Flag that authentication has failed once on this wp_xmlrpc_server instance + $this->auth_failed = true; + + /** + * Filters the XML-RPC user login error message. + * + * @since 3.5.0 + * + * @param string $error The XML-RPC error message. + * @param WP_Error $user WP_Error object. + */ + $this->error = apply_filters( 'xmlrpc_login_error', $this->error, $user ); + return false; + } + + wp_set_current_user( $user->ID ); + return $user; + } + + /** + * Check user's credentials. Deprecated. + * + * @since 1.5.0 + * @deprecated 2.8.0 Use wp_xmlrpc_server::login() + * @see wp_xmlrpc_server::login() + * + * @param string $username User's username. + * @param string $password User's password. + * @return bool Whether authentication passed. + */ + public function login_pass_ok( $username, $password ) { + return (bool) $this->login( $username, $password ); + } + + /** + * Escape string or array of strings for database. + * + * @since 1.5.2 + * + * @param string|array $data Escape single string or array of strings. + * @return string|void Returns with string is passed, alters by-reference + * when array is passed. + */ + public function escape( &$data ) { + if ( ! is_array( $data ) ) { + return wp_slash( $data ); + } + + foreach ( $data as &$v ) { + if ( is_array( $v ) ) { + $this->escape( $v ); + } elseif ( ! is_object( $v ) ) { + $v = wp_slash( $v ); + } + } + } + + /** + * Retrieve custom fields for post. + * + * @since 2.5.0 + * + * @param int $post_id Post ID. + * @return array Custom fields, if exist. + */ + public function get_custom_fields( $post_id ) { + $post_id = (int) $post_id; + + $custom_fields = array(); + + foreach ( (array) has_meta( $post_id ) as $meta ) { + // Don't expose protected fields. + if ( ! current_user_can( 'edit_post_meta', $post_id, $meta['meta_key'] ) ) { + continue; + } + + $custom_fields[] = array( + 'id' => $meta['meta_id'], + 'key' => $meta['meta_key'], + 'value' => $meta['meta_value'], + ); + } + + return $custom_fields; + } + + /** + * Set custom fields for post. + * + * @since 2.5.0 + * + * @param int $post_id Post ID. + * @param array $fields Custom fields. + */ + public function set_custom_fields( $post_id, $fields ) { + $post_id = (int) $post_id; + + foreach ( (array) $fields as $meta ) { + if ( isset( $meta['id'] ) ) { + $meta['id'] = (int) $meta['id']; + $pmeta = get_metadata_by_mid( 'post', $meta['id'] ); + + if ( ! $pmeta || $pmeta->post_id != $post_id ) { + continue; + } + + if ( isset( $meta['key'] ) ) { + $meta['key'] = wp_unslash( $meta['key'] ); + if ( $meta['key'] !== $pmeta->meta_key ) { + continue; + } + $meta['value'] = wp_unslash( $meta['value'] ); + if ( current_user_can( 'edit_post_meta', $post_id, $meta['key'] ) ) { + update_metadata_by_mid( 'post', $meta['id'], $meta['value'] ); + } + } elseif ( current_user_can( 'delete_post_meta', $post_id, $pmeta->meta_key ) ) { + delete_metadata_by_mid( 'post', $meta['id'] ); + } + } elseif ( current_user_can( 'add_post_meta', $post_id, wp_unslash( $meta['key'] ) ) ) { + add_post_meta( $post_id, $meta['key'], $meta['value'] ); + } + } + } + + /** + * Retrieve custom fields for a term. + * + * @since 4.9.0 + * + * @param int $term_id Term ID. + * @return array Array of custom fields, if they exist. + */ + public function get_term_custom_fields( $term_id ) { + $term_id = (int) $term_id; + + $custom_fields = array(); + + foreach ( (array) has_term_meta( $term_id ) as $meta ) { + + if ( ! current_user_can( 'edit_term_meta', $term_id ) ) { + continue; + } + + $custom_fields[] = array( + 'id' => $meta['meta_id'], + 'key' => $meta['meta_key'], + 'value' => $meta['meta_value'], + ); + } + + return $custom_fields; + } + + /** + * Set custom fields for a term. + * + * @since 4.9.0 + * + * @param int $term_id Term ID. + * @param array $fields Custom fields. + */ + public function set_term_custom_fields( $term_id, $fields ) { + $term_id = (int) $term_id; + + foreach ( (array) $fields as $meta ) { + if ( isset( $meta['id'] ) ) { + $meta['id'] = (int) $meta['id']; + $pmeta = get_metadata_by_mid( 'term', $meta['id'] ); + if ( isset( $meta['key'] ) ) { + $meta['key'] = wp_unslash( $meta['key'] ); + if ( $meta['key'] !== $pmeta->meta_key ) { + continue; + } + $meta['value'] = wp_unslash( $meta['value'] ); + if ( current_user_can( 'edit_term_meta', $term_id ) ) { + update_metadata_by_mid( 'term', $meta['id'], $meta['value'] ); + } + } elseif ( current_user_can( 'delete_term_meta', $term_id ) ) { + delete_metadata_by_mid( 'term', $meta['id'] ); + } + } elseif ( current_user_can( 'add_term_meta', $term_id ) ) { + add_term_meta( $term_id, $meta['key'], $meta['value'] ); + } + } + } + + /** + * Set up blog options property. + * + * Passes property through {@see 'xmlrpc_blog_options'} filter. + * + * @since 2.6.0 + */ + public function initialise_blog_option_info() { + $this->blog_options = array( + // Read only options + 'software_name' => array( + 'desc' => __( 'Software Name' ), + 'readonly' => true, + 'value' => 'WordPress', + ), + 'software_version' => array( + 'desc' => __( 'Software Version' ), + 'readonly' => true, + 'value' => get_bloginfo( 'version' ), + ), + 'blog_url' => array( + 'desc' => __( 'WordPress Address (URL)' ), + 'readonly' => true, + 'option' => 'siteurl', + ), + 'home_url' => array( + 'desc' => __( 'Site Address (URL)' ), + 'readonly' => true, + 'option' => 'home', + ), + 'login_url' => array( + 'desc' => __( 'Login Address (URL)' ), + 'readonly' => true, + 'value' => wp_login_url(), + ), + 'admin_url' => array( + 'desc' => __( 'The URL to the admin area' ), + 'readonly' => true, + 'value' => get_admin_url(), + ), + 'image_default_link_type' => array( + 'desc' => __( 'Image default link type' ), + 'readonly' => true, + 'option' => 'image_default_link_type', + ), + 'image_default_size' => array( + 'desc' => __( 'Image default size' ), + 'readonly' => true, + 'option' => 'image_default_size', + ), + 'image_default_align' => array( + 'desc' => __( 'Image default align' ), + 'readonly' => true, + 'option' => 'image_default_align', + ), + 'template' => array( + 'desc' => __( 'Template' ), + 'readonly' => true, + 'option' => 'template', + ), + 'stylesheet' => array( + 'desc' => __( 'Stylesheet' ), + 'readonly' => true, + 'option' => 'stylesheet', + ), + 'post_thumbnail' => array( + 'desc' => __( 'Post Thumbnail' ), + 'readonly' => true, + 'value' => current_theme_supports( 'post-thumbnails' ), + ), + + // Updatable options + 'time_zone' => array( + 'desc' => __( 'Time Zone' ), + 'readonly' => false, + 'option' => 'gmt_offset', + ), + 'blog_title' => array( + 'desc' => __( 'Site Title' ), + 'readonly' => false, + 'option' => 'blogname', + ), + 'blog_tagline' => array( + 'desc' => __( 'Site Tagline' ), + 'readonly' => false, + 'option' => 'blogdescription', + ), + 'date_format' => array( + 'desc' => __( 'Date Format' ), + 'readonly' => false, + 'option' => 'date_format', + ), + 'time_format' => array( + 'desc' => __( 'Time Format' ), + 'readonly' => false, + 'option' => 'time_format', + ), + 'users_can_register' => array( + 'desc' => __( 'Allow new users to sign up' ), + 'readonly' => false, + 'option' => 'users_can_register', + ), + 'thumbnail_size_w' => array( + 'desc' => __( 'Thumbnail Width' ), + 'readonly' => false, + 'option' => 'thumbnail_size_w', + ), + 'thumbnail_size_h' => array( + 'desc' => __( 'Thumbnail Height' ), + 'readonly' => false, + 'option' => 'thumbnail_size_h', + ), + 'thumbnail_crop' => array( + 'desc' => __( 'Crop thumbnail to exact dimensions' ), + 'readonly' => false, + 'option' => 'thumbnail_crop', + ), + 'medium_size_w' => array( + 'desc' => __( 'Medium size image width' ), + 'readonly' => false, + 'option' => 'medium_size_w', + ), + 'medium_size_h' => array( + 'desc' => __( 'Medium size image height' ), + 'readonly' => false, + 'option' => 'medium_size_h', + ), + 'medium_large_size_w' => array( + 'desc' => __( 'Medium-Large size image width' ), + 'readonly' => false, + 'option' => 'medium_large_size_w', + ), + 'medium_large_size_h' => array( + 'desc' => __( 'Medium-Large size image height' ), + 'readonly' => false, + 'option' => 'medium_large_size_h', + ), + 'large_size_w' => array( + 'desc' => __( 'Large size image width' ), + 'readonly' => false, + 'option' => 'large_size_w', + ), + 'large_size_h' => array( + 'desc' => __( 'Large size image height' ), + 'readonly' => false, + 'option' => 'large_size_h', + ), + 'default_comment_status' => array( + 'desc' => __( 'Allow people to submit comments on new posts.' ), + 'readonly' => false, + 'option' => 'default_comment_status', + ), + 'default_ping_status' => array( + 'desc' => __( 'Allow link notifications from other blogs (pingbacks and trackbacks) on new posts.' ), + 'readonly' => false, + 'option' => 'default_ping_status', + ), + ); + + /** + * Filters the XML-RPC blog options property. + * + * @since 2.6.0 + * + * @param array $blog_options An array of XML-RPC blog options. + */ + $this->blog_options = apply_filters( 'xmlrpc_blog_options', $this->blog_options ); + } + + /** + * Retrieve the blogs of the user. + * + * @since 2.6.0 + * + * @param array $args { + * Method arguments. Note: arguments must be ordered as documented. + * + * @type string $username Username. + * @type string $password Password. + * } + * @return array|IXR_Error Array contains: + * - 'isAdmin' + * - 'isPrimary' - whether the blog is the user's primary blog + * - 'url' + * - 'blogid' + * - 'blogName' + * - 'xmlrpc' - url of xmlrpc endpoint + */ + public function wp_getUsersBlogs( $args ) { + if ( ! $this->minimum_args( $args, 2 ) ) { + return $this->error; + } + + // If this isn't on WPMU then just use blogger_getUsersBlogs + if ( ! is_multisite() ) { + array_unshift( $args, 1 ); + return $this->blogger_getUsersBlogs( $args ); + } + + $this->escape( $args ); + + $username = $args[0]; + $password = $args[1]; + + $user = $this->login( $username, $password ); + if ( ! $user ) { + return $this->error; + } + + /** + * Fires after the XML-RPC user has been authenticated but before the rest of + * the method logic begins. + * + * All built-in XML-RPC methods use the action xmlrpc_call, with a parameter + * equal to the method's name, e.g., wp.getUsersBlogs, wp.newPost, etc. + * + * @since 2.5.0 + * + * @param string $name The method name. + */ + do_action( 'xmlrpc_call', 'wp.getUsersBlogs' ); + + $blogs = (array) get_blogs_of_user( $user->ID ); + $struct = array(); + $primary_blog_id = 0; + $active_blog = get_active_blog_for_user( $user->ID ); + if ( $active_blog ) { + $primary_blog_id = (int) $active_blog->blog_id; + } + + foreach ( $blogs as $blog ) { + // Don't include blogs that aren't hosted at this site. + if ( $blog->site_id != get_current_network_id() ) { + continue; + } + + $blog_id = $blog->userblog_id; + + switch_to_blog( $blog_id ); + + $is_admin = current_user_can( 'manage_options' ); + $is_primary = ( (int) $blog_id === $primary_blog_id ); + + $struct[] = array( + 'isAdmin' => $is_admin, + 'isPrimary' => $is_primary, + 'url' => home_url( '/' ), + 'blogid' => (string) $blog_id, + 'blogName' => get_option( 'blogname' ), + 'xmlrpc' => site_url( 'xmlrpc.php', 'rpc' ), + ); + + restore_current_blog(); + } + + return $struct; + } + + /** + * Checks if the method received at least the minimum number of arguments. + * + * @since 3.4.0 + * + * @param array $args An array of arguments to check. + * @param int $count Minimum number of arguments. + * @return bool True if `$args` contains at least `$count` arguments, false otherwise. + */ + protected function minimum_args( $args, $count ) { + if ( ! is_array( $args ) || count( $args ) < $count ) { + $this->error = new IXR_Error( 400, __( 'Insufficient arguments passed to this XML-RPC method.' ) ); + return false; + } + + return true; + } + + /** + * Prepares taxonomy data for return in an XML-RPC object. + * + * @param object $taxonomy The unprepared taxonomy data. + * @param array $fields The subset of taxonomy fields to return. + * @return array The prepared taxonomy data. + */ + protected function _prepare_taxonomy( $taxonomy, $fields ) { + $_taxonomy = array( + 'name' => $taxonomy->name, + 'label' => $taxonomy->label, + 'hierarchical' => (bool) $taxonomy->hierarchical, + 'public' => (bool) $taxonomy->public, + 'show_ui' => (bool) $taxonomy->show_ui, + '_builtin' => (bool) $taxonomy->_builtin, + ); + + if ( in_array( 'labels', $fields ) ) { + $_taxonomy['labels'] = (array) $taxonomy->labels; + } + + if ( in_array( 'cap', $fields ) ) { + $_taxonomy['cap'] = (array) $taxonomy->cap; + } + + if ( in_array( 'menu', $fields ) ) { + $_taxonomy['show_in_menu'] = (bool) $_taxonomy->show_in_menu; + } + + if ( in_array( 'object_type', $fields ) ) { + $_taxonomy['object_type'] = array_unique( (array) $taxonomy->object_type ); + } + + /** + * Filters XML-RPC-prepared data for the given taxonomy. + * + * @since 3.4.0 + * + * @param array $_taxonomy An array of taxonomy data. + * @param WP_Taxonomy $taxonomy Taxonomy object. + * @param array $fields The subset of taxonomy fields to return. + */ + return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy, $fields ); + } + + /** + * Prepares term data for return in an XML-RPC object. + * + * @param array|object $term The unprepared term data. + * @return array The prepared term data. + */ + protected function _prepare_term( $term ) { + $_term = $term; + if ( ! is_array( $_term ) ) { + $_term = get_object_vars( $_term ); + } + + // For integers which may be larger than XML-RPC supports ensure we return strings. + $_term['term_id'] = strval( $_term['term_id'] ); + $_term['term_group'] = strval( $_term['term_group'] ); + $_term['term_taxonomy_id'] = strval( $_term['term_taxonomy_id'] ); + $_term['parent'] = strval( $_term['parent'] ); + + // Count we are happy to return as an integer because people really shouldn't use terms that much. + $_term['count'] = intval( $_term['count'] ); + + // Get term meta. + $_term['custom_fields'] = $this->get_term_custom_fields( $_term['term_id'] ); + + /** + * Filters XML-RPC-prepared data for the given term. + * + * @since 3.4.0 + * + * @param array $_term An array of term data. + * @param array|object $term Term object or array. + */ + return apply_filters( 'xmlrpc_prepare_term', $_term, $term ); + } + + /** + * Convert a WordPress date string to an IXR_Date object. + * + * @param string $date Date string to convert. + * @return IXR_Date IXR_Date object. + */ + protected function _convert_date( $date ) { + if ( $date === '0000-00-00 00:00:00' ) { + return new IXR_Date( '00000000T00:00:00Z' ); + } + return new IXR_Date( mysql2date( 'Ymd\TH:i:s', $date, false ) ); + } + + /** + * Convert a WordPress GMT date string to an IXR_Date object. + * + * @param string $date_gmt WordPress GMT date string. + * @param string $date Date string. + * @return IXR_Date IXR_Date object. + */ + protected function _convert_date_gmt( $date_gmt, $date ) { + if ( $date !== '0000-00-00 00:00:00' && $date_gmt === '0000-00-00 00:00:00' ) { + return new IXR_Date( get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $date, false ), 'Ymd\TH:i:s' ) ); + } + return $this->_convert_date( $date_gmt ); + } + + /** + * Prepares post data for return in an XML-RPC object. + * + * @param array $post The unprepared post data. + * @param array $fields The subset of post type fields to return. + * @return array The prepared post data. + */ + protected function _prepare_post( $post, $fields ) { + // Holds the data for this post. built up based on $fields. + $_post = array( 'post_id' => strval( $post['ID'] ) ); + + // Prepare common post fields. + $post_fields = array( + 'post_title' => $post['post_title'], + 'post_date' => $this->_convert_date( $post['post_date'] ), + 'post_date_gmt' => $this->_convert_date_gmt( $post['post_date_gmt'], $post['post_date'] ), + 'post_modified' => $this->_convert_date( $post['post_modified'] ), + 'post_modified_gmt' => $this->_convert_date_gmt( $post['post_modified_gmt'], $post['post_modified'] ), + 'post_status' => $post['post_status'], + 'post_type' => $post['post_type'], + 'post_name' => $post['post_name'], + 'post_author' => $post['post_author'], + 'post_password' => $post['post_password'], + 'post_excerpt' => $post['post_excerpt'], + 'post_content' => $post['post_content'], + 'post_parent' => strval( $post['post_parent'] ), + 'post_mime_type' => $post['post_mime_type'], + 'link' => get_permalink( $post['ID'] ), + 'guid' => $post['guid'], + 'menu_order' => intval( $post['menu_order'] ), + 'comment_status' => $post['comment_status'], + 'ping_status' => $post['ping_status'], + 'sticky' => ( $post['post_type'] === 'post' && is_sticky( $post['ID'] ) ), + ); + + // Thumbnail. + $post_fields['post_thumbnail'] = array(); + $thumbnail_id = get_post_thumbnail_id( $post['ID'] ); + if ( $thumbnail_id ) { + $thumbnail_size = current_theme_supports( 'post-thumbnail' ) ? 'post-thumbnail' : 'thumbnail'; + $post_fields['post_thumbnail'] = $this->_prepare_media_item( get_post( $thumbnail_id ), $thumbnail_size ); + } + + // Consider future posts as published. + if ( $post_fields['post_status'] === 'future' ) { + $post_fields['post_status'] = 'publish'; + } + + // Fill in blank post format. + $post_fields['post_format'] = get_post_format( $post['ID'] ); + if ( empty( $post_fields['post_format'] ) ) { + $post_fields['post_format'] = 'standard'; + } + + // Merge requested $post_fields fields into $_post. + if ( in_array( 'post', $fields ) ) { + $_post = array_merge( $_post, $post_fields ); + } else { + $requested_fields = array_intersect_key( $post_fields, array_flip( $fields ) ); + $_post = array_merge( $_post, $requested_fields ); + } + + $all_taxonomy_fields = in_array( 'taxonomies', $fields ); + + if ( $all_taxonomy_fields || in_array( 'terms', $fields ) ) { + $post_type_taxonomies = get_object_taxonomies( $post['post_type'], 'names' ); + $terms = wp_get_object_terms( $post['ID'], $post_type_taxonomies ); + $_post['terms'] = array(); + foreach ( $terms as $term ) { + $_post['terms'][] = $this->_prepare_term( $term ); + } + } + + if ( in_array( 'custom_fields', $fields ) ) { + $_post['custom_fields'] = $this->get_custom_fields( $post['ID'] ); + } + + if ( in_array( 'enclosure', $fields ) ) { + $_post['enclosure'] = array(); + $enclosures = (array) get_post_meta( $post['ID'], 'enclosure' ); + if ( ! empty( $enclosures ) ) { + $encdata = explode( "\n", $enclosures[0] ); + $_post['enclosure']['url'] = trim( htmlspecialchars( $encdata[0] ) ); + $_post['enclosure']['length'] = (int) trim( $encdata[1] ); + $_post['enclosure']['type'] = trim( $encdata[2] ); + } + } + + /** + * Filters XML-RPC-prepared date for the given post. + * + * @since 3.4.0 + * + * @param array $_post An array of modified post data. + * @param array $post An array of post data. + * @param array $fields An array of post fields. + */ + return apply_filters( 'xmlrpc_prepare_post', $_post, $post, $fields ); + } + + /** + * Prepares post data for return in an XML-RPC object. + * + * @since 3.4.0 + * @since 4.6.0 Converted the `$post_type` parameter to accept a WP_Post_Type object. + * + * @param WP_Post_Type $post_type Post type object. + * @param array $fields The subset of post fields to return. + * @return array The prepared post type data. + */ + protected function _prepare_post_type( $post_type, $fields ) { + $_post_type = array( + 'name' => $post_type->name, + 'label' => $post_type->label, + 'hierarchical' => (bool) $post_type->hierarchical, + 'public' => (bool) $post_type->public, + 'show_ui' => (bool) $post_type->show_ui, + '_builtin' => (bool) $post_type->_builtin, + 'has_archive' => (bool) $post_type->has_archive, + 'supports' => get_all_post_type_supports( $post_type->name ), + ); + + if ( in_array( 'labels', $fields ) ) { + $_post_type['labels'] = (array) $post_type->labels; + } + + if ( in_array( 'cap', $fields ) ) { + $_post_type['cap'] = (array) $post_type->cap; + $_post_type['map_meta_cap'] = (bool) $post_type->map_meta_cap; + } + + if ( in_array( 'menu', $fields ) ) { + $_post_type['menu_position'] = (int) $post_type->menu_position; + $_post_type['menu_icon'] = $post_type->menu_icon; + $_post_type['show_in_menu'] = (bool) $post_type->show_in_menu; + } + + if ( in_array( 'taxonomies', $fields ) ) { + $_post_type['taxonomies'] = get_object_taxonomies( $post_type->name, 'names' ); + } + + /** + * Filters XML-RPC-prepared date for the given post type. + * + * @since 3.4.0 + * @since 4.6.0 Converted the `$post_type` parameter to accept a WP_Post_Type object. + * + * @param array $_post_type An array of post type data. + * @param WP_Post_Type $post_type Post type object. + */ + return apply_filters( 'xmlrpc_prepare_post_type', $_post_type, $post_type ); + } + + /** + * Prepares media item data for return in an XML-RPC object. + * + * @param object $media_item The unprepared media item data. + * @param string $thumbnail_size The image size to use for the thumbnail URL. + * @return array The prepared media item data. + */ + protected function _prepare_media_item( $media_item, $thumbnail_size = 'thumbnail' ) { + $_media_item = array( + 'attachment_id' => strval( $media_item->ID ), + 'date_created_gmt' => $this->_convert_date_gmt( $media_item->post_date_gmt, $media_item->post_date ), + 'parent' => $media_item->post_parent, + 'link' => wp_get_attachment_url( $media_item->ID ), + 'title' => $media_item->post_title, + 'caption' => $media_item->post_excerpt, + 'description' => $media_item->post_content, + 'metadata' => wp_get_attachment_metadata( $media_item->ID ), + 'type' => $media_item->post_mime_type, + ); + + $thumbnail_src = image_downsize( $media_item->ID, $thumbnail_size ); + if ( $thumbnail_src ) { + $_media_item['thumbnail'] = $thumbnail_src[0]; + } else { + $_media_item['thumbnail'] = $_media_item['link']; + } + + /** + * Filters XML-RPC-prepared data for the given media item. + * + * @since 3.4.0 + * + * @param array $_media_item An array of media item data. + * @param object $media_item Media item object. + * @param string $thumbnail_size Image size. + */ + return apply_filters( 'xmlrpc_prepare_media_item', $_media_item, $media_item, $thumbnail_size ); + } + + /** + * Prepares page data for return in an XML-RPC object. + * |