wp_xmlrpc_server::_insert_post() WordPress Method

The wp_xmlrpc_server::_insert_post() method is used to insert a new post into a WordPress site. This is done by sending a request to the WordPress XML-RPC server with the required information for the new post. The method can be used to insert a post into a WordPress site from any external application that supports XML-RPC.

wp_xmlrpc_server::_insert_post( WP_User $user, array|IXR_Error $content_struct ) #

Helper method for wp_newPost() and wp_editPost(), containing shared logic.

Description
- See also
Parameters
Return
Source
Related
- Uses
- Used By
Changelog

Description

Top ↑

Parameters

$user: (WP_User)(Required)The post author if post_author isn't set in $content_struct.
$content_struct: (array|IXR_Error)(Required)Post data to insert.

Top ↑

Return

(IXR_Error|string)

Top ↑

Source

File: wp-includes/class-wp-xmlrpc-server.php

protected function _insert_post( $user, $content_struct ) {
    $defaults = array(
        'post_status'    => 'draft',
        'post_type'      => 'post',
        'post_author'    => null,
        'post_password'  => null,
        'post_excerpt'   => null,
        'post_content'   => null,
        'post_title'     => null,
        'post_date'      => null,
        'post_date_gmt'  => null,
        'post_format'    => null,
        'post_name'      => null,
        'post_thumbnail' => null,
        'post_parent'    => null,
        'ping_status'    => null,
        'comment_status' => null,
        'custom_fields'  => null,
        'terms_names'    => null,
        'terms'          => null,
        'sticky'         => null,
        'enclosure'      => null,
        'ID'             => null,
    );
 
    $post_data = wp_parse_args( array_intersect_key( $content_struct, $defaults ), $defaults );
 
    $post_type = get_post_type_object( $post_data['post_type'] );
    if ( ! $post_type ) {
        return new IXR_Error( 403, __( 'Invalid post type.' ) );
    }
 
    $update = ! empty( $post_data['ID'] );
 
    if ( $update ) {
        if ( ! get_post( $post_data['ID'] ) ) {
            return new IXR_Error( 401, __( 'Invalid post ID.' ) );
        }
        if ( ! current_user_can( 'edit_post', $post_data['ID'] ) ) {
            return new IXR_Error( 401, __( 'Sorry, you are not allowed to edit this post.' ) );
        }
        if ( get_post_type( $post_data['ID'] ) !== $post_data['post_type'] ) {
            return new IXR_Error( 401, __( 'The post type may not be changed.' ) );
        }
    } else {
        if ( ! current_user_can( $post_type->cap->create_posts ) || ! current_user_can( $post_type->cap->edit_posts ) ) {
            return new IXR_Error( 401, __( 'Sorry, you are not allowed to post on this site.' ) );
        }
    }
 
    switch ( $post_data['post_status'] ) {
        case 'draft':
        case 'pending':
            break;
        case 'private':
            if ( ! current_user_can( $post_type->cap->publish_posts ) ) {
                return new IXR_Error( 401, __( 'Sorry, you are not allowed to create private posts in this post type.' ) );
            }
            break;
        case 'publish':
        case 'future':
            if ( ! current_user_can( $post_type->cap->publish_posts ) ) {
                return new IXR_Error( 401, __( 'Sorry, you are not allowed to publish posts in this post type.' ) );
            }
            break;
        default:
            if ( ! get_post_status_object( $post_data['post_status'] ) ) {
                $post_data['post_status'] = 'draft';
            }
            break;
    }
 
    if ( ! empty( $post_data['post_password'] ) && ! current_user_can( $post_type->cap->publish_posts ) ) {
        return new IXR_Error( 401, __( 'Sorry, you are not allowed to create password protected posts in this post type.' ) );
    }
 
    $post_data['post_author'] = absint( $post_data['post_author'] );
    if ( ! empty( $post_data['post_author'] ) && $post_data['post_author'] != $user->ID ) {
        if ( ! current_user_can( $post_type->cap->edit_others_posts ) ) {
            return new IXR_Error( 401, __( 'Sorry, you are not allowed to create posts as this user.' ) );
        }
 
        $author = get_userdata( $post_data['post_author'] );
 
        if ( ! $author ) {
            return new IXR_Error( 404, __( 'Invalid author ID.' ) );
        }
    } else {
        $post_data['post_author'] = $user->ID;
    }
 
    if ( isset( $post_data['comment_status'] ) && 'open' !== $post_data['comment_status'] && 'closed' !== $post_data['comment_status'] ) {
        unset( $post_data['comment_status'] );
    }
 
    if ( isset( $post_data['ping_status'] ) && 'open' !== $post_data['ping_status'] && 'closed' !== $post_data['ping_status'] ) {
        unset( $post_data['ping_status'] );
    }
 
    // Do some timestamp voodoo.
    if ( ! empty( $post_data['post_date_gmt'] ) ) {
        // We know this is supposed to be GMT, so we're going to slap that Z on there by force.
        $dateCreated = rtrim( $post_data['post_date_gmt']->getIso(), 'Z' ) . 'Z';
    } elseif ( ! empty( $post_data['post_date'] ) ) {
        $dateCreated = $post_data['post_date']->getIso();
    }
 
    // Default to not flagging the post date to be edited unless it's intentional.
    $post_data['edit_date'] = false;
 
    if ( ! empty( $dateCreated ) ) {
        $post_data['post_date']     = iso8601_to_datetime( $dateCreated );
        $post_data['post_date_gmt'] = iso8601_to_datetime( $dateCreated, 'gmt' );
 
        // Flag the post date to be edited.
        $post_data['edit_date'] = true;
    }
 
    if ( ! isset( $post_data['ID'] ) ) {
        $post_data['ID'] = get_default_post_to_edit( $post_data['post_type'], true )->ID;
    }
    $post_ID = $post_data['ID'];
 
    if ( 'post' === $post_data['post_type'] ) {
        $error = $this->_toggle_sticky( $post_data, $update );
        if ( $error ) {
            return $error;
        }
    }
 
    if ( isset( $post_data['post_thumbnail'] ) ) {
        // Empty value deletes, non-empty value adds/updates.
        if ( ! $post_data['post_thumbnail'] ) {
            delete_post_thumbnail( $post_ID );
        } elseif ( ! get_post( absint( $post_data['post_thumbnail'] ) ) ) {
            return new IXR_Error( 404, __( 'Invalid attachment ID.' ) );
        }
        set_post_thumbnail( $post_ID, $post_data['post_thumbnail'] );
        unset( $content_struct['post_thumbnail'] );
    }
 
    if ( isset( $post_data['custom_fields'] ) ) {
        $this->set_custom_fields( $post_ID, $post_data['custom_fields'] );
    }
 
    if ( isset( $post_data['terms'] ) || isset( $post_data['terms_names'] ) ) {
        $post_type_taxonomies = get_object_taxonomies( $post_data['post_type'], 'objects' );
 
        // Accumulate term IDs from terms and terms_names.
        $terms = array();
 
        // First validate the terms specified by ID.
        if ( isset( $post_data['terms'] ) && is_array( $post_data['terms'] ) ) {
            $taxonomies = array_keys( $post_data['terms'] );
 
            // Validating term IDs.
            foreach ( $taxonomies as $taxonomy ) {
                if ( ! array_key_exists( $taxonomy, $post_type_taxonomies ) ) {
                    return new IXR_Error( 401, __( 'Sorry, one of the given taxonomies is not supported by the post type.' ) );
                }
 
                if ( ! current_user_can( $post_type_taxonomies[ $taxonomy ]->cap->assign_terms ) ) {
                    return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) );
                }
 
                $term_ids           = $post_data['terms'][ $taxonomy ];
                $terms[ $taxonomy ] = array();
                foreach ( $term_ids as $term_id ) {
                    $term = get_term_by( 'id', $term_id, $taxonomy );
 
                    if ( ! $term ) {
                        return new IXR_Error( 403, __( 'Invalid term ID.' ) );
                    }
 
                    $terms[ $taxonomy ][] = (int) $term_id;
                }
            }
        }
 
        // Now validate terms specified by name.
        if ( isset( $post_data['terms_names'] ) && is_array( $post_data['terms_names'] ) ) {
            $taxonomies = array_keys( $post_data['terms_names'] );
 
            foreach ( $taxonomies as $taxonomy ) {
                if ( ! array_key_exists( $taxonomy, $post_type_taxonomies ) ) {
                    return new IXR_Error( 401, __( 'Sorry, one of the given taxonomies is not supported by the post type.' ) );
                }
 
                if ( ! current_user_can( $post_type_taxonomies[ $taxonomy ]->cap->assign_terms ) ) {
                    return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) );
                }
 
                /*
                 * For hierarchical taxonomies, we can't assign a term when multiple terms
                 * in the hierarchy share the same name.
                 */
                $ambiguous_terms = array();
                if ( is_taxonomy_hierarchical( $taxonomy ) ) {
                    $tax_term_names = get_terms(
                        array(
                            'taxonomy'   => $taxonomy,
                            'fields'     => 'names',
                            'hide_empty' => false,
                        )
                    );
 
                    // Count the number of terms with the same name.
                    $tax_term_names_count = array_count_values( $tax_term_names );
 
                    // Filter out non-ambiguous term names.
                    $ambiguous_tax_term_counts = array_filter( $tax_term_names_count, array( $this, '_is_greater_than_one' ) );
 
                    $ambiguous_terms = array_keys( $ambiguous_tax_term_counts );
                }
 
                $term_names = $post_data['terms_names'][ $taxonomy ];
                foreach ( $term_names as $term_name ) {
                    if ( in_array( $term_name, $ambiguous_terms, true ) ) {
                        return new IXR_Error( 401, __( 'Ambiguous term name used in a hierarchical taxonomy. Please use term ID instead.' ) );
                    }
 
                    $term = get_term_by( 'name', $term_name, $taxonomy );
 
                    if ( ! $term ) {
                        // Term doesn't exist, so check that the user is allowed to create new terms.
                        if ( ! current_user_can( $post_type_taxonomies[ $taxonomy ]->cap->edit_terms ) ) {
                            return new IXR_Error( 401, __( 'Sorry, you are not allowed to add a term to one of the given taxonomies.' ) );
                        }
 
                        // Create the new term.
                        $term_info = wp_insert_term( $term_name, $taxonomy );
                        if ( is_wp_error( $term_info ) ) {
                            return new IXR_Error( 500, $term_info->get_error_message() );
                        }
 
                        $terms[ $taxonomy ][] = (int) $term_info['term_id'];
                    } else {
                        $terms[ $taxonomy ][] = (int) $term->term_id;
                    }
                }
            }
        }
 
        $post_data['tax_input'] = $terms;
        unset( $post_data['terms'], $post_data['terms_names'] );
    }
 
    if ( isset( $post_data['post_format'] ) ) {
        $format = set_post_format( $post_ID, $post_data['post_format'] );
 
        if ( is_wp_error( $format ) ) {
            return new IXR_Error( 500, $format->get_error_message() );
        }
 
        unset( $post_data['post_format'] );
    }
 
    // Handle enclosures.
    $enclosure = isset( $post_data['enclosure'] ) ? $post_data['enclosure'] : null;
    $this->add_enclosure_if_new( $post_ID, $enclosure );
 
    $this->attach_uploads( $post_ID, $post_data['post_content'] );
 
    /**
     * Filters post data array to be inserted via XML-RPC.
     *
     * @since 3.4.0
     *
     * @param array $post_data      Parsed array of post data.
     * @param array $content_struct Post data array.
     */
    $post_data = apply_filters( 'xmlrpc_wp_insert_post_data', $post_data, $content_struct );
 
    $post_ID = $update ? wp_update_post( $post_data, true ) : wp_insert_post( $post_data, true );
    if ( is_wp_error( $post_ID ) ) {
        return new IXR_Error( 500, $post_ID->get_error_message() );
    }
 
    if ( ! $post_ID ) {
        if ( $update ) {
            return new IXR_Error( 401, __( 'Sorry, the post could not be updated.' ) );
        } else {
            return new IXR_Error( 401, __( 'Sorry, the post could not be created.' ) );
        }
    }
 
    return (string) $post_ID;
}

