WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
08/26/2015 12:39:07 PM (10 years ago)
Author:
wonderboymusic
Message:

Posts: move WP_Post into its own file. post.php loads the new files, so this is 100% BC if someone is loading post.php directly. New files created using svn cp.

Creates:
class-wp-post.php
post-functions.php

post.php contains only top-level code. Class file only contains the class. Functions file only contains functions.

See #33413.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/post.php

    r33734 r33759  
    88 */
    99
    10 //
    11 // Post Type Registration
    12 //
    13 
    14 /**
    15  * Creates the initial post types when 'init' action is fired.
    16  *
    17  * @since 2.9.0
    18  */
    19 function create_initial_post_types() {
    20     register_post_type( 'post', array(
    21         'labels' => array(
    22             'name_admin_bar' => _x( 'Post', 'add new on admin bar' ),
    23         ),
    24         'public'  => true,
    25         '_builtin' => true, /* internal use only. don't use this when registering your own post type. */
    26         '_edit_link' => 'post.php?post=%d', /* internal use only. don't use this when registering your own post type. */
    27         'capability_type' => 'post',
    28         'map_meta_cap' => true,
    29         'menu_position' => 5,
    30         'hierarchical' => false,
    31         'rewrite' => false,
    32         'query_var' => false,
    33         'delete_with_user' => true,
    34         'supports' => array( 'title', 'editor', 'author', 'thumbnail', 'excerpt', 'trackbacks', 'custom-fields', 'comments', 'revisions', 'post-formats' ),
    35     ) );
    36 
    37     register_post_type( 'page', array(
    38         'labels' => array(
    39             'name_admin_bar' => _x( 'Page', 'add new on admin bar' ),
    40         ),
    41         'public' => true,
    42         'publicly_queryable' => false,
    43         '_builtin' => true, /* internal use only. don't use this when registering your own post type. */
    44         '_edit_link' => 'post.php?post=%d', /* internal use only. don't use this when registering your own post type. */
    45         'capability_type' => 'page',
    46         'map_meta_cap' => true,
    47         'menu_position' => 20,
    48         'hierarchical' => true,
    49         'rewrite' => false,
    50         'query_var' => false,
    51         'delete_with_user' => true,
    52         'supports' => array( 'title', 'editor', 'author', 'thumbnail', 'page-attributes', 'custom-fields', 'comments', 'revisions' ),
    53     ) );
    54 
    55     register_post_type( 'attachment', array(
    56         'labels' => array(
    57             'name' => _x('Media', 'post type general name'),
    58             'name_admin_bar' => _x( 'Media', 'add new from admin bar' ),
    59             'add_new' => _x( 'Add New', 'add new media' ),
    60             'edit_item' => __( 'Edit Media' ),
    61             'view_item' => __( 'View Attachment Page' ),
    62         ),
    63         'public' => true,
    64         'show_ui' => true,
    65         '_builtin' => true, /* internal use only. don't use this when registering your own post type. */
    66         '_edit_link' => 'post.php?post=%d', /* internal use only. don't use this when registering your own post type. */
    67         'capability_type' => 'post',
    68         'capabilities' => array(
    69             'create_posts' => 'upload_files',
    70         ),
    71         'map_meta_cap' => true,
    72         'hierarchical' => false,
    73         'rewrite' => false,
    74         'query_var' => false,
    75         'show_in_nav_menus' => false,
    76         'delete_with_user' => true,
    77         'supports' => array( 'title', 'author', 'comments' ),
    78     ) );
    79     add_post_type_support( 'attachment:audio', 'thumbnail' );
    80     add_post_type_support( 'attachment:video', 'thumbnail' );
    81 
    82     register_post_type( 'revision', array(
    83         'labels' => array(
    84             'name' => __( 'Revisions' ),
    85             'singular_name' => __( 'Revision' ),
    86         ),
    87         'public' => false,
    88         '_builtin' => true, /* internal use only. don't use this when registering your own post type. */
    89         '_edit_link' => 'revision.php?revision=%d', /* internal use only. don't use this when registering your own post type. */
    90         'capability_type' => 'post',
    91         'map_meta_cap' => true,
    92         'hierarchical' => false,
    93         'rewrite' => false,
    94         'query_var' => false,
    95         'can_export' => false,
    96         'delete_with_user' => true,
    97         'supports' => array( 'author' ),
    98     ) );
    99 
    100     register_post_type( 'nav_menu_item', array(
    101         'labels' => array(
    102             'name' => __( 'Navigation Menu Items' ),
    103             'singular_name' => __( 'Navigation Menu Item' ),
    104         ),
    105         'public' => false,
    106         '_builtin' => true, /* internal use only. don't use this when registering your own post type. */
    107         'hierarchical' => false,
    108         'rewrite' => false,
    109         'delete_with_user' => false,
    110         'query_var' => false,
    111     ) );
    112 
    113     register_post_status( 'publish', array(
    114         'label'       => _x( 'Published', 'post' ),
    115         'public'      => true,
    116         '_builtin'    => true, /* internal use only. */
    117         'label_count' => _n_noop( 'Published <span class="count">(%s)</span>', 'Published <span class="count">(%s)</span>' ),
    118     ) );
    119 
    120     register_post_status( 'future', array(
    121         'label'       => _x( 'Scheduled', 'post' ),
    122         'protected'   => true,
    123         '_builtin'    => true, /* internal use only. */
    124         'label_count' => _n_noop('Scheduled <span class="count">(%s)</span>', 'Scheduled <span class="count">(%s)</span>' ),
    125     ) );
    126 
    127     register_post_status( 'draft', array(
    128         'label'       => _x( 'Draft', 'post' ),
    129         'protected'   => true,
    130         '_builtin'    => true, /* internal use only. */
    131         'label_count' => _n_noop( 'Draft <span class="count">(%s)</span>', 'Drafts <span class="count">(%s)</span>' ),
    132     ) );
    133 
    134     register_post_status( 'pending', array(
    135         'label'       => _x( 'Pending', 'post' ),
    136         'protected'   => true,
    137         '_builtin'    => true, /* internal use only. */
    138         'label_count' => _n_noop( 'Pending <span class="count">(%s)</span>', 'Pending <span class="count">(%s)</span>' ),
    139     ) );
    140 
    141     register_post_status( 'private', array(
    142         'label'       => _x( 'Private', 'post' ),
    143         'private'     => true,
    144         '_builtin'    => true, /* internal use only. */
    145         'label_count' => _n_noop( 'Private <span class="count">(%s)</span>', 'Private <span class="count">(%s)</span>' ),
    146     ) );
    147 
    148     register_post_status( 'trash', array(
    149         'label'       => _x( 'Trash', 'post' ),
    150         'internal'    => true,
    151         '_builtin'    => true, /* internal use only. */
    152         'label_count' => _n_noop( 'Trash <span class="count">(%s)</span>', 'Trash <span class="count">(%s)</span>' ),
    153         'show_in_admin_status_list' => true,
    154     ) );
    155 
    156     register_post_status( 'auto-draft', array(
    157         'label'    => 'auto-draft',
    158         'internal' => true,
    159         '_builtin' => true, /* internal use only. */
    160     ) );
    161 
    162     register_post_status( 'inherit', array(
    163         'label'    => 'inherit',
    164         'internal' => true,
    165         '_builtin' => true, /* internal use only. */
    166         'exclude_from_search' => false,
    167     ) );
    168 }
    169 
    170 /**
    171  * Retrieve attached file path based on attachment ID.
    172  *
    173  * By default the path will go through the 'get_attached_file' filter, but
    174  * passing a true to the $unfiltered argument of get_attached_file() will
    175  * return the file path unfiltered.
    176  *
    177  * The function works by getting the single post meta name, named
    178  * '_wp_attached_file' and returning it. This is a convenience function to
    179  * prevent looking up the meta name and provide a mechanism for sending the
    180  * attached filename through a filter.
    181  *
    182  * @since 2.0.0
    183  *
    184  * @param int  $attachment_id Attachment ID.
    185  * @param bool $unfiltered    Optional. Whether to apply filters. Default false.
    186  * @return string|false The file path to where the attached file should be, false otherwise.
    187  */
    188 function get_attached_file( $attachment_id, $unfiltered = false ) {
    189     $file = get_post_meta( $attachment_id, '_wp_attached_file', true );
    190     // If the file is relative, prepend upload dir.
    191     if ( $file && 0 !== strpos($file, '/') && !preg_match('|^.:\\\|', $file) && ( ($uploads = wp_upload_dir()) && false === $uploads['error'] ) )
    192         $file = $uploads['basedir'] . "/$file";
    193     if ( $unfiltered )
    194         return $file;
    195 
    196     /**
    197      * Filter the attached file based on the given ID.
    198      *
    199      * @since 2.1.0
    200      *
    201      * @param string $file          Path to attached file.
    202      * @param int    $attachment_id Attachment ID.
    203      */
    204     return apply_filters( 'get_attached_file', $file, $attachment_id );
    205 }
    206 
    207 /**
    208  * Update attachment file path based on attachment ID.
    209  *
    210  * Used to update the file path of the attachment, which uses post meta name
    211  * '_wp_attached_file' to store the path of the attachment.
    212  *
    213  * @since 2.1.0
    214  *
    215  * @param int    $attachment_id Attachment ID.
    216  * @param string $file          File path for the attachment.
    217  * @return bool True on success, false on failure.
    218  */
    219 function update_attached_file( $attachment_id, $file ) {
    220     if ( !get_post( $attachment_id ) )
    221         return false;
    222 
    223     /**
    224      * Filter the path to the attached file to update.
    225      *
    226      * @since 2.1.0
    227      *
    228      * @param string $file          Path to the attached file to update.
    229      * @param int    $attachment_id Attachment ID.
    230      */
    231     $file = apply_filters( 'update_attached_file', $file, $attachment_id );
    232 
    233     if ( $file = _wp_relative_upload_path( $file ) )
    234         return update_post_meta( $attachment_id, '_wp_attached_file', $file );
    235     else
    236         return delete_post_meta( $attachment_id, '_wp_attached_file' );
    237 }
    238 
    239 /**
    240  * Return relative path to an uploaded file.
    241  *
    242  * The path is relative to the current upload dir.
    243  *
    244  * @since 2.9.0
    245  *
    246  * @param string $path Full path to the file.
    247  * @return string Relative path on success, unchanged path on failure.
    248  */
    249 function _wp_relative_upload_path( $path ) {
    250     $new_path = $path;
    251 
    252     $uploads = wp_upload_dir();
    253     if ( 0 === strpos( $new_path, $uploads['basedir'] ) ) {
    254             $new_path = str_replace( $uploads['basedir'], '', $new_path );
    255             $new_path = ltrim( $new_path, '/' );
    256     }
    257 
    258     /**
    259      * Filter the relative path to an uploaded file.
    260      *
    261      * @since 2.9.0
    262      *
    263      * @param string $new_path Relative path to the file.
    264      * @param string $path     Full path to the file.
    265      */
    266     return apply_filters( '_wp_relative_upload_path', $new_path, $path );
    267 }
    268 
    269 /**
    270  * Retrieve all children of the post parent ID.
    271  *
    272  * Normally, without any enhancements, the children would apply to pages. In the
    273  * context of the inner workings of WordPress, pages, posts, and attachments
    274  * share the same table, so therefore the functionality could apply to any one
    275  * of them. It is then noted that while this function does not work on posts, it
    276  * does not mean that it won't work on posts. It is recommended that you know
    277  * what context you wish to retrieve the children of.
    278  *
    279  * Attachments may also be made the child of a post, so if that is an accurate
    280  * statement (which needs to be verified), it would then be possible to get
    281  * all of the attachments for a post. Attachments have since changed since
    282  * version 2.5, so this is most likely unaccurate, but serves generally as an
    283  * example of what is possible.
    284  *
    285  * The arguments listed as defaults are for this function and also of the
    286  * {@link get_posts()} function. The arguments are combined with the
    287  * get_children defaults and are then passed to the {@link get_posts()}
    288  * function, which accepts additional arguments. You can replace the defaults in
    289  * this function, listed below and the additional arguments listed in the
    290  * {@link get_posts()} function.
    291  *
    292  * The 'post_parent' is the most important argument and important attention
    293  * needs to be paid to the $args parameter. If you pass either an object or an
    294  * integer (number), then just the 'post_parent' is grabbed and everything else
    295  * is lost. If you don't specify any arguments, then it is assumed that you are
    296  * in The Loop and the post parent will be grabbed for from the current post.
    297  *
    298  * The 'post_parent' argument is the ID to get the children. The 'numberposts'
    299  * is the amount of posts to retrieve that has a default of '-1', which is
    300  * used to get all of the posts. Giving a number higher than 0 will only
    301  * retrieve that amount of posts.
    302  *
    303  * The 'post_type' and 'post_status' arguments can be used to choose what
    304  * criteria of posts to retrieve. The 'post_type' can be anything, but WordPress
    305  * post types are 'post', 'pages', and 'attachments'. The 'post_status'
    306  * argument will accept any post status within the write administration panels.
    307  *
    308  * @since 2.0.0
    309  *
    310  * @see get_posts()
    311  * @todo Check validity of description.
    312  *
    313  * @global WP_Post $post
    314  *
    315  * @param mixed  $args   Optional. User defined arguments for replacing the defaults. Default empty.
    316  * @param string $output Optional. Constant for return type. Accepts OBJECT, ARRAY_A, ARRAY_N.
    317  *                       Default OBJECT.
    318  * @return array Array of children, where the type of each element is determined by $output parameter.
    319  *               Empty array on failure.
    320  */
    321 function get_children( $args = '', $output = OBJECT ) {
    322     $kids = array();
    323     if ( empty( $args ) ) {
    324         if ( isset( $GLOBALS['post'] ) ) {
    325             $args = array('post_parent' => (int) $GLOBALS['post']->post_parent );
    326         } else {
    327             return $kids;
    328         }
    329     } elseif ( is_object( $args ) ) {
    330         $args = array('post_parent' => (int) $args->post_parent );
    331     } elseif ( is_numeric( $args ) ) {
    332         $args = array('post_parent' => (int) $args);
    333     }
    334 
    335     $defaults = array(
    336         'numberposts' => -1, 'post_type' => 'any',
    337         'post_status' => 'any', 'post_parent' => 0,
    338     );
    339 
    340     $r = wp_parse_args( $args, $defaults );
    341 
    342     $children = get_posts( $r );
    343 
    344     if ( ! $children )
    345         return $kids;
    346 
    347     if ( ! empty( $r['fields'] ) )
    348         return $children;
    349 
    350     update_post_cache($children);
    351 
    352     foreach ( $children as $key => $child )
    353         $kids[$child->ID] = $children[$key];
    354 
    355     if ( $output == OBJECT ) {
    356         return $kids;
    357     } elseif ( $output == ARRAY_A ) {
    358         $weeuns = array();
    359         foreach ( (array) $kids as $kid ) {
    360             $weeuns[$kid->ID] = get_object_vars($kids[$kid->ID]);
    361         }
    362         return $weeuns;
    363     } elseif ( $output == ARRAY_N ) {
    364         $babes = array();
    365         foreach ( (array) $kids as $kid ) {
    366             $babes[$kid->ID] = array_values(get_object_vars($kids[$kid->ID]));
    367         }
    368         return $babes;
    369     } else {
    370         return $kids;
    371     }
    372 }
    373 
    374 /**
    375  * Get extended entry info (<!--more-->).
    376  *
    377  * There should not be any space after the second dash and before the word
    378  * 'more'. There can be text or space(s) after the word 'more', but won't be
    379  * referenced.
    380  *
    381  * The returned array has 'main', 'extended', and 'more_text' keys. Main has the text before
    382  * the `<!--more-->`. The 'extended' key has the content after the
    383  * `<!--more-->` comment. The 'more_text' key has the custom "Read More" text.
    384  *
    385  * @since 1.0.0
    386  *
    387  * @param string $post Post content.
    388  * @return array Post before ('main'), after ('extended'), and custom readmore ('more_text').
    389  */
    390 function get_extended( $post ) {
    391     //Match the new style more links.
    392     if ( preg_match('/<!--more(.*?)?-->/', $post, $matches) ) {
    393         list($main, $extended) = explode($matches[0], $post, 2);
    394         $more_text = $matches[1];
    395     } else {
    396         $main = $post;
    397         $extended = '';
    398         $more_text = '';
    399     }
    400 
    401     //  leading and trailing whitespace.
    402     $main = preg_replace('/^[\s]*(.*)[\s]*$/', '\\1', $main);
    403     $extended = preg_replace('/^[\s]*(.*)[\s]*$/', '\\1', $extended);
    404     $more_text = preg_replace('/^[\s]*(.*)[\s]*$/', '\\1', $more_text);
    405 
    406     return array( 'main' => $main, 'extended' => $extended, 'more_text' => $more_text );
    407 }
    408 
    409 /**
    410  * Retrieves post data given a post ID or post object.
    411  *
    412  * See {@link sanitize_post()} for optional $filter values. Also, the parameter
    413  * $post, must be given as a variable, since it is passed by reference.
    414  *
    415  * @since 1.5.1
    416  *
    417  * @global WP_Post $post
    418  *
    419  * @param int|WP_Post|null $post   Optional. Post ID or post object. Defaults to global $post.
    420  * @param string           $output Optional, default is Object. Accepts OBJECT, ARRAY_A, or ARRAY_N.
    421  *                                 Default OBJECT.
    422  * @param string           $filter Optional. Type of filter to apply. Accepts 'raw', 'edit', 'db',
    423  *                                 or 'display'. Default 'raw'.
    424  * @return WP_Post|array|null Type corresponding to $output on success or null on failure.
    425  *                            When $output is OBJECT, a `WP_Post` instance is returned.
    426  */
    427 function get_post( $post = null, $output = OBJECT, $filter = 'raw' ) {
    428     if ( empty( $post ) && isset( $GLOBALS['post'] ) )
    429         $post = $GLOBALS['post'];
    430 
    431     if ( $post instanceof WP_Post ) {
    432         $_post = $post;
    433     } elseif ( is_object( $post ) ) {
    434         if ( empty( $post->filter ) ) {
    435             $_post = sanitize_post( $post, 'raw' );
    436             $_post = new WP_Post( $_post );
    437         } elseif ( 'raw' == $post->filter ) {
    438             $_post = new WP_Post( $post );
    439         } else {
    440             $_post = WP_Post::get_instance( $post->ID );
    441         }
    442     } else {
    443         $_post = WP_Post::get_instance( $post );
    444     }
    445 
    446     if ( ! $_post )
    447         return null;
    448 
    449     $_post = $_post->filter( $filter );
    450 
    451     if ( $output == ARRAY_A )
    452         return $_post->to_array();
    453     elseif ( $output == ARRAY_N )
    454         return array_values( $_post->to_array() );
    455 
    456     return $_post;
    457 }
    458 
    459 /**
    460  * WordPress Post class.
    461  *
    462  * @since 3.5.0
    463  *
    464  * @property string $page_template
    465  *
    466  * @property-read array  $ancestors
    467  * @property-read int    $post_category
    468  * @property-read string $tag_input
    469  *
    470  */
    471 final class WP_Post {
    472 
    473     /**
    474      * Post ID.
    475      *
    476      * @var int
    477      */
    478     public $ID;
    479 
    480     /**
    481      * ID of post author.
    482      *
    483      * A numeric string, for compatibility reasons.
    484      *
    485      * @var string
    486      */
    487     public $post_author = 0;
    488 
    489     /**
    490      * The post's local publication time.
    491      *
    492      * @var string
    493      */
    494     public $post_date = '0000-00-00 00:00:00';
    495 
    496     /**
    497      * The post's GMT publication time.
    498      *
    499      * @var string
    500      */
    501     public $post_date_gmt = '0000-00-00 00:00:00';
    502 
    503     /**
    504      * The post's content.
    505      *
    506      * @var string
    507      */
    508     public $post_content = '';
    509 
    510     /**
    511      * The post's title.
    512      *
    513      * @var string
    514      */
    515     public $post_title = '';
    516 
    517     /**
    518      * The post's excerpt.
    519      *
    520      * @var string
    521      */
    522     public $post_excerpt = '';
    523 
    524     /**
    525      * The post's status.
    526      *
    527      * @var string
    528      */
    529     public $post_status = 'publish';
    530 
    531     /**
    532      * Whether comments are allowed.
    533      *
    534      * @var string
    535      */
    536     public $comment_status = 'open';
    537 
    538     /**
    539      * Whether pings are allowed.
    540      *
    541      * @var string
    542      */
    543     public $ping_status = 'open';
    544 
    545     /**
    546      * The post's password in plain text.
    547      *
    548      * @var string
    549      */
    550     public $post_password = '';
    551 
    552     /**
    553      * The post's slug.
    554      *
    555      * @var string
    556      */
    557     public $post_name = '';
    558 
    559     /**
    560      * URLs queued to be pinged.
    561      *
    562      * @var string
    563      */
    564     public $to_ping = '';
    565 
    566     /**
    567      * URLs that have been pinged.
    568      *
    569      * @var string
    570      */
    571     public $pinged = '';
    572 
    573     /**
    574      * The post's local modified time.
    575      *
    576      * @var string
    577      */
    578     public $post_modified = '0000-00-00 00:00:00';
    579 
    580     /**
    581      * The post's GMT modified time.
    582      *
    583      * @var string
    584      */
    585     public $post_modified_gmt = '0000-00-00 00:00:00';
    586 
    587     /**
    588      * A utility DB field for post content.
    589      *
    590      *
    591      * @var string
    592      */
    593     public $post_content_filtered = '';
    594 
    595     /**
    596      * ID of a post's parent post.
    597      *
    598      * @var int
    599      */
    600     public $post_parent = 0;
    601 
    602     /**
    603      * The unique identifier for a post, not necessarily a URL, used as the feed GUID.
    604      *
    605      * @var string
    606      */
    607     public $guid = '';
    608 
    609     /**
    610      * A field used for ordering posts.
    611      *
    612      * @var int
    613      */
    614     public $menu_order = 0;
    615 
    616     /**
    617      * The post's type, like post or page.
    618      *
    619      * @var string
    620      */
    621     public $post_type = 'post';
    622 
    623     /**
    624      * An attachment's mime type.
    625      *
    626      * @var string
    627      */
    628     public $post_mime_type = '';
    629 
    630     /**
    631      * Cached comment count.
    632      *
    633      * A numeric string, for compatibility reasons.
    634      *
    635      * @var string
    636      */
    637     public $comment_count = 0;
    638 
    639     /**
    640      * Stores the post object's sanitization level.
    641      *
    642      * Does not correspond to a DB field.
    643      *
    644      * @var string
    645      */
    646     public $filter;
    647 
    648     /**
    649      * Retrieve WP_Post instance.
    650      *
    651      * @static
    652      * @access public
    653      *
    654      * @global wpdb $wpdb
    655      *
    656      * @param int $post_id Post ID.
    657      * @return WP_Post|false Post object, false otherwise.
    658      */
    659     public static function get_instance( $post_id ) {
    660         global $wpdb;
    661 
    662         $post_id = (int) $post_id;
    663         if ( ! $post_id )
    664             return false;
    665 
    666         $_post = wp_cache_get( $post_id, 'posts' );
    667 
    668         if ( ! $_post ) {
    669             $_post = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1", $post_id ) );
    670 
    671             if ( ! $_post )
    672                 return false;
    673 
    674             $_post = sanitize_post( $_post, 'raw' );
    675             wp_cache_add( $_post->ID, $_post, 'posts' );
    676         } elseif ( empty( $_post->filter ) ) {
    677             $_post = sanitize_post( $_post, 'raw' );
    678         }
    679 
    680         return new WP_Post( $_post );
    681     }
    682 
    683     /**
    684      * Constructor.
    685      *
    686      * @param WP_Post|object $post Post object.
    687      */
    688     public function __construct( $post ) {
    689         foreach ( get_object_vars( $post ) as $key => $value )
    690             $this->$key = $value;
    691     }
    692 
    693     /**
    694      * Isset-er.
    695      *
    696      * @param string $key Property to check if set.
    697      * @return bool
    698      */
    699     public function __isset( $key ) {
    700         if ( 'ancestors' == $key )
    701             return true;
    702 
    703         if ( 'page_template' == $key )
    704             return ( 'page' == $this->post_type );
    705 
    706         if ( 'post_category' == $key )
    707            return true;
    708 
    709         if ( 'tags_input' == $key )
    710            return true;
    711 
    712         return metadata_exists( 'post', $this->ID, $key );
    713     }
    714 
    715     /**
    716      * Getter.
    717      *
    718      * @param string $key Key to get.
    719      * @return mixed
    720      */
    721     public function __get( $key ) {
    722         if ( 'page_template' == $key && $this->__isset( $key ) ) {
    723             return get_post_meta( $this->ID, '_wp_page_template', true );
    724         }
    725 
    726         if ( 'post_category' == $key ) {
    727             if ( is_object_in_taxonomy( $this->post_type, 'category' ) )
    728                 $terms = get_the_terms( $this, 'category' );
    729 
    730             if ( empty( $terms ) )
    731                 return array();
    732 
    733             return wp_list_pluck( $terms, 'term_id' );
    734         }
    735 
    736         if ( 'tags_input' == $key ) {
    737             if ( is_object_in_taxonomy( $this->post_type, 'post_tag' ) )
    738                 $terms = get_the_terms( $this, 'post_tag' );
    739 
    740             if ( empty( $terms ) )
    741                 return array();
    742 
    743             return wp_list_pluck( $terms, 'name' );
    744         }
    745 
    746         // Rest of the values need filtering.
    747         if ( 'ancestors' == $key )
    748             $value = get_post_ancestors( $this );
    749         else
    750             $value = get_post_meta( $this->ID, $key, true );
    751 
    752         if ( $this->filter )
    753             $value = sanitize_post_field( $key, $value, $this->ID, $this->filter );
    754 
    755         return $value;
    756     }
    757 
    758     /**
    759      * {@Missing Summary}
    760      *
    761      * @param string $filter Filter.
    762      * @return self|array|bool|object|WP_Post
    763      */
    764     public function filter( $filter ) {
    765         if ( $this->filter == $filter )
    766             return $this;
    767 
    768         if ( $filter == 'raw' )
    769             return self::get_instance( $this->ID );
    770 
    771         return sanitize_post( $this, $filter );
    772     }
    773 
    774     /**
    775      * Convert object to array.
    776      *
    777      * @return array Object as array.
    778      */
    779     public function to_array() {
    780         $post = get_object_vars( $this );
    781 
    782         foreach ( array( 'ancestors', 'page_template', 'post_category', 'tags_input' ) as $key ) {
    783             if ( $this->__isset( $key ) )
    784                 $post[ $key ] = $this->__get( $key );
    785         }
    786 
    787         return $post;
    788     }
    789 }
    790 
    791 /**
    792  * Retrieve ancestors of a post.
    793  *
    794  * @since 2.5.0
    795  *
    796  * @param int|WP_Post $post Post ID or post object.
    797  * @return array Ancestor IDs or empty array if none are found.
    798  */
    799 function get_post_ancestors( $post ) {
    800     $post = get_post( $post );
    801 
    802     if ( ! $post || empty( $post->post_parent ) || $post->post_parent == $post->ID )
    803         return array();
    804 
    805     $ancestors = array();
    806 
    807     $id = $ancestors[] = $post->post_parent;
    808 
    809     while ( $ancestor = get_post( $id ) ) {
    810         // Loop detection: If the ancestor has been seen before, break.
    811         if ( empty( $ancestor->post_parent ) || ( $ancestor->post_parent == $post->ID ) || in_array( $ancestor->post_parent, $ancestors ) )
    812             break;
    813 
    814         $id = $ancestors[] = $ancestor->post_parent;
    815     }
    816 
    817     return $ancestors;
    818 }
    819 
    820 /**
    821  * Retrieve data from a post field based on Post ID.
    822  *
    823  * Examples of the post field will be, 'post_type', 'post_status', 'post_content',
    824  * etc and based off of the post object property or key names.
    825  *
    826  * The context values are based off of the taxonomy filter functions and
    827  * supported values are found within those functions.
    828  *
    829  * @since 2.3.0
    830  *
    831  * @see sanitize_post_field()
    832  *
    833  * @param string      $field   Post field name.
    834  * @param int|WP_Post $post    Post ID or post object.
    835  * @param string      $context Optional. How to filter the field. Accepts 'raw', 'edit', 'db',
    836  *                             or 'display'. Default 'display'.
    837  * @return string The value of the post field on success, empty string on failure.
    838  */
    839 function get_post_field( $field, $post, $context = 'display' ) {
    840     $post = get_post( $post );
    841 
    842     if ( !$post )
    843         return '';
    844 
    845     if ( !isset($post->$field) )
    846         return '';
    847 
    848     return sanitize_post_field($field, $post->$field, $post->ID, $context);
    849 }
    850 
    851 /**
    852  * Retrieve the mime type of an attachment based on the ID.
    853  *
    854  * This function can be used with any post type, but it makes more sense with
    855  * attachments.
    856  *
    857  * @since 2.0.0
    858  *
    859  * @param int|WP_Post $ID Optional. Post ID or post object. Default empty.
    860  * @return string|false The mime type on success, false on failure.
    861  */
    862 function get_post_mime_type( $ID = '' ) {
    863     $post = get_post($ID);
    864 
    865     if ( is_object($post) )
    866         return $post->post_mime_type;
    867 
    868     return false;
    869 }
    870 
    871 /**
    872  * Retrieve the post status based on the Post ID.
    873  *
    874  * If the post ID is of an attachment, then the parent post status will be given
    875  * instead.
    876  *
    877  * @since 2.0.0
    878  *
    879  * @param int|WP_Post $ID Optional. Post ID or post object. Default empty.
    880  * @return string|false Post status on success, false on failure.
    881  */
    882 function get_post_status( $ID = '' ) {
    883     $post = get_post($ID);
    884 
    885     if ( !is_object($post) )
    886         return false;
    887 
    888     if ( 'attachment' == $post->post_type ) {
    889         if ( 'private' == $post->post_status )
    890             return 'private';
    891 
    892         // Unattached attachments are assumed to be published.
    893         if ( ( 'inherit' == $post->post_status ) && ( 0 == $post->post_parent) )
    894             return 'publish';
    895 
    896         // Inherit status from the parent.
    897         if ( $post->post_parent && ( $post->ID != $post->post_parent ) ) {
    898             $parent_post_status = get_post_status( $post->post_parent );
    899             if ( 'trash' == $parent_post_status ) {
    900                 return get_post_meta( $post->post_parent, '_wp_trash_meta_status', true );
    901             } else {
    902                 return $parent_post_status;
    903             }
    904         }
    905 
    906     }
    907 
    908     return $post->post_status;
    909 }
    910 
    911 /**
    912  * Retrieve all of the WordPress supported post statuses.
    913  *
    914  * Posts have a limited set of valid status values, this provides the
    915  * post_status values and descriptions.
    916  *
    917  * @since 2.5.0
    918  *
    919  * @return array List of post statuses.
    920  */
    921 function get_post_statuses() {
    922     $status = array(
    923         'draft'   => __( 'Draft' ),
    924         'pending' => __( 'Pending Review' ),
    925         'private' => __( 'Private' ),
    926         'publish' => __( 'Published' )
    927     );
    928 
    929     return $status;
    930 }
    931 
    932 /**
    933  * Retrieve all of the WordPress support page statuses.
    934  *
    935  * Pages have a limited set of valid status values, this provides the
    936  * post_status values and descriptions.
    937  *
    938  * @since 2.5.0
    939  *
    940  * @return array List of page statuses.
    941  */
    942 function get_page_statuses() {
    943     $status = array(
    944         'draft'   => __( 'Draft' ),
    945         'private' => __( 'Private' ),
    946         'publish' => __( 'Published' )
    947     );
    948 
    949     return $status;
    950 }
    951 
    952 /**
    953  * Register a post status. Do not use before init.
    954  *
    955  * A simple function for creating or modifying a post status based on the
    956  * parameters given. The function will accept an array (second optional
    957  * parameter), along with a string for the post status name.
    958  *
    959  * Arguments prefixed with an _underscore shouldn't be used by plugins and themes.
    960  *
    961  * @since 3.0.0
    962  * @global array $wp_post_statuses Inserts new post status object into the list
    963  *
    964  * @param string $post_status Name of the post status.
    965  * @param array|string $args {
    966  *     Optional. Array or string of post status arguments.
    967  *
    968  *     @type bool|string $label                     A descriptive name for the post status marked
    969  *                                                  for translation. Defaults to value of $post_status.
    970  *     @type bool|array  $label_count               Descriptive text to use for nooped plurals.
    971  *                                                  Default array of $label, twice
    972  *     @type bool        $exclude_from_search       Whether to exclude posts with this post status
    973  *                                                  from search results. Default is value of $internal.
    974  *     @type bool        $_builtin                  Whether the status is built-in. Core-use only.
    975  *                                                  Default false.
    976  *     @type bool        $public                    Whether posts of this status should be shown
    977  *                                                  in the front end of the site. Default false.
    978  *     @type bool        $internal                  Whether the status is for internal use only.
    979  *                                                  Default false.
    980  *     @type bool        $protected                 Whether posts with this status should be protected.
    981  *                                                  Default false.
    982  *     @type bool        $private                   Whether posts with this status should be private.
    983  *                                                  Default false.
    984  *     @type bool        $publicly_queryable        Whether posts with this status should be publicly-
    985  *                                                  queryable. Default is value of $public.
    986  *     @type bool        $show_in_admin_all_list    Whether to include posts in the edit listing for
    987  *                                                  their post type. Default is value of $internal.
    988  *     @type bool        $show_in_admin_status_list Show in the list of statuses with post counts at
    989  *                                                  the top of the edit listings,
    990  *                                                  e.g. All (12) | Published (9) | My Custom Status (2)
    991  *                                                  Default is value of $internal.
    992  * }
    993  * @return object
    994  */
    995 function register_post_status( $post_status, $args = array() ) {
    996     global $wp_post_statuses;
    997 
    998     if (!is_array($wp_post_statuses))
    999         $wp_post_statuses = array();
    1000 
    1001     // Args prefixed with an underscore are reserved for internal use.
    1002     $defaults = array(
    1003         'label' => false,
    1004         'label_count' => false,
    1005         'exclude_from_search' => null,
    1006         '_builtin' => false,
    1007         'public' => null,
    1008         'internal' => null,
    1009         'protected' => null,
    1010         'private' => null,
    1011         'publicly_queryable' => null,
    1012         'show_in_admin_status_list' => null,
    1013         'show_in_admin_all_list' => null,
    1014     );
    1015     $args = wp_parse_args($args, $defaults);
    1016     $args = (object) $args;
    1017 
    1018     $post_status = sanitize_key($post_status);
    1019     $args->name = $post_status;
    1020 
    1021     // Set various defaults.
    1022     if ( null === $args->public && null === $args->internal && null === $args->protected && null === $args->private )
    1023         $args->internal = true;
    1024 
    1025     if ( null === $args->public  )
    1026         $args->public = false;
    1027 
    1028     if ( null === $args->private  )
    1029         $args->private = false;
    1030 
    1031     if ( null === $args->protected  )
    1032         $args->protected = false;
    1033 
    1034     if ( null === $args->internal  )
    1035         $args->internal = false;
    1036 
    1037     if ( null === $args->publicly_queryable )
    1038         $args->publicly_queryable = $args->public;
    1039 
    1040     if ( null === $args->exclude_from_search )
    1041         $args->exclude_from_search = $args->internal;
    1042 
    1043     if ( null === $args->show_in_admin_all_list )
    1044         $args->show_in_admin_all_list = !$args->internal;
    1045 
    1046     if ( null === $args->show_in_admin_status_list )
    1047         $args->show_in_admin_status_list = !$args->internal;
    1048 
    1049     if ( false === $args->label )
    1050         $args->label = $post_status;
    1051 
    1052     if ( false === $args->label_count )
    1053         $args->label_count = array( $args->label, $args->label );
    1054 
    1055     $wp_post_statuses[$post_status] = $args;
    1056 
    1057     return $args;
    1058 }
    1059 
    1060 /**
    1061  * Retrieve a post status object by name.
    1062  *
    1063  * @since 3.0.0
    1064  *
    1065  * @global array $wp_post_statuses List of post statuses.
    1066  *
    1067  * @see register_post_status()
    1068  *
    1069  * @param string $post_status The name of a registered post status.
    1070  * @return object|null A post status object.
    1071  */
    1072 function get_post_status_object( $post_status ) {
    1073     global $wp_post_statuses;
    1074 
    1075     if ( empty($wp_post_statuses[$post_status]) )
    1076         return null;
    1077 
    1078     return $wp_post_statuses[$post_status];
    1079 }
    1080 
    1081 /**
    1082  * Get a list of post statuses.
    1083  *
    1084  * @since 3.0.0
    1085  *
    1086  * @global array $wp_post_statuses List of post statuses.
    1087  *
    1088  * @see register_post_status()
    1089  *
    1090  * @param array|string $args     Optional. Array or string of post status arguments to compare against
    1091  *                               properties of the global `$wp_post_statuses objects`. Default empty array.
    1092  * @param string       $output   Optional. The type of output to return, either 'names' or 'objects'. Default 'names'.
    1093  * @param string       $operator Optional. The logical operation to perform. 'or' means only one element
    1094  *                               from the array needs to match; 'and' means all elements must match.
    1095  *                               Default 'and'.
    1096  * @return array A list of post status names or objects.
    1097  */
    1098 function get_post_stati( $args = array(), $output = 'names', $operator = 'and' ) {
    1099     global $wp_post_statuses;
    1100 
    1101     $field = ('names' == $output) ? 'name' : false;
    1102 
    1103     return wp_filter_object_list($wp_post_statuses, $args, $operator, $field);
    1104 }
    1105 
    1106 /**
    1107  * Whether the post type is hierarchical.
    1108  *
    1109  * A false return value might also mean that the post type does not exist.
    1110  *
    1111  * @since 3.0.0
    1112  *
    1113  * @see get_post_type_object()
    1114  *
    1115  * @param string $post_type Post type name
    1116  * @return bool Whether post type is hierarchical.
    1117  */
    1118 function is_post_type_hierarchical( $post_type ) {
    1119     if ( ! post_type_exists( $post_type ) )
    1120         return false;
    1121 
    1122     $post_type = get_post_type_object( $post_type );
    1123     return $post_type->hierarchical;
    1124 }
    1125 
    1126 /**
    1127  * Check if a post type is registered.
    1128  *
    1129  * @since 3.0.0
    1130  *
    1131  * @see get_post_type_object()
    1132  *
    1133  * @param string $post_type Post type name.
    1134  * @return bool Whether post type is registered.
    1135  */
    1136 function post_type_exists( $post_type ) {
    1137     return (bool) get_post_type_object( $post_type );
    1138 }
    1139 
    1140 /**
    1141  * Retrieve the post type of the current post or of a given post.
    1142  *
    1143  * @since 2.1.0
    1144  *
    1145  * @param int|WP_Post|null $post Optional. Post ID or post object. Default is global $post.
    1146  * @return string|false          Post type on success, false on failure.
    1147  */
    1148 function get_post_type( $post = null ) {
    1149     if ( $post = get_post( $post ) )
    1150         return $post->post_type;
    1151 
    1152     return false;
    1153 }
    1154 
    1155 /**
    1156  * Retrieve a post type object by name.
    1157  *
    1158  * @since 3.0.0
    1159  *
    1160  * @global array $wp_post_types List of post types.
    1161  *
    1162  * @see register_post_type()
    1163  *
    1164  * @param string $post_type The name of a registered post type.
    1165  * @return object|null A post type object.
    1166  */
    1167 function get_post_type_object( $post_type ) {
    1168     global $wp_post_types;
    1169 
    1170     if ( empty($wp_post_types[$post_type]) )
    1171         return null;
    1172 
    1173     return $wp_post_types[$post_type];
    1174 }
    1175 
    1176 /**
    1177  * Get a list of all registered post type objects.
    1178  *
    1179  * @since 2.9.0
    1180  *
    1181  * @global array $wp_post_types List of post types.
    1182  *
    1183  * @see register_post_type() for accepted arguments.
    1184  *
    1185  * @param array|string $args     Optional. An array of key => value arguments to match against
    1186  *                               the post type objects. Default empty array.
    1187  * @param string       $output   Optional. The type of output to return. Accepts post type 'names'
    1188  *                               or 'objects'. Default 'names'.
    1189  * @param string       $operator Optional. The logical operation to perform. 'or' means only one
    1190  *                               element from the array needs to match; 'and' means all elements
    1191  *                               must match. Accepts 'or' or 'and'. Default 'and'.
    1192  * @return array A list of post type names or objects.
    1193  */
    1194 function get_post_types( $args = array(), $output = 'names', $operator = 'and' ) {
    1195     global $wp_post_types;
    1196 
    1197     $field = ('names' == $output) ? 'name' : false;
    1198 
    1199     return wp_filter_object_list($wp_post_types, $args, $operator, $field);
    1200 }
    1201 
    1202 /**
    1203  * Register a post type. Do not use before init.
    1204  *
    1205  * A function for creating or modifying a post type based on the
    1206  * parameters given. The function will accept an array (second optional
    1207  * parameter), along with a string for the post type name.
    1208  *
    1209  * @since 2.9.0
    1210  *
    1211  * @global array      $wp_post_types List of post types.
    1212  * @global WP_Rewrite $wp_rewrite    Used for default feeds.
    1213  * @global WP         $wp            Used to add query vars.
    1214  *
    1215  * @param string $post_type Post type key, must not exceed 20 characters.
    1216  * @param array|string $args {
    1217  *     Array or string of arguments for registering a post type.
    1218  *
    1219  *     @type string      $label                Name of the post type shown in the menu. Usually plural.
    1220  *                                             Default is value of $labels['name'].
    1221  *     @type array       $labels               An array of labels for this post type. If not set, post
    1222  *                                             labels are inherited for non-hierarchical types and page
    1223  *                                             labels for hierarchical ones. {@see get_post_type_labels()}.
    1224  *     @type string      $description          A short descriptive summary of what the post type is.
    1225  *                                             Default empty.
    1226  *     @type bool        $public               Whether a post type is intended for use publicly either via
    1227  *                                             the admin interface or by front-end users. While the default
    1228  *                                             settings of $exclude_from_search, $publicly_queryable, $show_ui,
    1229  *                                             and $show_in_nav_menus are inherited from public, each does not
    1230  *                                             rely on this relationship and controls a very specific intention.
    1231  *                                             Default false.
    1232  *     @type bool        $hierarchical         Whether the post type is hierarchical (e.g. page). Default false.
    1233  *     @type bool        $exclude_from_search  Whether to exclude posts with this post type from front end search
    1234  *                                             results. Default is the opposite value of $public.
    1235  *     @type bool        $publicly_queryable   Whether queries can be performed on the front end for the post type
    1236  *                                             as part of {@see parse_request()}. Endpoints would include:
    1237  *                                             * ?post_type={post_type_key}
    1238  *                                             * ?{post_type_key}={single_post_slug}
    1239  *                                             * ?{post_type_query_var}={single_post_slug}
    1240  *                                             If not set, the default is inherited from $public.
    1241  *     @type bool        $show_ui              Whether to generate a default UI for managing this post type in the
    1242  *                                             admin. Default is value of $public.
    1243  *     @type bool        $show_in_menu         Where to show the post type in the admin menu. To work, $show_ui
    1244  *                                             must be true. If true, the post type is shown in its own top level
    1245  *                                             menu. If false, no menu is shown. If a string of an existing top
    1246  *                                             level menu (eg. 'tools.php' or 'edit.php?post_type=page'), the post
    1247  *                                             type will be placed as a sub-menu of that.
    1248  *                                             Default is value of $show_ui.
    1249  *     @type bool        $show_in_nav_menus    Makes this post type available for selection in navigation menus.
    1250  *                                             Default is value $public.
    1251  *     @type bool        $show_in_admin_bar    Makes this post type available via the admin bar. Default is value
    1252  *                                             of $show_in_menu.
    1253  *     @type int         $menu_position        The position in the menu order the post type should appear. To work,
    1254  *                                             $show_in_menu must be true. Default null (at the bottom).
    1255  *     @type string      $menu_icon            The url to the icon to be used for this menu. Pass a base64-encoded
    1256  *                                             SVG using a data URI, which will be colored to match the color scheme
    1257  *                                             -- this should begin with 'data:image/svg+xml;base64,'. Pass the name
    1258  *                                             of a Dashicons helper class to use a font icon, e.g.
    1259  *                                             'dashicons-chart-pie'. Pass 'none' to leave div.wp-menu-image empty
    1260  *                                             so an icon can be added via CSS. Defaults to use the posts icon.
    1261  *     @type string      $capability_type      The string to use to build the read, edit, and delete capabilities.
    1262  *                                             May be passed as an array to allow for alternative plurals when using
    1263  *                                             this argument as a base to construct the capabilities, e.g.
    1264  *                                             array('story', 'stories'). Default 'post'.
    1265  *     @type array       $capabilities         Array of capabilities for this post type. $capability_type is used
    1266  *                                             as a base to construct capabilities by default.
    1267  *                                             {@see get_post_type_capabilities()}.
    1268  *     @type bool        $map_meta_cap         Whether to use the internal default meta capability handling.
    1269  *                                             Default false.
    1270  *     @type array       $supports             An alias for calling {@see add_post_type_support()} directly.
    1271  *                                             Defaults to array containing 'title' & 'editor'.
    1272  *     @type callback    $register_meta_box_cb Provide a callback function that sets up the meta boxes for the
    1273  *                                             edit form. Do remove_meta_box() and add_meta_box() calls in the
    1274  *                                             callback. Default null.
    1275  *     @type array       $taxonomies           An array of taxonomy identifiers that will be registered for the
    1276  *                                             post type. Taxonomies can be registered later with
    1277  *                                             {@see register_taxonomy()} or {@see register_taxonomy_for_object_type()}.
    1278  *                                             Default empty array.
    1279  *     @type bool|string $has_archive          Whether there should be post type archives, or if a string, the
    1280  *                                             archive slug to use. Will generate the proper rewrite rules if
    1281  *                                             $rewrite is enabled. Default false.
    1282  *     @type bool|array  $rewrite              {
    1283  *         Triggers the handling of rewrites for this post type. To prevent rewrite, set to false.
    1284  *         Defaults to true, using $post_type as slug. To specify rewrite rules, an array can be
    1285  *         passed with any of these keys:
    1286  *
    1287  *         @type string $slug       Customize the permastruct slug. Defaults to $post_type key.
    1288  *         @type bool   $with_front Whether the permastruct should be prepended with WP_Rewrite::$front.
    1289  *                                  Default true.
    1290  *         @type bool   $feeds      Whether the feed permastruct should be built for this post type.
    1291  *                                  Default is value of $has_archive.
    1292  *         @type bool   $pages      Whether the permastruct should provide for pagination. Default true.
    1293  *         @type const  $ep_mask    Endpoint mask to assign. If not specified and permalink_epmask is set,
    1294  *                                  inherits from $permalink_epmask. If not specified and permalink_epmask
    1295  *                                  is not set, defaults to EP_PERMALINK.
    1296  *     }
    1297  *     @type string|bool $query_var            Sets the query_var key for this post type. Defaults to $post_type
    1298  *                                             key. If false, a post type cannot be loaded at
    1299  *                                             ?{query_var}={post_slug}. If specified as a string, the query
    1300  *                                             ?{query_var_string}={post_slug} will be valid.
    1301  *     @type bool        $can_export           Whether to allow this post type to be exported. Default true.
    1302  *     @type bool        $delete_with_user     Whether to delete posts of this type when deleting a user. If true,
    1303  *                                             posts of this type belonging to the user will be moved to trash
    1304  *                                             when then user is deleted. If false, posts of this type belonging
    1305  *                                             to the user will *not* be trashed or deleted. If not set (the default),
    1306  *                                             posts are trashed if post_type_supports('author'). Otherwise posts
    1307  *                                             are not trashed or deleted. Default null.
    1308  *     @type bool        $_builtin             FOR INTERNAL USE ONLY! True if this post type is a native or
    1309  *                                             "built-in" post_type. Default false.
    1310  *     @type string      $_edit_link           FOR INTERNAL USE ONLY! URL segment to use for edit link of
    1311  *                                             this post type. Default 'post.php?post=%d'.
    1312  * }
    1313  * @return object|WP_Error The registered post type object, or an error object.
    1314  */
    1315 function register_post_type( $post_type, $args = array() ) {
    1316     global $wp_post_types, $wp_rewrite, $wp;
    1317 
    1318     if ( ! is_array( $wp_post_types ) )
    1319         $wp_post_types = array();
    1320 
    1321     // Args prefixed with an underscore are reserved for internal use.
    1322     $defaults = array(
    1323         'labels'               => array(),
    1324         'description'          => '',
    1325         'public'               => false,
    1326         'hierarchical'         => false,
    1327         'exclude_from_search'  => null,
    1328         'publicly_queryable'   => null,
    1329         'show_ui'              => null,
    1330         'show_in_menu'         => null,
    1331         'show_in_nav_menus'    => null,
    1332         'show_in_admin_bar'    => null,
    1333         'menu_position'        => null,
    1334         'menu_icon'            => null,
    1335         'capability_type'      => 'post',
    1336         'capabilities'         => array(),
    1337         'map_meta_cap'         => null,
    1338         'supports'             => array(),
    1339         'register_meta_box_cb' => null,
    1340         'taxonomies'           => array(),
    1341         'has_archive'          => false,
    1342         'rewrite'              => true,
    1343         'query_var'            => true,
    1344         'can_export'           => true,
    1345         'delete_with_user'     => null,
    1346         '_builtin'             => false,
    1347         '_edit_link'           => 'post.php?post=%d',
    1348     );
    1349     $args = wp_parse_args( $args, $defaults );
    1350     $args = (object) $args;
    1351 
    1352     $post_type = sanitize_key( $post_type );
    1353     $args->name = $post_type;
    1354 
    1355     if ( empty( $post_type ) || strlen( $post_type ) > 20 ) {
    1356         _doing_it_wrong( __FUNCTION__, __( 'Post type names must be between 1 and 20 characters in length.' ), '4.2' );
    1357         return new WP_Error( 'post_type_length_invalid', __( 'Post type names must be between 1 and 20 characters in length.' ) );
    1358     }
    1359 
    1360     // If not set, default to the setting for public.
    1361     if ( null === $args->publicly_queryable )
    1362         $args->publicly_queryable = $args->public;
    1363 
    1364     // If not set, default to the setting for public.
    1365     if ( null === $args->show_ui )
    1366         $args->show_ui = $args->public;
    1367 
    1368     // If not set, default to the setting for show_ui.
    1369     if ( null === $args->show_in_menu || ! $args->show_ui )
    1370         $args->show_in_menu = $args->show_ui;
    1371 
    1372     // If not set, default to the whether the full UI is shown.
    1373     if ( null === $args->show_in_admin_bar )
    1374         $args->show_in_admin_bar = (bool) $args->show_in_menu;
    1375 
    1376     // If not set, default to the setting for public.
    1377     if ( null === $args->show_in_nav_menus )
    1378         $args->show_in_nav_menus = $args->public;
    1379 
    1380     // If not set, default to true if not public, false if public.
    1381     if ( null === $args->exclude_from_search )
    1382         $args->exclude_from_search = !$args->public;
    1383 
    1384     // Back compat with quirky handling in version 3.0. #14122.
    1385     if ( empty( $args->capabilities ) && null === $args->map_meta_cap && in_array( $args->capability_type, array( 'post', 'page' ) ) )
    1386         $args->map_meta_cap = true;
    1387 
    1388     // If not set, default to false.
    1389     if ( null === $args->map_meta_cap )
    1390         $args->map_meta_cap = false;
    1391 
    1392     $args->cap = get_post_type_capabilities( $args );
    1393     unset( $args->capabilities );
    1394 
    1395     if ( is_array( $args->capability_type ) )
    1396         $args->capability_type = $args->capability_type[0];
    1397 
    1398     if ( ! empty( $args->supports ) ) {
    1399         add_post_type_support( $post_type, $args->supports );
    1400         unset( $args->supports );
    1401     } elseif ( false !== $args->supports ) {
    1402         // Add default features
    1403         add_post_type_support( $post_type, array( 'title', 'editor' ) );
    1404     }
    1405 
    1406     if ( false !== $args->query_var && ! empty( $wp ) ) {
    1407         if ( true === $args->query_var )
    1408             $args->query_var = $post_type;
    1409         else
    1410             $args->query_var = sanitize_title_with_dashes( $args->query_var );
    1411         $wp->add_query_var( $args->query_var );
    1412     }
    1413 
    1414     if ( false !== $args->rewrite && ( is_admin() || '' != get_option( 'permalink_structure' ) ) ) {
    1415         if ( ! is_array( $args->rewrite ) )
    1416             $args->rewrite = array();
    1417         if ( empty( $args->rewrite['slug'] ) )
    1418             $args->rewrite['slug'] = $post_type;
    1419         if ( ! isset( $args->rewrite['with_front'] ) )
    1420             $args->rewrite['with_front'] = true;
    1421         if ( ! isset( $args->rewrite['pages'] ) )
    1422             $args->rewrite['pages'] = true;
    1423         if ( ! isset( $args->rewrite['feeds'] ) || ! $args->has_archive )
    1424             $args->rewrite['feeds'] = (bool) $args->has_archive;
    1425         if ( ! isset( $args->rewrite['ep_mask'] ) ) {
    1426             if ( isset( $args->permalink_epmask ) )
    1427                 $args->rewrite['ep_mask'] = $args->permalink_epmask;
    1428             else
    1429                 $args->rewrite['ep_mask'] = EP_PERMALINK;
    1430         }
    1431 
    1432         if ( $args->hierarchical )
    1433             add_rewrite_tag( "%$post_type%", '(.+?)', $args->query_var ? "{$args->query_var}=" : "post_type=$post_type&pagename=" );
    1434         else
    1435             add_rewrite_tag( "%$post_type%", '([^/]+)', $args->query_var ? "{$args->query_var}=" : "post_type=$post_type&name=" );
    1436 
    1437         if ( $args->has_archive ) {
    1438             $archive_slug = $args->has_archive === true ? $args->rewrite['slug'] : $args->has_archive;
    1439             if ( $args->rewrite['with_front'] )
    1440                 $archive_slug = substr( $wp_rewrite->front, 1 ) . $archive_slug;
    1441             else
    1442                 $archive_slug = $wp_rewrite->root . $archive_slug;
    1443 
    1444             add_rewrite_rule( "{$archive_slug}/?$", "index.php?post_type=$post_type", 'top' );
    1445             if ( $args->rewrite['feeds'] && $wp_rewrite->feeds ) {
    1446                 $feeds = '(' . trim( implode( '|', $wp_rewrite->feeds ) ) . ')';
    1447                 add_rewrite_rule( "{$archive_slug}/feed/$feeds/?$", "index.php?post_type=$post_type" . '&feed=$matches[1]', 'top' );
    1448                 add_rewrite_rule( "{$archive_slug}/$feeds/?$", "index.php?post_type=$post_type" . '&feed=$matches[1]', 'top' );
    1449             }
    1450             if ( $args->rewrite['pages'] )
    1451                 add_rewrite_rule( "{$archive_slug}/{$wp_rewrite->pagination_base}/([0-9]{1,})/?$", "index.php?post_type=$post_type" . '&paged=$matches[1]', 'top' );
    1452         }
    1453 
    1454         $permastruct_args = $args->rewrite;
    1455         $permastruct_args['feed'] = $permastruct_args['feeds'];
    1456         add_permastruct( $post_type, "{$args->rewrite['slug']}/%$post_type%", $permastruct_args );
    1457     }
    1458 
    1459     // Register the post type meta box if a custom callback was specified.
    1460     if ( $args->register_meta_box_cb )
    1461         add_action( 'add_meta_boxes_' . $post_type, $args->register_meta_box_cb, 10, 1 );
    1462 
    1463     $args->labels = get_post_type_labels( $args );
    1464     $args->label = $args->labels->name;
    1465 
    1466     $wp_post_types[ $post_type ] = $args;
    1467 
    1468     add_action( 'future_' . $post_type, '_future_post_hook', 5, 2 );
    1469 
    1470     foreach ( $args->taxonomies as $taxonomy ) {
    1471         register_taxonomy_for_object_type( $taxonomy, $post_type );
    1472     }
    1473 
    1474     /**
    1475      * Fires after a post type is registered.
    1476      *
    1477      * @since 3.3.0
    1478      *
    1479      * @param string $post_type Post type.
    1480      * @param object $args      Arguments used to register the post type.
    1481      */
    1482     do_action( 'registered_post_type', $post_type, $args );
    1483 
    1484     return $args;
    1485 }
    1486 
    1487 /**
    1488  * Build an object with all post type capabilities out of a post type object
    1489  *
    1490  * Post type capabilities use the 'capability_type' argument as a base, if the
    1491  * capability is not set in the 'capabilities' argument array or if the
    1492  * 'capabilities' argument is not supplied.
    1493  *
    1494  * The capability_type argument can optionally be registered as an array, with
    1495  * the first value being singular and the second plural, e.g. array('story, 'stories')
    1496  * Otherwise, an 's' will be added to the value for the plural form. After
    1497  * registration, capability_type will always be a string of the singular value.
    1498  *
    1499  * By default, seven keys are accepted as part of the capabilities array:
    1500  *
    1501  * - edit_post, read_post, and delete_post are meta capabilities, which are then
    1502  *   generally mapped to corresponding primitive capabilities depending on the
    1503  *   context, which would be the post being edited/read/deleted and the user or
    1504  *   role being checked. Thus these capabilities would generally not be granted
    1505  *   directly to users or roles.
    1506  *
    1507  * - edit_posts - Controls whether objects of this post type can be edited.
    1508  * - edit_others_posts - Controls whether objects of this type owned by other users
    1509  *   can be edited. If the post type does not support an author, then this will
    1510  *   behave like edit_posts.
    1511  * - publish_posts - Controls publishing objects of this post type.
    1512  * - read_private_posts - Controls whether private objects can be read.
    1513  *
    1514  * These four primitive capabilities are checked in core in various locations.
    1515  * There are also seven other primitive capabilities which are not referenced
    1516  * directly in core, except in map_meta_cap(), which takes the three aforementioned
    1517  * meta capabilities and translates them into one or more primitive capabilities
    1518  * that must then be checked against the user or role, depending on the context.
    1519  *
    1520  * - read - Controls whether objects of this post type can be read.
    1521  * - delete_posts - Controls whether objects of this post type can be deleted.
    1522  * - delete_private_posts - Controls whether private objects can be deleted.
    1523  * - delete_published_posts - Controls whether published objects can be deleted.
    1524  * - delete_others_posts - Controls whether objects owned by other users can be
    1525  *   can be deleted. If the post type does not support an author, then this will
    1526  *   behave like delete_posts.
    1527  * - edit_private_posts - Controls whether private objects can be edited.
    1528  * - edit_published_posts - Controls whether published objects can be edited.
    1529  *
    1530  * These additional capabilities are only used in map_meta_cap(). Thus, they are
    1531  * only assigned by default if the post type is registered with the 'map_meta_cap'
    1532  * argument set to true (default is false).
    1533  *
    1534  * @since 3.0.0
    1535  *
    1536  * @see register_post_type()
    1537  * @see map_meta_cap()
    1538  *
    1539  * @param object $args Post type registration arguments.
    1540  * @return object object with all the capabilities as member variables.
    1541  */
    1542 function get_post_type_capabilities( $args ) {
    1543     if ( ! is_array( $args->capability_type ) )
    1544         $args->capability_type = array( $args->capability_type, $args->capability_type . 's' );
    1545 
    1546     // Singular base for meta capabilities, plural base for primitive capabilities.
    1547     list( $singular_base, $plural_base ) = $args->capability_type;
    1548 
    1549     $default_capabilities = array(
    1550         // Meta capabilities
    1551         'edit_post'          => 'edit_'         . $singular_base,
    1552         'read_post'          => 'read_'         . $singular_base,
    1553         'delete_post'        => 'delete_'       . $singular_base,
    1554         // Primitive capabilities used outside of map_meta_cap():
    1555         'edit_posts'         => 'edit_'         . $plural_base,
    1556         'edit_others_posts'  => 'edit_others_'  . $plural_base,
    1557         'publish_posts'      => 'publish_'      . $plural_base,
    1558         'read_private_posts' => 'read_private_' . $plural_base,
    1559     );
    1560 
    1561     // Primitive capabilities used within map_meta_cap():
    1562     if ( $args->map_meta_cap ) {
    1563         $default_capabilities_for_mapping = array(
    1564             'read'                   => 'read',
    1565             'delete_posts'           => 'delete_'           . $plural_base,
    1566             'delete_private_posts'   => 'delete_private_'   . $plural_base,
    1567             'delete_published_posts' => 'delete_published_' . $plural_base,
    1568             'delete_others_posts'    => 'delete_others_'    . $plural_base,
    1569             'edit_private_posts'     => 'edit_private_'     . $plural_base,
    1570             'edit_published_posts'   => 'edit_published_'   . $plural_base,
    1571         );
    1572         $default_capabilities = array_merge( $default_capabilities, $default_capabilities_for_mapping );
    1573     }
    1574 
    1575     $capabilities = array_merge( $default_capabilities, $args->capabilities );
    1576 
    1577     // Post creation capability simply maps to edit_posts by default:
    1578     if ( ! isset( $capabilities['create_posts'] ) )
    1579         $capabilities['create_posts'] = $capabilities['edit_posts'];
    1580 
    1581     // Remember meta capabilities for future reference.
    1582     if ( $args->map_meta_cap )
    1583         _post_type_meta_capabilities( $capabilities );
    1584 
    1585     return (object) $capabilities;
    1586 }
    1587 
    1588 /**
    1589  * Store or return a list of post type meta caps for map_meta_cap().
    1590  *
    1591  * @since 3.1.0
    1592  * @access private
    1593  *
    1594  * @staticvar array $meta_caps
    1595  *
    1596  * @param array|void $capabilities Post type meta capabilities.
    1597  */
    1598 function _post_type_meta_capabilities( $capabilities = null ) {
    1599     static $meta_caps = array();
    1600     if ( null === $capabilities )
    1601         return $meta_caps;
    1602     foreach ( $capabilities as $core => $custom ) {
    1603         if ( in_array( $core, array( 'read_post', 'delete_post', 'edit_post' ) ) )
    1604             $meta_caps[ $custom ] = $core;
    1605     }
    1606 }
    1607 
    1608 /**
    1609  * Build an object with all post type labels out of a post type object
    1610  *
    1611  * Accepted keys of the label array in the post type object:
    1612  *
    1613  * - name - general name for the post type, usually plural. The same and overridden
    1614  *          by $post_type_object->label. Default is Posts/Pages
    1615  * - singular_name - name for one object of this post type. Default is Post/Page
    1616  * - add_new - Default is Add New for both hierarchical and non-hierarchical types.
    1617  *             When internationalizing this string, please use a gettext context
    1618  *             {@link https://codex.wordpress.org/I18n_for_WordPress_Developers#Disambiguation_by_context}
    1619  *             matching your post type. Example: `_x( 'Add New', 'product' );`.
    1620  * - add_new_item - Default is Add New Post/Add New Page.
    1621  * - edit_item - Default is Edit Post/Edit Page.
    1622  * - new_item - Default is New Post/New Page.
    1623  * - view_item - Default is View Post/View Page.
    1624  * - search_items - Default is Search Posts/Search Pages.
    1625  * - not_found - Default is No posts found/No pages found.
    1626  * - not_found_in_trash - Default is No posts found in Trash/No pages found in Trash.
    1627  * - parent_item_colon - This string isn't used on non-hierarchical types. In hierarchical
    1628  *                       ones the default is 'Parent Page:'.
    1629  * - all_items - String for the submenu. Default is All Posts/All Pages.
    1630  * - featured_image - Default is Featured Image.
    1631  * - set_featured_image - Default is Set featured image.
    1632  * - remove_featured_image - Default is Remove featured image.
    1633  * - use_featured_image - Default is Use as featured image.
    1634  * - menu_name - Default is the same as `name`.
    1635  *
    1636  * Above, the first default value is for non-hierarchical post types (like posts)
    1637  * and the second one is for hierarchical post types (like pages).
    1638  *
    1639  * @since 3.0.0
    1640  * @since 4.3.0 Added the `featured_image`, `set_featured_image`, `remove_featured_image`,
    1641  *              and `use_featured_image` labels.
    1642  * @access private
    1643  *
    1644  * @param object $post_type_object Post type object.
    1645  * @return object object with all the labels as member variables.
    1646  */
    1647 function get_post_type_labels( $post_type_object ) {
    1648     $nohier_vs_hier_defaults = array(
    1649         'name' => array( _x('Posts', 'post type general name'), _x('Pages', 'post type general name') ),
    1650         'singular_name' => array( _x('Post', 'post type singular name'), _x('Page', 'post type singular name') ),
    1651         'add_new' => array( _x('Add New', 'post'), _x('Add New', 'page') ),
    1652         'add_new_item' => array( __('Add New Post'), __('Add New Page') ),
    1653         'edit_item' => array( __('Edit Post'), __('Edit Page') ),
    1654         'new_item' => array( __('New Post'), __('New Page') ),
    1655         'view_item' => array( __('View Post'), __('View Page') ),
    1656         'search_items' => array( __('Search Posts'), __('Search Pages') ),
    1657         'not_found' => array( __('No posts found.'), __('No pages found.') ),
    1658         'not_found_in_trash' => array( __('No posts found in Trash.'), __('No pages found in Trash.') ),
    1659         'parent_item_colon' => array( null, __('Parent Page:') ),
    1660         'all_items' => array( __( 'All Posts' ), __( 'All Pages' ) ),
    1661         'featured_image' => array( __( 'Featured Image' ), __( 'Featured Image' ) ),
    1662         'set_featured_image' => array( __( 'Set featured image' ), __( 'Set featured image' ) ),
    1663         'remove_featured_image' => array( __( 'Remove featured image' ), __( 'Remove featured image' ) ),
    1664         'use_featured_image' => array( __( 'Use as featured image' ), __( 'Use as featured image' ) ),
    1665     );
    1666     $nohier_vs_hier_defaults['menu_name'] = $nohier_vs_hier_defaults['name'];
    1667 
    1668     $labels = _get_custom_object_labels( $post_type_object, $nohier_vs_hier_defaults );
    1669 
    1670     $post_type = $post_type_object->name;
    1671 
    1672     /**
    1673      * Filter the labels of a specific post type.
    1674      *
    1675      * The dynamic portion of the hook name, `$post_type`, refers to
    1676      * the post type slug.
    1677      *
    1678      * @since 3.5.0
    1679      *
    1680      * @see get_post_type_labels() for the full list of labels.
    1681      *
    1682      * @param object $labels Object with labels for the post type as member variables.
    1683      */
    1684     return apply_filters( "post_type_labels_{$post_type}", $labels );
    1685 }
    1686 
    1687 /**
    1688  * Build an object with custom-something object (post type, taxonomy) labels
    1689  * out of a custom-something object
    1690  *
    1691  * @since 3.0.0
    1692  * @access private
    1693  *
    1694  * @param object $object                  A custom-something object.
    1695  * @param array  $nohier_vs_hier_defaults Hierarchical vs non-hierarchical default labels.
    1696  */
    1697 function _get_custom_object_labels( $object, $nohier_vs_hier_defaults ) {
    1698     $object->labels = (array) $object->labels;
    1699 
    1700     if ( isset( $object->label ) && empty( $object->labels['name'] ) )
    1701         $object->labels['name'] = $object->label;
    1702 
    1703     if ( !isset( $object->labels['singular_name'] ) && isset( $object->labels['name'] ) )
    1704         $object->labels['singular_name'] = $object->labels['name'];
    1705 
    1706     if ( ! isset( $object->labels['name_admin_bar'] ) )
    1707         $object->labels['name_admin_bar'] = isset( $object->labels['singular_name'] ) ? $object->labels['singular_name'] : $object->name;
    1708 
    1709     if ( !isset( $object->labels['menu_name'] ) && isset( $object->labels['name'] ) )
    1710         $object->labels['menu_name'] = $object->labels['name'];
    1711 
    1712     if ( !isset( $object->labels['all_items'] ) && isset( $object->labels['menu_name'] ) )
    1713         $object->labels['all_items'] = $object->labels['menu_name'];
    1714 
    1715     $defaults = array();
    1716     foreach ( $nohier_vs_hier_defaults as $key => $value ) {
    1717         $defaults[$key] = $object->hierarchical ? $value[1] : $value[0];
    1718     }
    1719     $labels = array_merge( $defaults, $object->labels );
    1720     return (object) $labels;
    1721 }
    1722 
    1723 /**
    1724  * Add submenus for post types.
    1725  *
    1726  * @access private
    1727  * @since 3.1.0
    1728  */
    1729 function _add_post_type_submenus() {
    1730     foreach ( get_post_types( array( 'show_ui' => true ) ) as $ptype ) {
    1731         $ptype_obj = get_post_type_object( $ptype );
    1732         // Sub-menus only.
    1733         if ( ! $ptype_obj->show_in_menu || $ptype_obj->show_in_menu === true )
    1734             continue;
    1735         add_submenu_page( $ptype_obj->show_in_menu, $ptype_obj->labels->name, $ptype_obj->labels->all_items, $ptype_obj->cap->edit_posts, "edit.php?post_type=$ptype" );
    1736     }
    1737 }
    1738 
    1739 /**
    1740  * Register support of certain features for a post type.
    1741  *
    1742  * All core features are directly associated with a functional area of the edit
    1743  * screen, such as the editor or a meta box. Features include: 'title', 'editor',
    1744  * 'comments', 'revisions', 'trackbacks', 'author', 'excerpt', 'page-attributes',
    1745  * 'thumbnail', 'custom-fields', and 'post-formats'.
    1746  *
    1747  * Additionally, the 'revisions' feature dictates whether the post type will
    1748  * store revisions, and the 'comments' feature dictates whether the comments
    1749  * count will show on the edit screen.
    1750  *
    1751  * @since 3.0.0
    1752  *
    1753  * @global array $_wp_post_type_features
    1754  *
    1755  * @param string       $post_type The post type for which to add the feature.
    1756  * @param string|array $feature   The feature being added, accepts an array of
    1757  *                                feature strings or a single string.
    1758  */
    1759 function add_post_type_support( $post_type, $feature ) {
    1760     global $_wp_post_type_features;
    1761 
    1762     $features = (array) $feature;
    1763     foreach ($features as $feature) {
    1764         if ( func_num_args() == 2 )
    1765             $_wp_post_type_features[$post_type][$feature] = true;
    1766         else
    1767             $_wp_post_type_features[$post_type][$feature] = array_slice( func_get_args(), 2 );
    1768     }
    1769 }
    1770 
    1771 /**
    1772  * Remove support for a feature from a post type.
    1773  *
    1774  * @since 3.0.0
    1775  *
    1776  * @global array $_wp_post_type_features
    1777  *
    1778  * @param string $post_type The post type for which to remove the feature.
    1779  * @param string $feature   The feature being removed.
    1780  */
    1781 function remove_post_type_support( $post_type, $feature ) {
    1782     global $_wp_post_type_features;
    1783 
    1784     unset( $_wp_post_type_features[ $post_type ][ $feature ] );
    1785 }
    1786 
    1787 /**
    1788  * Get all the post type features
    1789  *
    1790  * @since 3.4.0
    1791  *
    1792  * @global array $_wp_post_type_features
    1793  *
    1794  * @param string $post_type The post type.
    1795  * @return array Post type supports list.
    1796  */
    1797 function get_all_post_type_supports( $post_type ) {
    1798     global $_wp_post_type_features;
    1799 
    1800     if ( isset( $_wp_post_type_features[$post_type] ) )
    1801         return $_wp_post_type_features[$post_type];
    1802 
    1803     return array();
    1804 }
    1805 
    1806 /**
    1807  * Check a post type's support for a given feature.
    1808  *
    1809  * @since 3.0.0
    1810  *
    1811  * @global array $_wp_post_type_features
    1812  *
    1813  * @param string $post_type The post type being checked.
    1814  * @param string $feature   The feature being checked.
    1815  * @return bool Whether the post type supports the given feature.
    1816  */
    1817 function post_type_supports( $post_type, $feature ) {
    1818     global $_wp_post_type_features;
    1819 
    1820     return ( isset( $_wp_post_type_features[$post_type][$feature] ) );
    1821 }
    1822 
    1823 /**
    1824  * Update the post type for the post ID.
    1825  *
    1826  * The page or post cache will be cleaned for the post ID.
    1827  *
    1828  * @since 2.5.0
    1829  *
    1830  * @global wpdb $wpdb WordPress database abstraction object.
    1831  *
    1832  * @param int    $post_id   Optional. Post ID to change post type. Default 0.
    1833  * @param string $post_type Optional. Post type. Accepts 'post' or 'page' to
    1834  *                          name a few. Default 'post'.
    1835  * @return int|false Amount of rows changed. Should be 1 for success and 0 for failure.
    1836  */
    1837 function set_post_type( $post_id = 0, $post_type = 'post' ) {
    1838     global $wpdb;
    1839 
    1840     $post_type = sanitize_post_field('post_type', $post_type, $post_id, 'db');
    1841     $return = $wpdb->update( $wpdb->posts, array('post_type' => $post_type), array('ID' => $post_id) );
    1842 
    1843     clean_post_cache( $post_id );
    1844 
    1845     return $return;
    1846 }
    1847 
    1848 /**
    1849  * Determines whether a post type is considered "viewable".
    1850  *
    1851  * For built-in post types such as posts and pages, the 'public' value will be evaluated.
    1852  * For all others, the 'publicly_queryable' value will be used.
    1853  *
    1854  * @since 4.4.0
    1855  *
    1856  * @param object $post_type_object Post type object.
    1857  * @return bool Whether the post type should be considered viewable.
    1858  */
    1859 function is_post_type_viewable( $post_type_object ) {
    1860     return $post_type_object->publicly_queryable || ( $post_type_object->_builtin && $post_type_object->public );
    1861 }
    1862 
    1863 /**
    1864  * Retrieve list of latest posts or posts matching criteria.
    1865  *
    1866  * The defaults are as follows:
    1867  *
    1868  * @since 1.2.0
    1869  *
    1870  * @see WP_Query::parse_query()
    1871  *
    1872  * @param array $args {
    1873  *     Optional. Arguments to retrieve posts. {@see WP_Query::parse_query()} for more
    1874  *     available arguments.
    1875  *
    1876  *     @type int        $numberposts      Total number of posts to retrieve. Is an alias of $posts_per_page
    1877  *                                        in WP_Query. Accepts 1+ and -1 for all. Default 5.
    1878  *     @type int        $offset           The number of posts to offset before retrieval. Default 0.
    1879  *     @type int|string $category         Category ID or comma-separated list of IDs (this or any children).
    1880  *                                        Is an alias of $cat in WP_Query. Default 0.
    1881  *     @type string     $orderby          Which field to order posts by. Accepts post fields. Default 'date'.
    1882  *     @type array      $include          An array of post IDs to retrieve, sticky posts will be included.
    1883  *                                        Is an alias of $post__in in WP_Query. Default empty array.
    1884  *     @type array      $exclude          An array of post IDs not to retrieve. Default empty array.
    1885  *     @type string     $meta_key         Custom field key. Default empty.
    1886  *     @type mixed      $meta_value       Custom field value. Default empty string.
    1887  *     @type string     $post_type        Post type. Default 'post'.
    1888  *     @type bool       $suppress_filters Whether to suppress filters. Default true.
    1889  * }
    1890  * @return array List of posts.
    1891  */
    1892 function get_posts( $args = null ) {
    1893     $defaults = array(
    1894         'numberposts' => 5, 'offset' => 0,
    1895         'category' => 0, 'orderby' => 'date',
    1896         'order' => 'DESC', 'include' => array(),
    1897         'exclude' => array(), 'meta_key' => '',
    1898         'meta_value' =>'', 'post_type' => 'post',
    1899         'suppress_filters' => true
    1900     );
    1901 
    1902     $r = wp_parse_args( $args, $defaults );
    1903     if ( empty( $r['post_status'] ) )
    1904         $r['post_status'] = ( 'attachment' == $r['post_type'] ) ? 'inherit' : 'publish';
    1905     if ( ! empty($r['numberposts']) && empty($r['posts_per_page']) )
    1906         $r['posts_per_page'] = $r['numberposts'];
    1907     if ( ! empty($r['category']) )
    1908         $r['cat'] = $r['category'];
    1909     if ( ! empty($r['include']) ) {
    1910         $incposts = wp_parse_id_list( $r['include'] );
    1911         $r['posts_per_page'] = count($incposts);  // only the number of posts included
    1912         $r['post__in'] = $incposts;
    1913     } elseif ( ! empty($r['exclude']) )
    1914         $r['post__not_in'] = wp_parse_id_list( $r['exclude'] );
    1915 
    1916     $r['ignore_sticky_posts'] = true;
    1917     $r['no_found_rows'] = true;
    1918 
    1919     $get_posts = new WP_Query;
    1920     return $get_posts->query($r);
    1921 
    1922 }
    1923 
    1924 //
    1925 // Post meta functions
    1926 //
    1927 
    1928 /**
    1929  * Add meta data field to a post.
    1930  *
    1931  * Post meta data is called "Custom Fields" on the Administration Screen.
    1932  *
    1933  * @since 1.5.0
    1934  *
    1935  * @param int    $post_id    Post ID.
    1936  * @param string $meta_key   Metadata name.
    1937  * @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
    1938  * @param bool   $unique     Optional. Whether the same key should not be added.
    1939  *                           Default false.
    1940  * @return int|false Meta ID on success, false on failure.
    1941  */
    1942 function add_post_meta( $post_id, $meta_key, $meta_value, $unique = false ) {
    1943     // Make sure meta is added to the post, not a revision.
    1944     if ( $the_post = wp_is_post_revision($post_id) )
    1945         $post_id = $the_post;
    1946 
    1947     return add_metadata('post', $post_id, $meta_key, $meta_value, $unique);
    1948 }
    1949 
    1950 /**
    1951  * Remove metadata matching criteria from a post.
    1952  *
    1953  * You can match based on the key, or key and value. Removing based on key and
    1954  * value, will keep from removing duplicate metadata with the same key. It also
    1955  * allows removing all metadata matching key, if needed.
    1956  *
    1957  * @since 1.5.0
    1958  *
    1959  * @param int    $post_id    Post ID.
    1960  * @param string $meta_key   Metadata name.
    1961  * @param mixed  $meta_value Optional. Metadata value. Must be serializable if
    1962  *                           non-scalar. Default empty.
    1963  * @return bool True on success, false on failure.
    1964  */
    1965 function delete_post_meta( $post_id, $meta_key, $meta_value = '' ) {
    1966     // Make sure meta is added to the post, not a revision.
    1967     if ( $the_post = wp_is_post_revision($post_id) )
    1968         $post_id = $the_post;
    1969 
    1970     return delete_metadata('post', $post_id, $meta_key, $meta_value);
    1971 }
    1972 
    1973 /**
    1974  * Retrieve post meta field for a post.
    1975  *
    1976  * @since 1.5.0
    1977  *
    1978  * @param int    $post_id Post ID.
    1979  * @param string $key     Optional. The meta key to retrieve. By default, returns
    1980  *                        data for all keys. Default empty.
    1981  * @param bool   $single  Optional. Whether to return a single value. Default false.
    1982  * @return mixed Will be an array if $single is false. Will be value of meta data
    1983  *               field if $single is true.
    1984  */
    1985 function get_post_meta( $post_id, $key = '', $single = false ) {
    1986     return get_metadata('post', $post_id, $key, $single);
    1987 }
    1988 
    1989 /**
    1990  * Update post meta field based on post ID.
    1991  *
    1992  * Use the $prev_value parameter to differentiate between meta fields with the
    1993  * same key and post ID.
    1994  *
    1995  * If the meta field for the post does not exist, it will be added.
    1996  *
    1997  * @since 1.5.0
    1998  *
    1999  * @param int    $post_id    Post ID.
    2000  * @param string $meta_key   Metadata key.
    2001  * @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
    2002  * @param mixed  $prev_value Optional. Previous value to check before removing.
    2003  *                           Default empty.
    2004  * @return int|bool Meta ID if the key didn't exist, true on successful update,
    2005  *                  false on failure.
    2006  */
    2007 function update_post_meta( $post_id, $meta_key, $meta_value, $prev_value = '' ) {
    2008     // Make sure meta is added to the post, not a revision.
    2009     if ( $the_post = wp_is_post_revision($post_id) )
    2010         $post_id = $the_post;
    2011 
    2012     return update_metadata('post', $post_id, $meta_key, $meta_value, $prev_value);
    2013 }
    2014 
    2015 /**
    2016  * Delete everything from post meta matching meta key.
    2017  *
    2018  * @since 2.3.0
    2019  *
    2020  * @param string $post_meta_key Key to search for when deleting.
    2021  * @return bool Whether the post meta key was deleted from the database.
    2022  */
    2023 function delete_post_meta_by_key( $post_meta_key ) {
    2024     return delete_metadata( 'post', null, $post_meta_key, '', true );
    2025 }
    2026 
    2027 /**
    2028  * Retrieve post meta fields, based on post ID.
    2029  *
    2030  * The post meta fields are retrieved from the cache where possible,
    2031  * so the function is optimized to be called more than once.
    2032  *
    2033  * @since 1.2.0
    2034  *
    2035  * @param int $post_id Optional. Post ID. Default is ID of the global $post.
    2036  * @return array Post meta for the given post.
    2037  */
    2038 function get_post_custom( $post_id = 0 ) {
    2039     $post_id = absint( $post_id );
    2040     if ( ! $post_id )
    2041         $post_id = get_the_ID();
    2042 
    2043     return get_post_meta( $post_id );
    2044 }
    2045 
    2046 /**
    2047  * Retrieve meta field names for a post.
    2048  *
    2049  * If there are no meta fields, then nothing (null) will be returned.
    2050  *
    2051  * @since 1.2.0
    2052  *
    2053  * @param int $post_id Optional. Post ID. Default is ID of the global $post.
    2054  * @return array|void Array of the keys, if retrieved.
    2055  */
    2056 function get_post_custom_keys( $post_id = 0 ) {
    2057     $custom = get_post_custom( $post_id );
    2058 
    2059     if ( !is_array($custom) )
    2060         return;
    2061 
    2062     if ( $keys = array_keys($custom) )
    2063         return $keys;
    2064 }
    2065 
    2066 /**
    2067  * Retrieve values for a custom post field.
    2068  *
    2069  * The parameters must not be considered optional. All of the post meta fields
    2070  * will be retrieved and only the meta field key values returned.
    2071  *
    2072  * @since 1.2.0
    2073  *
    2074  * @param string $key     Optional. Meta field key. Default empty.
    2075  * @param int    $post_id Optional. Post ID. Default is ID of the global $post.
    2076  * @return array|null Meta field values.
    2077  */
    2078 function get_post_custom_values( $key = '', $post_id = 0 ) {
    2079     if ( !$key )
    2080         return null;
    2081 
    2082     $custom = get_post_custom($post_id);
    2083 
    2084     return isset($custom[$key]) ? $custom[$key] : null;
    2085 }
    2086 
    2087 /**
    2088  * Check if post is sticky.
    2089  *
    2090  * Sticky posts should remain at the top of The Loop. If the post ID is not
    2091  * given, then The Loop ID for the current post will be used.
    2092  *
    2093  * @since 2.7.0
    2094  *
    2095  * @param int $post_id Optional. Post ID. Default is ID of the global $post.
    2096  * @return bool Whether post is sticky.
    2097  */
    2098 function is_sticky( $post_id = 0 ) {
    2099     $post_id = absint( $post_id );
    2100 
    2101     if ( ! $post_id )
    2102         $post_id = get_the_ID();
    2103 
    2104     $stickies = get_option( 'sticky_posts' );
    2105 
    2106     if ( ! is_array( $stickies ) )
    2107         return false;
    2108 
    2109     if ( in_array( $post_id, $stickies ) )
    2110         return true;
    2111 
    2112     return false;
    2113 }
    2114 
    2115 /**
    2116  * Sanitize every post field.
    2117  *
    2118  * If the context is 'raw', then the post object or array will get minimal
    2119  * sanitization of the integer fields.
    2120  *
    2121  * @since 2.3.0
    2122  *
    2123  * @see sanitize_post_field()
    2124  *
    2125  * @param object|WP_Post|array $post    The Post Object or Array
    2126  * @param string               $context Optional. How to sanitize post fields.
    2127  *                                      Accepts 'raw', 'edit', 'db', or 'display'.
    2128  *                                      Default 'display'.
    2129  * @return object|WP_Post|array The now sanitized Post Object or Array (will be the
    2130  *                              same type as $post).
    2131  */
    2132 function sanitize_post( $post, $context = 'display' ) {
    2133     if ( is_object($post) ) {
    2134         // Check if post already filtered for this context.
    2135         if ( isset($post->filter) && $context == $post->filter )
    2136             return $post;
    2137         if ( !isset($post->ID) )
    2138             $post->ID = 0;
    2139         foreach ( array_keys(get_object_vars($post)) as $field )
    2140             $post->$field = sanitize_post_field($field, $post->$field, $post->ID, $context);
    2141         $post->filter = $context;
    2142     } else {
    2143         // Check if post already filtered for this context.
    2144         if ( isset($post['filter']) && $context == $post['filter'] )
    2145             return $post;
    2146         if ( !isset($post['ID']) )
    2147             $post['ID'] = 0;
    2148         foreach ( array_keys($post) as $field )
    2149             $post[$field] = sanitize_post_field($field, $post[$field], $post['ID'], $context);
    2150         $post['filter'] = $context;
    2151     }
    2152     return $post;
    2153 }
    2154 
    2155 /**
    2156  * Sanitize post field based on context.
    2157  *
    2158  * Possible context values are:  'raw', 'edit', 'db', 'display', 'attribute' and
    2159  * 'js'. The 'display' context is used by default. 'attribute' and 'js' contexts
    2160  * are treated like 'display' when calling filters.
    2161  *
    2162  * @since 2.3.0
    2163  *
    2164  * @param string $field   The Post Object field name.
    2165  * @param mixed  $value   The Post Object value.
    2166  * @param int    $post_id Post ID.
    2167  * @param string $context How to sanitize post fields. Looks for 'raw', 'edit',
    2168  *                        'db', 'display', 'attribute' and 'js'.
    2169  * @return mixed Sanitized value.
    2170  */
    2171 function sanitize_post_field($field, $value, $post_id, $context) {
    2172     $int_fields = array('ID', 'post_parent', 'menu_order');
    2173     if ( in_array($field, $int_fields) )
    2174         $value = (int) $value;
    2175 
    2176     // Fields which contain arrays of integers.
    2177     $array_int_fields = array( 'ancestors' );
    2178     if ( in_array($field, $array_int_fields) ) {
    2179         $value = array_map( 'absint', $value);
    2180         return $value;
    2181     }
    2182 
    2183     if ( 'raw' == $context )
    2184         return $value;
    2185 
    2186     $prefixed = false;
    2187     if ( false !== strpos($field, 'post_') ) {
    2188         $prefixed = true;
    2189         $field_no_prefix = str_replace('post_', '', $field);
    2190     }
    2191 
    2192     if ( 'edit' == $context ) {
    2193         $format_to_edit = array('post_content', 'post_excerpt', 'post_title', 'post_password');
    2194 
    2195         if ( $prefixed ) {
    2196 
    2197             /**
    2198              * Filter the value of a specific post field to edit.
    2199              *
    2200              * The dynamic portion of the hook name, `$field`, refers to the post
    2201              * field name.
    2202              *
    2203              * @since 2.3.0
    2204              *
    2205              * @param mixed $value   Value of the post field.
    2206              * @param int   $post_id Post ID.
    2207              */
    2208             $value = apply_filters( "edit_{$field}", $value, $post_id );
    2209 
    2210             /**
    2211              * Filter the value of a specific post field to edit.
    2212              *
    2213              * The dynamic portion of the hook name, `$field_no_prefix`, refers to
    2214              * the post field name.
    2215              *
    2216              * @since 2.3.0
    2217              *
    2218              * @param mixed $value   Value of the post field.
    2219              * @param int   $post_id Post ID.
    2220              */
    2221             $value = apply_filters( "{$field_no_prefix}_edit_pre", $value, $post_id );
    2222         } else {
    2223             $value = apply_filters( "edit_post_{$field}", $value, $post_id );
    2224         }
    2225 
    2226         if ( in_array($field, $format_to_edit) ) {
    2227             if ( 'post_content' == $field )
    2228                 $value = format_to_edit($value, user_can_richedit());
    2229             else
    2230                 $value = format_to_edit($value);
    2231         } else {
    2232             $value = esc_attr($value);
    2233         }
    2234     } elseif ( 'db' == $context ) {
    2235         if ( $prefixed ) {
    2236 
    2237             /**
    2238              * Filter the value of a specific post field before saving.
    2239              *
    2240              * The dynamic portion of the hook name, `$field`, refers to the post
    2241              * field name.
    2242              *
    2243              * @since 2.3.0
    2244              *
    2245              * @param mixed $value Value of the post field.
    2246              */
    2247             $value = apply_filters( "pre_{$field}", $value );
    2248 
    2249             /**
    2250              * Filter the value of a specific field before saving.
    2251              *
    2252              * The dynamic portion of the hook name, `$field_no_prefix`, refers
    2253              * to the post field name.
    2254              *
    2255              * @since 2.3.0
    2256              *
    2257              * @param mixed $value Value of the post field.
    2258              */
    2259             $value = apply_filters( "{$field_no_prefix}_save_pre", $value );
    2260         } else {
    2261             $value = apply_filters( "pre_post_{$field}", $value );
    2262 
    2263             /**
    2264              * Filter the value of a specific post field before saving.
    2265              *
    2266              * The dynamic portion of the hook name, `$field`, refers to the post
    2267              * field name.
    2268              *
    2269              * @since 2.3.0
    2270              *
    2271              * @param mixed $value Value of the post field.
    2272              */
    2273             $value = apply_filters( "{$field}_pre", $value );
    2274         }
    2275     } else {
    2276 
    2277         // Use display filters by default.
    2278         if ( $prefixed ) {
    2279 
    2280             /**
    2281              * Filter the value of a specific post field for display.
    2282              *
    2283              * The dynamic portion of the hook name, `$field`, refers to the post
    2284              * field name.
    2285              *
    2286              * @since 2.3.0
    2287              *
    2288              * @param mixed  $value   Value of the prefixed post field.
    2289              * @param int    $post_id Post ID.
    2290              * @param string $context Context for how to sanitize the field. Possible
    2291              *                        values include 'raw', 'edit', 'db', 'display',
    2292              *                        'attribute' and 'js'.
    2293              */
    2294             $value = apply_filters( $field, $value, $post_id, $context );
    2295         } else {
    2296             $value = apply_filters( "post_{$field}", $value, $post_id, $context );
    2297         }
    2298     }
    2299 
    2300     if ( 'attribute' == $context )
    2301         $value = esc_attr($value);
    2302     elseif ( 'js' == $context )
    2303         $value = esc_js($value);
    2304 
    2305     return $value;
    2306 }
    2307 
    2308 /**
    2309  * Make a post sticky.
    2310  *
    2311  * Sticky posts should be displayed at the top of the front page.
    2312  *
    2313  * @since 2.7.0
    2314  *
    2315  * @param int $post_id Post ID.
    2316  */
    2317 function stick_post( $post_id ) {
    2318     $stickies = get_option('sticky_posts');
    2319 
    2320     if ( !is_array($stickies) )
    2321         $stickies = array($post_id);
    2322 
    2323     if ( ! in_array($post_id, $stickies) )
    2324         $stickies[] = $post_id;
    2325 
    2326     update_option('sticky_posts', $stickies);
    2327 }
    2328 
    2329 /**
    2330  * Un-stick a post.
    2331  *
    2332  * Sticky posts should be displayed at the top of the front page.
    2333  *
    2334  * @since 2.7.0
    2335  *
    2336  * @param int $post_id Post ID.
    2337  */
    2338 function unstick_post( $post_id ) {
    2339     $stickies = get_option('sticky_posts');
    2340 
    2341     if ( !is_array($stickies) )
    2342         return;
    2343 
    2344     if ( ! in_array($post_id, $stickies) )
    2345         return;
    2346 
    2347     $offset = array_search($post_id, $stickies);
    2348     if ( false === $offset )
    2349         return;
    2350 
    2351     array_splice($stickies, $offset, 1);
    2352 
    2353     update_option('sticky_posts', $stickies);
    2354 }
    2355 
    2356 /**
    2357  * Return the cache key for wp_count_posts() based on the passed arguments.
    2358  *
    2359  * @since 3.9.0
    2360  *
    2361  * @param string $type Optional. Post type to retrieve count Default 'post'.
    2362  * @param string $perm Optional. 'readable' or empty. Default empty.
    2363  * @return string The cache key.
    2364  */
    2365 function _count_posts_cache_key( $type = 'post', $perm = '' ) {
    2366     $cache_key = 'posts-' . $type;
    2367     if ( 'readable' == $perm && is_user_logged_in() ) {
    2368         $post_type_object = get_post_type_object( $type );
    2369         if ( $post_type_object && ! current_user_can( $post_type_object->cap->read_private_posts ) ) {
    2370             $cache_key .= '_' . $perm . '_' . get_current_user_id();
    2371         }
    2372     }
    2373     return $cache_key;
    2374 }
    2375 
    2376 /**
    2377  * Count number of posts of a post type and if user has permissions to view.
    2378  *
    2379  * This function provides an efficient method of finding the amount of post's
    2380  * type a blog has. Another method is to count the amount of items in
    2381  * get_posts(), but that method has a lot of overhead with doing so. Therefore,
    2382  * when developing for 2.5+, use this function instead.
    2383  *
    2384  * The $perm parameter checks for 'readable' value and if the user can read
    2385  * private posts, it will display that for the user that is signed in.
    2386  *
    2387  * @since 2.5.0
    2388  *
    2389  * @global wpdb $wpdb
    2390  *
    2391  * @param string $type Optional. Post type to retrieve count. Default 'post'.
    2392  * @param string $perm Optional. 'readable' or empty. Default empty.
    2393  * @return object Number of posts for each status.
    2394  */
    2395 function wp_count_posts( $type = 'post', $perm = '' ) {
    2396     global $wpdb;
    2397 
    2398     if ( ! post_type_exists( $type ) )
    2399         return new stdClass;
    2400 
    2401     $cache_key = _count_posts_cache_key( $type, $perm );
    2402 
    2403     $counts = wp_cache_get( $cache_key, 'counts' );
    2404     if ( false !== $counts ) {
    2405         /** This filter is documented in wp-includes/post.php */
    2406         return apply_filters( 'wp_count_posts', $counts, $type, $perm );
    2407     }
    2408 
    2409     $query = "SELECT post_status, COUNT( * ) AS num_posts FROM {$wpdb->posts} WHERE post_type = %s";
    2410     if ( 'readable' == $perm && is_user_logged_in() ) {
    2411         $post_type_object = get_post_type_object($type);
    2412         if ( ! current_user_can( $post_type_object->cap->read_private_posts ) ) {
    2413             $query .= $wpdb->prepare( " AND (post_status != 'private' OR ( post_author = %d AND post_status = 'private' ))",
    2414                 get_current_user_id()
    2415             );
    2416         }
    2417     }
    2418     $query .= ' GROUP BY post_status';
    2419 
    2420     $results = (array) $wpdb->get_results( $wpdb->prepare( $query, $type ), ARRAY_A );
    2421     $counts = array_fill_keys( get_post_stati(), 0 );
    2422 
    2423     foreach ( $results as $row ) {
    2424         $counts[ $row['post_status'] ] = $row['num_posts'];
    2425     }
    2426 
    2427     $counts = (object) $counts;
    2428     wp_cache_set( $cache_key, $counts, 'counts' );
    2429 
    2430     /**
    2431      * Modify returned post counts by status for the current post type.
    2432      *
    2433      * @since 3.7.0
    2434      *
    2435      * @param object $counts An object containing the current post_type's post
    2436      *                       counts by status.
    2437      * @param string $type   Post type.
    2438      * @param string $perm   The permission to determine if the posts are 'readable'
    2439      *                       by the current user.
    2440      */
    2441     return apply_filters( 'wp_count_posts', $counts, $type, $perm );
    2442 }
    2443 
    2444 /**
    2445  * Count number of attachments for the mime type(s).
    2446  *
    2447  * If you set the optional mime_type parameter, then an array will still be
    2448  * returned, but will only have the item you are looking for. It does not give
    2449  * you the number of attachments that are children of a post. You can get that
    2450  * by counting the number of children that post has.
    2451  *
    2452  * @since 2.5.0
    2453  *
    2454  * @global wpdb $wpdb
    2455  *
    2456  * @param string|array $mime_type Optional. Array or comma-separated list of
    2457  *                                MIME patterns. Default empty.
    2458  * @return object An object containing the attachment counts by mime type.
    2459  */
    2460 function wp_count_attachments( $mime_type = '' ) {
    2461     global $wpdb;
    2462 
    2463     $and = wp_post_mime_type_where( $mime_type );
    2464     $count = $wpdb->get_results( "SELECT post_mime_type, COUNT( * ) AS num_posts FROM $wpdb->posts WHERE post_type = 'attachment' AND post_status != 'trash' $and GROUP BY post_mime_type", ARRAY_A );
    2465 
    2466     $counts = array();
    2467     foreach ( (array) $count as $row ) {
    2468         $counts[ $row['post_mime_type'] ] = $row['num_posts'];
    2469     }
    2470     $counts['trash'] = $wpdb->get_var( "SELECT COUNT( * ) FROM $wpdb->posts WHERE post_type = 'attachment' AND post_status = 'trash' $and");
    2471 
    2472     /**
    2473      * Modify returned attachment counts by mime type.
    2474      *
    2475      * @since 3.7.0
    2476      *
    2477      * @param object $counts    An object containing the attachment counts by
    2478      *                          mime type.
    2479      * @param string $mime_type The mime type pattern used to filter the attachments
    2480      *                          counted.
    2481      */
    2482     return apply_filters( 'wp_count_attachments', (object) $counts, $mime_type );
    2483 }
    2484 
    2485 /**
    2486  * Get default post mime types.
    2487  *
    2488  * @since 2.9.0
    2489  *
    2490  * @return array List of post mime types.
    2491  */
    2492 function get_post_mime_types() {
    2493     $post_mime_types = array(   //  array( adj, noun )
    2494         'image' => array(__('Images'), __('Manage Images'), _n_noop('Image <span class="count">(%s)</span>', 'Images <span class="count">(%s)</span>')),
    2495         'audio' => array(__('Audio'), __('Manage Audio'), _n_noop('Audio <span class="count">(%s)</span>', 'Audio <span class="count">(%s)</span>')),
    2496         'video' => array(__('Video'), __('Manage Video'), _n_noop('Video <span class="count">(%s)</span>', 'Video <span class="count">(%s)</span>')),
    2497     );
    2498 
    2499     /**
    2500      * Filter the default list of post mime types.
    2501      *
    2502      * @since 2.5.0
    2503      *
    2504      * @param array $post_mime_types Default list of post mime types.
    2505      */
    2506     return apply_filters( 'post_mime_types', $post_mime_types );
    2507 }
    2508 
    2509 /**
    2510  * Check a MIME-Type against a list.
    2511  *
    2512  * If the wildcard_mime_types parameter is a string, it must be comma separated
    2513  * list. If the real_mime_types is a string, it is also comma separated to
    2514  * create the list.
    2515  *
    2516  * @since 2.5.0
    2517  *
    2518  * @param string|array $wildcard_mime_types Mime types, e.g. audio/mpeg or image (same as image/*)
    2519  *                                          or flash (same as *flash*).
    2520  * @param string|array $real_mime_types     Real post mime type values.
    2521  * @return array array(wildcard=>array(real types)).
    2522  */
    2523 function wp_match_mime_types( $wildcard_mime_types, $real_mime_types ) {
    2524     $matches = array();
    2525     if ( is_string( $wildcard_mime_types ) ) {
    2526         $wildcard_mime_types = array_map( 'trim', explode( ',', $wildcard_mime_types ) );
    2527     }
    2528     if ( is_string( $real_mime_types ) ) {
    2529         $real_mime_types = array_map( 'trim', explode( ',', $real_mime_types ) );
    2530     }
    2531 
    2532     $patternses = array();
    2533     $wild = '[-._a-z0-9]*';
    2534 
    2535     foreach ( (array) $wildcard_mime_types as $type ) {
    2536         $mimes = array_map( 'trim', explode( ',', $type ) );
    2537         foreach ( $mimes as $mime ) {
    2538             $regex = str_replace( '__wildcard__', $wild, preg_quote( str_replace( '*', '__wildcard__', $mime ) ) );
    2539             $patternses[][$type] = "^$regex$";
    2540             if ( false === strpos( $mime, '/' ) ) {
    2541                 $patternses[][$type] = "^$regex/";
    2542                 $patternses[][$type] = $regex;
    2543             }
    2544         }
    2545     }
    2546     asort( $patternses );
    2547 
    2548     foreach ( $patternses as $patterns ) {
    2549         foreach ( $patterns as $type => $pattern ) {
    2550             foreach ( (array) $real_mime_types as $real ) {
    2551                 if ( preg_match( "#$pattern#", $real ) && ( empty( $matches[$type] ) || false === array_search( $real, $matches[$type] ) ) ) {
    2552                     $matches[$type][] = $real;
    2553                 }
    2554             }
    2555         }
    2556     }
    2557     return $matches;
    2558 }
    2559 
    2560 /**
    2561  * Convert MIME types into SQL.
    2562  *
    2563  * @since 2.5.0
    2564  *
    2565  * @param string|array $post_mime_types List of mime types or comma separated string
    2566  *                                      of mime types.
    2567  * @param string       $table_alias     Optional. Specify a table alias, if needed.
    2568  *                                      Default empty.
    2569  * @return string The SQL AND clause for mime searching.
    2570  */
    2571 function wp_post_mime_type_where( $post_mime_types, $table_alias = '' ) {
    2572     $where = '';
    2573     $wildcards = array('', '%', '%/%');
    2574     if ( is_string($post_mime_types) )
    2575         $post_mime_types = array_map('trim', explode(',', $post_mime_types));
    2576 
    2577     $wheres = array();
    2578 
    2579     foreach ( (array) $post_mime_types as $mime_type ) {
    2580         $mime_type = preg_replace('/\s/', '', $mime_type);
    2581         $slashpos = strpos($mime_type, '/');
    2582         if ( false !== $slashpos ) {
    2583             $mime_group = preg_replace('/[^-*.a-zA-Z0-9]/', '', substr($mime_type, 0, $slashpos));
    2584             $mime_subgroup = preg_replace('/[^-*.+a-zA-Z0-9]/', '', substr($mime_type, $slashpos + 1));
    2585             if ( empty($mime_subgroup) )
    2586                 $mime_subgroup = '*';
    2587             else
    2588                 $mime_subgroup = str_replace('/', '', $mime_subgroup);
    2589             $mime_pattern = "$mime_group/$mime_subgroup";
    2590         } else {
    2591             $mime_pattern = preg_replace('/[^-*.a-zA-Z0-9]/', '', $mime_type);
    2592             if ( false === strpos($mime_pattern, '*') )
    2593                 $mime_pattern .= '/*';
    2594         }
    2595 
    2596         $mime_pattern = preg_replace('/\*+/', '%', $mime_pattern);
    2597 
    2598         if ( in_array( $mime_type, $wildcards ) )
    2599             return '';
    2600 
    2601         if ( false !== strpos($mime_pattern, '%') )
    2602             $wheres[] = empty($table_alias) ? "post_mime_type LIKE '$mime_pattern'" : "$table_alias.post_mime_type LIKE '$mime_pattern'";
    2603         else
    2604             $wheres[] = empty($table_alias) ? "post_mime_type = '$mime_pattern'" : "$table_alias.post_mime_type = '$mime_pattern'";
    2605     }
    2606     if ( !empty($wheres) )
    2607         $where = ' AND (' . join(' OR ', $wheres) . ') ';
    2608     return $where;
    2609 }
    2610 
    2611 /**
    2612  * Trash or delete a post or page.
    2613  *
    2614  * When the post and page is permanently deleted, everything that is tied to
    2615  * it is deleted also. This includes comments, post meta fields, and terms
    2616  * associated with the post.
    2617  *
    2618  * The post or page is moved to trash instead of permanently deleted unless
    2619  * trash is disabled, item is already in the trash, or $force_delete is true.
    2620  *
    2621  * @since 1.0.0
    2622  *
    2623  * @global wpdb $wpdb WordPress database abstraction object.
    2624  * @see wp_delete_attachment()
    2625  * @see wp_trash_post()
    2626  *
    2627  * @param int  $postid       Optional. Post ID. Default 0.
    2628  * @param bool $force_delete Optional. Whether to bypass trash and force deletion.
    2629  *                           Default false.
    2630  * @return array|false|WP_Post False on failure.
    2631  */
    2632 function wp_delete_post( $postid = 0, $force_delete = false ) {
    2633     global $wpdb;
    2634 
    2635     if ( !$post = $wpdb->get_row($wpdb->prepare("SELECT * FROM $wpdb->posts WHERE ID = %d", $postid)) )
    2636         return $post;
    2637 
    2638     if ( !$force_delete && ( $post->post_type == 'post' || $post->post_type == 'page') && get_post_status( $postid ) != 'trash' && EMPTY_TRASH_DAYS )
    2639         return wp_trash_post( $postid );
    2640 
    2641     if ( $post->post_type == 'attachment' )
    2642         return wp_delete_attachment( $postid, $force_delete );
    2643 
    2644     /**
    2645      * Fires before a post is deleted, at the start of wp_delete_post().
    2646      *
    2647      * @since 3.2.0
    2648      *
    2649      * @see wp_delete_post()
    2650      *
    2651      * @param int $postid Post ID.
    2652      */
    2653     do_action( 'before_delete_post', $postid );
    2654 
    2655     delete_post_meta($postid,'_wp_trash_meta_status');
    2656     delete_post_meta($postid,'_wp_trash_meta_time');
    2657 
    2658     wp_delete_object_term_relationships($postid, get_object_taxonomies($post->post_type));
    2659 
    2660     $parent_data = array( 'post_parent' => $post->post_parent );
    2661     $parent_where = array( 'post_parent' => $postid );
    2662 
    2663     if ( is_post_type_hierarchical( $post->post_type ) ) {
    2664         // Point children of this page to its parent, also clean the cache of affected children.
    2665         $children_query = $wpdb->prepare( "SELECT * FROM $wpdb->posts WHERE post_parent = %d AND post_type = %s", $postid, $post->post_type );
    2666         $children = $wpdb->get_results( $children_query );
    2667 
    2668         $wpdb->update( $wpdb->posts, $parent_data, $parent_where + array( 'post_type' => $post->post_type ) );
    2669     }
    2670 
    2671     // Do raw query. wp_get_post_revisions() is filtered.
    2672     $revision_ids = $wpdb->get_col( $wpdb->prepare( "SELECT ID FROM $wpdb->posts WHERE post_parent = %d AND post_type = 'revision'", $postid ) );
    2673     // Use wp_delete_post (via wp_delete_post_revision) again. Ensures any meta/misplaced data gets cleaned up.
    2674     foreach ( $revision_ids as $revision_id )
    2675         wp_delete_post_revision( $revision_id );
    2676 
    2677     // Point all attachments to this post up one level.
    2678     $wpdb->update( $wpdb->posts, $parent_data, $parent_where + array( 'post_type' => 'attachment' ) );
    2679 
    2680     $comment_ids = $wpdb->get_col( $wpdb->prepare( "SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d", $postid ));
    2681     foreach ( $comment_ids as $comment_id )
    2682         wp_delete_comment( $comment_id, true );
    2683 
    2684     $post_meta_ids = $wpdb->get_col( $wpdb->prepare( "SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d ", $postid ));
    2685     foreach ( $post_meta_ids as $mid )
    2686         delete_metadata_by_mid( 'post', $mid );
    2687 
    2688     /**
    2689      * Fires immediately before a post is deleted from the database.
    2690      *
    2691      * @since 1.2.0
    2692      *
    2693      * @param int $postid Post ID.
    2694      */
    2695     do_action( 'delete_post', $postid );
    2696     $result = $wpdb->delete( $wpdb->posts, array( 'ID' => $postid ) );
    2697     if ( ! $result ) {
    2698         return false;
    2699     }
    2700 
    2701     /**
    2702      * Fires immediately after a post is deleted from the database.
    2703      *
    2704      * @since 2.2.0
    2705      *
    2706      * @param int $postid Post ID.
    2707      */
    2708     do_action( 'deleted_post', $postid );
    2709 
    2710     clean_post_cache( $post );
    2711 
    2712     if ( is_post_type_hierarchical( $post->post_type ) && $children ) {
    2713         foreach ( $children as $child )
    2714             clean_post_cache( $child );
    2715     }
    2716 
    2717     wp_clear_scheduled_hook('publish_future_post', array( $postid ) );
    2718 
    2719     /**
    2720      * Fires after a post is deleted, at the conclusion of wp_delete_post().
    2721      *
    2722      * @since 3.2.0
    2723      *
    2724      * @see wp_delete_post()
    2725      *
    2726      * @param int $postid Post ID.
    2727      */
    2728     do_action( 'after_delete_post', $postid );
    2729 
    2730     return $post;
    2731 }
    2732 
    2733 /**
    2734  * Reset the page_on_front, show_on_front, and page_for_post settings when
    2735  * a linked page is deleted or trashed.
    2736  *
    2737  * Also ensures the post is no longer sticky.
    2738  *
    2739  * @since 3.7.0
    2740  * @access private
    2741  *
    2742  * @param int $post_id Post ID.
    2743  */
    2744 function _reset_front_page_settings_for_post( $post_id ) {
    2745     $post = get_post( $post_id );
    2746     if ( 'page' == $post->post_type ) {
    2747         /*
    2748          * If the page is defined in option page_on_front or post_for_posts,
    2749          * adjust the corresponding options.
    2750          */
    2751         if ( get_option( 'page_on_front' ) == $post->ID ) {
    2752             update_option( 'show_on_front', 'posts' );
    2753             update_option( 'page_on_front', 0 );
    2754         }
    2755         if ( get_option( 'page_for_posts' ) == $post->ID ) {
    2756             delete_option( 'page_for_posts', 0 );
    2757         }
    2758     }
    2759     unstick_post( $post->ID );
    2760 }
    2761 
    2762 /**
    2763  * Move a post or page to the Trash
    2764  *
    2765  * If trash is disabled, the post or page is permanently deleted.
    2766  *
    2767  * @since 2.9.0
    2768  *
    2769  * @see wp_delete_post()
    2770  *
    2771  * @param int $post_id Optional. Post ID. Default is ID of the global $post
    2772  *                     if EMPTY_TRASH_DAYS equals true.
    2773  * @return false|array|WP_Post|null Post data array, otherwise false.
    2774  */
    2775 function wp_trash_post( $post_id = 0 ) {
    2776     if ( !EMPTY_TRASH_DAYS )
    2777         return wp_delete_post($post_id, true);
    2778 
    2779     if ( !$post = get_post($post_id, ARRAY_A) )
    2780         return $post;
    2781 
    2782     if ( $post['post_status'] == 'trash' )
    2783         return false;
    2784 
    2785     /**
    2786      * Fires before a post is sent to the trash.
    2787      *
    2788      * @since 3.3.0
    2789      *
    2790      * @param int $post_id Post ID.
    2791      */
    2792     do_action( 'wp_trash_post', $post_id );
    2793 
    2794     add_post_meta($post_id,'_wp_trash_meta_status', $post['post_status']);
    2795     add_post_meta($post_id,'_wp_trash_meta_time', time());
    2796 
    2797     $post['post_status'] = 'trash';
    2798     wp_insert_post($post);
    2799 
    2800     wp_trash_post_comments($post_id);
    2801 
    2802     /**
    2803      * Fires after a post is sent to the trash.
    2804      *
    2805      * @since 2.9.0
    2806      *
    2807      * @param int $post_id Post ID.
    2808      */
    2809     do_action( 'trashed_post', $post_id );
    2810 
    2811     return $post;
    2812 }
    2813 
    2814 /**
    2815  * Restore a post or page from the Trash.
    2816  *
    2817  * @since 2.9.0
    2818  *
    2819  * @param int $post_id Optional. Post ID. Default is ID of the global $post.
    2820  * @return WP_Post|false WP_Post object. False on failure.
    2821  */
    2822 function wp_untrash_post( $post_id = 0 ) {
    2823     if ( !$post = get_post($post_id, ARRAY_A) )
    2824         return $post;
    2825 
    2826     if ( $post['post_status'] != 'trash' )
    2827         return false;
    2828 
    2829     /**
    2830      * Fires before a post is restored from the trash.
    2831      *
    2832      * @since 2.9.0
    2833      *
    2834      * @param int $post_id Post ID.
    2835      */
    2836     do_action( 'untrash_post', $post_id );
    2837 
    2838     $post_status = get_post_meta($post_id, '_wp_trash_meta_status', true);
    2839 
    2840     $post['post_status'] = $post_status;
    2841 
    2842     delete_post_meta($post_id, '_wp_trash_meta_status');
    2843     delete_post_meta($post_id, '_wp_trash_meta_time');
    2844 
    2845     wp_insert_post($post);
    2846 
    2847     wp_untrash_post_comments($post_id);
    2848 
    2849     /**
    2850      * Fires after a post is restored from the trash.
    2851      *
    2852      * @since 2.9.0
    2853      *
    2854      * @param int $post_id Post ID.
    2855      */
    2856     do_action( 'untrashed_post', $post_id );
    2857 
    2858     return $post;
    2859 }
    2860 
    2861 /**
    2862  * Moves comments for a post to the trash.
    2863  *
    2864  * @since 2.9.0
    2865  *
    2866  * @global wpdb $wpdb WordPress database abstraction object.
    2867  *
    2868  * @param int|WP_Post|null $post Optional. Post ID or post object. Defaults to global $post.
    2869  * @return mixed|void False on failure.
    2870  */
    2871 function wp_trash_post_comments( $post = null ) {
    2872     global $wpdb;
    2873 
    2874     $post = get_post($post);
    2875     if ( empty($post) )
    2876         return;
    2877 
    2878     $post_id = $post->ID;
    2879 
    2880     /**
    2881      * Fires before comments are sent to the trash.
    2882      *
    2883      * @since 2.9.0
    2884      *
    2885      * @param int $post_id Post ID.
    2886      */
    2887     do_action( 'trash_post_comments', $post_id );
    2888 
    2889     $comments = $wpdb->get_results( $wpdb->prepare("SELECT comment_ID, comment_approved FROM $wpdb->comments WHERE comment_post_ID = %d", $post_id) );
    2890     if ( empty($comments) )
    2891         return;
    2892 
    2893     // Cache current status for each comment.
    2894     $statuses = array();
    2895     foreach ( $comments as $comment )
    2896         $statuses[$comment->comment_ID] = $comment->comment_approved;
    2897     add_post_meta($post_id, '_wp_trash_meta_comments_status', $statuses);
    2898 
    2899     // Set status for all comments to post-trashed.
    2900     $result = $wpdb->update($wpdb->comments, array('comment_approved' => 'post-trashed'), array('comment_post_ID' => $post_id));
    2901 
    2902     clean_comment_cache( array_keys($statuses) );
    2903 
    2904     /**
    2905      * Fires after comments are sent to the trash.
    2906      *
    2907      * @since 2.9.0
    2908      *
    2909      * @param int   $post_id  Post ID.
    2910      * @param array $statuses Array of comment statuses.
    2911      */
    2912     do_action( 'trashed_post_comments', $post_id, $statuses );
    2913 
    2914     return $result;
    2915 }
    2916 
    2917 /**
    2918  * Restore comments for a post from the trash.
    2919  *
    2920  * @since 2.9.0
    2921  *
    2922  * @global wpdb $wpdb
    2923  *
    2924  * @param int|WP_Post|null $post Optional. Post ID or post object. Defaults to global $post.
    2925  * @return true|void
    2926  */
    2927 function wp_untrash_post_comments( $post = null ) {
    2928     global $wpdb;
    2929 
    2930     $post = get_post($post);
    2931     if ( empty($post) )
    2932         return;
    2933 
    2934     $post_id = $post->ID;
    2935 
    2936     $statuses = get_post_meta($post_id, '_wp_trash_meta_comments_status', true);
    2937 
    2938     if ( empty($statuses) )
    2939         return true;
    2940 
    2941     /**
    2942      * Fires before comments are restored for a post from the trash.
    2943      *
    2944      * @since 2.9.0
    2945      *
    2946      * @param int $post_id Post ID.
    2947      */
    2948     do_action( 'untrash_post_comments', $post_id );
    2949 
    2950     // Restore each comment to its original status.
    2951     $group_by_status = array();
    2952     foreach ( $statuses as $comment_id => $comment_status )
    2953         $group_by_status[$comment_status][] = $comment_id;
    2954 
    2955     foreach ( $group_by_status as $status => $comments ) {
    2956         // Sanity check. This shouldn't happen.
    2957         if ( 'post-trashed' == $status ) {
    2958             $status = '0';
    2959         }
    2960         $comments_in = implode( ', ', array_map( 'intval', $comments ) );
    2961         $wpdb->query( $wpdb->prepare( "UPDATE $wpdb->comments SET comment_approved = %s WHERE comment_ID IN ($comments_in)", $status ) );
    2962     }
    2963 
    2964     clean_comment_cache( array_keys($statuses) );
    2965 
    2966     delete_post_meta($post_id, '_wp_trash_meta_comments_status');
    2967 
    2968     /**
    2969      * Fires after comments are restored for a post from the trash.
    2970      *
    2971      * @since 2.9.0
    2972      *
    2973      * @param int $post_id Post ID.
    2974      */
    2975     do_action( 'untrashed_post_comments', $post_id );
    2976 }
    2977 
    2978 /**
    2979  * Retrieve the list of categories for a post.
    2980  *
    2981  * Compatibility layer for themes and plugins. Also an easy layer of abstraction
    2982  * away from the complexity of the taxonomy layer.
    2983  *
    2984  * @since 2.1.0
    2985  *
    2986  * @see wp_get_object_terms()
    2987  *
    2988  * @param int   $post_id Optional. The Post ID. Does not default to the ID of the
    2989  *                       global $post. Default 0.
    2990  * @param array $args    Optional. Category arguments. Default empty.
    2991  * @return array List of categories.
    2992  */
    2993 function wp_get_post_categories( $post_id = 0, $args = array() ) {
    2994     $post_id = (int) $post_id;
    2995 
    2996     $defaults = array('fields' => 'ids');
    2997     $args = wp_parse_args( $args, $defaults );
    2998 
    2999     $cats = wp_get_object_terms($post_id, 'category', $args);
    3000     return $cats;
    3001 }
    3002 
    3003 /**
    3004  * Retrieve the tags for a post.
    3005  *
    3006  * There is only one default for this function, called 'fields' and by default
    3007  * is set to 'all'. There are other defaults that can be overridden in
    3008  * {@link wp_get_object_terms()}.
    3009  *
    3010  * @since 2.3.0
    3011  *
    3012  * @param int   $post_id Optional. The Post ID. Does not default to the ID of the
    3013  *                       global $post. Defualt 0.
    3014  * @param array $args Optional. Overwrite the defaults
    3015  * @return array List of post tags.
    3016  */
    3017 function wp_get_post_tags( $post_id = 0, $args = array() ) {
    3018     return wp_get_post_terms( $post_id, 'post_tag', $args);
    3019 }
    3020 
    3021 /**
    3022  * Retrieve the terms for a post.
    3023  *
    3024  * There is only one default for this function, called 'fields' and by default
    3025  * is set to 'all'. There are other defaults that can be overridden in
    3026  * {@link wp_get_object_terms()}.
    3027  *
    3028  * @since 2.8.0
    3029  *
    3030  * @param int    $post_id  Optional. The Post ID. Does not default to the ID of the
    3031  *                         global $post. Default 0.
    3032  * @param string $taxonomy Optional. The taxonomy for which to retrieve terms. Default 'post_tag'.
    3033  * @param array  $args     Optional. {@link wp_get_object_terms()} arguments. Default empty array.
    3034  * @return array|WP_Error  List of post terms or empty array if no terms were found. WP_Error object
    3035  *                         if `$taxonomy` doesn't exist.
    3036  */
    3037 function wp_get_post_terms( $post_id = 0, $taxonomy = 'post_tag', $args = array() ) {
    3038     $post_id = (int) $post_id;
    3039 
    3040     $defaults = array('fields' => 'all');
    3041     $args = wp_parse_args( $args, $defaults );
    3042 
    3043     $tags = wp_get_object_terms($post_id, $taxonomy, $args);
    3044 
    3045     return $tags;
    3046 }
    3047 
    3048 /**
    3049  * Retrieve a number of recent posts.
    3050  *
    3051  * @since 1.0.0
    3052  *
    3053  * @see get_posts()
    3054  *
    3055  * @param array  $args       Optional. Arguments to retrieve posts. Default empty array.
    3056  * @param string $output     Optional. Type of output. Accepts ARRAY_A or ''. Default ARRAY_A.
    3057  * @return array|false Associative array if $output equals ARRAY_A, array or false if no results.
    3058  */
    3059 function wp_get_recent_posts( $args = array(), $output = ARRAY_A ) {
    3060 
    3061     if ( is_numeric( $args ) ) {
    3062         _deprecated_argument( __FUNCTION__, '3.1', __( 'Passing an integer number of posts is deprecated. Pass an array of arguments instead.' ) );
    3063         $args = array( 'numberposts' => absint( $args ) );
    3064     }
    3065 
    3066     // Set default arguments.
    3067     $defaults = array(
    3068         'numberposts' => 10, 'offset' => 0,
    3069         'category' => 0, 'orderby' => 'post_date',
    3070         'order' => 'DESC', 'include' => '',
    3071         'exclude' => '', 'meta_key' => '',
    3072         'meta_value' =>'', 'post_type' => 'post', 'post_status' => 'draft, publish, future, pending, private',
    3073         'suppress_filters' => true
    3074     );
    3075 
    3076     $r = wp_parse_args( $args, $defaults );
    3077 
    3078     $results = get_posts( $r );
    3079 
    3080     // Backward compatibility. Prior to 3.1 expected posts to be returned in array.
    3081     if ( ARRAY_A == $output ){
    3082         foreach ( $results as $key => $result ) {
    3083             $results[$key] = get_object_vars( $result );
    3084         }
    3085         return $results ? $results : array();
    3086     }
    3087 
    3088     return $results ? $results : false;
    3089 
    3090 }
    3091 
    3092 /**
    3093  * Insert or update a post.
    3094  *
    3095  * If the $postarr parameter has 'ID' set to a value, then post will be updated.
    3096  *
    3097  * You can set the post date manually, by setting the values for 'post_date'
    3098  * and 'post_date_gmt' keys. You can close the comments or open the comments by
    3099  * setting the value for 'comment_status' key.
    3100  *
    3101  * @since 1.0.0
    3102  * @since 4.2.0 Support was added for encoding emoji in the post title, content, and excerpt.
    3103  *
    3104  * @see sanitize_post()
    3105  * @global wpdb $wpdb WordPress database abstraction object.
    3106  *
    3107  * @param array $postarr {
    3108  *     An array of elements that make up a post to update or insert.
    3109  *
    3110  *     @type int    $ID                    The post ID. If equal to something other than 0,
    3111  *                                         the post with that ID will be updated. Default 0.
    3112  *     @type int    $post_author           The ID of the user who added the post. Default is
    3113  *                                         the current user ID.
    3114  *     @type string $post_date             The date of the post. Default is the current time.
    3115  *     @type string $post_date_gmt         The date of the post in the GMT timezone. Default is
    3116  *                                         the value of `$post_date`.
    3117  *     @type mixed  $post_content          The post content. Default empty.
    3118  *     @type string $post_content_filtered The filtered post content. Default empty.
    3119  *     @type string $post_title            The post title. Default empty.
    3120  *     @type string $post_excerpt          The post excerpt. Default empty.
    3121  *     @type string $post_status           The post status. Default 'draft'.
    3122  *     @type string $post_type             The post type. Default 'post'.
    3123  *     @type string $comment_status        Whether the post can accept comments. Accepts 'open' or 'closed'.
    3124  *                                         Default is the value of 'default_comment_status' option.
    3125  *     @type string $ping_status           Whether the post can accept pings. Accepts 'open' or 'closed'.
    3126  *                                         Default is the value of 'default_ping_status' option.
    3127  *     @type string $post_password         The password to access the post. Default empty.
    3128  *     @type string $post_name             The post name. Default is the sanitized post title.
    3129  *     @type string $to_ping               Space or carriage return-separated list of URLs to ping.
    3130  *                                         Default empty.
    3131  *     @type string $pinged                Space or carriage return-separated list of URLs that have
    3132  *                                         been pinged. Default empty.
    3133  *     @type string $post_modified         The date when the post was last modified. Default is
    3134  *                                         the current time.
    3135  *     @type string $post_modified_gmt     The date when the post was last modified in the GMT
    3136  *                                         timezone. Default is the current time.
    3137  *     @type int    $post_parent           Set this for the post it belongs to, if any. Default 0.
    3138  *     @type int    $menu_order            The order the post should be displayed in. Default 0.
    3139  *     @type string $post_mime_type        The mime type of the post. Default empty.
    3140  *     @type string $guid                  Global Unique ID for referencing the post. Default empty.
    3141  * }
    3142  * @param bool  $wp_error Optional. Whether to allow return of WP_Error on failure. Default false.
    3143  * @return int|WP_Error The post ID on success. The value 0 or WP_Error on failure.
    3144  */
    3145 function wp_insert_post( $postarr, $wp_error = false ) {
    3146     global $wpdb;
    3147 
    3148     $user_id = get_current_user_id();
    3149 
    3150     $defaults = array(
    3151         'post_author' => $user_id,
    3152         'post_content' => '',
    3153         'post_content_filtered' => '',
    3154         'post_title' => '',
    3155         'post_excerpt' => '',
    3156         'post_status' => 'draft',
    3157         'post_type' => 'post',
    3158         'comment_status' => '',
    3159         'ping_status' => '',
    3160         'post_password' => '',
    3161         'to_ping' =>  '',
    3162         'pinged' => '',
    3163         'post_parent' => 0,
    3164         'menu_order' => 0,
    3165         'guid' => '',
    3166         'import_id' => 0,
    3167         'context' => '',
    3168     );
    3169 
    3170     $postarr = wp_parse_args($postarr, $defaults);
    3171 
    3172     unset( $postarr[ 'filter' ] );
    3173 
    3174     $postarr = sanitize_post($postarr, 'db');
    3175 
    3176     // Are we updating or creating?
    3177     $post_ID = 0;
    3178     $update = false;
    3179     $guid = $postarr['guid'];
    3180 
    3181     if ( ! empty( $postarr['ID'] ) ) {
    3182         $update = true;
    3183 
    3184         // Get the post ID and GUID.
    3185         $post_ID = $postarr['ID'];
    3186         $post_before = get_post( $post_ID );
    3187         if ( is_null( $post_before ) ) {
    3188             if ( $wp_error ) {
    3189                 return new WP_Error( 'invalid_post', __( 'Invalid post ID.' ) );
    3190             }
    3191             return 0;
    3192         }
    3193 
    3194         $guid = get_post_field( 'guid', $post_ID );
    3195         $previous_status = get_post_field('post_status', $post_ID );
    3196     } else {
    3197         $previous_status = 'new';
    3198     }
    3199 
    3200     $post_type = empty( $postarr['post_type'] ) ? 'post' : $postarr['post_type'];
    3201 
    3202     $post_title = $postarr['post_title'];
    3203     $post_content = $postarr['post_content'];
    3204     $post_excerpt = $postarr['post_excerpt'];
    3205     if ( isset( $postarr['post_name'] ) ) {
    3206         $post_name = $postarr['post_name'];
    3207     }
    3208 
    3209     $maybe_empty = 'attachment' !== $post_type
    3210         && ! $post_content && ! $post_title && ! $post_excerpt
    3211         && post_type_supports( $post_type, 'editor' )
    3212         && post_type_supports( $post_type, 'title' )
    3213         && post_type_supports( $post_type, 'excerpt' );
    3214 
    3215     /**
    3216      * Filter whether the post should be considered "empty".
    3217      *
    3218      * The post is considered "empty" if both:
    3219      * 1. The post type supports the title, editor, and excerpt fields
    3220      * 2. The title, editor, and excerpt fields are all empty
    3221      *
    3222      * Returning a truthy value to the filter will effectively short-circuit
    3223      * the new post being inserted, returning 0. If $wp_error is true, a WP_Error
    3224      * will be returned instead.
    3225      *
    3226      * @since 3.3.0
    3227      *
    3228      * @param bool  $maybe_empty Whether the post should be considered "empty".
    3229      * @param array $postarr     Array of post data.
    3230      */
    3231     if ( apply_filters( 'wp_insert_post_empty_content', $maybe_empty, $postarr ) ) {
    3232         if ( $wp_error ) {
    3233             return new WP_Error( 'empty_content', __( 'Content, title, and excerpt are empty.' ) );
    3234         } else {
    3235             return 0;
    3236         }
    3237     }
    3238 
    3239     $post_status = empty( $postarr['post_status'] ) ? 'draft' : $postarr['post_status'];
    3240     if ( 'attachment' === $post_type && ! in_array( $post_status, array( 'inherit', 'private', 'trash' ) ) ) {
    3241         $post_status = 'inherit';
    3242     }
    3243 
    3244     if ( ! empty( $postarr['post_category'] ) ) {
    3245         // Filter out empty terms.
    3246         $post_category = array_filter( $postarr['post_category'] );
    3247     }
    3248 
    3249     // Make sure we set a valid category.
    3250     if ( empty( $post_category ) || 0 == count( $post_category ) || ! is_array( $post_category ) ) {
    3251         // 'post' requires at least one category.
    3252         if ( 'post' == $post_type && 'auto-draft' != $post_status ) {
    3253             $post_category = array( get_option('default_category') );
    3254         } else {
    3255             $post_category = array();
    3256         }
    3257     }
    3258 
    3259     // Don't allow contributors to set the post slug for pending review posts.
    3260     if ( 'pending' == $post_status && !current_user_can( 'publish_posts' ) ) {
    3261         $post_name = '';
    3262     }
    3263 
    3264     /*
    3265      * Create a valid post name. Drafts and pending posts are allowed to have
    3266      * an empty post name.
    3267      */
    3268     if ( empty($post_name) ) {
    3269         if ( !in_array( $post_status, array( 'draft', 'pending', 'auto-draft' ) ) ) {
    3270             $post_name = sanitize_title($post_title);
    3271         } else {
    3272             $post_name = '';
    3273         }
    3274     } else {
    3275         // On updates, we need to check to see if it's using the old, fixed sanitization context.
    3276         $check_name = sanitize_title( $post_name, '', 'old-save' );
    3277         if ( $update && strtolower( urlencode( $post_name ) ) == $check_name && get_post_field( 'post_name', $post_ID ) == $check_name ) {
    3278             $post_name = $check_name;
    3279         } else { // new post, or slug has changed.
    3280             $post_name = sanitize_title($post_name);
    3281         }
    3282     }
    3283 
    3284     /*
    3285      * If the post date is empty (due to having been new or a draft) and status
    3286      * is not 'draft' or 'pending', set date to now.
    3287      */
    3288     if ( empty( $postarr['post_date'] ) || '0000-00-00 00:00:00' == $postarr['post_date'] ) {
    3289         $post_date = current_time( 'mysql' );
    3290     } else {
    3291         $post_date = $postarr['post_date'];
    3292     }
    3293 
    3294     // Validate the date.
    3295     $mm = substr( $post_date, 5, 2 );
    3296     $jj = substr( $post_date, 8, 2 );
    3297     $aa = substr( $post_date, 0, 4 );
    3298     $valid_date = wp_checkdate( $mm, $jj, $aa, $post_date );
    3299     if ( ! $valid_date ) {
    3300         if ( $wp_error ) {
    3301             return new WP_Error( 'invalid_date', __( 'Whoops, the provided date is invalid.' ) );
    3302         } else {
    3303             return 0;
    3304         }
    3305     }
    3306 
    3307     if ( empty( $postarr['post_date_gmt'] ) || '0000-00-00 00:00:00' == $postarr['post_date_gmt'] ) {
    3308         if ( ! in_array( $post_status, array( 'draft', 'pending', 'auto-draft' ) ) ) {
    3309             $post_date_gmt = get_gmt_from_date( $post_date );
    3310         } else {
    3311             $post_date_gmt = '0000-00-00 00:00:00';
    3312         }
    3313     } else {
    3314         $post_date_gmt = $postarr['post_date_gmt'];
    3315     }
    3316 
    3317     if ( $update || '0000-00-00 00:00:00' == $post_date ) {
    3318         $post_modified     = current_time( 'mysql' );
    3319         $post_modified_gmt = current_time( 'mysql', 1 );
    3320     } else {
    3321         $post_modified     = $post_date;
    3322         $post_modified_gmt = $post_date_gmt;
    3323     }
    3324 
    3325     if ( 'attachment' !== $post_type ) {
    3326         if ( 'publish' == $post_status ) {
    3327             $now = gmdate('Y-m-d H:i:59');
    3328             if ( mysql2date('U', $post_date_gmt, false) > mysql2date('U', $now, false) ) {
    3329                 $post_status = 'future';
    3330             }
    3331         } elseif ( 'future' == $post_status ) {
    3332             $now = gmdate('Y-m-d H:i:59');
    3333             if ( mysql2date('U', $post_date_gmt, false) <= mysql2date('U', $now, false) ) {
    3334                 $post_status = 'publish';
    3335             }
    3336         }
    3337     }
    3338 
    3339     // Comment status.
    3340     if ( empty( $postarr['comment_status'] ) ) {
    3341         if ( $update ) {
    3342             $comment_status = 'closed';
    3343         } else {
    3344             $comment_status = get_default_comment_status( $post_type );
    3345         }
    3346     } else {
    3347         $comment_status = $postarr['comment_status'];
    3348     }
    3349 
    3350     // These variables are needed by compact() later.
    3351     $post_content_filtered = $postarr['post_content_filtered'];
    3352     $post_author = empty( $postarr['post_author'] ) ? $user_id : $postarr['post_author'];
    3353     $ping_status = empty( $postarr['ping_status'] ) ? get_default_comment_status( $post_type, 'pingback' ) : $postarr['ping_status'];
    3354     $to_ping = isset( $postarr['to_ping'] ) ? sanitize_trackback_urls( $postarr['to_ping'] ) : '';
    3355     $pinged = isset( $postarr['pinged'] ) ? $postarr['pinged'] : '';
    3356     $import_id = isset( $postarr['import_id'] ) ? $postarr['import_id'] : 0;
    3357 
    3358     /*
    3359      * The 'wp_insert_post_parent' filter expects all variables to be present.
    3360      * Previously, these variables would have already been extracted
    3361      */
    3362     if ( isset( $postarr['menu_order'] ) ) {
    3363         $menu_order = (int) $postarr['menu_order'];
    3364     } else {
    3365         $menu_order = 0;
    3366     }
    3367 
    3368     $post_password = isset( $postarr['post_password'] ) ? $postarr['post_password'] : '';
    3369     if ( 'private' == $post_status ) {
    3370         $post_password = '';
    3371     }
    3372 
    3373     if ( isset( $postarr['post_parent'] ) ) {
    3374         $post_parent = (int) $postarr['post_parent'];
    3375     } else {
    3376         $post_parent = 0;
    3377     }
    3378 
    3379     /**
    3380      * Filter the post parent -- used to check for and prevent hierarchy loops.
    3381      *
    3382      * @since 3.1.0
    3383      *
    3384      * @param int   $post_parent Post parent ID.
    3385      * @param int   $post_ID     Post ID.
    3386      * @param array $new_postarr Array of parsed post data.
    3387      * @param array $postarr     Array of sanitized, but otherwise unmodified post data.
    3388      */
    3389     $post_parent = apply_filters( 'wp_insert_post_parent', $post_parent, $post_ID, compact( array_keys( $postarr ) ), $postarr );
    3390 
    3391     $post_name = wp_unique_post_slug( $post_name, $post_ID, $post_status, $post_type, $post_parent );
    3392 
    3393     // Don't unslash.
    3394     $post_mime_type = isset( $postarr['post_mime_type'] ) ? $postarr['post_mime_type'] : '';
    3395 
    3396     // Expected_slashed (everything!).
    3397     $data = compact( 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_content_filtered', 'post_title', 'post_excerpt', 'post_status', 'post_type', 'comment_status', 'ping_status', 'post_password', 'post_name', 'to_ping', 'pinged', 'post_modified', 'post_modified_gmt', 'post_parent', 'menu_order', 'post_mime_type', 'guid' );
    3398 
    3399     $emoji_fields = array( 'post_title', 'post_content', 'post_excerpt' );
    3400 
    3401     foreach ( $emoji_fields as $emoji_field ) {
    3402         if ( isset( $data[ $emoji_field ] ) ) {
    3403             $charset = $wpdb->get_col_charset( $wpdb->posts, $emoji_field );
    3404             if ( 'utf8' === $charset ) {
    3405                 $data[ $emoji_field ] = wp_encode_emoji( $data[ $emoji_field ] );
    3406             }
    3407         }
    3408     }
    3409 
    3410     if ( 'attachment' === $post_type ) {
    3411         /**
    3412          * Filter attachment post data before it is updated in or added to the database.
    3413          *
    3414          * @since 3.9.0
    3415          *
    3416          * @param array $data    An array of sanitized attachment post data.
    3417          * @param array $postarr An array of unsanitized attachment post data.
    3418          */
    3419         $data = apply_filters( 'wp_insert_attachment_data', $data, $postarr );
    3420     } else {
    3421         /**
    3422          * Filter slashed post data just before it is inserted into the database.
    3423          *
    3424          * @since 2.7.0
    3425          *
    3426          * @param array $data    An array of slashed post data.
    3427          * @param array $postarr An array of sanitized, but otherwise unmodified post data.
    3428          */
    3429         $data = apply_filters( 'wp_insert_post_data', $data, $postarr );
    3430     }
    3431     $data = wp_unslash( $data );
    3432     $where = array( 'ID' => $post_ID );
    3433 
    3434     if ( $update ) {
    3435         /**
    3436          * Fires immediately before an existing post is updated in the database.
    3437          *
    3438          * @since 2.5.0
    3439          *
    3440          * @param int   $post_ID Post ID.
    3441          * @param array $data    Array of unslashed post data.
    3442          */
    3443         do_action( 'pre_post_update', $post_ID, $data );
    3444         if ( false === $wpdb->update( $wpdb->posts, $data, $where ) ) {
    3445             if ( $wp_error ) {
    3446                 return new WP_Error('db_update_error', __('Could not update post in the database'), $wpdb->last_error);
    3447             } else {
    3448                 return 0;
    3449             }
    3450         }
    3451     } else {
    3452         // If there is a suggested ID, use it if not already present.
    3453         if ( ! empty( $import_id ) ) {
    3454             $import_id = (int) $import_id;
    3455             if ( ! $wpdb->get_var( $wpdb->prepare("SELECT ID FROM $wpdb->posts WHERE ID = %d", $import_id) ) ) {
    3456                 $data['ID'] = $import_id;
    3457             }
    3458         }
    3459         if ( false === $wpdb->insert( $wpdb->posts, $data ) ) {
    3460             if ( $wp_error ) {
    3461                 return new WP_Error('db_insert_error', __('Could not insert post into the database'), $wpdb->last_error);
    3462             } else {
    3463                 return 0;
    3464             }
    3465         }
    3466         $post_ID = (int) $wpdb->insert_id;
    3467 
    3468         // Use the newly generated $post_ID.
    3469         $where = array( 'ID' => $post_ID );
    3470     }
    3471 
    3472     if ( empty( $data['post_name'] ) && ! in_array( $data['post_status'], array( 'draft', 'pending', 'auto-draft' ) ) ) {
    3473         $data['post_name'] = wp_unique_post_slug( sanitize_title( $data['post_title'], $post_ID ), $post_ID, $data['post_status'], $post_type, $post_parent );
    3474         $wpdb->update( $wpdb->posts, array( 'post_name' => $data['post_name'] ), $where );
    3475         clean_post_cache( $post_ID );
    3476     }
    3477 
    3478     if ( is_object_in_taxonomy( $post_type, 'category' ) ) {
    3479         wp_set_post_categories( $post_ID, $post_category );
    3480     }
    3481 
    3482     if ( isset( $postarr['tags_input'] ) && is_object_in_taxonomy( $post_type, 'post_tag' ) ) {
    3483         wp_set_post_tags( $post_ID, $postarr['tags_input'] );
    3484     }
    3485 
    3486     // New-style support for all custom taxonomies.
    3487     if ( ! empty( $postarr['tax_input'] ) ) {
    3488         foreach ( $postarr['tax_input'] as $taxonomy => $tags ) {
    3489             $taxonomy_obj = get_taxonomy($taxonomy);
    3490             // array = hierarchical, string = non-hierarchical.
    3491             if ( is_array( $tags ) ) {
    3492                 $tags = array_filter($tags);
    3493             }
    3494             if ( current_user_can( $taxonomy_obj->cap->assign_terms ) ) {
    3495                 wp_set_post_terms( $post_ID, $tags, $taxonomy );
    3496             }
    3497         }
    3498     }
    3499 
    3500     $current_guid = get_post_field( 'guid', $post_ID );
    3501 
    3502     // Set GUID.
    3503     if ( ! $update && '' == $current_guid ) {
    3504         $wpdb->update( $wpdb->posts, array( 'guid' => get_permalink( $post_ID ) ), $where );
    3505     }
    3506 
    3507     if ( 'attachment' === $postarr['post_type'] ) {
    3508         if ( ! empty( $postarr['file'] ) ) {
    3509             update_attached_file( $post_ID, $postarr['file'] );
    3510         }
    3511 
    3512         if ( ! empty( $postarr['context'] ) ) {
    3513             add_post_meta( $post_ID, '_wp_attachment_context', $postarr['context'], true );
    3514         }
    3515     }
    3516 
    3517     clean_post_cache( $post_ID );
    3518 
    3519     $post = get_post( $post_ID );
    3520 
    3521     if ( ! empty( $postarr['page_template'] ) && 'page' == $data['post_type'] ) {
    3522         $post->page_template = $postarr['page_template'];
    3523         $page_templates = wp_get_theme()->get_page_templates( $post );
    3524         if ( 'default' != $postarr['page_template'] && ! isset( $page_templates[ $postarr['page_template'] ] ) ) {
    3525             if ( $wp_error ) {
    3526                 return new WP_Error('invalid_page_template', __('The page template is invalid.'));
    3527             }
    3528             update_post_meta( $post_ID, '_wp_page_template', 'default' );
    3529         } else {
    3530             update_post_meta( $post_ID, '_wp_page_template', $postarr['page_template'] );
    3531         }
    3532     }
    3533 
    3534     if ( 'attachment' !== $postarr['post_type'] ) {
    3535         wp_transition_post_status( $data['post_status'], $previous_status, $post );
    3536     } else {
    3537         if ( $update ) {
    3538             /**
    3539              * Fires once an existing attachment has been updated.
    3540              *
    3541              * @since 2.0.0
    3542              *
    3543              * @param int $post_ID Attachment ID.
    3544              */
    3545             do_action( 'edit_attachment', $post_ID );
    3546         } else {
    3547 
    3548             /**
    3549              * Fires once an attachment has been added.
    3550              *
    3551              * @since 2.0.0
    3552              *
    3553              * @param int $post_ID Attachment ID.
    3554              */
    3555             do_action( 'add_attachment', $post_ID );
    3556         }
    3557 
    3558         return $post_ID;
    3559     }
    3560 
    3561     if ( $update ) {
    3562         /**
    3563          * Fires once an existing post has been updated.
    3564          *
    3565          * @since 1.2.0
    3566          *
    3567          * @param int     $post_ID Post ID.
    3568          * @param WP_Post $post    Post object.
    3569          */
    3570         do_action( 'edit_post', $post_ID, $post );
    3571         $post_after = get_post($post_ID);
    3572 
    3573         /**
    3574          * Fires once an existing post has been updated.
    3575          *
    3576          * @since 3.0.0
    3577          *
    3578          * @param int     $post_ID      Post ID.
    3579          * @param WP_Post $post_after   Post object following the update.
    3580          * @param WP_Post $post_before  Post object before the update.
    3581          */
    3582         do_action( 'post_updated', $post_ID, $post_after, $post_before);
    3583     }
    3584 
    3585     /**
    3586      * Fires once a post has been saved.
    3587      *
    3588      * The dynamic portion of the hook name, `$post->post_type`, refers to
    3589      * the post type slug.
    3590      *
    3591      * @since 3.7.0
    3592      *
    3593      * @param int     $post_ID Post ID.
    3594      * @param WP_Post $post    Post object.
    3595      * @param bool    $update  Whether this is an existing post being updated or not.
    3596      */
    3597     do_action( "save_post_{$post->post_type}", $post_ID, $post, $update );
    3598 
    3599     /**
    3600      * Fires once a post has been saved.
    3601      *
    3602      * @since 1.5.0
    3603      *
    3604      * @param int     $post_ID Post ID.
    3605      * @param WP_Post $post    Post object.
    3606      * @param bool    $update  Whether this is an existing post being updated or not.
    3607      */
    3608     do_action( 'save_post', $post_ID, $post, $update );
    3609 
    3610     /**
    3611      * Fires once a post has been saved.
    3612      *
    3613      * @since 2.0.0
    3614      *
    3615      * @param int     $post_ID Post ID.
    3616      * @param WP_Post $post    Post object.
    3617      * @param bool    $update  Whether this is an existing post being updated or not.
    3618      */
    3619     do_action( 'wp_insert_post', $post_ID, $post, $update );
    3620 
    3621     return $post_ID;
    3622 }
    3623 
    3624 /**
    3625  * Update a post with new post data.
    3626  *
    3627  * The date does not have to be set for drafts. You can set the date and it will
    3628  * not be overridden.
    3629  *
    3630  * @since 1.0.0
    3631  *
    3632  * @param array|object $postarr  Optional. Post data. Arrays are expected to be escaped,
    3633  *                               objects are not. Default array.
    3634  * @param bool         $wp_error Optional. Allow return of WP_Error on failure. Default false.
    3635  * @return int|WP_Error The value 0 or WP_Error on failure. The post ID on success.
    3636  */
    3637 function wp_update_post( $postarr = array(), $wp_error = false ) {
    3638     if ( is_object($postarr) ) {
    3639         // Non-escaped post was passed.
    3640         $postarr = get_object_vars($postarr);
    3641         $postarr = wp_slash($postarr);
    3642     }
    3643 
    3644     // First, get all of the original fields.
    3645     $post = get_post($postarr['ID'], ARRAY_A);
    3646 
    3647     if ( is_null( $post ) ) {
    3648         if ( $wp_error )
    3649             return new WP_Error( 'invalid_post', __( 'Invalid post ID.' ) );
    3650         return 0;
    3651     }
    3652 
    3653     // Escape data pulled from DB.
    3654     $post = wp_slash($post);
    3655 
    3656     // Passed post category list overwrites existing category list if not empty.
    3657     if ( isset($postarr['post_category']) && is_array($postarr['post_category'])
    3658              && 0 != count($postarr['post_category']) )
    3659         $post_cats = $postarr['post_category'];
    3660     else
    3661         $post_cats = $post['post_category'];
    3662 
    3663     // Drafts shouldn't be assigned a date unless explicitly done so by the user.
    3664     if ( isset( $post['post_status'] ) && in_array($post['post_status'], array('draft', 'pending', 'auto-draft')) && empty($postarr['edit_date']) &&
    3665              ('0000-00-00 00:00:00' == $post['post_date_gmt']) )
    3666         $clear_date = true;
    3667     else
    3668         $clear_date = false;
    3669 
    3670     // Merge old and new fields with new fields overwriting old ones.
    3671     $postarr = array_merge($post, $postarr);
    3672     $postarr['post_category'] = $post_cats;
    3673     if ( $clear_date ) {
    3674         $postarr['post_date'] = current_time('mysql');
    3675         $postarr['post_date_gmt'] = '';
    3676     }
    3677 
    3678     if ($postarr['post_type'] == 'attachment')
    3679         return wp_insert_attachment($postarr);
    3680 
    3681     return wp_insert_post( $postarr, $wp_error );
    3682 }
    3683 
    3684 /**
    3685  * Publish a post by transitioning the post status.
    3686  *
    3687  * @since 2.1.0
    3688  *
    3689  * @global wpdb $wpdb WordPress database abstraction object.
    3690  *
    3691  * @param int|WP_Post $post Post ID or post object.
    3692  */
    3693 function wp_publish_post( $post ) {
    3694     global $wpdb;
    3695 
    3696     if ( ! $post = get_post( $post ) )
    3697         return;
    3698 
    3699     if ( 'publish' == $post->post_status )
    3700         return;
    3701 
    3702     $wpdb->update( $wpdb->posts, array( 'post_status' => 'publish' ), array( 'ID' => $post->ID ) );
    3703 
    3704     clean_post_cache( $post->ID );
    3705 
    3706     $old_status = $post->post_status;
    3707     $post->post_status = 'publish';
    3708     wp_transition_post_status( 'publish', $old_status, $post );
    3709 
    3710     /** This action is documented in wp-includes/post.php */
    3711     do_action( 'edit_post', $post->ID, $post );
    3712 
    3713     /** This action is documented in wp-includes/post.php */
    3714     do_action( "save_post_{$post->post_type}", $post->ID, $post, true );
    3715 
    3716     /** This action is documented in wp-includes/post.php */
    3717     do_action( 'save_post', $post->ID, $post, true );
    3718 
    3719     /** This action is documented in wp-includes/post.php */
    3720     do_action( 'wp_insert_post', $post->ID, $post, true );
    3721 }
    3722 
    3723 /**
    3724  * Publish future post and make sure post ID has future post status.
    3725  *
    3726  * Invoked by cron 'publish_future_post' event. This safeguard prevents cron
    3727  * from publishing drafts, etc.
    3728  *
    3729  * @since 2.5.0
    3730  *
    3731  * @param int|WP_Post $post_id Post ID or post object.
    3732  */
    3733 function check_and_publish_future_post( $post_id ) {
    3734     $post = get_post($post_id);
    3735 
    3736     if ( empty($post) )
    3737         return;
    3738 
    3739     if ( 'future' != $post->post_status )
    3740         return;
    3741 
    3742     $time = strtotime( $post->post_date_gmt . ' GMT' );
    3743 
    3744     // Uh oh, someone jumped the gun!
    3745     if ( $time > time() ) {
    3746         wp_clear_scheduled_hook( 'publish_future_post', array( $post_id ) ); // clear anything else in the system
    3747         wp_schedule_single_event( $time, 'publish_future_post', array( $post_id ) );
    3748         return;
    3749     }
    3750 
    3751     // wp_publish_post(_ returns no meaninful value
    3752     wp_publish_post( $post_id );
    3753 }
    3754 
    3755 /**
    3756  * Computes a unique slug for the post, when given the desired slug and some post details.
    3757  *
    3758  * @since 2.8.0
    3759  *
    3760  * @global wpdb       $wpdb WordPress database abstraction object.
    3761  * @global WP_Rewrite $wp_rewrite
    3762  *
    3763  * @param string $slug        The desired slug (post_name).
    3764  * @param int    $post_ID     Post ID.
    3765  * @param string $post_status No uniqueness checks are made if the post is still draft or pending.
    3766  * @param string $post_type   Post type.
    3767  * @param int    $post_parent Post parent ID.
    3768  * @return string Unique slug for the post, based on $post_name (with a -1, -2, etc. suffix)
    3769  */
    3770 function wp_unique_post_slug( $slug, $post_ID, $post_status, $post_type, $post_parent ) {
    3771     if ( in_array( $post_status, array( 'draft', 'pending', 'auto-draft' ) ) || ( 'inherit' == $post_status && 'revision' == $post_type ) )
    3772         return $slug;
    3773 
    3774     global $wpdb, $wp_rewrite;
    3775 
    3776     $original_slug = $slug;
    3777 
    3778     $feeds = $wp_rewrite->feeds;
    3779     if ( ! is_array( $feeds ) )
    3780         $feeds = array();
    3781 
    3782     if ( 'attachment' == $post_type ) {
    3783         // Attachment slugs must be unique across all types.
    3784         $check_sql = "SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND ID != %d LIMIT 1";
    3785         $post_name_check = $wpdb->get_var( $wpdb->prepare( $check_sql, $slug, $post_ID ) );
    3786 
    3787         /**
    3788          * Filter whether the post slug would make a bad attachment slug.
    3789          *
    3790          * @since 3.1.0
    3791          *
    3792          * @param bool   $bad_slug Whether the slug would be bad as an attachment slug.
    3793          * @param string $slug     The post slug.
    3794          */
    3795         if ( $post_name_check || in_array( $slug, $feeds ) || apply_filters( 'wp_unique_post_slug_is_bad_attachment_slug', false, $slug ) ) {
    3796             $suffix = 2;
    3797             do {
    3798                 $alt_post_name = _truncate_post_slug( $slug, 200 - ( strlen( $suffix ) + 1 ) ) . "-$suffix";
    3799                 $post_name_check = $wpdb->get_var( $wpdb->prepare( $check_sql, $alt_post_name, $post_ID ) );
    3800                 $suffix++;
    3801             } while ( $post_name_check );
    3802             $slug = $alt_post_name;
    3803         }
    3804     } elseif ( is_post_type_hierarchical( $post_type ) ) {
    3805         if ( 'nav_menu_item' == $post_type )
    3806             return $slug;
    3807 
    3808         /*
    3809          * Page slugs must be unique within their own trees. Pages are in a separate
    3810          * namespace than posts so page slugs are allowed to overlap post slugs.
    3811          */
    3812         $check_sql = "SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND post_type IN ( %s, 'attachment' ) AND ID != %d AND post_parent = %d LIMIT 1";
    3813         $post_name_check = $wpdb->get_var( $wpdb->prepare( $check_sql, $slug, $post_type, $post_ID, $post_parent ) );
    3814 
    3815         /**
    3816          * Filter whether the post slug would make a bad hierarchical post slug.
    3817          *
    3818          * @since 3.1.0
    3819          *
    3820          * @param bool   $bad_slug    Whether the post slug would be bad in a hierarchical post context.
    3821          * @param string $slug        The post slug.
    3822          * @param string $post_type   Post type.
    3823          * @param int    $post_parent Post parent ID.
    3824          */
    3825         if ( $post_name_check || in_array( $slug, $feeds ) || preg_match( "@^($wp_rewrite->pagination_base)?\d+$@", $slug )  || apply_filters( 'wp_unique_post_slug_is_bad_hierarchical_slug', false, $slug, $post_type, $post_parent ) ) {
    3826             $suffix = 2;
    3827             do {
    3828                 $alt_post_name = _truncate_post_slug( $slug, 200 - ( strlen( $suffix ) + 1 ) ) . "-$suffix";
    3829                 $post_name_check = $wpdb->get_var( $wpdb->prepare( $check_sql, $alt_post_name, $post_type, $post_ID, $post_parent ) );
    3830                 $suffix++;
    3831             } while ( $post_name_check );
    3832             $slug = $alt_post_name;
    3833         }
    3834     } else {
    3835         // Post slugs must be unique across all posts.
    3836         $check_sql = "SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND post_type = %s AND ID != %d LIMIT 1";
    3837         $post_name_check = $wpdb->get_var( $wpdb->prepare( $check_sql, $slug, $post_type, $post_ID ) );
    3838 
    3839         // Prevent new post slugs that could result in URLs that conflict with date archives.
    3840         $post = get_post( $post_ID );
    3841         $conflicts_with_date_archive = false;
    3842         if ( 'post' === $post_type && ( ! $post || $post->post_name !== $slug ) && preg_match( '/^[0-9]+$/', $slug ) && $slug_num = intval( $slug ) ) {
    3843             $permastructs   = array_values( array_filter( explode( '/', get_option( 'permalink_structure' ) ) ) );
    3844             $postname_index = array_search( '%postname%', $permastructs );
    3845 
    3846             /*
    3847              * Potential date clashes are as follows:
    3848              *
    3849              * - Any integer in the first permastruct position could be a year.
    3850              * - An integer between 1 and 12 that follows 'year' conflicts with 'monthnum'.
    3851              * - An integer between 1 and 31 that follows 'monthnum' conflicts with 'day'.
    3852              */
    3853             if ( 0 === $postname_index ||
    3854                 ( $postname_index && '%year%' === $permastructs[ $postname_index - 1 ] && 13 > $slug_num ) ||
    3855                 ( $postname_index && '%monthnum%' === $permastructs[ $postname_index - 1 ] && 32 > $slug_num )
    3856             ) {
    3857                 $conflicts_with_date_archive = true;
    3858             }
    3859         }
    3860 
    3861         /**
    3862          * Filter whether the post slug would be bad as a flat slug.
    3863          *
    3864          * @since 3.1.0
    3865          *
    3866          * @param bool   $bad_slug  Whether the post slug would be bad as a flat slug.
    3867          * @param string $slug      The post slug.
    3868          * @param string $post_type Post type.
    3869          */
    3870         if ( $post_name_check || in_array( $slug, $feeds ) || $conflicts_with_date_archive || apply_filters( 'wp_unique_post_slug_is_bad_flat_slug', false, $slug, $post_type ) ) {
    3871             $suffix = 2;
    3872             do {
    3873                 $alt_post_name = _truncate_post_slug( $slug, 200 - ( strlen( $suffix ) + 1 ) ) . "-$suffix";
    3874                 $post_name_check = $wpdb->get_var( $wpdb->prepare( $check_sql, $alt_post_name, $post_type, $post_ID ) );
    3875                 $suffix++;
    3876             } while ( $post_name_check );
    3877             $slug = $alt_post_name;
    3878         }
    3879     }
    3880 
    3881     /**
    3882      * Filter the unique post slug.
    3883      *
    3884      * @since 3.3.0
    3885      *
    3886      * @param string $slug          The post slug.
    3887      * @param int    $post_ID       Post ID.
    3888      * @param string $post_status   The post status.
    3889      * @param string $post_type     Post type.
    3890      * @param int    $post_parent   Post parent ID
    3891      * @param string $original_slug The original post slug.
    3892      */
    3893     return apply_filters( 'wp_unique_post_slug', $slug, $post_ID, $post_status, $post_type, $post_parent, $original_slug );
    3894 }
    3895 
    3896 /**
    3897  * Truncate a post slug.
    3898  *
    3899  * @since 3.6.0
    3900  * @access private
    3901  *
    3902  * @see utf8_uri_encode()
    3903  *
    3904  * @param string $slug   The slug to truncate.
    3905  * @param int    $length Optional. Max length of the slug. Default 200 (characters).
    3906  * @return string The truncated slug.
    3907  */
    3908 function _truncate_post_slug( $slug, $length = 200 ) {
    3909     if ( strlen( $slug ) > $length ) {
    3910         $decoded_slug = urldecode( $slug );
    3911         if ( $decoded_slug === $slug )
    3912             $slug = substr( $slug, 0, $length );
    3913         else
    3914             $slug = utf8_uri_encode( $decoded_slug, $length );
    3915     }
    3916 
    3917     return rtrim( $slug, '-' );
    3918 }
    3919 
    3920 /**
    3921  * Add tags to a post.
    3922  *
    3923  * @see wp_set_post_tags()
    3924  *
    3925  * @since 2.3.0
    3926  *
    3927  * @param int    $post_id Optional. The Post ID. Does not default to the ID of the global $post.
    3928  *                        Default 0.
    3929  * @param string $tags    Optional. The tags to set for the post, separated by commas. Default empty.
    3930  * @return array|false|WP_Error Will return false if $post_id is not an integer or is 0.
    3931  */
    3932 function wp_add_post_tags( $post_id = 0, $tags = '' ) {
    3933     return wp_set_post_tags($post_id, $tags, true);
    3934 }
    3935 
    3936 /**
    3937  * Set the tags for a post.
    3938  *
    3939  * @since 2.3.0
    3940  *
    3941  * @see wp_set_object_terms()
    3942  *
    3943  * @param int    $post_id Optional. The Post ID. Does not default to the ID of the global $post.
    3944  * @param string $tags    Optional. The tags to set for the post, separated by commas.
    3945  *                        Default empty.
    3946  * @param bool   $append  Optional. If true, don't delete existing tags, just add on. If false,
    3947  *                        replace the tags with the new tags. Default false.
    3948  * @return array|false|WP_Error Array of affected term IDs. WP_Error or false on failure.
    3949  */
    3950 function wp_set_post_tags( $post_id = 0, $tags = '', $append = false ) {
    3951     return wp_set_post_terms( $post_id, $tags, 'post_tag', $append);
    3952 }
    3953 
    3954 /**
    3955  * Set the terms for a post.
    3956  *
    3957  * @since 2.8.0
    3958  *
    3959  * @see wp_set_object_terms()
    3960  *
    3961  * @param int    $post_id  Optional. The Post ID. Does not default to the ID of the global $post.
    3962  * @param string $tags     Optional. The tags to set for the post, separated by commas. Default empty.
    3963  * @param string $taxonomy Optional. Taxonomy name. Default 'post_tag'.
    3964  * @param bool   $append   Optional. If true, don't delete existing tags, just add on. If false,
    3965  *                         replace the tags with the new tags. Default false.
    3966  * @return array|false|WP_Error Array of affected term IDs. WP_Error or false on failure.
    3967  */
    3968 function wp_set_post_terms( $post_id = 0, $tags = '', $taxonomy = 'post_tag', $append = false ) {
    3969     $post_id = (int) $post_id;
    3970 
    3971     if ( !$post_id )
    3972         return false;
    3973 
    3974     if ( empty($tags) )
    3975         $tags = array();
    3976 
    3977     if ( ! is_array( $tags ) ) {
    3978         $comma = _x( ',', 'tag delimiter' );
    3979         if ( ',' !== $comma )
    3980             $tags = str_replace( $comma, ',', $tags );
    3981         $tags = explode( ',', trim( $tags, " \n\t\r\0\x0B," ) );
    3982     }
    3983 
    3984     /*
    3985      * Hierarchical taxonomies must always pass IDs rather than names so that
    3986      * children with the same names but different parents aren't confused.
    3987      */
    3988     if ( is_taxonomy_hierarchical( $taxonomy ) ) {
    3989         $tags = array_unique( array_map( 'intval', $tags ) );
    3990     }
    3991 
    3992     return wp_set_object_terms( $post_id, $tags, $taxonomy, $append );
    3993 }
    3994 
    3995 /**
    3996  * Set categories for a post.
    3997  *
    3998  * If the post categories parameter is not set, then the default category is
    3999  * going used.
    4000  *
    4001  * @since 2.1.0
    4002  *
    4003  * @param int       $post_ID         Optional. The Post ID. Does not default to the ID
    4004  *                                   of the global $post. Default 0.
    4005  * @param array|int $post_categories Optional. List of categories or ID of category.
    4006  *                                   Default empty array.
    4007  * @param bool      $append         If true, don't delete existing categories, just add on.
    4008  *                                  If false, replace the categories with the new categories.
    4009  * @return array|bool|WP_Error
    4010  */
    4011 function wp_set_post_categories( $post_ID = 0, $post_categories = array(), $append = false ) {
    4012     $post_ID = (int) $post_ID;
    4013     $post_type = get_post_type( $post_ID );
    4014     $post_status = get_post_status( $post_ID );
    4015     // If $post_categories isn't already an array, make it one:
    4016     $post_categories = (array) $post_categories;
    4017     if ( empty( $post_categories ) ) {
    4018         if ( 'post' == $post_type && 'auto-draft' != $post_status ) {
    4019             $post_categories = array( get_option('default_category') );
    4020             $append = false;
    4021         } else {
    4022             $post_categories = array();
    4023         }
    4024     } elseif ( 1 == count( $post_categories ) && '' == reset( $post_categories ) ) {
    4025         return true;
    4026     }
    4027 
    4028     return wp_set_post_terms( $post_ID, $post_categories, 'category', $append );
    4029 }
    4030 
    4031 /**
    4032  * Fires actions related to the transitioning of a post's status.
    4033  *
    4034  * When a post is saved, the post status is "transitioned" from one status to another,
    4035  * though this does not always mean the status has actually changed before and after
    4036  * the save. This function fires a number of action hooks related to that transition:
    4037  * the generic 'transition_post_status' action, as well as the dynamic hooks
    4038  * `"{$old_status}_to_{$new_status}"` and `"{$new_status}_{$post->post_type}"`. Note
    4039  * that the function does not transition the post object in the database.
    4040  *
    4041  * For instance: When publishing a post for the first time, the post status may transition
    4042  * from 'draft' – or some other status – to 'publish'. However, if a post is already
    4043  * published and is simply being updated, the "old" and "new" statuses may both be 'publish'
    4044  * before and after the transition.
    4045  *
    4046  * @since 2.3.0
    4047  *
    4048  * @param string  $new_status Transition to this post status.
    4049  * @param string  $old_status Previous post status.
    4050  * @param WP_Post $post Post data.
    4051  */
    4052 function wp_transition_post_status( $new_status, $old_status, $post ) {
    4053     /**
    4054      * Fires when a post is transitioned from one status to another.
    4055      *
    4056      * @since 2.3.0
    4057      *
    4058      * @param string  $new_status New post status.
    4059      * @param string  $old_status Old post status.
    4060      * @param WP_Post $post       Post object.
    4061      */
    4062     do_action( 'transition_post_status', $new_status, $old_status, $post );
    4063 
    4064     /**
    4065      * Fires when a post is transitioned from one status to another.
    4066      *
    4067      * The dynamic portions of the hook name, `$new_status` and `$old status`,
    4068      * refer to the old and new post statuses, respectively.
    4069      *
    4070      * @since 2.3.0
    4071      *
    4072      * @param WP_Post $post Post object.
    4073      */
    4074     do_action( "{$old_status}_to_{$new_status}", $post );
    4075 
    4076     /**
    4077      * Fires when a post is transitioned from one status to another.
    4078      *
    4079      * The dynamic portions of the hook name, `$new_status` and `$post->post_type`,
    4080      * refer to the new post status and post type, respectively.
    4081      *
    4082      * Please note: When this action is hooked using a particular post status (like
    4083      * 'publish', as `publish_{$post->post_type}`), it will fire both when a post is
    4084      * first transitioned to that status from something else, as well as upon
    4085      * subsequent post updates (old and new status are both the same).
    4086      *
    4087      * Therefore, if you are looking to only fire a callback when a post is first
    4088      * transitioned to a status, use the {@see 'transition_post_status'} hook instead.
    4089      *
    4090      * @since 2.3.0
    4091      *
    4092      * @param int     $post_id Post ID.
    4093      * @param WP_Post $post    Post object.
    4094      */
    4095     do_action( "{$new_status}_{$post->post_type}", $post->ID, $post );
    4096 }
    4097 
    4098 //
    4099 // Comment, trackback, and pingback functions.
    4100 //
    4101 
    4102 /**
    4103  * Add a URL to those already pinged.
    4104  *
    4105  * @since 1.5.0
    4106  *
    4107  * @global wpdb $wpdb WordPress database abstraction object.
    4108  *
    4109  * @param int    $post_id Post ID.
    4110  * @param string $uri     Ping URI.
    4111  * @return int|false How many rows were updated.
    4112  */
    4113 function add_ping( $post_id, $uri ) {
    4114     global $wpdb;
    4115     $pung = $wpdb->get_var( $wpdb->prepare( "SELECT pinged FROM $wpdb->posts WHERE ID = %d", $post_id ));
    4116     $pung = trim($pung);
    4117     $pung = preg_split('/\s/', $pung);
    4118     $pung[] = $uri;
    4119     $new = implode("\n", $pung);
    4120 
    4121     /**
    4122      * Filter the new ping URL to add for the given post.
    4123      *
    4124      * @since 2.0.0
    4125      *
    4126      * @param string $new New ping URL to add.
    4127      */
    4128     $new = apply_filters( 'add_ping', $new );
    4129 
    4130     // expected_slashed ($new).
    4131     $new = wp_unslash($new);
    4132     return $wpdb->update( $wpdb->posts, array( 'pinged' => $new ), array( 'ID' => $post_id ) );
    4133 }
    4134 
    4135 /**
    4136  * Retrieve enclosures already enclosed for a post.
    4137  *
    4138  * @since 1.5.0
    4139  *
    4140  * @param int $post_id Post ID.
    4141  * @return array List of enclosures.
    4142  */
    4143 function get_enclosed( $post_id ) {
    4144     $custom_fields = get_post_custom( $post_id );
    4145     $pung = array();
    4146     if ( !is_array( $custom_fields ) )
    4147         return $pung;
    4148 
    4149     foreach ( $custom_fields as $key => $val ) {
    4150         if ( 'enclosure' != $key || !is_array( $val ) )
    4151             continue;
    4152         foreach ( $val as $enc ) {
    4153             $enclosure = explode( "\n", $enc );
    4154             $pung[] = trim( $enclosure[ 0 ] );
    4155         }
    4156     }
    4157 
    4158     /**
    4159      * Filter the list of enclosures already enclosed for the given post.
    4160      *
    4161      * @since 2.0.0
    4162      *
    4163      * @param array $pung    Array of enclosures for the given post.
    4164      * @param int   $post_id Post ID.
    4165      */
    4166     return apply_filters( 'get_enclosed', $pung, $post_id );
    4167 }
    4168 
    4169 /**
    4170  * Retrieve URLs already pinged for a post.
    4171  *
    4172  * @since 1.5.0
    4173  *
    4174  * @global wpdb $wpdb WordPress database abstraction object.
    4175  *
    4176  * @param int $post_id Post ID.
    4177  * @return array
    4178  */
    4179 function get_pung( $post_id ) {
    4180     global $wpdb;
    4181     $pung = $wpdb->get_var( $wpdb->prepare( "SELECT pinged FROM $wpdb->posts WHERE ID = %d", $post_id ));
    4182     $pung = trim($pung);
    4183     $pung = preg_split('/\s/', $pung);
    4184 
    4185     /**
    4186      * Filter the list of already-pinged URLs for the given post.
    4187      *
    4188      * @since 2.0.0
    4189      *
    4190      * @param array $pung Array of URLs already pinged for the given post.
    4191      */
    4192     return apply_filters( 'get_pung', $pung );
    4193 }
    4194 
    4195 /**
    4196  * Retrieve URLs that need to be pinged.
    4197  *
    4198  * @since 1.5.0
    4199  *
    4200  * @global wpdb $wpdb WordPress database abstraction object.
    4201  *
    4202  * @param int $post_id Post ID
    4203  * @return array
    4204  */
    4205 function get_to_ping( $post_id ) {
    4206     global $wpdb;
    4207     $to_ping = $wpdb->get_var( $wpdb->prepare( "SELECT to_ping FROM $wpdb->posts WHERE ID = %d", $post_id ));
    4208     $to_ping = sanitize_trackback_urls( $to_ping );
    4209     $to_ping = preg_split('/\s/', $to_ping, -1, PREG_SPLIT_NO_EMPTY);
    4210 
    4211     /**
    4212      * Filter the list of URLs yet to ping for the given post.
    4213      *
    4214      * @since 2.0.0
    4215      *
    4216      * @param array $to_ping List of URLs yet to ping.
    4217      */
    4218     return apply_filters( 'get_to_ping', $to_ping );
    4219 }
    4220 
    4221 /**
    4222  * Do trackbacks for a list of URLs.
    4223  *
    4224  * @since 1.0.0
    4225  *
    4226  * @param string $tb_list Comma separated list of URLs.
    4227  * @param int    $post_id Post ID.
    4228  */
    4229 function trackback_url_list( $tb_list, $post_id ) {
    4230     if ( ! empty( $tb_list ) ) {
    4231         // Get post data.
    4232         $postdata = get_post( $post_id, ARRAY_A );
    4233 
    4234         // Form an excerpt.
    4235         $excerpt = strip_tags( $postdata['post_excerpt'] ? $postdata['post_excerpt'] : $postdata['post_content'] );
    4236 
    4237         if ( strlen( $excerpt ) > 255 ) {
    4238             $excerpt = substr( $excerpt, 0, 252 ) . '&hellip;';
    4239         }
    4240 
    4241         $trackback_urls = explode( ',', $tb_list );
    4242         foreach ( (array) $trackback_urls as $tb_url ) {
    4243             $tb_url = trim( $tb_url );
    4244             trackback( $tb_url, wp_unslash( $postdata['post_title'] ), $excerpt, $post_id );
    4245         }
    4246     }
    4247 }
    4248 
    4249 //
    4250 // Page functions
    4251 //
    4252 
    4253 /**
    4254  * Get a list of page IDs.
    4255  *
    4256  * @since 2.0.0
    4257  *
    4258  * @global wpdb $wpdb WordPress database abstraction object.
    4259  *
    4260  * @return array List of page IDs.
    4261  */
    4262 function get_all_page_ids() {
    4263     global $wpdb;
    4264 
    4265     $page_ids = wp_cache_get('all_page_ids', 'posts');
    4266     if ( ! is_array( $page_ids ) ) {
    4267         $page_ids = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE post_type = 'page'");
    4268         wp_cache_add('all_page_ids', $page_ids, 'posts');
    4269     }
    4270 
    4271     return $page_ids;
    4272 }
    4273 
    4274 /**
    4275  * Retrieves page data given a page ID or page object.
    4276  *
    4277  * Use get_post() instead of get_page().
    4278  *
    4279  * @since 1.5.1
    4280  * @deprecated 3.5.0 Use get_post()
    4281  *
    4282  * @param mixed  $page   Page object or page ID. Passed by reference.
    4283  * @param string $output Optional. What to output. Accepts OBJECT, ARRAY_A, or ARRAY_N.
    4284  *                       Default OBJECT.
    4285  * @param string $filter Optional. How the return value should be filtered. Accepts 'raw',
    4286  *                       'edit', 'db', 'display'. Default 'raw'.
    4287  * @return WP_Post|array|null WP_Post on success or null on failure.
    4288  */
    4289 function get_page( $page, $output = OBJECT, $filter = 'raw') {
    4290     return get_post( $page, $output, $filter );
    4291 }
    4292 
    4293 /**
    4294  * Retrieves a page given its path.
    4295  *
    4296  * @since 2.1.0
    4297  *
    4298  * @global wpdb $wpdb WordPress database abstraction object.
    4299  *
    4300  * @param string       $page_path Page path.
    4301  * @param string       $output    Optional. Output type. Accepts OBJECT, ARRAY_N, or ARRAY_A.
    4302  *                                Default OBJECT.
    4303  * @param string|array $post_type Optional. Post type or array of post types. Default 'page'.
    4304  * @return WP_Post|array|void WP_Post on success.
    4305  */
    4306 function get_page_by_path( $page_path, $output = OBJECT, $post_type = 'page' ) {
    4307     global $wpdb;
    4308 
    4309     $page_path = rawurlencode(urldecode($page_path));
    4310     $page_path = str_replace('%2F', '/', $page_path);
    4311     $page_path = str_replace('%20', ' ', $page_path);
    4312     $parts = explode( '/', trim( $page_path, '/' ) );
    4313     $parts = esc_sql( $parts );
    4314     $parts = array_map( 'sanitize_title_for_query', $parts );
    4315 
    4316     $in_string = "'" . implode( "','", $parts ) . "'";
    4317 
    4318     if ( is_array( $post_type ) ) {
    4319         $post_types = $post_type;
    4320     } else {
    4321         $post_types = array( $post_type, 'attachment' );
    4322     }
    4323 
    4324     $post_types = esc_sql( $post_types );
    4325     $post_type_in_string = "'" . implode( "','", $post_types ) . "'";
    4326     $sql = "
    4327         SELECT ID, post_name, post_parent, post_type
    4328         FROM $wpdb->posts
    4329         WHERE post_name IN ($in_string)
    4330         AND post_type IN ($post_type_in_string)
    4331     ";
    4332 
    4333     $pages = $wpdb->get_results( $sql, OBJECT_K );
    4334 
    4335     $revparts = array_reverse( $parts );
    4336 
    4337     $foundid = 0;
    4338     foreach ( (array) $pages as $page ) {
    4339         if ( $page->post_name == $revparts[0] ) {
    4340             $count = 0;
    4341             $p = $page;
    4342             while ( $p->post_parent != 0 && isset( $pages[ $p->post_parent ] ) ) {
    4343                 $count++;
    4344                 $parent = $pages[ $p->post_parent ];
    4345                 if ( ! isset( $revparts[ $count ] ) || $parent->post_name != $revparts[ $count ] )
    4346                     break;
    4347                 $p = $parent;
    4348             }
    4349 
    4350             if ( $p->post_parent == 0 && $count+1 == count( $revparts ) && $p->post_name == $revparts[ $count ] ) {
    4351                 $foundid = $page->ID;
    4352                 if ( $page->post_type == $post_type )
    4353                     break;
    4354             }
    4355         }
    4356     }
    4357 
    4358     if ( $foundid ) {
    4359         return get_post( $foundid, $output );
    4360     }
    4361 }
    4362 
    4363 /**
    4364  * Retrieve a page given its title.
    4365  *
    4366  * @since 2.1.0
    4367  *
    4368  * @global wpdb $wpdb WordPress database abstraction object.
    4369  *
    4370  * @param string       $page_title Page title
    4371  * @param string       $output     Optional. Output type. OBJECT, ARRAY_N, or ARRAY_A.
    4372  *                                 Default OBJECT.
    4373  * @param string|array $post_type  Optional. Post type or array of post types. Default 'page'.
    4374  * @return WP_Post|array|void WP_Post on success or null on failure
    4375  */
    4376 function get_page_by_title( $page_title, $output = OBJECT, $post_type = 'page' ) {
    4377     global $wpdb;
    4378 
    4379     if ( is_array( $post_type ) ) {
    4380         $post_type = esc_sql( $post_type );
    4381         $post_type_in_string = "'" . implode( "','", $post_type ) . "'";
    4382         $sql = $wpdb->prepare( "
    4383             SELECT ID
    4384             FROM $wpdb->posts
    4385             WHERE post_title = %s
    4386             AND post_type IN ($post_type_in_string)
    4387         ", $page_title );
    4388     } else {
    4389         $sql = $wpdb->prepare( "
    4390             SELECT ID
    4391             FROM $wpdb->posts
    4392             WHERE post_title = %s
    4393             AND post_type = %s
    4394         ", $page_title, $post_type );
    4395     }
    4396 
    4397     $page = $wpdb->get_var( $sql );
    4398 
    4399     if ( $page ) {
    4400         return get_post( $page, $output );
    4401     }
    4402 }
    4403 
    4404 /**
    4405  * Identify descendants of a given page ID in a list of page objects.
    4406  *
    4407  * Descendants are identified from the `$pages` array passed to the function. No database queries are performed.
    4408  *
    4409  * @since 1.5.1
    4410  *
    4411  * @param int   $page_id Page ID.
    4412  * @param array $pages   List of page objects from which descendants should be identified.
    4413  * @return array List of page children.
    4414  */
    4415 function get_page_children( $page_id, $pages ) {
    4416     // Build a hash of ID -> children.
    4417     $children = array();
    4418     foreach ( (array) $pages as $page ) {
    4419         $children[ intval( $page->post_parent ) ][] = $page;
    4420     }
    4421 
    4422     $page_list = array();
    4423 
    4424     // Start the search by looking at immediate children.
    4425     if ( isset( $children[ $page_id ] ) ) {
    4426         // Always start at the end of the stack in order to preserve original `$pages` order.
    4427         $to_look = array_reverse( $children[ $page_id ] );
    4428 
    4429         while ( $to_look ) {
    4430             $p = array_pop( $to_look );
    4431             $page_list[] = $p;
    4432             if ( isset( $children[ $p->ID ] ) ) {
    4433                 foreach ( array_reverse( $children[ $p->ID ] ) as $child ) {
    4434                     // Append to the `$to_look` stack to descend the tree.
    4435                     $to_look[] = $child;
    4436                 }
    4437             }
    4438         }
    4439     }
    4440 
    4441     return $page_list;
    4442 }
    4443 
    4444 /**
    4445  * Order the pages with children under parents in a flat list.
    4446  *
    4447  * It uses auxiliary structure to hold parent-children relationships and
    4448  * runs in O(N) complexity
    4449  *
    4450  * @since 2.0.0
    4451  *
    4452  * @param array $pages   Posts array, passed by reference.
    4453  * @param int   $page_id Optional. Parent page ID. Default 0.
    4454  * @return array A list arranged by hierarchy. Children immediately follow their parents.
    4455  */
    4456 function get_page_hierarchy( &$pages, $page_id = 0 ) {
    4457     if ( empty( $pages ) ) {
    4458         return array();
    4459     }
    4460 
    4461     $children = array();
    4462     foreach ( (array) $pages as $p ) {
    4463         $parent_id = intval( $p->post_parent );
    4464         $children[ $parent_id ][] = $p;
    4465     }
    4466 
    4467     $result = array();
    4468     _page_traverse_name( $page_id, $children, $result );
    4469 
    4470     return $result;
    4471 }
    4472 
    4473 /**
    4474  * Traverse and return all the nested children post names of a root page.
    4475  *
    4476  * $children contains parent-children relations
    4477  *
    4478  * @since 2.9.0
    4479  *
    4480  * @see _page_traverse_name()
    4481  *
    4482  * @param int   $page_id   Page ID.
    4483  * @param array &$children Parent-children relations, passed by reference.
    4484  * @param array &$result   Result, passed by reference.
    4485  */
    4486 function _page_traverse_name( $page_id, &$children, &$result ){
    4487     if ( isset( $children[ $page_id ] ) ){
    4488         foreach ( (array)$children[ $page_id ] as $child ) {
    4489             $result[ $child->ID ] = $child->post_name;
    4490             _page_traverse_name( $child->ID, $children, $result );
    4491         }
    4492     }
    4493 }
    4494 
    4495 /**
    4496  * Build URI for a page.
    4497  *
    4498  * Sub pages will be in the "directory" under the parent page post name.
    4499  *
    4500  * @since 1.5.0
    4501  *
    4502  * @param WP_Post|object|int $page Page object or page ID.
    4503  * @return string|false Page URI, false on error.
    4504  */
    4505 function get_page_uri( $page ) {
    4506     $page = get_post( $page );
    4507 
    4508     if ( ! $page )
    4509         return false;
    4510 
    4511     $uri = $page->post_name;
    4512 
    4513     foreach ( $page->ancestors as $parent ) {
    4514         $uri = get_post( $parent )->post_name . '/' . $uri;
    4515     }
    4516 
    4517     return $uri;
    4518 }
    4519 
    4520 /**
    4521  * Retrieve a list of pages.
    4522  *
    4523  * @global wpdb $wpdb WordPress database abstraction object.
    4524  *
    4525  * @since 1.5.0
    4526  *
    4527  * @param array|string $args {
    4528  *     Optional. Array or string of arguments to retrieve pages.
    4529  *
    4530  *     @type int          $child_of     Page ID to return child and grandchild pages of.
    4531  *                                      Default 0, or no restriction.
    4532  *     @type string       $sort_order   How to sort retrieved pages. Accepts 'ASC', 'DESC'. Default 'ASC'.
    4533  *     @type string       $sort_column  What columns to sort pages by, comma-separated. Accepts 'post_author',
    4534  *                                      'post_date', 'post_title', 'post_name', 'post_modified', 'menu_order',
    4535  *                                      'post_modified_gmt', 'post_parent', 'ID', 'rand', 'comment_count'.
    4536  *                                      'post_' can be omitted for any values that start with it.
    4537  *                                      Default 'post_title'.
    4538  *     @type bool         $hierarchical Whether to return pages hierarchically. Default true.
    4539  *     @type array        $exclude      Array of page IDs to exclude. Default empty array.
    4540  *     @type array        $include      Array of page IDs to include. Cannot be used with `$child_of`,
    4541  *                                      `$parent`, `$exclude`, `$meta_key`, `$meta_value`, or `$hierarchical`.
    4542  *                                      Default empty array.
    4543  *     @type string       $meta_key     Only include pages with this meta key. Default empty.
    4544  *     @type string       $meta_value   Only include pages with this meta value. Requires `$meta_key`.
    4545  *                                      Default empty.
    4546  *     @type string       $authors      A comma-separated list of author IDs. Default empty.
    4547  *     @type int          $parent       Page ID to return direct children of. `$hierarchical` must be false.
    4548  *                                      Default -1, or no restriction.
    4549  *     @type string|array $exclude_tree Comma-separated string or array of page IDs to exclude.
    4550  *                                      Default empty array.
    4551  *     @type int          $number       The number of pages to return. Default 0, or all pages.
    4552  *     @type int          $offset       The number of pages to skip before returning. Requires `$number`.
    4553  *                                      Default 0.
    4554  *     @type string       $post_type    The post type to query. Default 'page'.
    4555  *     @type string       $post_status  A comma-separated list of post status types to include.
    4556  *                                      Default 'publish'.
    4557  * }
    4558  * @return array|false List of pages matching defaults or `$args`.
    4559  */
    4560 function get_pages( $args = array() ) {
    4561     global $wpdb;
    4562 
    4563     $defaults = array(
    4564         'child_of' => 0, 'sort_order' => 'ASC',
    4565         'sort_column' => 'post_title', 'hierarchical' => 1,
    4566         'exclude' => array(), 'include' => array(),
    4567         'meta_key' => '', 'meta_value' => '',
    4568         'authors' => '', 'parent' => -1, 'exclude_tree' => array(),
    4569         'number' => '', 'offset' => 0,
    4570         'post_type' => 'page', 'post_status' => 'publish',
    4571     );
    4572 
    4573     $r = wp_parse_args( $args, $defaults );
    4574 
    4575     $number = (int) $r['number'];
    4576     $offset = (int) $r['offset'];
    4577     $child_of = (int) $r['child_of'];
    4578     $hierarchical = $r['hierarchical'];
    4579     $exclude = $r['exclude'];
    4580     $meta_key = $r['meta_key'];
    4581     $meta_value = $r['meta_value'];
    4582     $parent = $r['parent'];
    4583     $post_status = $r['post_status'];
    4584 
    4585     // Make sure the post type is hierarchical.
    4586     $hierarchical_post_types = get_post_types( array( 'hierarchical' => true ) );
    4587     if ( ! in_array( $r['post_type'], $hierarchical_post_types ) ) {
    4588         return false;
    4589     }
    4590 
    4591     if ( $parent > 0 && ! $child_of ) {
    4592         $hierarchical = false;
    4593     }
    4594 
    4595     // Make sure we have a valid post status.
    4596     if ( ! is_array( $post_status ) ) {
    4597         $post_status = explode( ',', $post_status );
    4598     }
    4599     if ( array_diff( $post_status, get_post_stati() ) ) {
    4600         return false;
    4601     }
    4602 
    4603     // $args can be whatever, only use the args defined in defaults to compute the key.
    4604     $key = md5( serialize( wp_array_slice_assoc( $r, array_keys( $defaults ) ) ) );
    4605     $last_changed = wp_cache_get( 'last_changed', 'posts' );
    4606     if ( ! $last_changed ) {
    4607         $last_changed = microtime();
    4608         wp_cache_set( 'last_changed', $last_changed, 'posts' );
    4609     }
    4610 
    4611     $cache_key = "get_pages:$key:$last_changed";
    4612     if ( $cache = wp_cache_get( $cache_key, 'posts' ) ) {
    4613         // Convert to WP_Post instances.
    4614         $pages = array_map( 'get_post', $cache );
    4615         /** This filter is documented in wp-includes/post.php */
    4616         $pages = apply_filters( 'get_pages', $pages, $r );
    4617         return $pages;
    4618     }
    4619 
    4620     $inclusions = '';
    4621     if ( ! empty( $r['include'] ) ) {
    4622         $child_of = 0; //ignore child_of, parent, exclude, meta_key, and meta_value params if using include
    4623         $parent = -1;
    4624         $exclude = '';
    4625         $meta_key = '';
    4626         $meta_value = '';
    4627         $hierarchical = false;
    4628         $incpages = wp_parse_id_list( $r['include'] );
    4629         if ( ! empty( $incpages ) ) {
    4630             $inclusions = ' AND ID IN (' . implode( ',', $incpages ) .  ')';
    4631         }
    4632     }
    4633 
    4634     $exclusions = '';
    4635     if ( ! empty( $exclude ) ) {
    4636         $expages = wp_parse_id_list( $exclude );
    4637         if ( ! empty( $expages ) ) {
    4638             $exclusions = ' AND ID NOT IN (' . implode( ',', $expages ) .  ')';
    4639         }
    4640     }
    4641 
    4642     $author_query = '';
    4643     if ( ! empty( $r['authors'] ) ) {
    4644         $post_authors = preg_split( '/[\s,]+/', $r['authors'] );
    4645 
    4646         if ( ! empty( $post_authors ) ) {
    4647             foreach ( $post_authors as $post_author ) {
    4648                 //Do we have an author id or an author login?
    4649                 if ( 0 == intval($post_author) ) {
    4650                     $post_author = get_user_by('login', $post_author);
    4651                     if ( empty( $post_author ) ) {
    4652                         continue;
    4653                     }
    4654                     if ( empty( $post_author->ID ) ) {
    4655                         continue;
    4656                     }
    4657                     $post_author = $post_author->ID;
    4658                 }
    4659 
    4660                 if ( '' == $author_query ) {
    4661                     $author_query = $wpdb->prepare(' post_author = %d ', $post_author);
    4662                 } else {
    4663                     $author_query .= $wpdb->prepare(' OR post_author = %d ', $post_author);
    4664                 }
    4665             }
    4666             if ( '' != $author_query ) {
    4667                 $author_query = " AND ($author_query)";
    4668             }
    4669         }
    4670     }
    4671 
    4672     $join = '';
    4673     $where = "$exclusions $inclusions ";
    4674     if ( '' !== $meta_key || '' !== $meta_value ) {
    4675         $join = " LEFT JOIN $wpdb->postmeta ON ( $wpdb->posts.ID = $wpdb->postmeta.post_id )";
    4676 
    4677         // meta_key and meta_value might be slashed
    4678         $meta_key = wp_unslash($meta_key);
    4679         $meta_value = wp_unslash($meta_value);
    4680         if ( '' !== $meta_key ) {
    4681             $where .= $wpdb->prepare(" AND $wpdb->postmeta.meta_key = %s", $meta_key);
    4682         }
    4683         if ( '' !== $meta_value ) {
    4684             $where .= $wpdb->prepare(" AND $wpdb->postmeta.meta_value = %s", $meta_value);
    4685         }
    4686 
    4687     }
    4688 
    4689     if ( is_array( $parent ) ) {
    4690         $post_parent__in = implode( ',', array_map( 'absint', (array) $parent ) );
    4691         if ( ! empty( $post_parent__in ) ) {
    4692             $where .= " AND post_parent IN ($post_parent__in)";
    4693         }
    4694     } elseif ( $parent >= 0 ) {
    4695         $where .= $wpdb->prepare(' AND post_parent = %d ', $parent);
    4696     }
    4697 
    4698     if ( 1 == count( $post_status ) ) {
    4699         $where_post_type = $wpdb->prepare( "post_type = %s AND post_status = %s", $r['post_type'], reset( $post_status ) );
    4700     } else {
    4701         $post_status = implode( "', '", $post_status );
    4702         $where_post_type = $wpdb->prepare( "post_type = %s AND post_status IN ('$post_status')", $r['post_type'] );
    4703     }
    4704 
    4705     $orderby_array = array();
    4706     $allowed_keys = array( 'author', 'post_author', 'date', 'post_date', 'title', 'post_title', 'name', 'post_name', 'modified',
    4707         'post_modified', 'modified_gmt', 'post_modified_gmt', 'menu_order', 'parent', 'post_parent',
    4708         'ID', 'rand', 'comment_count' );
    4709 
    4710     foreach ( explode( ',', $r['sort_column'] ) as $orderby ) {
    4711         $orderby = trim( $orderby );
    4712         if ( ! in_array( $orderby, $allowed_keys ) ) {
    4713             continue;
    4714         }
    4715 
    4716         switch ( $orderby ) {
    4717             case 'menu_order':
    4718                 break;
    4719             case 'ID':
    4720                 $orderby = "$wpdb->posts.ID";
    4721                 break;
    4722             case 'rand':
    4723                 $orderby = 'RAND()';
    4724                 break;
    4725             case 'comment_count':
    4726                 $orderby = "$wpdb->posts.comment_count";
    4727                 break;
    4728             default:
    4729                 if ( 0 === strpos( $orderby, 'post_' ) ) {
    4730                     $orderby = "$wpdb->posts." . $orderby;
    4731                 } else {
    4732                     $orderby = "$wpdb->posts.post_" . $orderby;
    4733                 }
    4734         }
    4735 
    4736         $orderby_array[] = $orderby;
    4737 
    4738     }
    4739     $sort_column = ! empty( $orderby_array ) ? implode( ',', $orderby_array ) : "$wpdb->posts.post_title";
    4740 
    4741     $sort_order = strtoupper( $r['sort_order'] );
    4742     if ( '' !== $sort_order && ! in_array( $sort_order, array( 'ASC', 'DESC' ) ) ) {
    4743         $sort_order = 'ASC';
    4744     }
    4745 
    4746     $query = "SELECT * FROM $wpdb->posts $join WHERE ($where_post_type) $where ";
    4747     $query .= $author_query;
    4748     $query .= " ORDER BY " . $sort_column . " " . $sort_order ;
    4749 
    4750     if ( ! empty( $number ) ) {
    4751         $query .= ' LIMIT ' . $offset . ',' . $number;
    4752     }
    4753 
    4754     $pages = $wpdb->get_results($query);
    4755 
    4756     if ( empty($pages) ) {
    4757         /** This filter is documented in wp-includes/post.php */
    4758         $pages = apply_filters( 'get_pages', array(), $r );
    4759         return $pages;
    4760     }
    4761 
    4762     // Sanitize before caching so it'll only get done once.
    4763     $num_pages = count($pages);
    4764     for ($i = 0; $i < $num_pages; $i++) {
    4765         $pages[$i] = sanitize_post($pages[$i], 'raw');
    4766     }
    4767 
    4768     // Update cache.
    4769     update_post_cache( $pages );
    4770 
    4771     if ( $child_of || $hierarchical ) {
    4772         $pages = get_page_children($child_of, $pages);
    4773     }
    4774 
    4775     if ( ! empty( $r['exclude_tree'] ) ) {
    4776         $exclude = wp_parse_id_list( $r['exclude_tree'] );
    4777         foreach ( $exclude as $id ) {
    4778             $children = get_page_children( $id, $pages );
    4779             foreach ( $children as $child ) {
    4780                 $exclude[] = $child->ID;
    4781             }
    4782         }
    4783 
    4784         $num_pages = count( $pages );
    4785         for ( $i = 0; $i < $num_pages; $i++ ) {
    4786             if ( in_array( $pages[$i]->ID, $exclude ) ) {
    4787                 unset( $pages[$i] );
    4788             }
    4789         }
    4790     }
    4791 
    4792     $page_structure = array();
    4793     foreach ( $pages as $page ) {
    4794         $page_structure[] = $page->ID;
    4795     }
    4796 
    4797     wp_cache_set( $cache_key, $page_structure, 'posts' );
    4798 
    4799     // Convert to WP_Post instances
    4800     $pages = array_map( 'get_post', $pages );
    4801 
    4802     /**
    4803      * Filter the retrieved list of pages.
    4804      *
    4805      * @since 2.1.0
    4806      *
    4807      * @param array $pages List of pages to retrieve.
    4808      * @param array $r     Array of get_pages() arguments.
    4809      */
    4810     return apply_filters( 'get_pages', $pages, $r );
    4811 }
    4812 
    4813 //
    4814 // Attachment functions
    4815 //
    4816 
    4817 /**
    4818  * Check if the attachment URI is local one and is really an attachment.
    4819  *
    4820  * @since 2.0.0
    4821  *
    4822  * @param string $url URL to check
    4823  * @return bool True on success, false on failure.
    4824  */
    4825 function is_local_attachment($url) {
    4826     if (strpos($url, home_url()) === false)
    4827         return false;
    4828     if (strpos($url, home_url('/?attachment_id=')) !== false)
    4829         return true;
    4830     if ( $id = url_to_postid($url) ) {
    4831         $post = get_post($id);
    4832         if ( 'attachment' == $post->post_type )
    4833             return true;
    4834     }
    4835     return false;
    4836 }
    4837 
    4838 /**
    4839  * Insert an attachment.
    4840  *
    4841  * If you set the 'ID' in the $args parameter, it will mean that you are
    4842  * updating and attempt to update the attachment. You can also set the
    4843  * attachment name or title by setting the key 'post_name' or 'post_title'.
    4844  *
    4845  * You can set the dates for the attachment manually by setting the 'post_date'
    4846  * and 'post_date_gmt' keys' values.
    4847  *
    4848  * By default, the comments will use the default settings for whether the
    4849  * comments are allowed. You can close them manually or keep them open by
    4850  * setting the value for the 'comment_status' key.
    4851  *
    4852  * @since 2.0.0
    4853  *
    4854  * @see wp_insert_post()
    4855  *
    4856  * @param string|array $args   Arguments for inserting an attachment.
    4857  * @param string       $file   Optional. Filename.
    4858  * @param int          $parent Optional. Parent post ID.
    4859  * @return int Attachment ID.
    4860  */
    4861 function wp_insert_attachment( $args, $file = false, $parent = 0 ) {
    4862     $defaults = array(
    4863         'file'        => $file,
    4864         'post_parent' => 0
    4865     );
    4866 
    4867     $data = wp_parse_args( $args, $defaults );
    4868 
    4869     if ( ! empty( $parent ) ) {
    4870         $data['post_parent'] = $parent;
    4871     }
    4872 
    4873     $data['post_type'] = 'attachment';
    4874 
    4875     return wp_insert_post( $data );
    4876 }
    4877 
    4878 /**
    4879  * Trash or delete an attachment.
    4880  *
    4881  * When an attachment is permanently deleted, the file will also be removed.
    4882  * Deletion removes all post meta fields, taxonomy, comments, etc. associated
    4883  * with the attachment (except the main post).
    4884  *
    4885  * The attachment is moved to the trash instead of permanently deleted unless trash
    4886  * for media is disabled, item is already in the trash, or $force_delete is true.
    4887  *
    4888  * @since 2.0.0
    4889  *
    4890  * @global wpdb $wpdb WordPress database abstraction object.
    4891  *
    4892  * @param int  $post_id      Attachment ID.
    4893  * @param bool $force_delete Optional. Whether to bypass trash and force deletion.
    4894  *                           Default false.
    4895  * @return mixed False on failure. Post data on success.
    4896  */
    4897 function wp_delete_attachment( $post_id, $force_delete = false ) {
    4898     global $wpdb;
    4899 
    4900     if ( !$post = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->posts WHERE ID = %d", $post_id) ) )
    4901         return $post;
    4902 
    4903     if ( 'attachment' != $post->post_type )
    4904         return false;
    4905 
    4906     if ( !$force_delete && EMPTY_TRASH_DAYS && MEDIA_TRASH && 'trash' != $post->post_status )
    4907         return wp_trash_post( $post_id );
    4908 
    4909     delete_post_meta($post_id, '_wp_trash_meta_status');
    4910     delete_post_meta($post_id, '_wp_trash_meta_time');
    4911 
    4912     $meta = wp_get_attachment_metadata( $post_id );
    4913     $backup_sizes = get_post_meta( $post->ID, '_wp_attachment_backup_sizes', true );
    4914     $file = get_attached_file( $post_id );
    4915 
    4916     if ( is_multisite() )
    4917         delete_transient( 'dirsize_cache' );
    4918 
    4919     /**
    4920      * Fires before an attachment is deleted, at the start of wp_delete_attachment().
    4921      *
    4922      * @since 2.0.0
    4923      *
    4924      * @param int $post_id Attachment ID.
    4925      */
    4926     do_action( 'delete_attachment', $post_id );
    4927 
    4928     wp_delete_object_term_relationships($post_id, array('category', 'post_tag'));
    4929     wp_delete_object_term_relationships($post_id, get_object_taxonomies($post->post_type));
    4930 
    4931     // Delete all for any posts.
    4932     delete_metadata( 'post', null, '_thumbnail_id', $post_id, true );
    4933 
    4934     $comment_ids = $wpdb->get_col( $wpdb->prepare( "SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d", $post_id ));
    4935     foreach ( $comment_ids as $comment_id )
    4936         wp_delete_comment( $comment_id, true );
    4937 
    4938     $post_meta_ids = $wpdb->get_col( $wpdb->prepare( "SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d ", $post_id ));
    4939     foreach ( $post_meta_ids as $mid )
    4940         delete_metadata_by_mid( 'post', $mid );
    4941 
    4942     /** This action is documented in wp-includes/post.php */
    4943     do_action( 'delete_post', $post_id );
    4944     $result = $wpdb->delete( $wpdb->posts, array( 'ID' => $post_id ) );
    4945     if ( ! $result ) {
    4946         return false;
    4947     }
    4948     /** This action is documented in wp-includes/post.php */
    4949     do_action( 'deleted_post', $post_id );
    4950 
    4951     $uploadpath = wp_upload_dir();
    4952 
    4953     if ( ! empty($meta['thumb']) ) {
    4954         // Don't delete the thumb if another attachment uses it.
    4955         if (! $wpdb->get_row( $wpdb->prepare( "SELECT meta_id FROM $wpdb->postmeta WHERE meta_key = '_wp_attachment_metadata' AND meta_value LIKE %s AND post_id <> %d", '%' . $wpdb->esc_like( $meta['thumb'] ) . '%', $post_id)) ) {
    4956             $thumbfile = str_replace(basename($file), $meta['thumb'], $file);
    4957             /** This filter is documented in wp-includes/functions.php */
    4958             $thumbfile = apply_filters( 'wp_delete_file', $thumbfile );
    4959             @ unlink( path_join($uploadpath['basedir'], $thumbfile) );
    4960         }
    4961     }
    4962 
    4963     // Remove intermediate and backup images if there are any.
    4964     if ( isset( $meta['sizes'] ) && is_array( $meta['sizes'] ) ) {
    4965         foreach ( $meta['sizes'] as $size => $sizeinfo ) {
    4966             $intermediate_file = str_replace( basename( $file ), $sizeinfo['file'], $file );
    4967             /** This filter is documented in wp-includes/functions.php */
    4968             $intermediate_file = apply_filters( 'wp_delete_file', $intermediate_file );
    4969             @ unlink( path_join( $uploadpath['basedir'], $intermediate_file ) );
    4970         }
    4971     }
    4972 
    4973     if ( is_array($backup_sizes) ) {
    4974         foreach ( $backup_sizes as $size ) {
    4975             $del_file = path_join( dirname($meta['file']), $size['file'] );
    4976             /** This filter is documented in wp-includes/functions.php */
    4977             $del_file = apply_filters( 'wp_delete_file', $del_file );
    4978             @ unlink( path_join($uploadpath['basedir'], $del_file) );
    4979         }
    4980     }
    4981 
    4982     wp_delete_file( $file );
    4983 
    4984     clean_post_cache( $post );
    4985 
    4986     return $post;
    4987 }
    4988 
    4989 /**
    4990  * Retrieve attachment meta field for attachment ID.
    4991  *
    4992  * @since 2.1.0
    4993  *
    4994  * @param int  $post_id    Attachment ID. Default 0.
    4995  * @param bool $unfiltered Optional. If true, filters are not run. Default false.
    4996  * @return mixed Attachment meta field. False on failure.
    4997  */
    4998 function wp_get_attachment_metadata( $post_id = 0, $unfiltered = false ) {
    4999     $post_id = (int) $post_id;
    5000     if ( !$post = get_post( $post_id ) )
    5001         return false;
    5002 
    5003     $data = get_post_meta( $post->ID, '_wp_attachment_metadata', true );
    5004 
    5005     if ( $unfiltered )
    5006         return $data;
    5007 
    5008     /**
    5009      * Filter the attachment meta data.
    5010      *
    5011      * @since 2.1.0
    5012      *
    5013      * @param array|bool $data    Array of meta data for the given attachment, or false
    5014      *                            if the object does not exist.
    5015      * @param int        $post_id Attachment ID.
    5016      */
    5017     return apply_filters( 'wp_get_attachment_metadata', $data, $post->ID );
    5018 }
    5019 
    5020 /**
    5021  * Update metadata for an attachment.
    5022  *
    5023  * @since 2.1.0
    5024  *
    5025  * @param int   $post_id Attachment ID.
    5026  * @param array $data    Attachment data.
    5027  * @return int|bool False if $post is invalid.
    5028  */
    5029 function wp_update_attachment_metadata( $post_id, $data ) {
    5030     $post_id = (int) $post_id;
    5031     if ( !$post = get_post( $post_id ) )
    5032         return false;
    5033 
    5034     /**
    5035      * Filter the updated attachment meta data.
    5036      *
    5037      * @since 2.1.0
    5038      *
    5039      * @param array $data    Array of updated attachment meta data.
    5040      * @param int   $post_id Attachment ID.
    5041      */
    5042     if ( $data = apply_filters( 'wp_update_attachment_metadata', $data, $post->ID ) )
    5043         return update_post_meta( $post->ID, '_wp_attachment_metadata', $data );
    5044     else
    5045         return delete_post_meta( $post->ID, '_wp_attachment_metadata' );
    5046 }
    5047 
    5048 /**
    5049  * Retrieve the URL for an attachment.
    5050  *
    5051  * @since 2.1.0
    5052  *
    5053  * @global string $pagenow
    5054  *
    5055  * @param int $post_id Optional. Attachment ID. Default 0.
    5056  * @return string|false Attachment URL, otherwise false.
    5057  */
    5058 function wp_get_attachment_url( $post_id = 0 ) {
    5059     $post_id = (int) $post_id;
    5060     if ( !$post = get_post( $post_id ) )
    5061         return false;
    5062 
    5063     if ( 'attachment' != $post->post_type )
    5064         return false;
    5065 
    5066     $url = '';
    5067     // Get attached file.
    5068     if ( $file = get_post_meta( $post->ID, '_wp_attached_file', true) ) {
    5069         // Get upload directory.
    5070         if ( ($uploads = wp_upload_dir()) && false === $uploads['error'] ) {
    5071             // Check that the upload base exists in the file location.
    5072             if ( 0 === strpos( $file, $uploads['basedir'] ) ) {
    5073                 // Replace file location with url location.
    5074                 $url = str_replace($uploads['basedir'], $uploads['baseurl'], $file);
    5075             } elseif ( false !== strpos($file, 'wp-content/uploads') ) {
    5076                 $url = $uploads['baseurl'] . substr( $file, strpos($file, 'wp-content/uploads') + 18 );
    5077             } else {
    5078                 // It's a newly-uploaded file, therefore $file is relative to the basedir.
    5079                 $url = $uploads['baseurl'] . "/$file";
    5080             }
    5081         }
    5082     }
    5083 
    5084     /*
    5085      * If any of the above options failed, Fallback on the GUID as used pre-2.7,
    5086      * not recommended to rely upon this.
    5087      */
    5088     if ( empty($url) ) {
    5089         $url = get_the_guid( $post->ID );
    5090     }
    5091 
    5092     // On SSL front-end, URLs should be HTTPS.
    5093     if ( is_ssl() && ! is_admin() && 'wp-login.php' !== $GLOBALS['pagenow'] ) {
    5094         $url = set_url_scheme( $url );
    5095     }
    5096 
    5097     /**
    5098      * Filter the attachment URL.
    5099      *
    5100      * @since 2.1.0
    5101      *
    5102      * @param string $url     URL for the given attachment.
    5103      * @param int    $post_id Attachment ID.
    5104      */
    5105     $url = apply_filters( 'wp_get_attachment_url', $url, $post->ID );
    5106 
    5107     if ( empty( $url ) )
    5108         return false;
    5109 
    5110     return $url;
    5111 }
    5112 
    5113 /**
    5114  * Retrieve thumbnail for an attachment.
    5115  *
    5116  * @since 2.1.0
    5117  *
    5118  * @param int $post_id Optional. Attachment ID. Default 0.
    5119  * @return string|false False on failure. Thumbnail file path on success.
    5120  */
    5121 function wp_get_attachment_thumb_file( $post_id = 0 ) {
    5122     $post_id = (int) $post_id;
    5123     if ( !$post = get_post( $post_id ) )
    5124         return false;
    5125     if ( !is_array( $imagedata = wp_get_attachment_metadata( $post->ID ) ) )
    5126         return false;
    5127 
    5128     $file = get_attached_file( $post->ID );
    5129 
    5130     if ( !empty($imagedata['thumb']) && ($thumbfile = str_replace(basename($file), $imagedata['thumb'], $file)) && file_exists($thumbfile) ) {
    5131         /**
    5132          * Filter the attachment thumbnail file path.
    5133          *
    5134          * @since 2.1.0
    5135          *
    5136          * @param string $thumbfile File path to the attachment thumbnail.
    5137          * @param int    $post_id   Attachment ID.
    5138          */
    5139         return apply_filters( 'wp_get_attachment_thumb_file', $thumbfile, $post->ID );
    5140     }
    5141     return false;
    5142 }
    5143 
    5144 /**
    5145  * Retrieve URL for an attachment thumbnail.
    5146  *
    5147  * @since 2.1.0
    5148  *
    5149  * @param int $post_id Optional. Attachment ID. Default 0.
    5150  * @return string|false False on failure. Thumbnail URL on success.
    5151  */
    5152 function wp_get_attachment_thumb_url( $post_id = 0 ) {
    5153     $post_id = (int) $post_id;
    5154     if ( !$post = get_post( $post_id ) )
    5155         return false;
    5156     if ( !$url = wp_get_attachment_url( $post->ID ) )
    5157         return false;
    5158 
    5159     $sized = image_downsize( $post_id, 'thumbnail' );
    5160     if ( $sized )
    5161         return $sized[0];
    5162 
    5163     if ( !$thumb = wp_get_attachment_thumb_file( $post->ID ) )
    5164         return false;
    5165 
    5166     $url = str_replace(basename($url), basename($thumb), $url);
    5167 
    5168     /**
    5169      * Filter the attachment thumbnail URL.
    5170      *
    5171      * @since 2.1.0
    5172      *
    5173      * @param string $url     URL for the attachment thumbnail.
    5174      * @param int    $post_id Attachment ID.
    5175      */
    5176     return apply_filters( 'wp_get_attachment_thumb_url', $url, $post->ID );
    5177 }
    5178 
    5179 /**
    5180  * Verifies an attachment is of a given type.
    5181  *
    5182  * @since 4.2.0
    5183  *
    5184  * @param string      $type    Attachment type. Accepts 'image', 'audio', or 'video'.
    5185  * @param int|WP_Post $post_id Optional. Attachment ID. Default 0.
    5186  * @return bool True if one of the accepted types, false otherwise.
    5187  */
    5188 function wp_attachment_is( $type, $post_id = 0 ) {
    5189     if ( ! $post = get_post( $post_id ) ) {
    5190         return false;
    5191     }
    5192 
    5193     if ( ! $file = get_attached_file( $post->ID ) ) {
    5194         return false;
    5195     }
    5196 
    5197     if ( 0 === strpos( $post->post_mime_type, $type . '/' ) ) {
    5198         return true;
    5199     }
    5200 
    5201     $check = wp_check_filetype( $file );
    5202     if ( empty( $check['ext'] ) ) {
    5203         return false;
    5204     }
    5205 
    5206     $ext = $check['ext'];
    5207 
    5208     if ( 'import' !== $post->post_mime_type ) {
    5209         return $type === $ext;
    5210     }
    5211 
    5212     switch ( $type ) {
    5213     case 'image':
    5214         $image_exts = array( 'jpg', 'jpeg', 'jpe', 'gif', 'png' );
    5215         return in_array( $ext, $image_exts );
    5216 
    5217     case 'audio':
    5218         return in_array( $ext, wp_get_audio_extensions() );
    5219 
    5220     case 'video':
    5221         return in_array( $ext, wp_get_video_extensions() );
    5222 
    5223     default:
    5224         return $type === $ext;
    5225     }
    5226 }
    5227 
    5228 /**
    5229  * Checks if the attachment is an image.
    5230  *
    5231  * @since 2.1.0
    5232  * @since 4.2.0 Modified into wrapper for wp_attachment_is() and
    5233  *              allowed WP_Post object to be passed.
    5234  *
    5235  * @param int|WP_Post $post Optional. Attachment ID. Default 0.
    5236  * @return bool Whether the attachment is an image.
    5237  */
    5238 function wp_attachment_is_image( $post = 0 ) {
    5239     return wp_attachment_is( 'image', $post );
    5240 }
    5241 
    5242 /**
    5243  * Retrieve the icon for a MIME type.
    5244  *
    5245  * @since 2.1.0
    5246  *
    5247  * @param string|int $mime MIME type or attachment ID.
    5248  * @return string|false Icon, false otherwise.
    5249  */
    5250 function wp_mime_type_icon( $mime = 0 ) {
    5251     if ( !is_numeric($mime) )
    5252         $icon = wp_cache_get("mime_type_icon_$mime");
    5253 
    5254     $post_id = 0;
    5255     if ( empty($icon) ) {
    5256         $post_mimes = array();
    5257         if ( is_numeric($mime) ) {
    5258             $mime = (int) $mime;
    5259             if ( $post = get_post( $mime ) ) {
    5260                 $post_id = (int) $post->ID;
    5261                 $ext = preg_replace('/^.+?\.([^.]+)$/', '$1', $post->guid);
    5262                 if ( !empty($ext) ) {
    5263                     $post_mimes[] = $ext;
    5264                     if ( $ext_type = wp_ext2type( $ext ) )
    5265                         $post_mimes[] = $ext_type;
    5266                 }
    5267                 $mime = $post->post_mime_type;
    5268             } else {
    5269                 $mime = 0;
    5270             }
    5271         } else {
    5272             $post_mimes[] = $mime;
    5273         }
    5274 
    5275         $icon_files = wp_cache_get('icon_files');
    5276 
    5277         if ( !is_array($icon_files) ) {
    5278             /**
    5279              * Filter the icon directory path.
    5280              *
    5281              * @since 2.0.0
    5282              *
    5283              * @param string $path Icon directory absolute path.
    5284              */
    5285             $icon_dir = apply_filters( 'icon_dir', ABSPATH . WPINC . '/images/media' );
    5286 
    5287             /**
    5288              * Filter the icon directory URI.
    5289              *
    5290              * @since 2.0.0
    5291              *
    5292              * @param string $uri Icon directory URI.
    5293              */
    5294             $icon_dir_uri = apply_filters( 'icon_dir_uri', includes_url( 'images/media' ) );
    5295 
    5296             /**
    5297              * Filter the list of icon directory URIs.
    5298              *
    5299              * @since 2.5.0
    5300              *
    5301              * @param array $uris List of icon directory URIs.
    5302              */
    5303             $dirs = apply_filters( 'icon_dirs', array( $icon_dir => $icon_dir_uri ) );
    5304             $icon_files = array();
    5305             while ( $dirs ) {
    5306                 $keys = array_keys( $dirs );
    5307                 $dir = array_shift( $keys );
    5308                 $uri = array_shift($dirs);
    5309                 if ( $dh = opendir($dir) ) {
    5310                     while ( false !== $file = readdir($dh) ) {
    5311                         $file = basename($file);
    5312                         if ( substr($file, 0, 1) == '.' )
    5313                             continue;
    5314                         if ( !in_array(strtolower(substr($file, -4)), array('.png', '.gif', '.jpg') ) ) {
    5315                             if ( is_dir("$dir/$file") )
    5316                                 $dirs["$dir/$file"] = "$uri/$file";
    5317                             continue;
    5318                         }
    5319                         $icon_files["$dir/$file"] = "$uri/$file";
    5320                     }
    5321                     closedir($dh);
    5322                 }
    5323             }
    5324             wp_cache_add( 'icon_files', $icon_files, 'default', 600 );
    5325         }
    5326 
    5327         $types = array();
    5328         // Icon basename - extension = MIME wildcard.
    5329         foreach ( $icon_files as $file => $uri )
    5330             $types[ preg_replace('/^([^.]*).*$/', '$1', basename($file)) ] =& $icon_files[$file];
    5331 
    5332         if ( ! empty($mime) ) {
    5333             $post_mimes[] = substr($mime, 0, strpos($mime, '/'));
    5334             $post_mimes[] = substr($mime, strpos($mime, '/') + 1);
    5335             $post_mimes[] = str_replace('/', '_', $mime);
    5336         }
    5337 
    5338         $matches = wp_match_mime_types(array_keys($types), $post_mimes);
    5339         $matches['default'] = array('default');
    5340 
    5341         foreach ( $matches as $match => $wilds ) {
    5342             if ( isset($types[$wilds[0]])) {
    5343                 $icon = $types[$wilds[0]];
    5344                 if ( !is_numeric($mime) )
    5345                     wp_cache_add("mime_type_icon_$mime", $icon);
    5346                 break;
    5347             }
    5348         }
    5349     }
    5350 
    5351     /**
    5352      * Filter the mime type icon.
    5353      *
    5354      * @since 2.1.0
    5355      *
    5356      * @param string $icon    Path to the mime type icon.
    5357      * @param string $mime    Mime type.
    5358      * @param int    $post_id Attachment ID. Will equal 0 if the function passed
    5359      *                        the mime type.
    5360      */
    5361     return apply_filters( 'wp_mime_type_icon', $icon, $mime, $post_id );
    5362 }
    5363 
    5364 /**
    5365  * Check for changed slugs for published post objects and save the old slug.
    5366  *
    5367  * The function is used when a post object of any type is updated,
    5368  * by comparing the current and previous post objects.
    5369  *
    5370  * If the slug was changed and not already part of the old slugs then it will be
    5371  * added to the post meta field ('_wp_old_slug') for storing old slugs for that
    5372  * post.
    5373  *
    5374  * The most logically usage of this function is redirecting changed post objects, so
    5375  * that those that linked to an changed post will be redirected to the new post.
    5376  *
    5377  * @since 2.1.0
    5378  *
    5379  * @param int     $post_id     Post ID.
    5380  * @param WP_Post $post        The Post Object
    5381  * @param WP_Post $post_before The Previous Post Object
    5382  */
    5383 function wp_check_for_changed_slugs( $post_id, $post, $post_before ) {
    5384     // Don't bother if it hasnt changed.
    5385     if ( $post->post_name == $post_before->post_name )
    5386         return;
    5387 
    5388     // We're only concerned with published, non-hierarchical objects.
    5389     if ( $post->post_status != 'publish' || is_post_type_hierarchical( $post->post_type ) )
    5390         return;
    5391 
    5392     $old_slugs = (array) get_post_meta($post_id, '_wp_old_slug');
    5393 
    5394     // If we haven't added this old slug before, add it now.
    5395     if ( !empty( $post_before->post_name ) && !in_array($post_before->post_name, $old_slugs) )
    5396         add_post_meta($post_id, '_wp_old_slug', $post_before->post_name);
    5397 
    5398     // If the new slug was used previously, delete it from the list.
    5399     if ( in_array($post->post_name, $old_slugs) )
    5400         delete_post_meta($post_id, '_wp_old_slug', $post->post_name);
    5401 }
    5402 
    5403 /**
    5404  * Retrieve the private post SQL based on capability.
    5405  *
    5406  * This function provides a standardized way to appropriately select on the
    5407  * post_status of a post type. The function will return a piece of SQL code
    5408  * that can be added to a WHERE clause; this SQL is constructed to allow all
    5409  * published posts, and all private posts to which the user has access.
    5410  *
    5411  * @since 2.2.0
    5412  * @since 4.3.0 Added the ability to pass an array to `$post_type`.
    5413  *
    5414  * @param string|array $post_type Single post type or an array of post types. Currently only supports 'post' or 'page'.
    5415  * @return string SQL code that can be added to a where clause.
    5416  */
    5417 function get_private_posts_cap_sql( $post_type ) {
    5418     return get_posts_by_author_sql( $post_type, false );
    5419 }
    5420 
    5421 /**
    5422  * Retrieve the post SQL based on capability, author, and type.
    5423  *
    5424  * @since 3.0.0
    5425  * @since 4.3.0 Introduced the ability to pass an array of post types to `$post_type`.
    5426  *
    5427  * @see get_private_posts_cap_sql()
    5428  *
    5429  * @global wpdb $wpdb
    5430  *
    5431  * @param array|string   $post_type   Single post type or an array of post types.
    5432  * @param bool           $full        Optional. Returns a full WHERE statement instead of just
    5433  *                                    an 'andalso' term. Default true.
    5434  * @param int            $post_author Optional. Query posts having a single author ID. Default null.
    5435  * @param bool           $public_only Optional. Only return public posts. Skips cap checks for
    5436  *                                    $current_user.  Default false.
    5437  * @return string SQL WHERE code that can be added to a query.
    5438  */
    5439 function get_posts_by_author_sql( $post_type, $full = true, $post_author = null, $public_only = false ) {
    5440     global $wpdb;
    5441 
    5442     if ( is_array( $post_type ) ) {
    5443         $post_types = $post_type;
    5444     } else {
    5445         $post_types = array( $post_type );
    5446     }
    5447 
    5448     $post_type_clauses = array();
    5449     foreach ( $post_types as $post_type ) {
    5450         $post_type_obj = get_post_type_object( $post_type );
    5451         if ( ! $post_type_obj ) {
    5452             continue;
    5453         }
    5454 
    5455         /**
    5456          * Filter the capability to read private posts for a custom post type
    5457          * when generating SQL for getting posts by author.
    5458          *
    5459          * @since 2.2.0
    5460          * @deprecated 3.2.0 The hook transitioned from "somewhat useless" to "totally useless".
    5461          *
    5462          * @param string $cap Capability.
    5463          */
    5464         if ( ! $cap = apply_filters( 'pub_priv_sql_capability', '' ) ) {
    5465             $cap = current_user_can( $post_type_obj->cap->read_private_posts );
    5466         }
    5467 
    5468         // Only need to check the cap if $public_only is false.
    5469         $post_status_sql = "post_status = 'publish'";
    5470         if ( false === $public_only ) {
    5471             if ( $cap ) {
    5472                 // Does the user have the capability to view private posts? Guess so.
    5473                 $post_status_sql .= " OR post_status = 'private'";
    5474             } elseif ( is_user_logged_in() ) {
    5475                 // Users can view their own private posts.
    5476                 $id = get_current_user_id();
    5477                 if ( null === $post_author || ! $full ) {
    5478                     $post_status_sql .= " OR post_status = 'private' AND post_author = $id";
    5479                 } elseif ( $id == (int) $post_author ) {
    5480                     $post_status_sql .= " OR post_status = 'private'";
    5481                 } // else none
    5482             } // else none
    5483         }
    5484 
    5485         $post_type_clauses[] = "( post_type = '" . $post_type . "' AND ( $post_status_sql ) )";
    5486     }
    5487 
    5488     if ( empty( $post_type_clauses ) ) {
    5489         return $full ? 'WHERE 1 = 0' : '1 = 0';
    5490     }
    5491 
    5492     $sql = '( '. implode( ' OR ', $post_type_clauses ) . ' )';
    5493 
    5494     if ( null !== $post_author ) {
    5495         $sql .= $wpdb->prepare( ' AND post_author = %d', $post_author );
    5496     }
    5497 
    5498     if ( $full ) {
    5499         $sql = 'WHERE ' . $sql;
    5500     }
    5501 
    5502     return $sql;
    5503 }
    5504 
    5505 /**
    5506  * Retrieve the date that the last post was published.
    5507  *
    5508  * The server timezone is the default and is the difference between GMT and
    5509  * server time. The 'blog' value is the date when the last post was posted. The
    5510  * 'gmt' is when the last post was posted in GMT formatted date.
    5511  *
    5512  * @since 0.71
    5513  *
    5514  * @param string $timezone The location to get the time. Accepts 'gmt', 'blog',
    5515  *                         or 'server'. Default 'server'.
    5516  * @return string The date of the last post.
    5517  */
    5518 function get_lastpostdate( $timezone = 'server' ) {
    5519     /**
    5520      * Filter the date the last post was published.
    5521      *
    5522      * @since 2.3.0
    5523      *
    5524      * @param string $date     Date the last post was published. Likely values are 'gmt',
    5525      *                         'blog', or 'server'.
    5526      * @param string $timezone Location to use for getting the post published date.
    5527      */
    5528     return apply_filters( 'get_lastpostdate', _get_last_post_time( $timezone, 'date' ), $timezone );
    5529 }
    5530 
    5531 /**
    5532  * Get the timestamp of the last time any post was modified.
    5533  *
    5534  * The server timezone is the default and is the difference between GMT and
    5535  * server time. The 'blog' value is just when the last post was modified. The
    5536  * 'gmt' is when the last post was modified in GMT time.
    5537  *
    5538  * @since 1.2.0
    5539  *
    5540  * @param string $timezone Optional. The timezone for the timestamp. Uses the server's internal timezone.
    5541  *                         Accepts 'server', 'blog', 'gmt'. or 'server'. 'server' uses the server's
    5542  *                         internal timezone. 'blog' uses the `post_modified` field, which proxies
    5543  *                         to the timezone set for the site. 'gmt' uses the `post_modified_gmt` field.
    5544  *                         Default 'server'.
    5545  * @return string The timestamp.
    5546  */
    5547 function get_lastpostmodified( $timezone = 'server' ) {
    5548     $lastpostmodified = _get_last_post_time( $timezone, 'modified' );
    5549 
    5550     $lastpostdate = get_lastpostdate($timezone);
    5551     if ( $lastpostdate > $lastpostmodified )
    5552         $lastpostmodified = $lastpostdate;
    5553 
    5554     /**
    5555      * Filter the date the last post was modified.
    5556      *
    5557      * @since 2.3.0
    5558      *
    5559      * @param string $lastpostmodified Date the last post was modified.
    5560      * @param string $timezone         Location to use for getting the post modified date.
    5561      *                                 See {@see get_lastpostmodified()} for accepted `$timezone` values.
    5562      */
    5563     return apply_filters( 'get_lastpostmodified', $lastpostmodified, $timezone );
    5564 }
    5565 
    5566 /**
    5567  * Get the timestamp of the last time any post was modified or published.
    5568  *
    5569  * @since 3.1.0
    5570  * @access private
    5571  *
    5572  * @global wpdb $wpdb
    5573  *
    5574  * @param string $timezone The timezone for the timestamp. See {@see get_lastpostmodified()}
    5575  *                         for information on accepted values.
    5576  * @param string $field    Post field to check. Accepts 'date' or 'modified'.
    5577  * @return string|false The timestamp.
    5578  */
    5579 function _get_last_post_time( $timezone, $field ) {
    5580     global $wpdb;
    5581 
    5582     if ( !in_array( $field, array( 'date', 'modified' ) ) )
    5583         return false;
    5584 
    5585     $timezone = strtolower( $timezone );
    5586 
    5587     $key = "lastpost{$field}:$timezone";
    5588 
    5589     $date = wp_cache_get( $key, 'timeinfo' );
    5590 
    5591     if ( !$date ) {
    5592         $add_seconds_server = date('Z');
    5593 
    5594         $post_types = get_post_types( array( 'public' => true ) );
    5595         array_walk( $post_types, array( &$wpdb, 'escape_by_ref' ) );
    5596         $post_types = "'" . implode( "', '", $post_types ) . "'";
    5597 
    5598         switch ( $timezone ) {
    5599             case 'gmt':
    5600                 $date = $wpdb->get_var("SELECT post_{$field}_gmt FROM $wpdb->posts WHERE post_status = 'publish' AND post_type IN ({$post_types}) ORDER BY post_{$field}_gmt DESC LIMIT 1");
    5601                 break;
    5602             case 'blog':
    5603                 $date = $wpdb->get_var("SELECT post_{$field} FROM $wpdb->posts WHERE post_status = 'publish' AND post_type IN ({$post_types}) ORDER BY post_{$field}_gmt DESC LIMIT 1");
    5604                 break;
    5605             case 'server':
    5606                 $date = $wpdb->get_var("SELECT DATE_ADD(post_{$field}_gmt, INTERVAL '$add_seconds_server' SECOND) FROM $wpdb->posts WHERE post_status = 'publish' AND post_type IN ({$post_types}) ORDER BY post_{$field}_gmt DESC LIMIT 1");
    5607                 break;
    5608         }
    5609 
    5610         if ( $date )
    5611             wp_cache_set( $key, $date, 'timeinfo' );
    5612     }
    5613 
    5614     return $date;
    5615 }
    5616 
    5617 /**
    5618  * Updates posts in cache.
    5619  *
    5620  * @since 1.5.1
    5621  *
    5622  * @param array $posts Array of post objects, passed by reference.
    5623  */
    5624 function update_post_cache( &$posts ) {
    5625     if ( ! $posts )
    5626         return;
    5627 
    5628     foreach ( $posts as $post )
    5629         wp_cache_add( $post->ID, $post, 'posts' );
    5630 }
    5631 
    5632 /**
    5633  * Will clean the post in the cache.
    5634  *
    5635  * Cleaning means delete from the cache of the post. Will call to clean the term
    5636  * object cache associated with the post ID.
    5637  *
    5638  * This function not run if $_wp_suspend_cache_invalidation is not empty. See
    5639  * wp_suspend_cache_invalidation().
    5640  *
    5641  * @since 2.0.0
    5642  *
    5643  * @global bool $_wp_suspend_cache_invalidation
    5644  * @global wpdb $wpdb WordPress database abstraction object.
    5645  *
    5646  * @param int|WP_Post $post Post ID or post object to remove from the cache.
    5647  */
    5648 function clean_post_cache( $post ) {
    5649     global $_wp_suspend_cache_invalidation, $wpdb;
    5650 
    5651     if ( ! empty( $_wp_suspend_cache_invalidation ) )
    5652         return;
    5653 
    5654     $post = get_post( $post );
    5655     if ( empty( $post ) )
    5656         return;
    5657 
    5658     wp_cache_delete( $post->ID, 'posts' );
    5659     wp_cache_delete( $post->ID, 'post_meta' );
    5660 
    5661     clean_object_term_cache( $post->ID, $post->post_type );
    5662 
    5663     wp_cache_delete( 'wp_get_archives', 'general' );
    5664 
    5665     /**
    5666      * Fires immediately after the given post's cache is cleaned.
    5667      *
    5668      * @since 2.5.0
    5669      *
    5670      * @param int     $post_id Post ID.
    5671      * @param WP_Post $post    Post object.
    5672      */
    5673     do_action( 'clean_post_cache', $post->ID, $post );
    5674 
    5675     if ( 'page' == $post->post_type ) {
    5676         wp_cache_delete( 'all_page_ids', 'posts' );
    5677 
    5678         /**
    5679          * Fires immediately after the given page's cache is cleaned.
    5680          *
    5681          * @since 2.5.0
    5682          *
    5683          * @param int $post_id Post ID.
    5684          */
    5685         do_action( 'clean_page_cache', $post->ID );
    5686     }
    5687 
    5688     wp_cache_set( 'last_changed', microtime(), 'posts' );
    5689 }
    5690 
    5691 /**
    5692  * Call major cache updating functions for list of Post objects.
    5693  *
    5694  * @since 1.5.0
    5695  *
    5696  * @param array  $posts             Array of Post objects
    5697  * @param string $post_type         Optional. Post type. Default 'post'.
    5698  * @param bool   $update_term_cache Optional. Whether to update the term cache. Default true.
    5699  * @param bool   $update_meta_cache Optional. Whether to update the meta cache. Default true.
    5700  */
    5701 function update_post_caches( &$posts, $post_type = 'post', $update_term_cache = true, $update_meta_cache = true ) {
    5702     // No point in doing all this work if we didn't match any posts.
    5703     if ( !$posts )
    5704         return;
    5705 
    5706     update_post_cache($posts);
    5707 
    5708     $post_ids = array();
    5709     foreach ( $posts as $post )
    5710         $post_ids[] = $post->ID;
    5711 
    5712     if ( ! $post_type )
    5713         $post_type = 'any';
    5714 
    5715     if ( $update_term_cache ) {
    5716         if ( is_array($post_type) ) {
    5717             $ptypes = $post_type;
    5718         } elseif ( 'any' == $post_type ) {
    5719             $ptypes = array();
    5720             // Just use the post_types in the supplied posts.
    5721             foreach ( $posts as $post ) {
    5722                 $ptypes[] = $post->post_type;
    5723             }
    5724             $ptypes = array_unique($ptypes);
    5725         } else {
    5726             $ptypes = array($post_type);
    5727         }
    5728 
    5729         if ( ! empty($ptypes) )
    5730             update_object_term_cache($post_ids, $ptypes);
    5731     }
    5732 
    5733     if ( $update_meta_cache )
    5734         update_postmeta_cache($post_ids);
    5735 }
    5736 
    5737 /**
    5738  * Updates metadata cache for list of post IDs.
    5739  *
    5740  * Performs SQL query to retrieve the metadata for the post IDs and updates the
    5741  * metadata cache for the posts. Therefore, the functions, which call this
    5742  * function, do not need to perform SQL queries on their own.
    5743  *
    5744  * @since 2.1.0
    5745  *
    5746  * @param array $post_ids List of post IDs.
    5747  * @return array|false Returns false if there is nothing to update or an array
    5748  *                     of metadata.
    5749  */
    5750 function update_postmeta_cache( $post_ids ) {
    5751     return update_meta_cache('post', $post_ids);
    5752 }
    5753 
    5754 /**
    5755  * Will clean the attachment in the cache.
    5756  *
    5757  * Cleaning means delete from the cache. Optionally will clean the term
    5758  * object cache associated with the attachment ID.
    5759  *
    5760  * This function will not run if $_wp_suspend_cache_invalidation is not empty.
    5761  *
    5762  * @since 3.0.0
    5763  *
    5764  * @global bool $_wp_suspend_cache_invalidation
    5765  *
    5766  * @param int  $id          The attachment ID in the cache to clean.
    5767  * @param bool $clean_terms Optional. Whether to clean terms cache. Default false.
    5768  */
    5769 function clean_attachment_cache( $id, $clean_terms = false ) {
    5770     global $_wp_suspend_cache_invalidation;
    5771 
    5772     if ( !empty($_wp_suspend_cache_invalidation) )
    5773         return;
    5774 
    5775     $id = (int) $id;
    5776 
    5777     wp_cache_delete($id, 'posts');
    5778     wp_cache_delete($id, 'post_meta');
    5779 
    5780     if ( $clean_terms )
    5781         clean_object_term_cache($id, 'attachment');
    5782 
    5783     /**
    5784      * Fires after the given attachment's cache is cleaned.
    5785      *
    5786      * @since 3.0.0
    5787      *
    5788      * @param int $id Attachment ID.
    5789      */
    5790     do_action( 'clean_attachment_cache', $id );
    5791 }
    5792 
    5793 //
    5794 // Hooks
    5795 //
    5796 
    5797 /**
    5798  * Hook for managing future post transitions to published.
    5799  *
    5800  * @since 2.3.0
    5801  * @access private
    5802  *
    5803  * @see wp_clear_scheduled_hook()
    5804  * @global wpdb $wpdb WordPress database abstraction object.
    5805  *
    5806  * @param string  $new_status New post status.
    5807  * @param string  $old_status Previous post status.
    5808  * @param WP_Post $post       Post object.
    5809  */
    5810 function _transition_post_status( $new_status, $old_status, $post ) {
    5811     global $wpdb;
    5812 
    5813     if ( $old_status != 'publish' && $new_status == 'publish' ) {
    5814         // Reset GUID if transitioning to publish and it is empty.
    5815         if ( '' == get_the_guid($post->ID) )
    5816             $wpdb->update( $wpdb->posts, array( 'guid' => get_permalink( $post->ID ) ), array( 'ID' => $post->ID ) );
    5817 
    5818         /**
    5819          * Fires when a post's status is transitioned from private to published.
    5820          *
    5821          * @since 1.5.0
    5822          * @deprecated 2.3.0 Use 'private_to_publish' instead.
    5823          *
    5824          * @param int $post_id Post ID.
    5825          */
    5826         do_action('private_to_published', $post->ID);
    5827     }
    5828 
    5829     // If published posts changed clear the lastpostmodified cache.
    5830     if ( 'publish' == $new_status || 'publish' == $old_status) {
    5831         foreach ( array( 'server', 'gmt', 'blog' ) as $timezone ) {
    5832             wp_cache_delete( "lastpostmodified:$timezone", 'timeinfo' );
    5833             wp_cache_delete( "lastpostdate:$timezone", 'timeinfo' );
    5834         }
    5835     }
    5836 
    5837     if ( $new_status !== $old_status ) {
    5838         wp_cache_delete( _count_posts_cache_key( $post->post_type ), 'counts' );
    5839         wp_cache_delete( _count_posts_cache_key( $post->post_type, 'readable' ), 'counts' );
    5840     }
    5841 
    5842     // Always clears the hook in case the post status bounced from future to draft.
    5843     wp_clear_scheduled_hook('publish_future_post', array( $post->ID ) );
    5844 }
    5845 
    5846 /**
    5847  * Hook used to schedule publication for a post marked for the future.
    5848  *
    5849  * The $post properties used and must exist are 'ID' and 'post_date_gmt'.
    5850  *
    5851  * @since 2.3.0
    5852  * @access private
    5853  *
    5854  * @param int     $deprecated Not used. Can be set to null. Never implemented. Not marked
    5855  *                            as deprecated with _deprecated_argument() as it conflicts with
    5856  *                            wp_transition_post_status() and the default filter for
    5857  *                            {@see _future_post_hook()}.
    5858  * @param WP_Post $post       Post object.
    5859  */
    5860 function _future_post_hook( $deprecated, $post ) {
    5861     wp_clear_scheduled_hook( 'publish_future_post', array( $post->ID ) );
    5862     wp_schedule_single_event( strtotime( get_gmt_from_date( $post->post_date ) . ' GMT') , 'publish_future_post', array( $post->ID ) );
    5863 }
    5864 
    5865 /**
    5866  * Hook to schedule pings and enclosures when a post is published.
    5867  *
    5868  * Uses XMLRPC_REQUEST and WP_IMPORTING constants.
    5869  *
    5870  * @since 2.3.0
    5871  * @access private
    5872  *
    5873  * @param int $post_id The ID in the database table of the post being published.
    5874  */
    5875 function _publish_post_hook( $post_id ) {
    5876     if ( defined( 'XMLRPC_REQUEST' ) ) {
    5877         /**
    5878          * Fires when _publish_post_hook() is called during an XML-RPC request.
    5879          *
    5880          * @since 2.1.0
    5881          *
    5882          * @param int $post_id Post ID.
    5883          */
    5884         do_action( 'xmlrpc_publish_post', $post_id );
    5885     }
    5886 
    5887     if ( defined('WP_IMPORTING') )
    5888         return;
    5889 
    5890     if ( get_option('default_pingback_flag') )
    5891         add_post_meta( $post_id, '_pingme', '1' );
    5892     add_post_meta( $post_id, '_encloseme', '1' );
    5893 
    5894     wp_schedule_single_event(time(), 'do_pings');
    5895 }
    5896 
    5897 /**
    5898  * Return the post's parent's post_ID
    5899  *
    5900  * @since 3.1.0
    5901  *
    5902  * @param int $post_ID
    5903  *
    5904  * @return int|false Post parent ID, otherwise false.
    5905  */
    5906 function wp_get_post_parent_id( $post_ID ) {
    5907     $post = get_post( $post_ID );
    5908     if ( !$post || is_wp_error( $post ) )
    5909         return false;
    5910     return (int) $post->post_parent;
    5911 }
    5912 
    5913 /**
    5914  * Check the given subset of the post hierarchy for hierarchy loops.
    5915  *
    5916  * Prevents loops from forming and breaks those that it finds. Attached
    5917  * to the 'wp_insert_post_parent' filter.
    5918  *
    5919  * @since 3.1.0
    5920  *
    5921  * @see wp_find_hierarchy_loop()
    5922  *
    5923  * @param int $post_parent ID of the parent for the post we're checking.
    5924  * @param int $post_ID     ID of the post we're checking.
    5925  * @return int The new post_parent for the post, 0 otherwise.
    5926  */
    5927 function wp_check_post_hierarchy_for_loops( $post_parent, $post_ID ) {
    5928     // Nothing fancy here - bail.
    5929     if ( !$post_parent )
    5930         return 0;
    5931 
    5932     // New post can't cause a loop.
    5933     if ( empty( $post_ID ) )
    5934         return $post_parent;
    5935 
    5936     // Can't be its own parent.
    5937     if ( $post_parent == $post_ID )
    5938         return 0;
    5939 
    5940     // Now look for larger loops.
    5941     if ( !$loop = wp_find_hierarchy_loop( 'wp_get_post_parent_id', $post_ID, $post_parent ) )
    5942         return $post_parent; // No loop
    5943 
    5944     // Setting $post_parent to the given value causes a loop.
    5945     if ( isset( $loop[$post_ID] ) )
    5946         return 0;
    5947 
    5948     // There's a loop, but it doesn't contain $post_ID. Break the loop.
    5949     foreach ( array_keys( $loop ) as $loop_member )
    5950         wp_update_post( array( 'ID' => $loop_member, 'post_parent' => 0 ) );
    5951 
    5952     return $post_parent;
    5953 }
    5954 
    5955 /**
    5956  * Set a post thumbnail.
    5957  *
    5958  * @since 3.1.0
    5959  *
    5960  * @param int|WP_Post $post         Post ID or post object where thumbnail should be attached.
    5961  * @param int         $thumbnail_id Thumbnail to attach.
    5962  * @return int|bool True on success, false on failure.
    5963  */
    5964 function set_post_thumbnail( $post, $thumbnail_id ) {
    5965     $post = get_post( $post );
    5966     $thumbnail_id = absint( $thumbnail_id );
    5967     if ( $post && $thumbnail_id && get_post( $thumbnail_id ) ) {
    5968         if ( wp_get_attachment_image( $thumbnail_id, 'thumbnail' ) )
    5969             return update_post_meta( $post->ID, '_thumbnail_id', $thumbnail_id );
    5970         else
    5971             return delete_post_meta( $post->ID, '_thumbnail_id' );
    5972     }
    5973     return false;
    5974 }
    5975 
    5976 /**
    5977  * Remove a post thumbnail.
    5978  *
    5979  * @since 3.3.0
    5980  *
    5981  * @param int|WP_Post $post Post ID or post object where thumbnail should be removed from.
    5982  * @return bool True on success, false on failure.
    5983  */
    5984 function delete_post_thumbnail( $post ) {
    5985     $post = get_post( $post );
    5986     if ( $post )
    5987         return delete_post_meta( $post->ID, '_thumbnail_id' );
    5988     return false;
    5989 }
    5990 
    5991 /**
    5992  * Delete auto-drafts for new posts that are > 7 days old.
    5993  *
    5994  * @since 3.4.0
    5995  *
    5996  * @global wpdb $wpdb WordPress database abstraction object.
    5997  */
    5998 function wp_delete_auto_drafts() {
    5999     global $wpdb;
    6000 
    6001     // Cleanup old auto-drafts more than 7 days old.
    6002     $old_posts = $wpdb->get_col( "SELECT ID FROM $wpdb->posts WHERE post_status = 'auto-draft' AND DATE_SUB( NOW(), INTERVAL 7 DAY ) > post_date" );
    6003     foreach ( (array) $old_posts as $delete ) {
    6004         // Force delete.
    6005         wp_delete_post( $delete, true );
    6006     }
    6007 }
    6008 
    6009 /**
    6010  * Update the custom taxonomies' term counts when a post's status is changed.
    6011  *
    6012  * For example, default posts term counts (for custom taxonomies) don't include
    6013  * private / draft posts.
    6014  *
    6015  * @since 3.3.0
    6016  * @access private
    6017  *
    6018  * @param string  $new_status New post status.
    6019  * @param string  $old_status Old post status.
    6020  * @param WP_Post $post       Post object.
    6021  */
    6022 function _update_term_count_on_transition_post_status( $new_status, $old_status, $post ) {
    6023     // Update counts for the post's terms.
    6024     foreach ( (array) get_object_taxonomies( $post->post_type ) as $taxonomy ) {
    6025         $tt_ids = wp_get_object_terms( $post->ID, $taxonomy, array( 'fields' => 'tt_ids' ) );
    6026         wp_update_term_count( $tt_ids, $taxonomy );
    6027     }
    6028 }
    6029 
    6030 /**
    6031  * Adds any posts from the given ids to the cache that do not already exist in cache
    6032  *
    6033  * @since 3.4.0
    6034  * @access private
    6035  *
    6036  * @see update_post_caches()
    6037  *
    6038  * @global wpdb $wpdb
    6039  *
    6040  * @param array $ids               ID list
    6041  * @param bool  $update_term_cache Optional. Whether to update the term cache. Default true.
    6042  * @param bool  $update_meta_cache Optional. Whether to update the meta cache. Default true.
    6043  */
    6044 function _prime_post_caches( $ids, $update_term_cache = true, $update_meta_cache = true ) {
    6045     global $wpdb;
    6046 
    6047     $non_cached_ids = _get_non_cached_ids( $ids, 'posts' );
    6048     if ( !empty( $non_cached_ids ) ) {
    6049         $fresh_posts = $wpdb->get_results( sprintf( "SELECT $wpdb->posts.* FROM $wpdb->posts WHERE ID IN (%s)", join( ",", $non_cached_ids ) ) );
    6050 
    6051         update_post_caches( $fresh_posts, 'any', $update_term_cache, $update_meta_cache );
    6052     }
    6053 }
     10require_once( ABSPATH . WPINC . '/post-functions.php' );
     11require_once( ABSPATH . WPINC . '/class-wp-post.php' );
Note: See TracChangeset for help on using the changeset viewer.