Expand full source code Collapse full source codeView on TracView on GitHub

Top ↑

Uses

Uses
Uses	Description
wp-includes/IXR/class-IXR-error.php:IXR_Error::__construct()	PHP5 constructor.
wp-includes/class-wp-xmlrpc-server.php:wp_xmlrpc_server::_toggle_sticky()	Encapsulate the logic for sticking a post and determining if the user has permission to do so
wp-admin/includes/post.php:get_default_post_to_edit()	Returns default post information to use when populating the “Write Post” form.
wp-includes/capabilities.php:current_user_can()	Returns whether the current user has the specified capability.
wp-includes/l10n.php:__()	Retrieve the translation of $text.
wp-includes/formatting.php:iso8601_to_datetime()	Given an ISO 8601 (Ymd\TH:i:sO) date, returns a MySQL DateTime (Y-m-d H:i:s) format used by post_date[_gmt].
wp-includes/pluggable.php:get_userdata()	Retrieve user info by user ID.
wp-includes/functions.php:wp_parse_args()	Merges user defined arguments into defaults array.
wp-includes/functions.php:absint()	Convert a value to non-negative integer.
wp-includes/taxonomy.php:wp_insert_term()	Adds a new term to the database.
wp-includes/taxonomy.php:get_term_by()	Gets all term data from database by term field and data.
wp-includes/taxonomy.php:get_terms()	Retrieves the terms in a given taxonomy or list of taxonomies.
wp-includes/taxonomy.php:get_object_taxonomies()	Returns the names or objects of the taxonomies which are registered for the requested object or object type, such as a post object or post type name.
wp-includes/taxonomy.php:is_taxonomy_hierarchical()	Determines whether the taxonomy object is hierarchical.
wp-includes/plugin.php:apply_filters()	Calls the callback functions that have been added to a filter hook.
wp-includes/post.php:delete_post_thumbnail()	Removes the thumbnail (featured image) from the given post.
wp-includes/post.php:set_post_thumbnail()	Sets the post thumbnail (featured image) for the given post.
wp-includes/post.php:wp_update_post()	Update a post with new post data.
wp-includes/post.php:wp_insert_post()	Insert or update a post.
wp-includes/post.php:get_post_type_object()	Retrieves a post type object by name.
wp-includes/post.php:get_post()	Retrieves post data given a post ID or post object.
wp-includes/post.php:get_post_type()	Retrieves the post type of the current post or of a given post.
wp-includes/post.php:get_post_status_object()	Retrieve a post status object by name.
wp-includes/post-formats.php:set_post_format()	Assign a format to a post
wp-includes/class-wp-xmlrpc-server.php:wp_xmlrpc_server::add_enclosure_if_new()	Adds an enclosure to a post if it’s new.
wp-includes/class-wp-xmlrpc-server.php:wp_xmlrpc_server::attach_uploads()	Attach upload to a post.
wp-includes/class-wp-xmlrpc-server.php:xmlrpc_wp_insert_post_data	Filters post data array to be inserted via XML-RPC.
wp-includes/class-wp-xmlrpc-server.php:wp_xmlrpc_server::set_custom_fields()	Set custom fields for post.
wp-includes/load.php:is_wp_error()	Checks whether the given variable is a WordPress Error.

Show 24 more uses Hide more uses

Top ↑

Used By

Used By
Used By	Description
wp-includes/class-wp-xmlrpc-server.php:wp_xmlrpc_server::wp_newPost()	Create a new post for any registered post type.
wp-includes/class-wp-xmlrpc-server.php:wp_xmlrpc_server::wp_editPost()	Edit a post for any registered post type.

Top ↑

Changelog

Changelog
Version	Description
3.4.0	Introduced.

wp_xmlrpc_server::_insert_post() WordPress Method

wp_xmlrpc_server::_insert_post( WP_User $user, array|IXR_Error $content_struct ) #

Contents

Description

See also

Parameters

Return

Source

Changelog

Class

Class Method

Hook