2004-05-23 21:34:57 -04:00
< ? php
2007-12-13 19:28:34 -05:00
/**
2008-06-14 12:31:08 -04:00
* Post functions and post utility function .
*
2007-12-13 19:28:34 -05:00
* @ package WordPress
* @ subpackage Post
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
*/
2004-05-23 21:34:57 -04:00
2009-10-06 10:43:05 -04:00
//
// Post Type Registration
//
/**
* Creates the initial post types when 'init' action is fired .
2010-11-16 08:16:13 -05:00
*
* @ since 2.9 . 0
2009-10-06 10:43:05 -04:00
*/
function create_initial_post_types () {
2010-05-04 02:13:28 -04:00
register_post_type ( 'post' , array (
2011-06-10 22:20:18 -04:00
'labels' => array (
'name_admin_bar' => _x ( 'Post' , 'add new on admin bar' ),
),
2010-05-04 02:13:28 -04:00
'public' => true ,
'_builtin' => true , /* internal use only. don't use this when registering your own post type. */
'_edit_link' => 'post.php?post=%d' , /* internal use only. don't use this when registering your own post type. */
'capability_type' => 'post' ,
2010-10-21 10:40:04 -04:00
'map_meta_cap' => true ,
2010-05-04 02:13:28 -04:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2012-05-08 13:01:50 -04:00
'delete_with_user' => true ,
2010-12-02 18:16:04 -05:00
'supports' => array ( 'title' , 'editor' , 'author' , 'thumbnail' , 'excerpt' , 'trackbacks' , 'custom-fields' , 'comments' , 'revisions' , 'post-formats' ),
2010-05-04 02:13:28 -04:00
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_type ( 'page' , array (
2011-06-10 22:20:18 -04:00
'labels' => array (
'name_admin_bar' => _x ( 'Page' , 'add new on admin bar' ),
),
2010-05-04 02:13:28 -04:00
'public' => true ,
2011-06-10 13:02:03 -04:00
'publicly_queryable' => false ,
2010-05-04 02:13:28 -04:00
'_builtin' => true , /* internal use only. don't use this when registering your own post type. */
'_edit_link' => 'post.php?post=%d' , /* internal use only. don't use this when registering your own post type. */
'capability_type' => 'page' ,
2010-10-21 10:40:04 -04:00
'map_meta_cap' => true ,
2010-05-04 02:13:28 -04:00
'hierarchical' => true ,
'rewrite' => false ,
'query_var' => false ,
2012-05-08 13:01:50 -04:00
'delete_with_user' => true ,
2010-05-04 02:13:28 -04:00
'supports' => array ( 'title' , 'editor' , 'author' , 'thumbnail' , 'page-attributes' , 'custom-fields' , 'comments' , 'revisions' ),
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_type ( 'attachment' , array (
2010-05-13 20:34:04 -04:00
'labels' => array (
2012-09-21 18:52:54 -04:00
'name' => _x ( 'Media' , 'post type general name' ),
'name_admin_bar' => _x ( 'Media' , 'add new from admin bar' ),
'add_new' => _x ( 'Add New' , 'add new media' ),
'edit_item' => __ ( 'Edit Media' ),
'view_item' => __ ( 'View Attachment Page' ),
2010-05-13 20:34:04 -04:00
),
2010-05-04 02:13:28 -04:00
'public' => true ,
2012-09-21 18:52:54 -04:00
'show_ui' => true ,
2010-05-04 02:13:28 -04:00
'_builtin' => true , /* internal use only. don't use this when registering your own post type. */
2012-09-21 18:52:54 -04:00
'_edit_link' => 'post.php?post=%d' , /* internal use only. don't use this when registering your own post type. */
2010-05-04 02:13:28 -04:00
'capability_type' => 'post' ,
2012-11-29 11:14:07 -05:00
'capabilities' => array (
'create_posts' => 'upload_files' ,
),
2010-10-21 20:25:14 -04:00
'map_meta_cap' => true ,
2010-05-04 02:13:28 -04:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2010-05-29 12:46:46 -04:00
'show_in_nav_menus' => false ,
2012-05-08 13:01:50 -04:00
'delete_with_user' => true ,
2012-09-21 18:52:54 -04:00
'supports' => array ( 'title' , 'author' , 'comments' ),
2010-05-04 02:13:28 -04:00
) );
2014-03-22 22:35:14 -04:00
add_post_type_support ( 'attachment:audio' , 'thumbnail' );
add_post_type_support ( 'attachment:video' , 'thumbnail' );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_type ( 'revision' , array (
2010-05-13 20:34:04 -04:00
'labels' => array (
'name' => __ ( 'Revisions' ),
'singular_name' => __ ( 'Revision' ),
),
2010-05-04 02:13:28 -04:00
'public' => false ,
'_builtin' => true , /* internal use only. don't use this when registering your own post type. */
'_edit_link' => 'revision.php?revision=%d' , /* internal use only. don't use this when registering your own post type. */
'capability_type' => 'post' ,
2010-10-21 20:25:14 -04:00
'map_meta_cap' => true ,
2010-05-04 02:13:28 -04:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2010-12-01 12:21:58 -05:00
'can_export' => false ,
2012-05-08 13:01:50 -04:00
'delete_with_user' => true ,
'supports' => array ( 'author' ),
2010-05-04 02:13:28 -04:00
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_type ( 'nav_menu_item' , array (
2010-05-13 20:34:04 -04:00
'labels' => array (
'name' => __ ( 'Navigation Menu Items' ),
'singular_name' => __ ( 'Navigation Menu Item' ),
),
2010-05-04 02:13:28 -04:00
'public' => false ,
'_builtin' => true , /* internal use only. don't use this when registering your own post type. */
'hierarchical' => false ,
'rewrite' => false ,
2012-05-08 13:01:50 -04:00
'delete_with_user' => false ,
2010-05-04 02:13:28 -04:00
'query_var' => false ,
) );
2010-02-20 17:35:39 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'publish' , array (
'label' => _x ( 'Published' , 'post' ),
'public' => true ,
'_builtin' => true , /* internal use only. */
'label_count' => _n_noop ( 'Published <span class="count">(%s)</span>' , 'Published <span class="count">(%s)</span>' ),
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'future' , array (
'label' => _x ( 'Scheduled' , 'post' ),
'protected' => true ,
'_builtin' => true , /* internal use only. */
'label_count' => _n_noop ( 'Scheduled <span class="count">(%s)</span>' , 'Scheduled <span class="count">(%s)</span>' ),
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'draft' , array (
'label' => _x ( 'Draft' , 'post' ),
'protected' => true ,
'_builtin' => true , /* internal use only. */
'label_count' => _n_noop ( 'Draft <span class="count">(%s)</span>' , 'Drafts <span class="count">(%s)</span>' ),
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'pending' , array (
'label' => _x ( 'Pending' , 'post' ),
'protected' => true ,
'_builtin' => true , /* internal use only. */
'label_count' => _n_noop ( 'Pending <span class="count">(%s)</span>' , 'Pending <span class="count">(%s)</span>' ),
) );
2010-02-16 16:13:44 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'private' , array (
'label' => _x ( 'Private' , 'post' ),
'private' => true ,
'_builtin' => true , /* internal use only. */
'label_count' => _n_noop ( 'Private <span class="count">(%s)</span>' , 'Private <span class="count">(%s)</span>' ),
) );
2010-01-18 06:44:51 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'trash' , array (
'label' => _x ( 'Trash' , 'post' ),
'internal' => true ,
'_builtin' => true , /* internal use only. */
'label_count' => _n_noop ( 'Trash <span class="count">(%s)</span>' , 'Trash <span class="count">(%s)</span>' ),
'show_in_admin_status_list' => true ,
) );
2010-02-06 12:09:34 -05:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'auto-draft' , array (
'label' => 'auto-draft' ,
'internal' => true ,
'_builtin' => true , /* internal use only. */
) );
2010-04-14 10:07:48 -04:00
2010-05-04 02:13:28 -04:00
register_post_status ( 'inherit' , array (
'label' => 'inherit' ,
'internal' => true ,
'_builtin' => true , /* internal use only. */
'exclude_from_search' => false ,
) );
2009-10-06 10:43:05 -04:00
}
add_action ( 'init' , 'create_initial_post_types' , 0 ); // highest priority
2007-12-13 19:28:34 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve attached file path based on attachment ID .
2007-12-13 19:28:34 -05:00
*
2013-08-05 18:07:42 -04:00
* By default the path will go through the 'get_attached_file' filter , but
* passing a true to the $unfiltered argument of get_attached_file () will
* return the file path unfiltered .
2008-06-27 11:32:57 -04:00
*
* The function works by getting the single post meta name , named
* '_wp_attached_file' and returning it . This is a convenience function to
* prevent looking up the meta name and provide a mechanism for sending the
* attached filename through a filter .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
2008-11-22 18:01:28 -05:00
* @ param int $attachment_id Attachment ID .
2010-02-24 15:13:23 -05:00
* @ param bool $unfiltered Whether to apply filters .
2013-09-24 17:29:08 -04:00
* @ return string | bool The file path to where the attached file should be , false otherwise .
2007-12-13 19:28:34 -05:00
*/
2006-12-05 17:37:19 -05:00
function get_attached_file ( $attachment_id , $unfiltered = false ) {
$file = get_post_meta ( $attachment_id , '_wp_attached_file' , true );
2008-09-02 18:55:39 -04:00
// If the file is relative, prepend upload dir
2012-04-27 12:08:58 -04:00
if ( $file && 0 !== strpos ( $file , '/' ) && ! preg_match ( '|^.:\\\|' , $file ) && ( ( $uploads = wp_upload_dir ()) && false === $uploads [ 'error' ] ) )
2008-09-02 18:55:39 -04:00
$file = $uploads [ 'basedir' ] . " / $file " ;
2006-12-05 17:37:19 -05:00
if ( $unfiltered )
return $file ;
2014-04-08 02:49:14 -04:00
/**
* Filter the attached file based on the given ID .
*
* @ since 2.1 . 0
*
* @ param string $file Path to attached file .
* @ param int $attachment_id Attachment ID .
*/
2006-12-05 17:37:19 -05:00
return apply_filters ( 'get_attached_file' , $file , $attachment_id );
}
2007-12-13 19:28:34 -05:00
/**
2008-06-27 11:32:57 -04:00
* Update attachment file path based on attachment ID .
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* Used to update the file path of the attachment , which uses post meta name
* '_wp_attached_file' to store the path of the attachment .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
* @ param int $attachment_id Attachment ID
2008-06-27 11:32:57 -04:00
* @ param string $file File path for the attachment
2013-06-21 08:45:11 -04:00
* @ return bool True on success , false on failure .
2007-12-13 19:28:34 -05:00
*/
2006-12-05 17:37:19 -05:00
function update_attached_file ( $attachment_id , $file ) {
if ( ! get_post ( $attachment_id ) )
return false ;
2014-04-08 02:49:14 -04:00
/**
* Filter the path to the attached file to update .
*
* @ since 2.1 . 0
*
* @ param string $file Path to the attached file to update .
* @ param int $attachment_id Attachment ID .
*/
2006-12-05 17:37:19 -05:00
$file = apply_filters ( 'update_attached_file' , $file , $attachment_id );
2014-04-08 02:49:14 -04:00
2012-09-24 09:07:34 -04:00
if ( $file = _wp_relative_upload_path ( $file ) )
return update_post_meta ( $attachment_id , '_wp_attached_file' , $file );
else
return delete_post_meta ( $attachment_id , '_wp_attached_file' );
2009-11-11 06:24:01 -05:00
}
/**
* Return relative path to an uploaded file .
*
* The path is relative to the current upload dir .
*
2010-03-26 15:23:39 -04:00
* @ since 2.9 . 0
2009-11-11 06:24:01 -05:00
*
* @ param string $path Full path to the file
* @ return string relative path on success , unchanged path on failure .
*/
function _wp_relative_upload_path ( $path ) {
$new_path = $path ;
2012-09-11 18:06:49 -04:00
$uploads = wp_upload_dir ();
if ( 0 === strpos ( $new_path , $uploads [ 'basedir' ] ) ) {
$new_path = str_replace ( $uploads [ 'basedir' ], '' , $new_path );
$new_path = ltrim ( $new_path , '/' );
2008-09-02 18:55:39 -04:00
}
2014-04-08 02:49:14 -04:00
/**
* Filter the relative path to an uploaded file .
*
* @ since 2.9 . 0
*
* @ param string $new_path Relative path to the file .
* @ param string $path Full path to the file .
*/
2009-11-11 06:24:01 -05:00
return apply_filters ( '_wp_relative_upload_path' , $new_path , $path );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve all children of the post parent ID .
*
* Normally , without any enhancements , the children would apply to pages . In the
* context of the inner workings of WordPress , pages , posts , and attachments
* share the same table , so therefore the functionality could apply to any one
* of them . It is then noted that while this function does not work on posts , it
* does not mean that it won ' t work on posts . It is recommended that you know
* what context you wish to retrieve the children of .
*
* Attachments may also be made the child of a post , so if that is an accurate
* statement ( which needs to be verified ), it would then be possible to get
* all of the attachments for a post . Attachments have since changed since
* version 2.5 , so this is most likely unaccurate , but serves generally as an
* example of what is possible .
*
* The arguments listed as defaults are for this function and also of the
2008-08-19 12:38:06 -04:00
* { @ link get_posts ()} function . The arguments are combined with the
* get_children defaults and are then passed to the { @ link get_posts ()}
* function , which accepts additional arguments . You can replace the defaults in
* this function , listed below and the additional arguments listed in the
* { @ link get_posts ()} function .
2008-06-27 11:32:57 -04:00
*
* The 'post_parent' is the most important argument and important attention
* needs to be paid to the $args parameter . If you pass either an object or an
* integer ( number ), then just the 'post_parent' is grabbed and everything else
* is lost . If you don ' t specify any arguments , then it is assumed that you are
* in The Loop and the post parent will be grabbed for from the current post .
*
* The 'post_parent' argument is the ID to get the children . The 'numberposts'
* is the amount of posts to retrieve that has a default of '-1' , which is
* used to get all of the posts . Giving a number higher than 0 will only
* retrieve that amount of posts .
*
* The 'post_type' and 'post_status' arguments can be used to choose what
* criteria of posts to retrieve . The 'post_type' can be anything , but WordPress
* post types are 'post' , 'pages' , and 'attachments' . The 'post_status'
* argument will accept any post status within the write administration panels .
*
* @ see get_posts () Has additional arguments that can be replaced .
* @ internal Claims made in the long description might be inaccurate .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* @ param mixed $args Optional . User defined arguments for replacing the defaults .
* @ param string $output Optional . Constant for return type , either OBJECT ( default ), ARRAY_A , ARRAY_N .
* @ return array | bool False on failure and the type will be determined by $output parameter .
2007-12-13 19:28:34 -05:00
*/
2010-12-01 15:23:57 -05:00
function get_children ( $args = '' , $output = OBJECT ) {
2009-07-31 05:31:56 -04:00
$kids = array ();
2007-05-10 23:10:05 -04:00
if ( empty ( $args ) ) {
if ( isset ( $GLOBALS [ 'post' ] ) ) {
2008-05-05 12:03:27 -04:00
$args = array ( 'post_parent' => ( int ) $GLOBALS [ 'post' ] -> post_parent );
2007-05-10 23:10:05 -04:00
} else {
2009-07-31 05:31:56 -04:00
return $kids ;
2007-05-10 23:10:05 -04:00
}
} elseif ( is_object ( $args ) ) {
2008-05-05 12:03:27 -04:00
$args = array ( 'post_parent' => ( int ) $args -> post_parent );
2007-05-10 23:10:05 -04:00
} elseif ( is_numeric ( $args ) ) {
2008-05-05 12:03:27 -04:00
$args = array ( 'post_parent' => ( int ) $args );
2007-05-10 23:10:05 -04:00
}
2007-06-13 22:25:30 -04:00
2007-05-10 23:10:05 -04:00
$defaults = array (
2008-12-08 16:00:25 -05:00
'numberposts' => - 1 , 'post_type' => 'any' ,
'post_status' => 'any' , 'post_parent' => 0 ,
2007-05-10 23:10:05 -04:00
);
2007-06-13 22:25:30 -04:00
2007-05-10 23:10:05 -04:00
$r = wp_parse_args ( $args , $defaults );
2006-06-07 19:17:59 -04:00
2006-11-19 23:23:12 -05:00
$children = get_posts ( $r );
2009-09-14 10:03:32 -04:00
2013-08-29 11:08:12 -04:00
if ( ! $children )
2008-08-25 17:50:11 -04:00
return $kids ;
2007-10-12 17:12:34 -04:00
2013-08-29 11:08:12 -04:00
if ( ! empty ( $r [ 'fields' ] ) )
return $children ;
2007-10-12 17:12:34 -04:00
update_post_cache ( $children );
foreach ( $children as $key => $child )
2010-12-01 15:23:57 -05:00
$kids [ $child -> ID ] = $children [ $key ];
2006-06-07 19:17:59 -04:00
if ( $output == OBJECT ) {
return $kids ;
} elseif ( $output == ARRAY_A ) {
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $kids as $kid )
2006-06-07 19:17:59 -04:00
$weeuns [ $kid -> ID ] = get_object_vars ( $kids [ $kid -> ID ]);
return $weeuns ;
} elseif ( $output == ARRAY_N ) {
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $kids as $kid )
2006-06-07 19:17:59 -04:00
$babes [ $kid -> ID ] = array_values ( get_object_vars ( $kids [ $kid -> ID ]));
return $babes ;
} else {
return $kids ;
}
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Get extended entry info ( <!-- more --> ) .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* There should not be any space after the second dash and before the word
* 'more' . There can be text or space ( s ) after the word 'more' , but won ' t be
* referenced .
*
2012-03-08 07:50:21 -05:00
* The returned array has 'main' , 'extended' , and 'more_text' keys . Main has the text before
2008-08-19 12:38:06 -04:00
* the < code ><!-- more --></ code >. The 'extended' key has the content after the
2012-03-08 07:50:21 -05:00
* < code ><!-- more --></ code > comment . The 'more_text' key has the custom " Read More " text .
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* @ since 1.0 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param string $post Post content .
2012-03-08 07:50:21 -05:00
* @ return array Post before ( 'main' ), after ( 'extended' ), and custom readmore ( 'more_text' ) .
2007-12-13 19:28:34 -05:00
*/
2006-06-07 19:17:59 -04:00
function get_extended ( $post ) {
2006-08-05 00:11:51 -04:00
//Match the new style more links
2007-04-11 18:47:36 -04:00
if ( preg_match ( '/<!--more(.*?)?-->/' , $post , $matches ) ) {
2007-01-27 18:31:42 -05:00
list ( $main , $extended ) = explode ( $matches [ 0 ], $post , 2 );
2012-03-08 07:50:21 -05:00
$more_text = $matches [ 1 ];
2006-08-05 00:11:51 -04:00
} else {
$main = $post ;
$extended = '' ;
2012-03-08 07:50:21 -05:00
$more_text = '' ;
2006-08-05 00:11:51 -04:00
}
2007-02-27 10:24:54 -05:00
2013-03-03 16:11:40 -05:00
// ` leading and trailing whitespace
2007-01-27 18:31:42 -05:00
$main = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $main );
$extended = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $extended );
2012-03-08 07:50:21 -05:00
$more_text = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $more_text );
2006-06-07 19:17:59 -04:00
2012-03-08 07:50:21 -05:00
return array ( 'main' => $main , 'extended' => $extended , 'more_text' => $more_text );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieves post data given a post ID or post object .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* See { @ link sanitize_post ()} for optional $filter values . Also , the parameter
* $post , must be given as a variable , since it is passed by reference .
2007-12-13 19:28:34 -05:00
*
* @ since 1.5 . 1
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post
2007-12-13 19:28:34 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Optional . Post ID or post object .
2008-08-19 12:38:06 -04:00
* @ param string $output Optional , default is Object . Either OBJECT , ARRAY_A , or ARRAY_N .
2008-12-09 13:03:31 -05:00
* @ param string $filter Optional , default is raw .
2012-08-23 16:34:41 -04:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-13 19:28:34 -05:00
*/
2012-09-04 12:29:28 -04:00
function get_post ( $post = null , $output = OBJECT , $filter = 'raw' ) {
2012-08-21 11:42:28 -04:00
if ( empty ( $post ) && isset ( $GLOBALS [ 'post' ] ) )
$post = $GLOBALS [ 'post' ];
2006-06-07 19:17:59 -04:00
2012-08-21 11:42:28 -04:00
if ( is_a ( $post , 'WP_Post' ) ) {
2011-09-30 15:06:18 -04:00
$_post = $post ;
2012-08-20 15:47:52 -04:00
} elseif ( is_object ( $post ) ) {
if ( empty ( $post -> filter ) ) {
$_post = sanitize_post ( $post , 'raw' );
$_post = new WP_Post ( $_post );
} elseif ( 'raw' == $post -> filter ) {
$_post = new WP_Post ( $post );
} else {
$_post = WP_Post :: get_instance ( $post -> ID );
}
2006-06-07 19:17:59 -04:00
} else {
2012-08-20 15:47:52 -04:00
$_post = WP_Post :: get_instance ( $post );
}
2012-08-21 11:42:28 -04:00
if ( ! $_post )
return null ;
2012-08-20 15:47:52 -04:00
$_post = $_post -> filter ( $filter );
2012-08-21 11:42:28 -04:00
if ( $output == ARRAY_A )
return $_post -> to_array ();
elseif ( $output == ARRAY_N )
return array_values ( $_post -> to_array () );
2012-08-20 15:47:52 -04:00
return $_post ;
}
/**
* WordPress Post class .
*
* @ since 3.5 . 0
*
*/
final class WP_Post {
2012-10-19 17:53:17 -04:00
/**
2013-08-22 11:58:09 -04:00
* Post ID .
2012-10-19 17:53:17 -04:00
*
* @ var int
*/
public $ID ;
/**
2013-08-22 11:58:09 -04:00
* ID of post author .
2012-10-19 17:53:17 -04:00
*
2013-08-22 11:58:09 -04:00
* A numeric string , for compatibility reasons .
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_author = 0 ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s local publication time .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_date = '0000-00-00 00:00:00' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s GMT publication time .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_date_gmt = '0000-00-00 00:00:00' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s content .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_content = '' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s title .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_title = '' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s excerpt .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_excerpt = '' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s status .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_status = 'publish' ;
/**
2013-08-22 11:58:09 -04:00
* Whether comments are allowed .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $comment_status = 'open' ;
/**
2013-08-22 11:58:09 -04:00
* Whether pings are allowed .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $ping_status = 'open' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s password in plain text .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_password = '' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s slug .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_name = '' ;
/**
2013-08-22 11:58:09 -04:00
* URLs queued to be pinged .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $to_ping = '' ;
/**
2013-08-22 11:58:09 -04:00
* URLs that have been pinged .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $pinged = '' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s local modified time .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_modified = '0000-00-00 00:00:00' ;
/**
2013-08-22 11:58:09 -04:00
* The post ' s GMT modified time .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_modified_gmt = '0000-00-00 00:00:00' ;
/**
2013-08-22 11:58:09 -04:00
* A utility DB field for post content .
*
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_content_filtered = '' ;
/**
2013-08-22 11:58:09 -04:00
* ID of a post ' s parent post .
2012-10-19 17:53:17 -04:00
*
* @ var int
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_parent = 0 ;
/**
2013-08-22 11:58:09 -04:00
* The unique identifier for a post , not necessarily a URL , used as the feed GUID .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $guid = '' ;
/**
2013-08-22 11:58:09 -04:00
* A field used for ordering posts .
2012-10-19 17:53:17 -04:00
*
* @ var int
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $menu_order = 0 ;
/**
2013-08-22 19:48:09 -04:00
* The post ' s type , like post or page .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_type = 'post' ;
/**
2013-08-22 11:58:09 -04:00
* An attachment ' s mime type .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2012-10-19 17:53:17 -04:00
public $post_mime_type = '' ;
/**
2013-08-22 11:58:09 -04:00
* Cached comment count .
2012-10-19 17:53:17 -04:00
*
2013-08-22 11:58:09 -04:00
* A numeric string , for compatibility reasons .
2012-10-19 17:53:17 -04:00
*
* @ var string
2012-11-02 12:13:53 -04:00
*/
2013-08-22 11:58:09 -04:00
public $comment_count = 0 ;
2012-08-20 15:47:52 -04:00
2013-05-20 07:05:50 -04:00
/**
2013-08-22 11:58:09 -04:00
* Stores the post object ' s sanitization level .
2013-05-20 07:05:50 -04:00
*
2013-08-22 11:58:09 -04:00
* Does not correspond to a DB field .
2013-05-20 07:05:50 -04:00
*
2013-08-22 11:58:09 -04:00
* @ var string
2013-05-20 07:05:50 -04:00
*/
2013-08-22 11:58:09 -04:00
public $filter ;
2013-05-20 07:05:50 -04:00
2012-08-20 15:47:52 -04:00
public static function get_instance ( $post_id ) {
global $wpdb ;
2010-06-10 10:55:26 -04:00
$post_id = ( int ) $post_id ;
2012-11-17 10:14:48 -05:00
if ( ! $post_id )
2012-08-20 15:47:52 -04:00
return false ;
2012-11-17 10:14:48 -05:00
$_post = wp_cache_get ( $post_id , 'posts' );
if ( ! $_post ) {
2012-10-14 23:08:43 -04:00
$_post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $post_id ) );
2012-08-20 15:47:52 -04:00
2008-06-23 17:50:19 -04:00
if ( ! $_post )
2012-08-20 15:47:52 -04:00
return false ;
$_post = sanitize_post ( $_post , 'raw' );
wp_cache_add ( $_post -> ID , $_post , 'posts' );
2012-11-17 10:14:48 -05:00
} elseif ( empty ( $_post -> filter ) ) {
$_post = sanitize_post ( $_post , 'raw' );
2006-06-07 19:17:59 -04:00
}
2012-08-20 15:47:52 -04:00
return new WP_Post ( $_post );
2006-06-07 19:17:59 -04:00
}
2012-08-20 15:47:52 -04:00
public function __construct ( $post ) {
foreach ( get_object_vars ( $post ) as $key => $value )
$this -> $key = $value ;
}
2007-07-11 15:57:43 -04:00
2012-08-20 15:47:52 -04:00
public function __isset ( $key ) {
if ( 'ancestors' == $key )
return true ;
2012-08-28 15:08:28 -04:00
if ( 'page_template' == $key )
return ( 'page' == $this -> post_type );
if ( 'post_category' == $key )
return true ;
if ( 'tags_input' == $key )
return true ;
2012-08-20 15:47:52 -04:00
return metadata_exists ( 'post' , $this -> ID , $key );
}
2012-08-29 09:23:54 -04:00
public function __get ( $key ) {
2012-08-28 15:08:28 -04:00
if ( 'page_template' == $key && $this -> __isset ( $key ) ) {
2012-08-29 09:42:11 -04:00
return get_post_meta ( $this -> ID , '_wp_page_template' , true );
2012-08-28 15:08:28 -04:00
}
if ( 'post_category' == $key ) {
2012-11-20 13:31:06 -05:00
if ( is_object_in_taxonomy ( $this -> post_type , 'category' ) )
$terms = get_the_terms ( $this , 'category' );
if ( empty ( $terms ) )
2012-08-29 09:42:11 -04:00
return array ();
2012-09-24 16:35:56 -04:00
return wp_list_pluck ( $terms , 'term_id' );
2012-08-28 15:08:28 -04:00
}
if ( 'tags_input' == $key ) {
2012-11-20 13:31:06 -05:00
if ( is_object_in_taxonomy ( $this -> post_type , 'post_tag' ) )
$terms = get_the_terms ( $this , 'post_tag' );
if ( empty ( $terms ) )
2012-08-29 09:42:11 -04:00
return array ();
2012-09-24 16:35:56 -04:00
return wp_list_pluck ( $terms , 'name' );
2012-08-28 15:08:28 -04:00
}
// Rest of the values need filtering
2012-08-29 09:42:11 -04:00
if ( 'ancestors' == $key )
2012-08-20 15:47:52 -04:00
$value = get_post_ancestors ( $this );
2012-08-29 09:42:11 -04:00
else
2012-08-20 15:47:52 -04:00
$value = get_post_meta ( $this -> ID , $key , true );
2012-08-29 09:42:11 -04:00
if ( $this -> filter )
2012-08-20 15:47:52 -04:00
$value = sanitize_post_field ( $key , $value , $this -> ID , $this -> filter );
return $value ;
}
public function filter ( $filter ) {
if ( $this -> filter == $filter )
return $this ;
if ( $filter == 'raw' )
return self :: get_instance ( $this -> ID );
return sanitize_post ( $this , $filter );
}
public function to_array () {
$post = get_object_vars ( $this );
2012-08-28 15:08:28 -04:00
foreach ( array ( 'ancestors' , 'page_template' , 'post_category' , 'tags_input' ) as $key ) {
if ( $this -> __isset ( $key ) )
$post [ $key ] = $this -> __get ( $key );
}
2012-08-20 15:47:52 -04:00
return $post ;
2006-06-07 19:17:59 -04:00
}
}
2008-02-27 18:28:18 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve ancestors of a post .
2008-02-27 18:28:18 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-02-27 18:28:18 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Post ID or post object .
2008-06-27 11:32:57 -04:00
* @ return array Ancestor IDs or empty array if none are found .
2008-02-27 18:28:18 -05:00
*/
2012-08-20 15:47:52 -04:00
function get_post_ancestors ( $post ) {
$post = get_post ( $post );
2012-03-12 14:23:48 -04:00
2013-03-07 01:49:46 -05:00
if ( ! $post || empty ( $post -> post_parent ) || $post -> post_parent == $post -> ID )
2012-09-22 12:21:06 -04:00
return array ();
2008-02-27 18:28:18 -05:00
2012-09-22 12:21:06 -04:00
$ancestors = array ();
2012-08-20 15:47:52 -04:00
2012-09-22 12:21:06 -04:00
$id = $ancestors [] = $post -> post_parent ;
2012-08-20 15:47:52 -04:00
2012-09-22 12:21:06 -04:00
while ( $ancestor = get_post ( $id ) ) {
// Loop detection: If the ancestor has been seen before, break.
if ( empty ( $ancestor -> post_parent ) || ( $ancestor -> post_parent == $post -> ID ) || in_array ( $ancestor -> post_parent , $ancestors ) )
break ;
$id = $ancestors [] = $ancestor -> post_parent ;
}
2012-08-20 15:47:52 -04:00
return $ancestors ;
2008-02-27 18:28:18 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve data from a post field based on Post ID .
*
2011-10-21 13:13:26 -04:00
* Examples of the post field will be , 'post_type' , 'post_status' , 'post_content' ,
2008-06-27 11:32:57 -04:00
* etc and based off of the post object property or key names .
*
* The context values are based off of the taxonomy filter functions and
* supported values are found within those functions .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2008-06-27 11:32:57 -04:00
* @ uses sanitize_post_field () See for possible $context values .
2007-12-13 19:28:34 -05:00
*
2013-06-21 08:45:11 -04:00
* @ param string $field Post field name .
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Post ID or post object .
2013-06-21 08:45:11 -04:00
* @ param string $context Optional . How to filter the field . Default is 'display' .
* @ return string The value of the post field on success , empty string on failure .
2007-12-13 19:28:34 -05:00
*/
2007-07-11 15:57:43 -04:00
function get_post_field ( $field , $post , $context = 'display' ) {
2007-07-12 12:00:51 -04:00
$post = get_post ( $post );
2007-07-11 15:57:43 -04:00
2012-08-20 15:47:52 -04:00
if ( ! $post )
2007-07-11 15:57:43 -04:00
return '' ;
if ( ! isset ( $post -> $field ) )
return '' ;
return sanitize_post_field ( $field , $post -> $field , $post -> ID , $context );
}
2007-12-13 19:28:34 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve the mime type of an attachment based on the ID .
*
* This function can be used with any post type , but it makes more sense with
* attachments .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $ID Optional . Post ID or post object .
2013-06-21 08:45:11 -04:00
* @ return string | bool The mime type on success , false on failure .
2007-12-13 19:28:34 -05:00
*/
2006-06-07 19:17:59 -04:00
function get_post_mime_type ( $ID = '' ) {
2012-08-23 16:01:10 -04:00
$post = get_post ( $ID );
2006-06-07 19:17:59 -04:00
if ( is_object ( $post ) )
return $post -> post_mime_type ;
return false ;
}
2007-12-13 19:28:34 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve the post status based on the Post ID .
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* If the post ID is of an attachment , then the parent post status will be given
* instead .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $ID Optional . Post ID or post object .
2013-06-21 08:45:11 -04:00
* @ return string | bool Post status on success , false on failure .
2007-12-13 19:28:34 -05:00
*/
2006-06-07 19:17:59 -04:00
function get_post_status ( $ID = '' ) {
$post = get_post ( $ID );
2010-04-14 11:20:15 -04:00
if ( ! is_object ( $post ) )
return false ;
2006-06-07 19:17:59 -04:00
2011-05-22 19:25:28 -04:00
if ( 'attachment' == $post -> post_type ) {
if ( 'private' == $post -> post_status )
return 'private' ;
2010-04-14 11:20:15 -04:00
2011-05-22 19:25:28 -04:00
// Unattached attachments are assumed to be published
if ( ( 'inherit' == $post -> post_status ) && ( 0 == $post -> post_parent ) )
return 'publish' ;
// Inherit status from the parent
if ( $post -> post_parent && ( $post -> ID != $post -> post_parent ) )
return get_post_status ( $post -> post_parent );
}
2010-04-14 11:20:15 -04:00
return $post -> post_status ;
2006-06-07 19:17:59 -04:00
}
2008-01-10 16:46:25 -05:00
/**
2008-06-27 11:32:57 -04:00
* Retrieve all of the WordPress supported post statuses .
2008-01-10 16:46:25 -05:00
*
* Posts have a limited set of valid status values , this provides the
* post_status values and descriptions .
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-01-10 16:46:25 -05:00
*
2008-06-27 11:32:57 -04:00
* @ return array List of post statuses .
2008-01-10 16:46:25 -05:00
*/
2013-01-04 05:13:51 -05:00
function get_post_statuses () {
2008-01-10 16:46:25 -05:00
$status = array (
'draft' => __ ( 'Draft' ),
'pending' => __ ( 'Pending Review' ),
'private' => __ ( 'Private' ),
'publish' => __ ( 'Published' )
);
return $status ;
}
/**
2008-06-27 11:32:57 -04:00
* Retrieve all of the WordPress support page statuses .
2008-01-10 16:46:25 -05:00
*
* Pages have a limited set of valid status values , this provides the
* post_status values and descriptions .
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-01-10 16:46:25 -05:00
*
2008-06-27 11:32:57 -04:00
* @ return array List of page statuses .
2008-01-10 16:46:25 -05:00
*/
2013-01-04 05:13:51 -05:00
function get_page_statuses () {
2008-01-10 16:46:25 -05:00
$status = array (
'draft' => __ ( 'Draft' ),
'private' => __ ( 'Private' ),
'publish' => __ ( 'Published' )
);
return $status ;
}
2010-01-13 13:49:56 -05:00
/**
2012-05-05 15:04:34 -04:00
* Register a post status . Do not use before init .
2010-01-13 13:49:56 -05:00
*
* A simple function for creating or modifying a post status based on the
* parameters given . The function will accept an array ( second optional
* parameter ), along with a string for the post status name .
*
*
* Optional $args contents :
*
* label - A descriptive name for the post status marked for translation . Defaults to $post_status .
2010-12-26 17:45:34 -05:00
* public - Whether posts of this status should be shown in the front end of the site . Defaults to true .
2011-06-27 17:22:31 -04:00
* exclude_from_search - Whether to exclude posts with this post status from search results . Defaults to false .
2010-12-26 17:45:34 -05:00
* show_in_admin_all_list - Whether to include posts in the edit listing for their post type
2011-01-05 23:11:14 -05:00
* show_in_admin_status_list - Show in the list of statuses with post counts at the top of the edit
2010-12-26 17:45:34 -05:00
* listings , e . g . All ( 12 ) | Published ( 9 ) | My Custom Status ( 2 ) ...
2011-01-05 23:11:14 -05:00
*
2010-12-26 17:45:34 -05:00
* Arguments prefixed with an _underscore shouldn ' t be used by plugins and themes .
2010-01-13 13:49:56 -05:00
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-13 13:49:56 -05:00
* @ uses $wp_post_statuses Inserts new post status object into the list
*
* @ param string $post_status Name of the post status .
* @ param array | string $args See above description .
*/
function register_post_status ( $post_status , $args = array ()) {
global $wp_post_statuses ;
if ( ! is_array ( $wp_post_statuses ))
$wp_post_statuses = array ();
// Args prefixed with an underscore are reserved for internal use.
2012-07-22 04:45:35 -04:00
$defaults = array (
'label' => false ,
'label_count' => false ,
'exclude_from_search' => null ,
'_builtin' => false ,
'public' => null ,
'internal' => null ,
'protected' => null ,
'private' => null ,
'publicly_queryable' => null ,
'show_in_admin_status_list' => null ,
'show_in_admin_all_list' => null ,
);
2010-01-13 13:49:56 -05:00
$args = wp_parse_args ( $args , $defaults );
$args = ( object ) $args ;
2010-09-20 11:28:58 -04:00
$post_status = sanitize_key ( $post_status );
2010-01-13 13:49:56 -05:00
$args -> name = $post_status ;
2010-02-16 16:13:44 -05:00
if ( null === $args -> public && null === $args -> internal && null === $args -> protected && null === $args -> private )
$args -> internal = true ;
if ( null === $args -> public )
$args -> public = false ;
if ( null === $args -> private )
$args -> private = false ;
if ( null === $args -> protected )
$args -> protected = false ;
if ( null === $args -> internal )
$args -> internal = false ;
2010-02-06 12:46:00 -05:00
if ( null === $args -> publicly_queryable )
$args -> publicly_queryable = $args -> public ;
if ( null === $args -> exclude_from_search )
2010-02-16 16:13:44 -05:00
$args -> exclude_from_search = $args -> internal ;
2010-02-06 12:46:00 -05:00
2010-02-16 16:13:44 -05:00
if ( null === $args -> show_in_admin_all_list )
$args -> show_in_admin_all_list = ! $args -> internal ;
if ( null === $args -> show_in_admin_status_list )
2012-07-22 04:45:35 -04:00
$args -> show_in_admin_status_list = ! $args -> internal ;
2010-02-16 16:13:44 -05:00
2010-01-13 13:49:56 -05:00
if ( false === $args -> label )
$args -> label = $post_status ;
if ( false === $args -> label_count )
2010-04-27 18:36:46 -04:00
$args -> label_count = array ( $args -> label , $args -> label );
2010-01-13 13:49:56 -05:00
$wp_post_statuses [ $post_status ] = $args ;
return $args ;
}
/**
* Retrieve a post status object by name
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-13 13:49:56 -05:00
* @ uses $wp_post_statuses
* @ see register_post_status
* @ see get_post_statuses
*
2010-09-07 07:21:11 -04:00
* @ param string $post_status The name of a registered post status
2010-01-13 13:49:56 -05:00
* @ return object A post status object
*/
function get_post_status_object ( $post_status ) {
global $wp_post_statuses ;
if ( empty ( $wp_post_statuses [ $post_status ]) )
return null ;
return $wp_post_statuses [ $post_status ];
}
/**
* Get a list of all registered post status objects .
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-13 13:49:56 -05:00
* @ uses $wp_post_statuses
* @ see register_post_status
* @ see get_post_status_object
*
2010-04-16 10:08:58 -04:00
* @ param array | string $args An array of key => value arguments to match against the post status objects .
2010-01-13 13:49:56 -05:00
* @ param string $output The type of output to return , either post status 'names' or 'objects' . 'names' is the default .
2010-05-03 16:26:11 -04:00
* @ param string $operator The logical operation to perform . 'or' means only one element
2010-04-16 10:08:58 -04:00
* from the array needs to match ; 'and' means all elements must match . The default is 'and' .
2012-05-13 03:41:47 -04:00
* @ return array A list of post status names or objects
2010-01-13 13:49:56 -05:00
*/
2010-04-16 10:08:58 -04:00
function get_post_stati ( $args = array (), $output = 'names' , $operator = 'and' ) {
2010-01-13 13:49:56 -05:00
global $wp_post_statuses ;
2010-04-16 10:08:58 -04:00
$field = ( 'names' == $output ) ? 'name' : false ;
2010-01-13 13:49:56 -05:00
2010-04-16 10:08:58 -04:00
return wp_filter_object_list ( $wp_post_statuses , $args , $operator , $field );
2010-01-13 13:49:56 -05:00
}
2010-04-10 07:42:45 -04:00
/**
* Whether the post type is hierarchical .
*
* A false return value might also mean that the post type does not exist .
*
* @ since 3.0 . 0
* @ see get_post_type_object
*
2010-09-07 07:21:11 -04:00
* @ param string $post_type Post type name
2010-05-08 18:10:28 -04:00
* @ return bool Whether post type is hierarchical .
2010-04-10 07:42:45 -04:00
*/
2010-05-08 18:10:28 -04:00
function is_post_type_hierarchical ( $post_type ) {
2010-06-11 11:53:41 -04:00
if ( ! post_type_exists ( $post_type ) )
2010-05-08 18:10:28 -04:00
return false ;
2010-04-10 07:54:33 -04:00
2010-05-08 18:10:28 -04:00
$post_type = get_post_type_object ( $post_type );
return $post_type -> hierarchical ;
2010-04-10 07:42:45 -04:00
}
2010-04-18 13:40:50 -04:00
/**
2010-05-08 18:10:28 -04:00
* Checks if a post type is registered .
2010-04-18 13:40:50 -04:00
*
* @ since 3.0 . 0
2010-06-11 11:53:41 -04:00
* @ uses get_post_type_object ()
2010-04-18 13:40:50 -04:00
*
2010-09-07 07:21:11 -04:00
* @ param string $post_type Post type name
2010-05-08 18:10:28 -04:00
* @ return bool Whether post type is registered .
2010-04-18 13:40:50 -04:00
*/
2010-06-11 11:53:41 -04:00
function post_type_exists ( $post_type ) {
2010-05-08 18:10:28 -04:00
return ( bool ) get_post_type_object ( $post_type );
2010-04-18 13:40:50 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve the post type of the current post or of a given post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Optional . Post ID or post object .
2013-06-21 08:45:11 -04:00
* @ return string | bool Post type on success , false on failure .
2007-12-13 19:28:34 -05:00
*/
2012-09-04 12:29:28 -04:00
function get_post_type ( $post = null ) {
if ( $post = get_post ( $post ) )
return $post -> post_type ;
2006-06-07 19:17:59 -04:00
return false ;
}
2010-01-04 11:58:43 -05:00
/**
* Retrieve a post type object by name
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-04 11:58:43 -05:00
* @ uses $wp_post_types
* @ see register_post_type
* @ see get_post_types
*
* @ param string $post_type The name of a registered post type
* @ return object A post type object
*/
function get_post_type_object ( $post_type ) {
global $wp_post_types ;
if ( empty ( $wp_post_types [ $post_type ]) )
return null ;
return $wp_post_types [ $post_type ];
}
2009-10-06 10:43:05 -04:00
/**
* Get a list of all registered post type objects .
*
* @ since 2.9 . 0
* @ uses $wp_post_types
* @ see register_post_type
*
2010-04-16 10:08:58 -04:00
* @ param array | string $args An array of key => value arguments to match against the post type objects .
2009-10-06 10:43:05 -04:00
* @ param string $output The type of output to return , either post type 'names' or 'objects' . 'names' is the default .
2010-05-03 16:26:11 -04:00
* @ param string $operator The logical operation to perform . 'or' means only one element
2010-04-16 10:08:58 -04:00
* from the array needs to match ; 'and' means all elements must match . The default is 'and' .
2009-10-06 10:43:05 -04:00
* @ return array A list of post type names or objects
*/
2010-04-16 10:08:58 -04:00
function get_post_types ( $args = array (), $output = 'names' , $operator = 'and' ) {
2009-10-06 10:43:05 -04:00
global $wp_post_types ;
2010-04-16 10:08:58 -04:00
$field = ( 'names' == $output ) ? 'name' : false ;
2009-10-06 10:43:05 -04:00
2010-04-16 10:08:58 -04:00
return wp_filter_object_list ( $wp_post_types , $args , $operator , $field );
2009-10-06 10:43:05 -04:00
}
/**
* Register a post type . Do not use before init .
*
2010-10-23 14:03:26 -04:00
* A function for creating or modifying a post type based on the
2009-10-06 10:43:05 -04:00
* parameters given . The function will accept an array ( second optional
* parameter ), along with a string for the post type name .
*
* Optional $args contents :
*
2010-05-13 22:13:49 -04:00
* - label - Name of the post type shown in the menu . Usually plural . If not set , labels [ 'name' ] will be used .
2012-05-07 12:25:06 -04:00
* - labels - An array of labels for this post type .
* * If not set , post labels are inherited for non - hierarchical types and page labels for hierarchical ones .
* * You can see accepted values in { @ link get_post_type_labels ()} .
2010-05-11 15:52:50 -04:00
* - description - A short descriptive summary of what the post type is . Defaults to blank .
2012-05-07 12:25:06 -04:00
* - public - Whether a post type is intended for use publicly either via the admin interface or by front - end users .
* * Defaults to false .
* * While the default settings of exclude_from_search , publicly_queryable , show_ui , and show_in_nav_menus are
* inherited from public , each does not rely on this relationship and controls a very specific intention .
2013-08-26 16:24:08 -04:00
* - hierarchical - Whether the post type is hierarchical ( e . g . page ) . Defaults to false .
2012-05-07 12:25:06 -04:00
* - exclude_from_search - Whether to exclude posts with this post type from front end search results .
2013-05-09 21:39:30 -04:00
* * If not set , the opposite of public ' s current value is used .
2012-05-07 12:25:06 -04:00
* - publicly_queryable - Whether queries can be performed on the front end for the post type as part of parse_request () .
* * ? post_type = { post_type_key }
* * ? { post_type_key } = { single_post_slug }
* * ? { post_type_query_var } = { single_post_slug }
* * If not set , the default is inherited from public .
* - show_ui - Whether to generate a default UI for managing this post type in the admin .
* * If not set , the default is inherited from public .
* - show_in_menu - Where to show the post type in the admin menu .
* * If true , the post type is shown in its own top level menu .
* * If false , no menu is shown
* * If a string of an existing top level menu ( eg . 'tools.php' or 'edit.php?post_type=page' ), the post type will
* be placed as a sub menu of that .
* * show_ui must be true .
* * If not set , the default is inherited from show_ui
2013-08-26 16:24:08 -04:00
* - show_in_nav_menus - Makes this post type available for selection in navigation menus .
* * If not set , the default is inherited from public .
2012-05-07 12:25:06 -04:00
* - show_in_admin_bar - Makes this post type available via the admin bar .
* * If not set , the default is inherited from show_in_menu
* - menu_position - The position in the menu order the post type should appear .
* * show_in_menu must be true
* * Defaults to null , which places it at the bottom of its area .
2010-05-11 15:52:50 -04:00
* - menu_icon - The url to the icon to be used for this menu . Defaults to use the posts icon .
2013-12-05 01:38:09 -05:00
* * Pass a base64 - encoded SVG using a data URI , which will be colored to match the color scheme .
* This should begin with 'data:image/svg+xml;base64,' .
2013-12-31 05:33:11 -05:00
* * Pass the name of a Dashicons helper class to use a font icon , e . g . 'dashicons-chart-pie' .
2013-12-05 01:38:09 -05:00
* * Pass 'none' to leave div . wp - menu - image empty so an icon can be added via CSS .
2010-11-10 09:50:14 -05:00
* - capability_type - The string to use to build the read , edit , and delete capabilities . Defaults to 'post' .
2012-05-07 12:25:06 -04:00
* * May be passed as an array to allow for alternative plurals when using this argument as a base to construct the
* capabilities , e . g . array ( 'story' , 'stories' ) .
* - capabilities - Array of capabilities for this post type .
* * By default the capability_type is used as a base to construct capabilities .
* * You can see accepted values in { @ link get_post_type_capabilities ()} .
2010-10-21 10:40:04 -04:00
* - map_meta_cap - Whether to use the internal default meta capability handling . Defaults to false .
2012-05-07 12:25:06 -04:00
* - supports - An alias for calling add_post_type_support () directly . Defaults to title and editor .
* * See { @ link add_post_type_support ()} for documentation .
2013-09-23 13:12:10 -04:00
* - register_meta_box_cb - Provide a callback function that sets up the meta boxes
* for the edit form . Do remove_meta_box () and add_meta_box () calls in the callback .
2010-10-23 14:03:26 -04:00
* - taxonomies - An array of taxonomy identifiers that will be registered for the post type .
2012-05-07 12:25:06 -04:00
* * Default is no taxonomies .
* * Taxonomies can be registered later with register_taxonomy () or register_taxonomy_for_object_type () .
* - has_archive - True to enable post type archives . Default is false .
* * Will generate the proper rewrite rules if rewrite is enabled .
* - rewrite - Triggers the handling of rewrites for this post type . Defaults to true , using $post_type as slug .
* * To prevent rewrite , set to false .
* * To specify rewrite rules , an array can be passed with any of these keys
* * 'slug' => string Customize the permastruct slug . Defaults to $post_type key
* * 'with_front' => bool Should the permastruct be prepended with WP_Rewrite :: $front . Defaults to true .
* * 'feeds' => bool Should a feed permastruct be built for this post type . Inherits default from has_archive .
* * 'pages' => bool Should the permastruct provide for pagination . Defaults to true .
* * 'ep_mask' => const Assign an endpoint mask .
* * If not specified and permalink_epmask is set , inherits from permalink_epmask .
* * If not specified and permalink_epmask is not set , defaults to EP_PERMALINK
* - query_var - Sets the query_var key for this post type . Defaults to $post_type key
* * If false , a post type cannot be loaded at ? { query_var } = { post_slug }
* * If specified as a string , the query ? { query_var_string } = { post_slug } will be valid .
* - can_export - Allows this post type to be exported . Defaults to true .
2012-05-08 13:01:50 -04:00
* - delete_with_user - Whether to delete posts of this type when deleting a user .
* * If true , posts of this type belonging to the user will be moved to trash when then user is deleted .
* * If false , posts of this type belonging to the user will * not * be trashed or deleted .
* * If not set ( the default ), posts are trashed if post_type_supports ( 'author' ) . Otherwise posts are not trashed or deleted .
2010-10-23 14:03:26 -04:00
* - _builtin - true if this post type is a native or " built-in " post_type . THIS IS FOR INTERNAL USE ONLY !
* - _edit_link - URL segement to use for edit link of this post type . THIS IS FOR INTERNAL USE ONLY !
2010-05-14 18:26:07 -04:00
*
2009-10-06 10:43:05 -04:00
* @ since 2.9 . 0
* @ uses $wp_post_types Inserts new post type object into the list
2013-08-26 16:24:08 -04:00
* @ uses $wp_rewrite Gets default feeds
* @ uses $wp Adds query vars
2009-10-06 10:43:05 -04:00
*
2013-08-26 16:24:08 -04:00
* @ param string $post_type Post type key , must not exceed 20 characters .
2012-05-07 12:25:06 -04:00
* @ param array | string $args See optional args description above .
2013-08-26 16:24:08 -04:00
* @ return object | WP_Error the registered post type object , or an error object .
2009-10-06 10:43:05 -04:00
*/
2012-05-07 12:25:06 -04:00
function register_post_type ( $post_type , $args = array () ) {
2010-02-01 18:12:26 -05:00
global $wp_post_types , $wp_rewrite , $wp ;
2009-10-06 10:43:05 -04:00
2013-08-26 16:24:08 -04:00
if ( ! is_array ( $wp_post_types ) )
2009-10-06 10:43:05 -04:00
$wp_post_types = array ();
2010-01-04 11:58:43 -05:00
// Args prefixed with an underscore are reserved for internal use.
2010-05-11 15:52:50 -04:00
$defaults = array (
2013-08-26 16:24:08 -04:00
'labels' => array (),
'description' => '' ,
'public' => false ,
'hierarchical' => false ,
'exclude_from_search' => null ,
'publicly_queryable' => null ,
'show_ui' => null ,
'show_in_menu' => null ,
'show_in_nav_menus' => null ,
'show_in_admin_bar' => null ,
'menu_position' => null ,
'menu_icon' => null ,
'capability_type' => 'post' ,
'capabilities' => array (),
'map_meta_cap' => null ,
'supports' => array (),
'register_meta_box_cb' => null ,
'taxonomies' => array (),
'has_archive' => false ,
'rewrite' => true ,
'query_var' => true ,
'can_export' => true ,
'delete_with_user' => null ,
'_builtin' => false ,
'_edit_link' => 'post.php?post=%d' ,
2010-05-11 15:52:50 -04:00
);
2013-08-26 16:24:08 -04:00
$args = wp_parse_args ( $args , $defaults );
2010-01-04 11:58:43 -05:00
$args = ( object ) $args ;
2009-10-06 10:43:05 -04:00
2013-08-26 16:24:08 -04:00
$post_type = sanitize_key ( $post_type );
2010-01-04 11:58:43 -05:00
$args -> name = $post_type ;
2010-12-01 15:43:39 -05:00
if ( strlen ( $post_type ) > 20 )
2013-08-26 16:24:08 -04:00
return new WP_Error ( 'post_type_too_long' , __ ( 'Post types cannot exceed 20 characters in length' ) );
2010-12-01 15:43:39 -05:00
2010-02-01 18:12:26 -05:00
// If not set, default to the setting for public.
if ( null === $args -> publicly_queryable )
$args -> publicly_queryable = $args -> public ;
2010-02-06 12:27:30 -05:00
// If not set, default to the setting for public.
if ( null === $args -> show_ui )
$args -> show_ui = $args -> public ;
2010-10-19 03:58:02 -04:00
// If not set, default to the setting for show_ui.
if ( null === $args -> show_in_menu || ! $args -> show_ui )
$args -> show_in_menu = $args -> show_ui ;
2011-06-10 22:20:18 -04:00
// If not set, default to the whether the full UI is shown.
if ( null === $args -> show_in_admin_bar )
$args -> show_in_admin_bar = true === $args -> show_in_menu ;
2013-08-26 16:24:08 -04:00
// If not set, default to the setting for public.
2010-05-13 13:29:45 -04:00
if ( null === $args -> show_in_nav_menus )
$args -> show_in_nav_menus = $args -> public ;
2010-02-01 18:12:26 -05:00
// If not set, default to true if not public, false if public.
if ( null === $args -> exclude_from_search )
$args -> exclude_from_search = ! $args -> public ;
2010-11-13 03:40:38 -05:00
// Back compat with quirky handling in version 3.0. #14122
2010-11-15 12:11:34 -05:00
if ( empty ( $args -> capabilities ) && null === $args -> map_meta_cap && in_array ( $args -> capability_type , array ( 'post' , 'page' ) ) )
2010-11-13 03:40:38 -05:00
$args -> map_meta_cap = true ;
2013-08-26 16:24:08 -04:00
// If not set, default to false.
2010-11-13 03:40:38 -05:00
if ( null === $args -> map_meta_cap )
$args -> map_meta_cap = false ;
2010-05-12 16:45:18 -04:00
$args -> cap = get_post_type_capabilities ( $args );
2013-08-26 16:24:08 -04:00
unset ( $args -> capabilities );
2010-01-04 11:58:43 -05:00
2010-10-23 14:03:26 -04:00
if ( is_array ( $args -> capability_type ) )
$args -> capability_type = $args -> capability_type [ 0 ];
2013-08-26 16:24:08 -04:00
if ( ! empty ( $args -> supports ) ) {
add_post_type_support ( $post_type , $args -> supports );
unset ( $args -> supports );
2012-09-13 13:02:39 -04:00
} elseif ( false !== $args -> supports ) {
2010-03-15 17:16:41 -04:00
// Add default features
2013-08-26 16:24:08 -04:00
add_post_type_support ( $post_type , array ( 'title' , 'editor' ) );
2010-01-18 06:44:51 -05:00
}
2013-08-26 16:24:08 -04:00
if ( false !== $args -> query_var && ! empty ( $wp ) ) {
2010-02-01 18:12:26 -05:00
if ( true === $args -> query_var )
$args -> query_var = $post_type ;
2012-08-20 13:25:06 -04:00
else
2013-08-26 16:24:08 -04:00
$args -> query_var = sanitize_title_with_dashes ( $args -> query_var );
$wp -> add_query_var ( $args -> query_var );
2010-02-01 18:12:26 -05:00
}
2013-08-26 16:24:08 -04:00
if ( false !== $args -> rewrite && ( is_admin () || '' != get_option ( 'permalink_structure' ) ) ) {
2010-10-23 14:29:22 -04:00
if ( ! is_array ( $args -> rewrite ) )
2010-02-01 18:12:26 -05:00
$args -> rewrite = array ();
2011-01-14 10:42:56 -05:00
if ( empty ( $args -> rewrite [ 'slug' ] ) )
2010-02-01 18:12:26 -05:00
$args -> rewrite [ 'slug' ] = $post_type ;
2010-10-23 14:29:22 -04:00
if ( ! isset ( $args -> rewrite [ 'with_front' ] ) )
2010-02-01 18:12:26 -05:00
$args -> rewrite [ 'with_front' ] = true ;
2010-10-26 03:12:06 -04:00
if ( ! isset ( $args -> rewrite [ 'pages' ] ) )
$args -> rewrite [ 'pages' ] = true ;
2010-10-23 14:29:22 -04:00
if ( ! isset ( $args -> rewrite [ 'feeds' ] ) || ! $args -> has_archive )
$args -> rewrite [ 'feeds' ] = ( bool ) $args -> has_archive ;
2012-01-23 14:12:04 -05:00
if ( ! isset ( $args -> rewrite [ 'ep_mask' ] ) ) {
2012-01-23 14:32:39 -05:00
if ( isset ( $args -> permalink_epmask ) )
$args -> rewrite [ 'ep_mask' ] = $args -> permalink_epmask ;
2012-01-23 14:12:04 -05:00
else
$args -> rewrite [ 'ep_mask' ] = EP_PERMALINK ;
}
2010-10-14 06:39:47 -04:00
2010-03-19 22:23:52 -04:00
if ( $args -> hierarchical )
2013-08-30 04:08:09 -04:00
add_rewrite_tag ( " % $post_type % " , '(.+?)' , $args -> query_var ? " { $args -> query_var } = " : " post_type= $post_type &pagename= " );
2010-03-19 22:23:52 -04:00
else
2013-08-26 16:24:08 -04:00
add_rewrite_tag ( " % $post_type % " , '([^/]+)' , $args -> query_var ? " { $args -> query_var } = " : " post_type= $post_type &name= " );
2010-10-14 06:39:47 -04:00
2010-10-23 14:29:22 -04:00
if ( $args -> has_archive ) {
$archive_slug = $args -> has_archive === true ? $args -> rewrite [ 'slug' ] : $args -> has_archive ;
2011-03-09 00:40:52 -05:00
if ( $args -> rewrite [ 'with_front' ] )
$archive_slug = substr ( $wp_rewrite -> front , 1 ) . $archive_slug ;
2011-03-09 23:24:48 -05:00
else
$archive_slug = $wp_rewrite -> root . $archive_slug ;
2011-03-09 00:40:52 -05:00
2012-02-28 15:29:33 -05:00
add_rewrite_rule ( " { $archive_slug } /? $ " , " index.php?post_type= $post_type " , 'top' );
2010-10-14 06:39:47 -04:00
if ( $args -> rewrite [ 'feeds' ] && $wp_rewrite -> feeds ) {
$feeds = '(' . trim ( implode ( '|' , $wp_rewrite -> feeds ) ) . ')' ;
2012-02-28 15:29:33 -05:00
add_rewrite_rule ( " { $archive_slug } /feed/ $feeds /? $ " , " index.php?post_type= $post_type " . '&feed=$matches[1]' , 'top' );
add_rewrite_rule ( " { $archive_slug } / $feeds /? $ " , " index.php?post_type= $post_type " . '&feed=$matches[1]' , 'top' );
2010-10-14 06:39:47 -04:00
}
2010-10-26 03:12:06 -04:00
if ( $args -> rewrite [ 'pages' ] )
2012-02-28 15:29:33 -05:00
add_rewrite_rule ( " { $archive_slug } / { $wp_rewrite -> pagination_base } /([0-9] { 1,})/? $ " , " index.php?post_type= $post_type " . '&paged=$matches[1]' , 'top' );
2010-10-14 06:39:47 -04:00
}
2013-07-28 18:28:18 -04:00
$permastruct_args = $args -> rewrite ;
$permastruct_args [ 'feed' ] = $permastruct_args [ 'feeds' ];
add_permastruct ( $post_type , " { $args -> rewrite [ 'slug' ] } /% $post_type % " , $permastruct_args );
2010-02-01 18:12:26 -05:00
}
2010-02-03 13:54:42 -05:00
if ( $args -> register_meta_box_cb )
2013-08-26 16:24:08 -04:00
add_action ( 'add_meta_boxes_' . $post_type , $args -> register_meta_box_cb , 10 , 1 );
2010-02-03 13:54:42 -05:00
2010-05-11 15:52:50 -04:00
$args -> labels = get_post_type_labels ( $args );
$args -> label = $args -> labels -> name ;
2013-08-26 16:24:08 -04:00
$wp_post_types [ $post_type ] = $args ;
2010-01-04 11:58:43 -05:00
2010-04-10 08:17:19 -04:00
add_action ( 'future_' . $post_type , '_future_post_hook' , 5 , 2 );
2010-02-03 14:50:37 -05:00
foreach ( $args -> taxonomies as $taxonomy ) {
register_taxonomy_for_object_type ( $taxonomy , $post_type );
}
2014-04-13 19:06:14 -04:00
/**
* Fires after a post type is registered .
*
* @ since 3.3 . 0
*
* @ param string $post_type Post type .
* @ param array $args Arguments used to register the post type .
*/
2011-09-30 05:53:35 -04:00
do_action ( 'registered_post_type' , $post_type , $args );
2011-10-24 15:13:23 -04:00
2010-01-04 11:58:43 -05:00
return $args ;
2009-10-06 10:43:05 -04:00
}
2010-05-12 16:45:18 -04:00
/**
* Builds an object with all post type capabilities out of a post type object
2010-05-25 22:42:15 -04:00
*
2010-10-23 14:03:26 -04:00
* Post type capabilities use the 'capability_type' argument as a base , if the
* capability is not set in the 'capabilities' argument array or if the
* 'capabilities' argument is not supplied .
*
* The capability_type argument can optionally be registered as an array , with
* the first value being singular and the second plural , e . g . array ( 'story, ' stories ' )
* Otherwise , an 's' will be added to the value for the plural form . After
* registration , capability_type will always be a string of the singular value .
*
* By default , seven keys are accepted as part of the capabilities array :
*
* - edit_post , read_post , and delete_post are meta capabilities , which are then
* generally mapped to corresponding primitive capabilities depending on the
* context , which would be the post being edited / read / deleted and the user or
* role being checked . Thus these capabilities would generally not be granted
* directly to users or roles .
*
* - edit_posts - Controls whether objects of this post type can be edited .
* - edit_others_posts - Controls whether objects of this type owned by other users
* can be edited . If the post type does not support an author , then this will
* behave like edit_posts .
* - publish_posts - Controls publishing objects of this post type .
* - read_private_posts - Controls whether private objects can be read .
2012-04-14 15:02:04 -04:00
*
2010-10-23 14:03:26 -04:00
* These four primitive capabilities are checked in core in various locations .
* There are also seven other primitive capabilities which are not referenced
* directly in core , except in map_meta_cap (), which takes the three aforementioned
* meta capabilities and translates them into one or more primitive capabilities
* that must then be checked against the user or role , depending on the context .
*
* - read - Controls whether objects of this post type can be read .
* - delete_posts - Controls whether objects of this post type can be deleted .
* - delete_private_posts - Controls whether private objects can be deleted .
* - delete_published_posts - Controls whether published objects can be deleted .
* - delete_others_posts - Controls whether objects owned by other users can be
* can be deleted . If the post type does not support an author , then this will
* behave like delete_posts .
* - edit_private_posts - Controls whether private objects can be edited .
2011-03-23 14:42:59 -04:00
* - edit_published_posts - Controls whether published objects can be edited .
2010-10-23 14:03:26 -04:00
*
* These additional capabilities are only used in map_meta_cap () . Thus , they are
* only assigned by default if the post type is registered with the 'map_meta_cap'
* argument set to true ( default is false ) .
2010-05-25 22:42:15 -04:00
*
2010-10-21 10:40:04 -04:00
* @ see map_meta_cap ()
2010-05-12 16:45:18 -04:00
* @ since 3.0 . 0
2010-10-21 10:40:04 -04:00
*
2010-10-23 14:03:26 -04:00
* @ param object $args Post type registration arguments
2010-05-12 16:45:18 -04:00
* @ return object object with all the capabilities as member variables
*/
function get_post_type_capabilities ( $args ) {
2010-10-23 14:03:26 -04:00
if ( ! is_array ( $args -> capability_type ) )
$args -> capability_type = array ( $args -> capability_type , $args -> capability_type . 's' );
// Singular base for meta capabilities, plural base for primitive capabilities.
list ( $singular_base , $plural_base ) = $args -> capability_type ;
2010-10-21 10:40:04 -04:00
$default_capabilities = array (
2010-10-23 14:03:26 -04:00
// Meta capabilities
'edit_post' => 'edit_' . $singular_base ,
'read_post' => 'read_' . $singular_base ,
'delete_post' => 'delete_' . $singular_base ,
// Primitive capabilities used outside of map_meta_cap():
'edit_posts' => 'edit_' . $plural_base ,
'edit_others_posts' => 'edit_others_' . $plural_base ,
'publish_posts' => 'publish_' . $plural_base ,
'read_private_posts' => 'read_private_' . $plural_base ,
2010-05-12 16:45:18 -04:00
);
2010-10-21 11:05:10 -04:00
2010-10-23 14:03:26 -04:00
// Primitive capabilities used within map_meta_cap():
2010-10-21 10:40:04 -04:00
if ( $args -> map_meta_cap ) {
$default_capabilities_for_mapping = array (
'read' => 'read' ,
2010-10-23 14:03:26 -04:00
'delete_posts' => 'delete_' . $plural_base ,
'delete_private_posts' => 'delete_private_' . $plural_base ,
'delete_published_posts' => 'delete_published_' . $plural_base ,
'delete_others_posts' => 'delete_others_' . $plural_base ,
'edit_private_posts' => 'edit_private_' . $plural_base ,
'edit_published_posts' => 'edit_published_' . $plural_base ,
2010-10-21 10:40:04 -04:00
);
$default_capabilities = array_merge ( $default_capabilities , $default_capabilities_for_mapping );
}
2010-10-21 11:05:10 -04:00
2010-10-21 10:40:04 -04:00
$capabilities = array_merge ( $default_capabilities , $args -> capabilities );
2010-10-21 11:05:10 -04:00
2012-10-24 18:15:43 -04:00
// Post creation capability simply maps to edit_posts by default:
if ( ! isset ( $capabilities [ 'create_posts' ] ) )
$capabilities [ 'create_posts' ] = $capabilities [ 'edit_posts' ];
2010-10-21 11:05:10 -04:00
// Remember meta capabilities for future reference.
2010-10-21 10:40:04 -04:00
if ( $args -> map_meta_cap )
_post_type_meta_capabilities ( $capabilities );
2010-10-21 11:05:10 -04:00
2010-10-21 10:40:04 -04:00
return ( object ) $capabilities ;
}
/**
* Stores or returns a list of post type meta caps for map_meta_cap () .
*
* @ since 3.1 . 0
* @ access private
*/
function _post_type_meta_capabilities ( $capabilities = null ) {
static $meta_caps = array ();
if ( null === $capabilities )
return $meta_caps ;
foreach ( $capabilities as $core => $custom ) {
if ( in_array ( $core , array ( 'read_post' , 'delete_post' , 'edit_post' ) ) )
$meta_caps [ $custom ] = $core ;
}
2010-05-12 16:45:18 -04:00
}
2010-05-11 15:52:50 -04:00
/**
* Builds an object with all post type labels out of a post type object
2010-05-25 22:42:15 -04:00
*
2010-05-11 15:52:50 -04:00
* Accepted keys of the label array in the post type object :
2011-09-05 15:08:15 -04:00
* - name - general name for the post type , usually plural . The same and overridden by $post_type_object -> label . Default is Posts / Pages
2010-05-11 15:52:50 -04:00
* - singular_name - name for one object of this post type . Default is Post / Page
* - add_new - Default is Add New for both hierarchical and non - hierarchical types . When internationalizing this string , please use a { @ link http :// codex . wordpress . org / I18n_for_WordPress_Developers #Disambiguation_by_context gettext context} matching your post type. Example: <code>_x('Add New', 'product');</code>
* - add_new_item - Default is Add New Post / Add New Page
* - edit_item - Default is Edit Post / Edit Page
* - new_item - Default is New Post / New Page
* - view_item - Default is View Post / View Page
* - search_items - Default is Search Posts / Search Pages
* - not_found - Default is No posts found / No pages found
* - not_found_in_trash - Default is No posts found in Trash / No pages found in Trash
2010-05-13 20:34:04 -04:00
* - parent_item_colon - This string isn ' t used on non - hierarchical types . In hierarchical ones the default is Parent Page :
2011-07-26 17:31:36 -04:00
* - all_items - String for the submenu . Default is All Posts / All Pages
* - menu_name - Default is the same as < code > name </ code >
2010-05-25 22:42:15 -04:00
*
2010-11-09 19:42:43 -05:00
* Above , the first default value is for non - hierarchical post types ( like posts ) and the second one is for hierarchical post types ( like pages ) .
2010-05-25 22:42:15 -04:00
*
2010-05-11 15:52:50 -04:00
* @ since 3.0 . 0
2013-09-21 13:44:09 -04:00
* @ access private
*
2010-05-11 15:52:50 -04:00
* @ param object $post_type_object
* @ return object object with all the labels as member variables
*/
function get_post_type_labels ( $post_type_object ) {
$nohier_vs_hier_defaults = array (
'name' => array ( _x ( 'Posts' , 'post type general name' ), _x ( 'Pages' , 'post type general name' ) ),
'singular_name' => array ( _x ( 'Post' , 'post type singular name' ), _x ( 'Page' , 'post type singular name' ) ),
'add_new' => array ( _x ( 'Add New' , 'post' ), _x ( 'Add New' , 'page' ) ),
'add_new_item' => array ( __ ( 'Add New Post' ), __ ( 'Add New Page' ) ),
'edit_item' => array ( __ ( 'Edit Post' ), __ ( 'Edit Page' ) ),
'new_item' => array ( __ ( 'New Post' ), __ ( 'New Page' ) ),
'view_item' => array ( __ ( 'View Post' ), __ ( 'View Page' ) ),
'search_items' => array ( __ ( 'Search Posts' ), __ ( 'Search Pages' ) ),
2010-10-31 19:21:56 -04:00
'not_found' => array ( __ ( 'No posts found.' ), __ ( 'No pages found.' ) ),
'not_found_in_trash' => array ( __ ( 'No posts found in Trash.' ), __ ( 'No pages found in Trash.' ) ),
2010-11-08 21:09:00 -05:00
'parent_item_colon' => array ( null , __ ( 'Parent Page:' ) ),
2011-05-11 16:09:28 -04:00
'all_items' => array ( __ ( 'All Posts' ), __ ( 'All Pages' ) )
2010-05-11 15:52:50 -04:00
);
2010-11-08 21:09:00 -05:00
$nohier_vs_hier_defaults [ 'menu_name' ] = $nohier_vs_hier_defaults [ 'name' ];
2012-10-10 09:50:42 -04:00
$labels = _get_custom_object_labels ( $post_type_object , $nohier_vs_hier_defaults );
$post_type = $post_type_object -> name ;
2014-04-08 02:49:14 -04:00
/**
* Filter the labels of a specific post type .
*
* The dynamic portion of the hook name , $post_type , refers to
* the post type slug .
*
* @ since 3.5 . 0
*
* @ see get_post_type_labels () for the full list of labels .
*
* @ param array $labels Array of labels for the given post type .
*/
2012-10-10 09:50:42 -04:00
return apply_filters ( " post_type_labels_ { $post_type } " , $labels );
2010-05-13 20:34:04 -04:00
}
/**
* Builds an object with custom - something object ( post type , taxonomy ) labels out of a custom - something object
2010-05-25 22:42:15 -04:00
*
2010-05-13 20:34:04 -04:00
* @ access private
2010-10-19 03:58:02 -04:00
* @ since 3.0 . 0
2010-05-13 20:34:04 -04:00
*/
function _get_custom_object_labels ( $object , $nohier_vs_hier_defaults ) {
2013-09-21 13:44:09 -04:00
$object -> labels = ( array ) $object -> labels ;
2010-05-25 22:42:15 -04:00
2010-06-10 12:07:33 -04:00
if ( isset ( $object -> label ) && empty ( $object -> labels [ 'name' ] ) )
2010-05-13 20:34:04 -04:00
$object -> labels [ 'name' ] = $object -> label ;
2010-05-25 22:42:15 -04:00
2010-06-10 12:07:33 -04:00
if ( ! isset ( $object -> labels [ 'singular_name' ] ) && isset ( $object -> labels [ 'name' ] ) )
2010-05-13 20:34:04 -04:00
$object -> labels [ 'singular_name' ] = $object -> labels [ 'name' ];
2010-05-25 22:42:15 -04:00
2011-06-10 22:20:18 -04:00
if ( ! isset ( $object -> labels [ 'name_admin_bar' ] ) )
$object -> labels [ 'name_admin_bar' ] = isset ( $object -> labels [ 'singular_name' ] ) ? $object -> labels [ 'singular_name' ] : $object -> name ;
2010-11-09 19:42:43 -05:00
if ( ! isset ( $object -> labels [ 'menu_name' ] ) && isset ( $object -> labels [ 'name' ] ) )
$object -> labels [ 'menu_name' ] = $object -> labels [ 'name' ];
2011-05-11 16:09:28 -04:00
if ( ! isset ( $object -> labels [ 'all_items' ] ) && isset ( $object -> labels [ 'menu_name' ] ) )
$object -> labels [ 'all_items' ] = $object -> labels [ 'menu_name' ];
2010-11-11 17:50:36 -05:00
foreach ( $nohier_vs_hier_defaults as $key => $value )
$defaults [ $key ] = $object -> hierarchical ? $value [ 1 ] : $value [ 0 ];
2010-05-13 20:34:04 -04:00
$labels = array_merge ( $defaults , $object -> labels );
2010-05-25 22:42:15 -04:00
return ( object ) $labels ;
2010-05-11 15:52:50 -04:00
}
2010-10-19 03:58:02 -04:00
/**
* Adds submenus for post types .
*
* @ access private
* @ since 3.1 . 0
2010-10-21 15:55:28 -04:00
*/
2010-10-19 03:58:02 -04:00
function _add_post_type_submenus () {
foreach ( get_post_types ( array ( 'show_ui' => true ) ) as $ptype ) {
$ptype_obj = get_post_type_object ( $ptype );
// Submenus only.
if ( ! $ptype_obj -> show_in_menu || $ptype_obj -> show_in_menu === true )
continue ;
2011-05-11 16:09:28 -04:00
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 " );
2010-10-19 03:58:02 -04:00
}
}
add_action ( 'admin_menu' , '_add_post_type_submenus' );
2010-01-09 20:23:14 -05:00
/**
* Register support of certain features for a post type .
2010-01-15 17:11:12 -05:00
*
2014-01-06 21:05:11 -05:00
* All core features are directly associated with a functional area of the edit
* screen , such as the editor or a meta box . Features include : 'title' , 'editor' ,
* 'comments' , 'revisions' , 'trackbacks' , 'author' , 'excerpt' , 'page-attributes' ,
* 'thumbnail' , 'custom-fields' , and 'post-formats' .
2010-04-04 00:14:17 -04:00
*
2014-01-06 21:05:11 -05:00
* Additionally , the 'revisions' feature dictates whether the post type will
* store revisions , and the 'comments' feature dictates whether the comments
* count will show on the edit screen .
2010-04-04 00:14:17 -04:00
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2014-01-06 21:05:11 -05:00
*
* @ param string $post_type The post type for which to add the feature .
* @ param string | array $feature The feature being added , accpets an array of
* feature strings or a single string .
2010-01-09 20:23:14 -05:00
*/
function add_post_type_support ( $post_type , $feature ) {
global $_wp_post_type_features ;
$features = ( array ) $feature ;
foreach ( $features as $feature ) {
if ( func_num_args () == 2 )
$_wp_post_type_features [ $post_type ][ $feature ] = true ;
else
$_wp_post_type_features [ $post_type ][ $feature ] = array_slice ( func_get_args (), 2 );
}
}
2010-03-15 17:16:41 -04:00
/**
* Remove support for a feature from a post type .
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-03-15 17:16:41 -04:00
* @ param string $post_type The post type for which to remove the feature
* @ param string $feature The feature being removed
*/
function remove_post_type_support ( $post_type , $feature ) {
global $_wp_post_type_features ;
2013-03-15 14:28:33 -04:00
if ( isset ( $_wp_post_type_features [ $post_type ][ $feature ] ) )
unset ( $_wp_post_type_features [ $post_type ][ $feature ] );
2010-03-15 17:16:41 -04:00
}
2012-03-23 13:53:14 -04:00
/**
* Get all the post type features
*
* @ since 3.4 . 0
* @ param string $post_type The post type
* @ return array
*/
function get_all_post_type_supports ( $post_type ) {
global $_wp_post_type_features ;
if ( isset ( $_wp_post_type_features [ $post_type ] ) )
return $_wp_post_type_features [ $post_type ];
return array ();
}
2010-01-09 20:23:14 -05:00
/**
* Checks a post type ' s support for a given feature
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-09 20:23:14 -05:00
* @ param string $post_type The post type being checked
* @ param string $feature the feature being checked
* @ return boolean
*/
function post_type_supports ( $post_type , $feature ) {
global $_wp_post_type_features ;
2013-03-15 14:28:33 -04:00
return ( isset ( $_wp_post_type_features [ $post_type ][ $feature ] ) );
2010-01-09 20:23:14 -05:00
}
2008-01-02 15:06:00 -05:00
/**
2008-08-19 12:38:06 -04:00
* Updates the post type for the post ID .
2008-01-02 15:06:00 -05:00
*
2008-08-19 12:38:06 -04:00
* The page or post cache will be cleaned for the post ID .
2008-01-02 15:06:00 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-01-02 15:06:00 -05:00
*
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID to change post type . Not actually optional .
2009-05-06 16:49:36 -04:00
* @ param string $post_type Optional , default is post . Supported values are 'post' or 'page' to
* name a few .
2008-08-19 12:38:06 -04:00
* @ return int Amount of rows changed . Should be 1 for success and 0 for failure .
2008-01-02 15:06:00 -05:00
*/
function set_post_type ( $post_id = 0 , $post_type = 'post' ) {
global $wpdb ;
$post_type = sanitize_post_field ( 'post_type' , $post_type , $post_id , 'db' );
2012-04-10 12:09:44 -04:00
$return = $wpdb -> update ( $wpdb -> posts , array ( 'post_type' => $post_type ), array ( 'ID' => $post_id ) );
2008-01-02 15:06:00 -05:00
2012-04-23 18:04:35 -04:00
clean_post_cache ( $post_id );
2008-01-02 15:06:00 -05:00
return $return ;
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve list of latest posts or posts matching criteria .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* The defaults are as follows :
* 'numberposts' - Default is 5. Total number of posts to retrieve .
* 'offset' - Default is 0. See { @ link WP_Query :: query ()} for more .
* 'category' - What category to pull the posts from .
2013-11-22 12:39:10 -05:00
* 'orderby' - Default is 'date' , which orders based on post_date . How to order the posts .
2008-08-19 12:38:06 -04:00
* 'order' - Default is 'DESC' . The order to retrieve the posts .
* 'include' - See { @ link WP_Query :: query ()} for more .
* 'exclude' - See { @ link WP_Query :: query ()} for more .
* 'meta_key' - See { @ link WP_Query :: query ()} for more .
* 'meta_value' - See { @ link WP_Query :: query ()} for more .
* 'post_type' - Default is 'post' . Can be 'page' , or 'attachment' to name a few .
* 'post_parent' - The parent of the post or post type .
2011-05-31 11:23:21 -04:00
* 'post_status' - Default is 'publish' . Post status to retrieve .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.2 . 0
* @ uses WP_Query :: query () See for more default arguments and information .
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Template_Tags / get_posts
2007-12-13 19:28:34 -05:00
*
2009-05-06 16:49:36 -04:00
* @ param array $args Optional . Overrides defaults .
2008-08-19 12:38:06 -04:00
* @ return array List of posts .
2007-12-13 19:28:34 -05:00
*/
2008-04-14 12:23:29 -04:00
function get_posts ( $args = null ) {
2007-05-10 23:10:05 -04:00
$defaults = array (
2007-09-03 19:32:58 -04:00
'numberposts' => 5 , 'offset' => 0 ,
2013-11-22 12:39:10 -05:00
'category' => 0 , 'orderby' => 'date' ,
2010-04-18 00:54:19 -04:00
'order' => 'DESC' , 'include' => array (),
'exclude' => array (), 'meta_key' => '' ,
2007-09-03 19:32:58 -04:00
'meta_value' => '' , 'post_type' => 'post' ,
2008-11-26 13:56:46 -05:00
'suppress_filters' => true
2007-05-10 23:10:05 -04:00
);
2007-06-13 22:25:30 -04:00
2007-05-10 23:10:05 -04:00
$r = wp_parse_args ( $args , $defaults );
2008-05-05 11:46:32 -04:00
if ( empty ( $r [ 'post_status' ] ) )
$r [ 'post_status' ] = ( 'attachment' == $r [ 'post_type' ] ) ? 'inherit' : 'publish' ;
2010-10-19 13:08:32 -04:00
if ( ! empty ( $r [ 'numberposts' ]) && empty ( $r [ 'posts_per_page' ]) )
2008-05-03 16:08:32 -04:00
$r [ 'posts_per_page' ] = $r [ 'numberposts' ];
if ( ! empty ( $r [ 'category' ]) )
$r [ 'cat' ] = $r [ 'category' ];
if ( ! empty ( $r [ 'include' ]) ) {
2010-04-18 00:54:19 -04:00
$incposts = wp_parse_id_list ( $r [ 'include' ] );
2008-05-03 16:08:32 -04:00
$r [ 'posts_per_page' ] = count ( $incposts ); // only the number of posts included
$r [ 'post__in' ] = $incposts ;
} elseif ( ! empty ( $r [ 'exclude' ]) )
2010-04-18 00:54:19 -04:00
$r [ 'post__not_in' ] = wp_parse_id_list ( $r [ 'exclude' ] );
2008-05-03 16:08:32 -04:00
2010-09-07 00:46:08 -04:00
$r [ 'ignore_sticky_posts' ] = true ;
2010-08-28 07:51:02 -04:00
$r [ 'no_found_rows' ] = true ;
2008-08-05 01:48:21 -04:00
2008-05-03 16:08:32 -04:00
$get_posts = new WP_Query ;
return $get_posts -> query ( $r );
2006-06-07 22:22:16 -04:00
}
2006-06-07 19:17:59 -04:00
//
// Post meta functions
//
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Add meta data field to a post .
2007-12-13 19:28:34 -05:00
*
2011-04-28 11:24:49 -04:00
* Post meta data is called " Custom Fields " on the Administration Screen .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / add_post_meta
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
2013-03-01 11:28:40 -05:00
* @ param string $meta_key Metadata name .
2013-08-21 17:11:09 -04:00
* @ param mixed $meta_value Metadata value . Must be serializable if non - scalar .
2013-02-14 17:51:06 -05:00
* @ param bool $unique Optional , default is false . Whether the same key should not be added .
2013-06-21 08:45:11 -04:00
* @ return int | bool Meta ID on success , false on failure .
2013-02-14 17:51:06 -05:00
*/
2013-03-01 11:28:40 -05:00
function add_post_meta ( $post_id , $meta_key , $meta_value , $unique = false ) {
2008-07-31 23:50:20 -04:00
// make sure meta is added to the post, not a revision
2013-03-01 11:28:40 -05:00
if ( $the_post = wp_is_post_revision ( $post_id ) )
2008-07-31 23:50:20 -04:00
$post_id = $the_post ;
2013-03-01 11:28:40 -05:00
return add_metadata ( 'post' , $post_id , $meta_key , $meta_value , $unique );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Remove metadata matching criteria from a post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* You can match based on the key , or key and value . Removing based on key and
* value , will keep from removing duplicate metadata with the same key . It also
* allows removing all metadata matching key , if needed .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / delete_post_meta
2007-12-13 19:28:34 -05:00
*
* @ param int $post_id post ID
2008-10-12 22:48:45 -04:00
* @ param string $meta_key Metadata name .
2013-08-21 17:11:09 -04:00
* @ param mixed $meta_value Optional . Metadata value . Must be serializable if non - scalar .
2013-06-21 08:45:11 -04:00
* @ return bool True on success , false on failure .
2007-12-13 19:28:34 -05:00
*/
2008-10-12 22:48:45 -04:00
function delete_post_meta ( $post_id , $meta_key , $meta_value = '' ) {
2008-10-20 01:47:13 -04:00
// make sure meta is added to the post, not a revision
if ( $the_post = wp_is_post_revision ( $post_id ) )
$post_id = $the_post ;
2007-10-12 22:36:38 -04:00
2009-09-17 16:17:33 -04:00
return delete_metadata ( 'post' , $post_id , $meta_key , $meta_value );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve post meta field for a post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_meta
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
2012-02-10 17:49:56 -05:00
* @ param string $key Optional . The meta key to retrieve . By default , returns data for all keys .
2008-08-19 12:38:06 -04:00
* @ param bool $single Whether to return a single value .
2009-05-06 16:49:36 -04:00
* @ return mixed Will be an array if $single is false . Will be value of meta data field if $single
* is true .
2007-12-13 19:28:34 -05:00
*/
2012-02-10 17:42:54 -05:00
function get_post_meta ( $post_id , $key = '' , $single = false ) {
2009-09-17 16:17:33 -04:00
return get_metadata ( 'post' , $post_id , $key , $single );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Update post meta field based on post ID .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* Use the $prev_value parameter to differentiate between meta fields with the
* same key and post ID .
*
* If the meta field for the post does not exist , it will be added .
2007-12-13 19:28:34 -05:00
*
2010-11-16 08:16:13 -05:00
* @ since 1.5 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / update_post_meta
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
2013-03-01 11:28:40 -05:00
* @ param string $meta_key Metadata key .
2013-08-21 17:11:09 -04:00
* @ param mixed $meta_value Metadata value . Must be serializable if non - scalar .
2013-02-14 17:51:06 -05:00
* @ param mixed $prev_value Optional . Previous value to check before removing .
2014-02-18 16:36:14 -05:00
* @ return int | bool Meta ID if the key didn ' t exist , true on successful update , false on failure .
2013-02-14 17:51:06 -05:00
*/
2013-03-01 11:28:40 -05:00
function update_post_meta ( $post_id , $meta_key , $meta_value , $prev_value = '' ) {
2008-10-20 01:47:13 -04:00
// make sure meta is added to the post, not a revision
2013-03-01 11:28:40 -05:00
if ( $the_post = wp_is_post_revision ( $post_id ) )
2008-10-20 01:47:13 -04:00
$post_id = $the_post ;
2013-03-01 11:28:40 -05:00
return update_metadata ( 'post' , $post_id , $meta_key , $meta_value , $prev_value );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Delete everything from post meta matching meta key .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param string $post_meta_key Key to search for when deleting .
2007-12-13 19:28:34 -05:00
* @ return bool Whether the post meta key was deleted from the database
*/
2007-08-29 15:12:20 -04:00
function delete_post_meta_by_key ( $post_meta_key ) {
2011-08-03 12:48:37 -04:00
return delete_metadata ( 'post' , null , $post_meta_key , '' , true );
2007-08-29 15:12:20 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve post meta fields , based on post ID .
2007-12-13 19:28:34 -05:00
*
2012-02-10 17:00:37 -05:00
* The post meta fields are retrieved from the cache where possible ,
* so the function is optimized to be called more than once .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.2 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_custom
2007-12-13 19:28:34 -05:00
*
2012-02-10 17:00:37 -05:00
* @ param int $post_id Post ID .
2008-08-19 12:38:06 -04:00
* @ return array
2007-12-13 19:28:34 -05:00
*/
2010-09-04 11:51:04 -04:00
function get_post_custom ( $post_id = 0 ) {
$post_id = absint ( $post_id );
if ( ! $post_id )
$post_id = get_the_ID ();
2006-10-11 05:18:54 -04:00
2012-02-10 17:42:54 -05:00
return get_post_meta ( $post_id );
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve meta field names for a post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* If there are no meta fields , then nothing ( null ) will be returned .
*
* @ since 1.2 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_custom_keys
2007-12-13 19:28:34 -05:00
*
* @ param int $post_id post ID
2008-08-19 12:38:06 -04:00
* @ return array | null Either array of the keys , or null if keys could not be retrieved .
2007-12-13 19:28:34 -05:00
*/
2006-06-07 19:17:59 -04:00
function get_post_custom_keys ( $post_id = 0 ) {
$custom = get_post_custom ( $post_id );
2006-10-24 06:52:59 -04:00
if ( ! is_array ( $custom ) )
2006-06-07 19:17:59 -04:00
return ;
if ( $keys = array_keys ( $custom ) )
return $keys ;
}
2008-06-27 11:32:57 -04:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve values for a custom post field .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* The parameters must not be considered optional . All of the post meta fields
* will be retrieved and only the meta field key values returned .
*
* @ since 1.2 . 0
2008-06-27 11:32:57 -04:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_custom_values
*
2008-08-19 12:38:06 -04:00
* @ param string $key Meta field key .
* @ param int $post_id Post ID
* @ return array Meta field values .
2008-06-27 11:32:57 -04:00
*/
2006-06-07 19:17:59 -04:00
function get_post_custom_values ( $key = '' , $post_id = 0 ) {
2009-03-04 17:59:16 -05:00
if ( ! $key )
return null ;
2009-03-17 22:43:45 -04:00
2006-06-07 19:17:59 -04:00
$custom = get_post_custom ( $post_id );
2008-12-25 21:59:04 -05:00
return isset ( $custom [ $key ]) ? $custom [ $key ] : null ;
2006-06-07 19:17:59 -04:00
}
2008-08-05 01:48:21 -04:00
/**
2008-08-19 12:38:06 -04:00
* Check if post is sticky .
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* Sticky posts should remain at the top of The Loop . If the post ID is not
* given , then The Loop ID for the current post will be used .
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.7 . 0
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Optional . Post ID .
2010-02-24 15:13:23 -05:00
* @ return bool Whether post is sticky .
2008-08-05 01:48:21 -04:00
*/
2010-09-04 11:51:04 -04:00
function is_sticky ( $post_id = 0 ) {
$post_id = absint ( $post_id );
2008-08-13 14:21:52 -04:00
2010-09-04 11:51:04 -04:00
if ( ! $post_id )
$post_id = get_the_ID ();
2008-08-13 14:21:52 -04:00
2010-09-04 11:51:04 -04:00
$stickies = get_option ( 'sticky_posts' );
2008-08-05 01:48:21 -04:00
2010-09-04 11:51:04 -04:00
if ( ! is_array ( $stickies ) )
2008-08-05 01:48:21 -04:00
return false ;
2010-09-04 11:51:04 -04:00
if ( in_array ( $post_id , $stickies ) )
2008-08-05 01:48:21 -04:00
return true ;
return false ;
}
2008-06-27 11:32:57 -04:00
/**
2008-08-19 12:38:06 -04:00
* Sanitize every post field .
2008-06-27 11:32:57 -04:00
*
2009-05-11 18:10:45 -04:00
* If the context is 'raw' , then the post object or array will get minimal santization of the int fields .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
* @ uses sanitize_post_field () Used to sanitize the fields .
2008-06-27 11:32:57 -04:00
*
2012-08-23 16:34:41 -04:00
* @ param object | WP_Post | array $post The Post Object or Array
2008-08-19 12:38:06 -04:00
* @ param string $context Optional , default is 'display' . How to sanitize post fields .
2012-08-23 16:34:41 -04:00
* @ return object | WP_Post | array The now sanitized Post Object or Array ( will be the same type as $post )
2008-06-27 11:32:57 -04:00
*/
2007-07-11 15:57:43 -04:00
function sanitize_post ( $post , $context = 'display' ) {
2008-02-22 12:43:56 -05:00
if ( is_object ( $post ) ) {
2009-10-19 17:28:44 -04:00
// Check if post already filtered for this context
if ( isset ( $post -> filter ) && $context == $post -> filter )
return $post ;
2008-08-25 17:50:11 -04:00
if ( ! isset ( $post -> ID ) )
$post -> ID = 0 ;
2008-02-13 01:49:23 -05:00
foreach ( array_keys ( get_object_vars ( $post )) as $field )
2007-07-11 15:57:43 -04:00
$post -> $field = sanitize_post_field ( $field , $post -> $field , $post -> ID , $context );
2008-12-16 18:50:39 -05:00
$post -> filter = $context ;
2008-02-22 12:43:56 -05:00
} else {
2009-10-19 17:28:44 -04:00
// Check if post already filtered for this context
if ( isset ( $post [ 'filter' ]) && $context == $post [ 'filter' ] )
return $post ;
2008-08-25 17:50:11 -04:00
if ( ! isset ( $post [ 'ID' ]) )
$post [ 'ID' ] = 0 ;
2008-02-13 01:49:23 -05:00
foreach ( array_keys ( $post ) as $field )
2007-09-03 19:32:58 -04:00
$post [ $field ] = sanitize_post_field ( $field , $post [ $field ], $post [ 'ID' ], $context );
2008-12-16 18:50:39 -05:00
$post [ 'filter' ] = $context ;
2008-02-22 12:43:56 -05:00
}
2007-07-11 15:57:43 -04:00
return $post ;
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Sanitize post field based on context .
2007-12-13 19:28:34 -05:00
*
2009-05-06 16:49:36 -04:00
* Possible context values are : 'raw' , 'edit' , 'db' , 'display' , 'attribute' and 'js' . The
* 'display' context is used by default . 'attribute' and 'js' contexts are treated like 'display'
* when calling filters .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param string $field The Post Object field name .
* @ param mixed $value The Post Object value .
* @ param int $post_id Post ID .
2009-05-06 16:49:36 -04:00
* @ param string $context How to sanitize post fields . Looks for 'raw' , 'edit' , 'db' , 'display' ,
* 'attribute' and 'js' .
2008-08-19 12:38:06 -04:00
* @ return mixed Sanitized value .
2007-12-13 19:28:34 -05:00
*/
2007-07-11 15:57:43 -04:00
function sanitize_post_field ( $field , $value , $post_id , $context ) {
2013-02-28 14:40:26 -05:00
$int_fields = array ( 'ID' , 'post_parent' , 'menu_order' );
2007-07-11 15:57:43 -04:00
if ( in_array ( $field , $int_fields ) )
$value = ( int ) $value ;
2010-02-07 16:49:00 -05:00
// Fields which contain arrays of ints.
$array_int_fields = array ( 'ancestors' );
if ( in_array ( $field , $array_int_fields ) ) {
$value = array_map ( 'absint' , $value );
return $value ;
}
2007-07-12 12:00:51 -04:00
if ( 'raw' == $context )
return $value ;
2007-07-11 15:57:43 -04:00
$prefixed = false ;
if ( false !== strpos ( $field , 'post_' ) ) {
$prefixed = true ;
$field_no_prefix = str_replace ( 'post_' , '' , $field );
}
if ( 'edit' == $context ) {
$format_to_edit = array ( 'post_content' , 'post_excerpt' , 'post_title' , 'post_password' );
if ( $prefixed ) {
2014-04-08 02:49:14 -04:00
/**
* Filter the value of a specific post field to edit .
*
2014-04-08 03:41:14 -04:00
* The dynamic portion of the hook name , $field , refers to the post field name .
2014-04-08 02:49:14 -04:00
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the post field .
* @ param int $post_id Post ID .
*/
$value = apply_filters ( " edit_ { $field } " , $value , $post_id );
/**
* Filter the value of a specific post field to edit .
*
* The dynamic portion of the hook name , $field_no_prefix , refers to
2014-04-08 03:41:14 -04:00
* the post field name .
2014-04-08 02:49:14 -04:00
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the post field .
* @ param int $post_id Post ID .
*/
$value = apply_filters ( " { $field_no_prefix } _edit_pre " , $value , $post_id );
2007-07-11 15:57:43 -04:00
} else {
2014-04-08 02:49:14 -04:00
$value = apply_filters ( " edit_post_ { $field } " , $value , $post_id );
2007-07-11 15:57:43 -04:00
}
if ( in_array ( $field , $format_to_edit ) ) {
if ( 'post_content' == $field )
$value = format_to_edit ( $value , user_can_richedit ());
else
$value = format_to_edit ( $value );
} else {
2009-05-05 15:43:53 -04:00
$value = esc_attr ( $value );
2007-07-11 15:57:43 -04:00
}
} else if ( 'db' == $context ) {
if ( $prefixed ) {
2014-04-08 02:49:14 -04:00
/**
2014-04-08 03:41:14 -04:00
* Filter the value of a specific post field before saving .
2014-04-08 02:49:14 -04:00
*
2014-04-08 03:41:14 -04:00
* The dynamic portion of the hook name , $field , refers to the post field name .
2014-04-08 02:49:14 -04:00
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the post field .
*/
$value = apply_filters ( " pre_ { $field } " , $value );
/**
* Filter the value of a specific field before saving .
*
* The dynamic portion of the hook name , $field_no_prefix , refers
2014-04-08 03:41:14 -04:00
* to the post field name .
2014-04-08 02:49:14 -04:00
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the post field .
*/
$value = apply_filters ( " { $field_no_prefix } _save_pre " , $value );
2007-07-11 15:57:43 -04:00
} else {
2014-04-08 02:49:14 -04:00
$value = apply_filters ( " pre_post_ { $field } " , $value );
/**
2014-04-08 03:41:14 -04:00
* Filter the value of a specific post field before saving .
2014-04-08 02:49:14 -04:00
*
2014-04-08 03:41:14 -04:00
* The dynamic portion of the hook name , $field , refers to the post field name .
2014-04-08 02:49:14 -04:00
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the post field .
*/
$value = apply_filters ( " { $field } _pre " , $value );
2007-07-11 15:57:43 -04:00
}
} else {
2014-04-08 02:49:14 -04:00
2007-07-11 15:57:43 -04:00
// Use display filters by default.
2014-04-08 02:49:14 -04:00
if ( $prefixed ) {
/**
* Filter the value of a specific post field for display .
*
2014-04-08 03:41:14 -04:00
* The dynamic portion of the hook name , $field , refers to the post field name .
2014-04-08 02:49:14 -04:00
*
2014-04-08 03:41:14 -04:00
* @ since 2.3 . 0
2014-04-08 02:49:14 -04:00
*
* @ param mixed $value Value of the prefixed post field .
* @ param int $post_id Post ID .
* @ param string $context Context for how to sanitize the field . Possible
* values include 'raw' , 'edit' , 'db' , 'display' ,
* 'attribute' and 'js' .
*/
$value = apply_filters ( $field , $value , $post_id , $context );
} else {
$value = apply_filters ( " post_ { $field } " , $value , $post_id , $context );
}
2007-07-11 15:57:43 -04:00
}
if ( 'attribute' == $context )
2009-05-05 15:43:53 -04:00
$value = esc_attr ( $value );
2007-07-11 15:57:43 -04:00
else if ( 'js' == $context )
2009-05-09 03:27:22 -04:00
$value = esc_js ( $value );
2007-07-11 15:57:43 -04:00
return $value ;
}
2008-08-05 01:48:21 -04:00
/**
2008-08-19 12:38:06 -04:00
* Make a post sticky .
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* Sticky posts should be displayed at the top of the front page .
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.7 . 0
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
2008-08-05 01:48:21 -04:00
*/
function stick_post ( $post_id ) {
$stickies = get_option ( 'sticky_posts' );
if ( ! is_array ( $stickies ) )
$stickies = array ( $post_id );
if ( ! in_array ( $post_id , $stickies ) )
$stickies [] = $post_id ;
update_option ( 'sticky_posts' , $stickies );
}
/**
2008-08-19 12:38:06 -04:00
* Unstick a post .
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* Sticky posts should be displayed at the top of the front page .
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.7 . 0
2008-08-05 01:48:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
2008-08-05 01:48:21 -04:00
*/
function unstick_post ( $post_id ) {
$stickies = get_option ( 'sticky_posts' );
if ( ! is_array ( $stickies ) )
return ;
if ( ! in_array ( $post_id , $stickies ) )
return ;
$offset = array_search ( $post_id , $stickies );
if ( false === $offset )
return ;
array_splice ( $stickies , $offset , 1 );
2008-08-09 01:36:14 -04:00
2008-08-05 01:48:21 -04:00
update_option ( 'sticky_posts' , $stickies );
}
2014-02-03 14:42:13 -05:00
/**
* Return the cache key for wp_count_posts () based on the passed arguments
*
* @ since 3.9 . 0
*
* @ param string $type Optional . Post type to retrieve count
* @ param string $perm Optional . 'readable' or empty .
* @ return string The cache key .
*/
function _count_posts_cache_key ( $type = 'post' , $perm = '' ) {
$cache_key = 'posts-' . $type ;
if ( 'readable' == $perm && is_user_logged_in () ) {
$post_type_object = get_post_type_object ( $type );
if ( ! current_user_can ( $post_type_object -> cap -> read_private_posts ) ) {
$cache_key .= '_' . $perm . '_' . get_current_user_id ();
}
}
return $cache_key ;
}
2008-02-05 14:08:14 -05:00
/**
2013-09-21 13:55:08 -04:00
* Count number of posts of a post type and if user has permissions to view .
2008-02-05 14:08:14 -05:00
*
2008-06-27 11:32:57 -04:00
* This function provides an efficient method of finding the amount of post ' s
* type a blog has . Another method is to count the amount of items in
* get_posts (), but that method has a lot of overhead with doing so . Therefore ,
* when developing for 2.5 + , use this function instead .
2008-06-14 12:31:08 -04:00
*
2008-06-27 11:32:57 -04:00
* The $perm parameter checks for 'readable' value and if the user can read
* private posts , it will display that for the user that is signed in .
2008-02-05 14:08:14 -05:00
*
2008-06-14 12:31:08 -04:00
* @ link http :// codex . wordpress . org / Template_Tags / wp_count_posts
2008-02-05 14:08:14 -05:00
*
2013-09-21 13:55:08 -04:00
* @ since 2.5 . 0
*
2008-06-14 12:31:08 -04:00
* @ param string $type Optional . Post type to retrieve count
* @ param string $perm Optional . 'readable' or empty .
* @ return object Number of posts for each status
2008-02-05 14:08:14 -05:00
*/
2008-02-29 16:49:49 -05:00
function wp_count_posts ( $type = 'post' , $perm = '' ) {
2008-02-05 14:08:14 -05:00
global $wpdb ;
2013-07-28 17:38:00 -04:00
if ( ! post_type_exists ( $type ) )
return new stdClass ;
2014-02-03 14:42:13 -05:00
$cache_key = _count_posts_cache_key ( $type , $perm );
2008-04-09 16:09:45 -04:00
2008-02-29 16:49:49 -05:00
$query = " SELECT post_status, COUNT( * ) AS num_posts FROM { $wpdb -> posts } WHERE post_type = %s " ;
if ( 'readable' == $perm && is_user_logged_in () ) {
2010-01-04 11:58:43 -05:00
$post_type_object = get_post_type_object ( $type );
2014-02-03 14:42:13 -05:00
if ( ! current_user_can ( $post_type_object -> cap -> read_private_posts ) ) {
$query .= $wpdb -> prepare ( " AND (post_status != 'private' OR ( post_author = %d AND post_status = 'private' )) " ,
get_current_user_id ()
);
2008-04-09 16:09:45 -04:00
}
2008-02-29 16:49:49 -05:00
}
$query .= ' GROUP BY post_status' ;
2008-04-09 16:09:45 -04:00
2013-09-21 13:55:08 -04:00
$counts = wp_cache_get ( $cache_key , 'counts' );
2013-09-23 15:08:09 -04:00
if ( false === $counts ) {
$results = ( array ) $wpdb -> get_results ( $wpdb -> prepare ( $query , $type ), ARRAY_A );
$counts = array_fill_keys ( get_post_stati (), 0 );
2008-02-13 04:30:26 -05:00
2013-09-23 15:08:09 -04:00
foreach ( $results as $row )
$counts [ $row [ 'post_status' ] ] = $row [ 'num_posts' ];
2010-02-18 15:03:04 -05:00
2013-09-23 15:08:09 -04:00
$counts = ( object ) $counts ;
wp_cache_set ( $cache_key , $counts , 'counts' );
}
2008-04-09 16:09:45 -04:00
2013-09-23 15:08:09 -04:00
/**
* Modify returned post counts by status for the current post type .
*
* @ since 3.7 . 0
*
2014-04-08 02:49:14 -04:00
* @ param object $counts An object containing the current post_type ' s post
* counts by status .
* @ param string $type Post type .
* @ param string $perm The permission to determine if the posts are 'readable'
* by the current user .
2013-09-23 15:08:09 -04:00
*/
return apply_filters ( 'wp_count_posts' , $counts , $type , $perm );
2008-02-05 14:08:14 -05:00
}
2008-02-19 01:13:20 -05:00
/**
2008-08-19 12:38:06 -04:00
* Count number of attachments for the mime type ( s ) .
2008-02-19 01:13:20 -05:00
*
2008-08-19 12:38:06 -04:00
* If you set the optional mime_type parameter , then an array will still be
* returned , but will only have the item you are looking for . It does not give
* you the number of attachments that are children of a post . You can get that
* by counting the number of children that post has .
2008-02-19 01:13:20 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-02-19 01:13:20 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param string | array $mime_type Optional . Array or comma - separated list of MIME patterns .
2014-03-28 01:43:15 -04:00
* @ return object An object containing the attachment counts by mime type .
2008-02-19 01:13:20 -05:00
*/
function wp_count_attachments ( $mime_type = '' ) {
global $wpdb ;
$and = wp_post_mime_type_where ( $mime_type );
2009-07-30 09:39:34 -04:00
$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 );
2008-02-19 01:13:20 -05:00
2013-09-23 15:11:09 -04:00
$counts = array ();
2008-02-19 01:13:20 -05:00
foreach ( ( array ) $count as $row ) {
2013-09-23 15:11:09 -04:00
$counts [ $row [ 'post_mime_type' ] ] = $row [ 'num_posts' ];
2008-02-19 01:13:20 -05:00
}
2013-09-23 15:11:09 -04:00
$counts [ 'trash' ] = $wpdb -> get_var ( " SELECT COUNT( * ) FROM $wpdb->posts WHERE post_type = 'attachment' AND post_status = 'trash' $and " );
2008-02-19 01:13:20 -05:00
2013-09-23 15:11:09 -04:00
/**
* Modify returned attachment counts by mime type .
*
* @ since 3.7 . 0
*
* @ param object $counts An object containing the attachment counts by mime type .
* @ param string $mime_type The mime type pattern used to filter the attachments counted .
*/
2013-09-23 16:18:10 -04:00
return apply_filters ( 'wp_count_attachments' , ( object ) $counts , $mime_type );
2008-02-19 01:13:20 -05:00
}
2012-11-21 05:18:59 -05:00
/**
* Get default post mime types
*
* @ since 2.9 . 0
*
* @ return array
*/
function get_post_mime_types () {
$post_mime_types = array ( // array( adj, noun )
'image' => array ( __ ( 'Images' ), __ ( 'Manage Images' ), _n_noop ( 'Image <span class="count">(%s)</span>' , 'Images <span class="count">(%s)</span>' )),
'audio' => array ( __ ( 'Audio' ), __ ( 'Manage Audio' ), _n_noop ( 'Audio <span class="count">(%s)</span>' , 'Audio <span class="count">(%s)</span>' )),
'video' => array ( __ ( 'Video' ), __ ( 'Manage Video' ), _n_noop ( 'Video <span class="count">(%s)</span>' , 'Video <span class="count">(%s)</span>' )),
);
2014-04-08 02:49:14 -04:00
/**
* Filter the default list of post mime types .
*
* @ since 2.5 . 0
*
* @ param array $post_mime_types Default list of post mime types .
*/
return apply_filters ( 'post_mime_types' , $post_mime_types );
2012-11-21 05:18:59 -05:00
}
2008-02-19 01:13:20 -05:00
/**
2008-08-19 12:38:06 -04:00
* Check a MIME - Type against a list .
2008-02-19 01:13:20 -05:00
*
2008-08-19 12:38:06 -04:00
* If the wildcard_mime_types parameter is a string , it must be comma separated
* list . If the real_mime_types is a string , it is also comma separated to
* create the list .
2008-02-19 01:13:20 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-02-19 01:13:20 -05:00
*
2009-05-06 16:49:36 -04:00
* @ param string | array $wildcard_mime_types e . g . audio / mpeg or image ( same as image /* ) or
* flash ( same as * flash * ) .
2008-02-19 01:13:20 -05:00
* @ param string | array $real_mime_types post_mime_type values
* @ return array array ( wildcard => array ( real types ))
*/
function wp_match_mime_types ( $wildcard_mime_types , $real_mime_types ) {
$matches = array ();
if ( is_string ( $wildcard_mime_types ) )
$wildcard_mime_types = array_map ( 'trim' , explode ( ',' , $wildcard_mime_types ));
if ( is_string ( $real_mime_types ) )
$real_mime_types = array_map ( 'trim' , explode ( ',' , $real_mime_types ));
$wild = '[-._a-z0-9]*' ;
foreach ( ( array ) $wildcard_mime_types as $type ) {
$type = str_replace ( '*' , $wild , $type );
2008-02-29 01:54:15 -05:00
$patternses [ 1 ][ $type ] = " ^ $type $ " ;
2008-02-19 01:13:20 -05:00
if ( false === strpos ( $type , '/' ) ) {
2008-02-29 01:54:15 -05:00
$patternses [ 2 ][ $type ] = " ^ $type / " ;
$patternses [ 3 ][ $type ] = $type ;
2008-02-19 01:13:20 -05:00
}
}
asort ( $patternses );
foreach ( $patternses as $patterns )
foreach ( $patterns as $type => $pattern )
foreach ( ( array ) $real_mime_types as $real )
if ( preg_match ( " # $pattern # " , $real ) && ( empty ( $matches [ $type ]) || false === array_search ( $real , $matches [ $type ]) ) )
$matches [ $type ][] = $real ;
return $matches ;
}
/**
2008-08-19 12:38:06 -04:00
* Convert MIME types into SQL .
2008-02-19 01:13:20 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-02-19 01:13:20 -05:00
*
2010-09-07 07:21:11 -04:00
* @ param string | array $post_mime_types List of mime types or comma separated string of mime types .
2010-05-23 03:49:21 -04:00
* @ param string $table_alias Optional . Specify a table alias , if needed .
2008-08-19 12:38:06 -04:00
* @ return string The SQL AND clause for mime searching .
2008-02-19 01:13:20 -05:00
*/
2010-05-06 14:03:05 -04:00
function wp_post_mime_type_where ( $post_mime_types , $table_alias = '' ) {
2008-02-19 01:13:20 -05:00
$where = '' ;
$wildcards = array ( '' , '%' , '%/%' );
if ( is_string ( $post_mime_types ) )
$post_mime_types = array_map ( 'trim' , explode ( ',' , $post_mime_types ));
foreach ( ( array ) $post_mime_types as $mime_type ) {
$mime_type = preg_replace ( '/\s/' , '' , $mime_type );
$slashpos = strpos ( $mime_type , '/' );
if ( false !== $slashpos ) {
$mime_group = preg_replace ( '/[^-*.a-zA-Z0-9]/' , '' , substr ( $mime_type , 0 , $slashpos ));
2009-02-04 15:27:30 -05:00
$mime_subgroup = preg_replace ( '/[^-*.+a-zA-Z0-9]/' , '' , substr ( $mime_type , $slashpos + 1 ));
2008-02-19 01:13:20 -05:00
if ( empty ( $mime_subgroup ) )
$mime_subgroup = '*' ;
else
$mime_subgroup = str_replace ( '/' , '' , $mime_subgroup );
$mime_pattern = " $mime_group / $mime_subgroup " ;
} else {
$mime_pattern = preg_replace ( '/[^-*.a-zA-Z0-9]/' , '' , $mime_type );
if ( false === strpos ( $mime_pattern , '*' ) )
$mime_pattern .= '/*' ;
}
$mime_pattern = preg_replace ( '/\*+/' , '%' , $mime_pattern );
if ( in_array ( $mime_type , $wildcards ) )
return '' ;
if ( false !== strpos ( $mime_pattern , '%' ) )
2010-05-06 14:03:05 -04:00
$wheres [] = empty ( $table_alias ) ? " post_mime_type LIKE ' $mime_pattern ' " : " $table_alias .post_mime_type LIKE ' $mime_pattern ' " ;
2008-02-19 01:13:20 -05:00
else
2010-05-06 14:03:05 -04:00
$wheres [] = empty ( $table_alias ) ? " post_mime_type = ' $mime_pattern ' " : " $table_alias .post_mime_type = ' $mime_pattern ' " ;
2008-02-19 01:13:20 -05:00
}
if ( ! empty ( $wheres ) )
$where = ' AND (' . join ( ' OR ' , $wheres ) . ') ' ;
return $where ;
}
2007-12-13 19:28:34 -05:00
/**
2010-04-04 08:20:19 -04:00
* Trashes or deletes a post or page .
2007-12-13 19:28:34 -05:00
*
2010-04-04 08:20:19 -04:00
* When the post and page is permanently deleted , everything that is tied to it is deleted also .
2008-08-19 12:38:06 -04:00
* This includes comments , post meta fields , and terms associated with the post .
2007-12-13 19:28:34 -05:00
*
2010-04-04 08:20:19 -04:00
* The post or page is moved to trash instead of permanently deleted unless trash is
* disabled , item is already in the trash , or $force_delete is true .
*
2008-06-27 11:32:57 -04:00
* @ since 1.0 . 0
2014-04-13 19:06:14 -04:00
*
2009-05-06 16:49:36 -04:00
* @ uses wp_delete_attachment () if post type is 'attachment' .
2010-04-04 08:20:19 -04:00
* @ uses wp_trash_post () if item should be trashed .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $postid Post ID .
2010-04-04 08:20:19 -04:00
* @ param bool $force_delete Whether to bypass trash and force deletion . Defaults to false .
2009-05-06 16:49:36 -04:00
* @ return mixed False on failure
2007-12-13 19:28:34 -05:00
*/
2009-11-09 15:12:07 -05:00
function wp_delete_post ( $postid = 0 , $force_delete = false ) {
2012-02-28 15:29:33 -05:00
global $wpdb ;
2006-06-07 19:17:59 -04:00
2007-10-02 14:45:47 -04:00
if ( ! $post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d " , $postid )) )
2006-06-07 19:17:59 -04:00
return $post ;
2010-04-04 08:20:19 -04:00
if ( ! $force_delete && ( $post -> post_type == 'post' || $post -> post_type == 'page' ) && get_post_status ( $postid ) != 'trash' && EMPTY_TRASH_DAYS )
2009-11-09 15:12:07 -05:00
return wp_trash_post ( $postid );
2009-09-14 10:03:32 -04:00
2009-07-30 09:39:34 -04:00
if ( $post -> post_type == 'attachment' )
2009-11-09 15:12:07 -05:00
return wp_delete_attachment ( $postid , $force_delete );
2006-06-07 19:17:59 -04:00
2014-04-13 19:06:14 -04:00
/**
* Fires before a post is deleted , at the start of wp_delete_post () .
*
* @ since 3.2 . 0
*
* @ see wp_delete_post ()
*
* @ param int $postid Post ID .
*/
do_action ( 'before_delete_post' , $postid );
2009-09-14 10:03:32 -04:00
2009-08-25 18:05:15 -04:00
delete_post_meta ( $postid , '_wp_trash_meta_status' );
delete_post_meta ( $postid , '_wp_trash_meta_time' );
2006-06-07 19:17:59 -04:00
2009-12-01 13:01:24 -05:00
wp_delete_object_term_relationships ( $postid , get_object_taxonomies ( $post -> post_type ));
2006-06-07 19:17:59 -04:00
2007-10-12 22:36:38 -04:00
$parent_data = array ( 'post_parent' => $post -> post_parent );
$parent_where = array ( 'post_parent' => $postid );
2012-01-13 13:37:46 -05:00
if ( is_post_type_hierarchical ( $post -> post_type ) ) {
// Point children of this page to its parent, also clean the cache of affected children
$children_query = $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE post_parent = %d AND post_type = %s " , $postid , $post -> post_type );
$children = $wpdb -> get_results ( $children_query );
$wpdb -> update ( $wpdb -> posts , $parent_data , $parent_where + array ( 'post_type' => $post -> post_type ) );
}
2011-12-13 18:45:31 -05:00
// Do raw query. wp_get_post_revisions() is filtered
2008-05-09 11:59:17 -04:00
$revision_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE post_parent = %d AND post_type = 'revision' " , $postid ) );
2011-12-13 18:45:31 -05:00
// Use wp_delete_post (via wp_delete_post_revision) again. Ensures any meta/misplaced data gets cleaned up.
2008-05-09 11:59:17 -04:00
foreach ( $revision_ids as $revision_id )
2008-05-29 18:21:36 -04:00
wp_delete_post_revision ( $revision_id );
2008-05-09 11:59:17 -04:00
2007-11-16 12:39:15 -05:00
// Point all attachments to this post up one level
2007-10-12 22:36:38 -04:00
$wpdb -> update ( $wpdb -> posts , $parent_data , $parent_where + array ( 'post_type' => 'attachment' ) );
2006-12-04 09:25:21 -05:00
2009-11-04 12:39:53 -05:00
$comment_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d " , $postid ));
2012-04-11 16:02:39 -04:00
foreach ( $comment_ids as $comment_id )
wp_delete_comment ( $comment_id , true );
2006-06-07 19:17:59 -04:00
2009-11-04 12:39:53 -05:00
$post_meta_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d " , $postid ));
2012-04-11 16:02:39 -04:00
foreach ( $post_meta_ids as $mid )
delete_metadata_by_mid ( 'post' , $mid );
2006-06-07 19:17:59 -04:00
2014-04-13 19:06:14 -04:00
/**
* Fires immediately before a post is deleted from the database .
*
* @ since 1.2 . 0
*
* @ param int $postid Post ID .
*/
2009-11-19 12:55:23 -05:00
do_action ( 'delete_post' , $postid );
2013-12-02 17:59:10 -05:00
$result = $wpdb -> delete ( $wpdb -> posts , array ( 'ID' => $postid ) );
if ( ! $result ) {
return false ;
}
2014-04-13 19:06:14 -04:00
/**
* Fires immediately after a post is deleted from the database .
*
* @ since 2.2 . 0
*
* @ param int $postid Post ID .
*/
2009-11-19 12:55:23 -05:00
do_action ( 'deleted_post' , $postid );
2009-03-31 15:16:53 -04:00
2012-04-23 18:04:35 -04:00
clean_post_cache ( $post );
2006-06-07 19:17:59 -04:00
2012-09-22 11:55:02 -04:00
if ( is_post_type_hierarchical ( $post -> post_type ) && $children ) {
foreach ( $children as $child )
2012-04-23 18:04:35 -04:00
clean_post_cache ( $child );
2012-01-13 13:37:46 -05:00
}
2009-12-24 06:24:32 -05:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $postid ) );
2009-05-24 19:47:49 -04:00
2014-04-13 19:06:14 -04:00
/**
* Fires after a post is deleted , at the conclusion of wp_delete_post () .
*
* @ since 3.2 . 0
*
* @ see wp_delete_post ()
*
* @ param int $postid Post ID .
*/
do_action ( 'after_delete_post' , $postid );
2009-04-01 12:10:14 -04:00
2006-06-07 19:17:59 -04:00
return $post ;
}
2013-10-02 23:51:09 -04:00
/**
* Resets the page_on_front , show_on_front , and page_for_post settings when a
* linked page is deleted or trashed .
*
* Also ensures the post is no longer sticky .
*
* @ access private
* @ since 3.7 . 0
* @ param $post_id
*/
function _reset_front_page_settings_for_post ( $post_id ) {
$post = get_post ( $post_id );
if ( 'page' == $post -> post_type ) {
// If the page is defined in option page_on_front or post_for_posts,
// adjust the corresponding options
if ( get_option ( 'page_on_front' ) == $post -> ID ) {
update_option ( 'show_on_front' , 'posts' );
update_option ( 'page_on_front' , 0 );
}
if ( get_option ( 'page_for_posts' ) == $post -> ID ) {
delete_option ( 'page_for_posts' , 0 );
}
}
unstick_post ( $post -> ID );
}
add_action ( 'before_delete_post' , '_reset_front_page_settings_for_post' );
add_action ( 'wp_trash_post' , '_reset_front_page_settings_for_post' );
2009-07-30 09:39:34 -04:00
/**
* Moves a post or page to the Trash
*
2010-04-04 08:20:19 -04:00
* If trash is disabled , the post or page is permanently deleted .
*
2009-07-30 09:39:34 -04:00
* @ since 2.9 . 0
2014-04-13 19:06:14 -04:00
*
2010-04-04 08:20:19 -04:00
* @ uses wp_delete_post () if trash is disabled
2009-07-30 09:39:34 -04:00
*
2010-09-07 07:21:11 -04:00
* @ param int $post_id Post ID .
2009-07-30 09:39:34 -04:00
* @ return mixed False on failure
*/
2009-08-25 18:05:15 -04:00
function wp_trash_post ( $post_id = 0 ) {
2010-04-04 08:20:19 -04:00
if ( ! EMPTY_TRASH_DAYS )
return wp_delete_post ( $post_id , true );
2009-07-30 09:39:34 -04:00
2012-08-28 15:08:28 -04:00
if ( ! $post = get_post ( $post_id , ARRAY_A ) )
2009-07-30 09:39:34 -04:00
return $post ;
2009-10-30 03:09:55 -04:00
if ( $post [ 'post_status' ] == 'trash' )
return false ;
2014-04-13 19:06:14 -04:00
/**
* Fires before a post is sent to the trash .
*
* @ since 3.3 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'wp_trash_post' , $post_id );
2009-07-30 09:39:34 -04:00
2013-03-01 11:28:40 -05:00
add_post_meta ( $post_id , '_wp_trash_meta_status' , $post [ 'post_status' ]);
add_post_meta ( $post_id , '_wp_trash_meta_time' , time ());
2009-07-30 09:39:34 -04:00
$post [ 'post_status' ] = 'trash' ;
wp_insert_post ( $post );
2009-11-05 16:03:09 -05:00
wp_trash_post_comments ( $post_id );
2014-04-13 19:06:14 -04:00
/**
* Fires after a post is sent to the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'trashed_post' , $post_id );
2009-07-30 09:39:34 -04:00
return $post ;
}
/**
2009-07-30 10:55:07 -04:00
* Restores a post or page from the Trash
2009-07-30 09:39:34 -04:00
*
* @ since 2.9 . 0
*
2010-09-07 07:21:11 -04:00
* @ param int $post_id Post ID .
2009-07-30 09:39:34 -04:00
* @ return mixed False on failure
*/
2009-08-25 18:05:15 -04:00
function wp_untrash_post ( $post_id = 0 ) {
2012-08-28 15:08:28 -04:00
if ( ! $post = get_post ( $post_id , ARRAY_A ) )
2009-07-30 09:39:34 -04:00
return $post ;
2009-10-30 03:09:55 -04:00
if ( $post [ 'post_status' ] != 'trash' )
return false ;
2014-04-13 19:06:14 -04:00
/**
* Fires before a post is restored from the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'untrash_post' , $post_id );
2009-07-30 10:55:07 -04:00
2009-08-26 00:57:29 -04:00
$post_status = get_post_meta ( $post_id , '_wp_trash_meta_status' , true );
2009-07-30 10:55:07 -04:00
2009-08-26 00:57:29 -04:00
$post [ 'post_status' ] = $post_status ;
delete_post_meta ( $post_id , '_wp_trash_meta_status' );
delete_post_meta ( $post_id , '_wp_trash_meta_time' );
2009-07-30 10:55:07 -04:00
2009-07-30 09:39:34 -04:00
wp_insert_post ( $post );
2009-07-30 10:55:07 -04:00
2009-11-05 16:03:09 -05:00
wp_untrash_post_comments ( $post_id );
2014-04-13 19:06:14 -04:00
/**
* Fires after a post is restored from the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'untrashed_post' , $post_id );
2009-07-30 09:39:34 -04:00
return $post ;
}
2009-11-05 16:03:09 -05:00
/**
* Moves comments for a post to the trash
*
* @ since 2.9 . 0
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Optional . Post ID or post object .
2009-11-05 16:03:09 -05:00
* @ return mixed False on failure
*/
function wp_trash_post_comments ( $post = null ) {
global $wpdb ;
$post = get_post ( $post );
if ( empty ( $post ) )
return ;
$post_id = $post -> ID ;
2014-04-13 19:06:14 -04:00
/**
* Fires before comments are sent to the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'trash_post_comments' , $post_id );
2009-11-05 16:03:09 -05:00
$comments = $wpdb -> get_results ( $wpdb -> prepare ( " SELECT comment_ID, comment_approved FROM $wpdb->comments WHERE comment_post_ID = %d " , $post_id ) );
if ( empty ( $comments ) )
return ;
// Cache current status for each comment
$statuses = array ();
foreach ( $comments as $comment )
$statuses [ $comment -> comment_ID ] = $comment -> comment_approved ;
2013-03-01 11:28:40 -05:00
add_post_meta ( $post_id , '_wp_trash_meta_comments_status' , $statuses );
2009-11-05 16:03:09 -05:00
// Set status for all comments to post-trashed
$result = $wpdb -> update ( $wpdb -> comments , array ( 'comment_approved' => 'post-trashed' ), array ( 'comment_post_ID' => $post_id ));
clean_comment_cache ( array_keys ( $statuses ) );
2014-04-13 19:06:14 -04:00
/**
* Fires after comments are sent to the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
* @ param array $statuses Array of comment statuses .
*/
do_action ( 'trashed_post_comments' , $post_id , $statuses );
2009-11-05 16:03:09 -05:00
return $result ;
}
/**
* Restore comments for a post from the trash
*
* @ since 2.9 . 0
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Optional . Post ID or post object .
2009-11-05 16:03:09 -05:00
* @ return mixed False on failure
*/
function wp_untrash_post_comments ( $post = null ) {
global $wpdb ;
$post = get_post ( $post );
if ( empty ( $post ) )
return ;
$post_id = $post -> ID ;
$statuses = get_post_meta ( $post_id , '_wp_trash_meta_comments_status' , true );
if ( empty ( $statuses ) )
return true ;
2014-04-13 19:06:14 -04:00
/**
* Fires before comments are restored for a post from the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'untrash_post_comments' , $post_id );
2009-11-05 16:03:09 -05:00
// Restore each comment to its original status
$group_by_status = array ();
foreach ( $statuses as $comment_id => $comment_status )
$group_by_status [ $comment_status ][] = $comment_id ;
foreach ( $group_by_status as $status => $comments ) {
// Sanity check. This shouldn't happen.
2015-08-04 01:00:06 -04:00
if ( 'post-trashed' == $status ) {
2009-11-05 16:03:09 -05:00
$status = '0' ;
2015-08-04 01:00:06 -04:00
}
$comments_in = implode ( ', ' , array_map ( 'intval' , $comments ) );
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->comments SET comment_approved = %s WHERE comment_ID IN ( $comments_in ) " , $status ) );
2009-11-05 16:03:09 -05:00
}
clean_comment_cache ( array_keys ( $statuses ) );
delete_post_meta ( $post_id , '_wp_trash_meta_comments_status' );
2014-04-13 19:06:14 -04:00
/**
* Fires after comments are restored for a post from the trash .
*
* @ since 2.9 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'untrashed_post_comments' , $post_id );
2009-11-05 16:03:09 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve the list of categories for a post .
2007-12-13 19:28:34 -05:00
*
* Compatibility layer for themes and plugins . Also an easy layer of abstraction
* away from the complexity of the taxonomy layer .
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ uses wp_get_object_terms () Retrieves the categories . Args details can be found here .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Optional . The Post ID .
* @ param array $args Optional . Overwrite the defaults .
* @ return array
2007-12-13 19:28:34 -05:00
*/
2007-05-27 01:15:18 -04:00
function wp_get_post_categories ( $post_id = 0 , $args = array () ) {
2007-03-22 16:52:29 -04:00
$post_id = ( int ) $post_id ;
2007-05-27 01:15:18 -04:00
$defaults = array ( 'fields' => 'ids' );
$args = wp_parse_args ( $args , $defaults );
2007-06-18 20:33:44 -04:00
$cats = wp_get_object_terms ( $post_id , 'category' , $args );
2007-05-23 14:07:53 -04:00
return $cats ;
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve the tags for a post .
*
* There is only one default for this function , called 'fields' and by default
2009-05-06 16:49:36 -04:00
* is set to 'all' . There are other defaults that can be overridden in
2008-08-19 12:38:06 -04:00
* { @ link wp_get_object_terms ()} .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2007-12-13 19:28:34 -05:00
*
* @ uses wp_get_object_terms () Gets the tags for returning . Args can be found here
*
* @ param int $post_id Optional . The Post ID
* @ param array $args Optional . Overwrite the defaults
2008-08-19 12:38:06 -04:00
* @ return array List of post tags .
2007-12-13 19:28:34 -05:00
*/
2007-05-27 01:15:18 -04:00
function wp_get_post_tags ( $post_id = 0 , $args = array () ) {
2008-12-18 14:12:26 -05:00
return wp_get_post_terms ( $post_id , 'post_tag' , $args );
}
/**
* Retrieve the terms for a post .
*
* There is only one default for this function , called 'fields' and by default
2009-05-06 16:49:36 -04:00
* is set to 'all' . There are other defaults that can be overridden in
2008-12-18 14:12:26 -05:00
* { @ link wp_get_object_terms ()} .
*
* @ since 2.8 . 0
*
* @ uses wp_get_object_terms () Gets the tags for returning . Args can be found here
*
* @ param int $post_id Optional . The Post ID
* @ param string $taxonomy The taxonomy for which to retrieve terms . Defaults to post_tag .
* @ param array $args Optional . Overwrite the defaults
* @ return array List of post tags .
*/
function wp_get_post_terms ( $post_id = 0 , $taxonomy = 'post_tag' , $args = array () ) {
2007-04-06 14:22:54 -04:00
$post_id = ( int ) $post_id ;
2007-05-27 01:15:18 -04:00
$defaults = array ( 'fields' => 'all' );
$args = wp_parse_args ( $args , $defaults );
2007-06-13 22:25:30 -04:00
2008-12-18 14:12:26 -05:00
$tags = wp_get_object_terms ( $post_id , $taxonomy , $args );
2007-05-27 01:15:18 -04:00
2007-05-22 01:12:38 -04:00
return $tags ;
2007-04-06 14:22:54 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve number of recent posts .
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* @ since 1.0 . 0
2010-10-26 09:50:38 -04:00
* @ uses wp_parse_args ()
* @ uses get_posts ()
2007-12-13 19:28:34 -05:00
*
2010-10-26 09:50:38 -04:00
* @ param string $deprecated Deprecated .
* @ param array $args Optional . Overrides defaults .
* @ param string $output Optional .
* @ return unknown .
2007-12-13 19:28:34 -05:00
*/
2010-10-26 09:50:38 -04:00
function wp_get_recent_posts ( $args = array (), $output = ARRAY_A ) {
2010-11-09 05:14:38 -05:00
if ( is_numeric ( $args ) ) {
2010-11-09 15:37:47 -05:00
_deprecated_argument ( __FUNCTION__ , '3.1' , __ ( 'Passing an integer number of posts is deprecated. Pass an array of arguments instead.' ) );
2010-10-26 09:50:38 -04:00
$args = array ( 'numberposts' => absint ( $args ) );
2010-11-09 05:14:38 -05:00
}
2010-11-17 13:47:34 -05:00
2010-10-26 09:50:38 -04:00
// Set default arguments
$defaults = array (
'numberposts' => 10 , 'offset' => 0 ,
'category' => 0 , 'orderby' => 'post_date' ,
'order' => 'DESC' , 'include' => '' ,
'exclude' => '' , 'meta_key' => '' ,
'meta_value' => '' , 'post_type' => 'post' , 'post_status' => 'draft, publish, future, pending, private' ,
'suppress_filters' => true
);
2010-10-28 11:46:11 -04:00
2010-10-26 09:50:38 -04:00
$r = wp_parse_args ( $args , $defaults );
2006-06-07 19:17:59 -04:00
2010-10-26 09:50:38 -04:00
$results = get_posts ( $r );
2010-10-28 11:46:11 -04:00
2010-10-26 09:50:38 -04:00
// Backward compatibility. Prior to 3.1 expected posts to be returned in array
if ( ARRAY_A == $output ){
foreach ( $results as $key => $result ) {
$results [ $key ] = get_object_vars ( $result );
}
return $results ? $results : array ();
2006-06-07 19:17:59 -04:00
}
2010-10-26 09:50:38 -04:00
return $results ? $results : false ;
2006-06-07 19:17:59 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2013-09-25 13:34:08 -04:00
* Insert or update a post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* If the $postarr parameter has 'ID' set to a value , then post will be updated .
2007-12-13 19:28:34 -05:00
*
2013-01-22 09:44:04 -05:00
* You can set the post date manually , by setting the values for 'post_date'
2008-08-19 12:38:06 -04:00
* and 'post_date_gmt' keys . You can close the comments or open the comments by
* setting the value for 'comment_status' key .
2007-12-13 19:28:34 -05:00
*
2013-09-25 13:34:08 -04:00
* @ global wpdb $wpdb WordPress database abstraction object .
2008-08-19 12:38:06 -04:00
*
* @ since 1.0 . 0
2013-09-25 13:34:08 -04:00
*
* @ param array $postarr {
* An array of elements that make up a post to update or insert .
*
2014-04-13 19:06:14 -04:00
* @ type int $ID The post ID . If equal to something other than 0 , the post with that ID will
* be updated . Default 0.
* @ type string $post_status The post status . Default 'draft' .
* @ type string $post_type The post type . Default 'post' .
* @ type int $post_author The ID of the user who added the post . Default the current user ID .
* @ type bool $ping_status Whether the post can accept pings . Default value of 'default_ping_status' option .
* @ type int $post_parent Set this for the post it belongs to , if any . Default 0.
* @ type int $menu_order The order it is displayed . Default 0.
* @ type string $to_ping Space or carriage return - separated list of URLs to ping . Default empty string .
* @ type string $pinged Space or carriage return - separated list of URLs that have been pinged .
* Default empty string .
* @ type string $post_password The password to access the post . Default empty string .
* @ type string $guid ' Global Unique ID for referencing the post .
* @ type string $post_content_filtered The filtered post content . Default empty string .
* @ type string $post_excerpt The post excerpt . Default empty string .
2013-09-25 13:34:08 -04:00
* }
* @ param bool $wp_error Optional . Allow return of WP_Error on failure .
* @ return int | WP_Error The post ID on success . The value 0 or WP_Error on failure .
2007-12-13 19:28:34 -05:00
*/
2013-09-25 13:34:08 -04:00
function wp_insert_post ( $postarr , $wp_error = false ) {
2013-10-02 17:10:09 -04:00
global $wpdb ;
$user_id = get_current_user_id ();
2005-06-18 21:33:38 -04:00
2013-10-02 17:10:09 -04:00
$defaults = array ( 'post_status' => 'draft' , 'post_type' => 'post' , 'post_author' => $user_id ,
2007-07-16 19:11:51 -04:00
'ping_status' => get_option ( 'default_ping_status' ), 'post_parent' => 0 ,
2008-01-10 16:27:08 -05:00
'menu_order' => 0 , 'to_ping' => '' , 'pinged' => '' , 'post_password' => '' ,
2010-02-06 09:49:54 -05:00
'guid' => '' , 'post_content_filtered' => '' , 'post_excerpt' => '' , 'import_id' => 0 ,
'post_content' => '' , 'post_title' => '' );
2007-07-11 15:57:43 -04:00
$postarr = wp_parse_args ( $postarr , $defaults );
2011-06-28 17:46:18 -04:00
unset ( $postarr [ 'filter' ] );
2007-07-12 12:00:51 -04:00
$postarr = sanitize_post ( $postarr , 'db' );
2005-11-22 20:35:08 -05:00
2004-05-23 21:34:57 -04:00
// export array as variables
2007-06-14 18:45:40 -04:00
extract ( $postarr , EXTR_SKIP );
2004-05-23 21:34:57 -04:00
2005-06-18 21:33:38 -04:00
// Are we updating or creating?
2013-03-18 10:33:09 -04:00
$post_ID = 0 ;
2005-06-18 21:33:38 -04:00
$update = false ;
2013-03-18 10:33:09 -04:00
if ( ! empty ( $ID ) ) {
2005-06-18 21:33:38 -04:00
$update = true ;
2013-03-18 10:33:09 -04:00
// Get the post ID and GUID
$post_ID = $ID ;
$post_before = get_post ( $post_ID );
if ( is_null ( $post_before ) ) {
if ( $wp_error )
return new WP_Error ( 'invalid_post' , __ ( 'Invalid post ID.' ) );
return 0 ;
}
$guid = get_post_field ( 'guid' , $post_ID );
2007-07-12 12:00:51 -04:00
$previous_status = get_post_field ( 'post_status' , $ID );
} else {
$previous_status = 'new' ;
2005-06-18 21:33:38 -04:00
}
2011-11-15 16:19:29 -05:00
$maybe_empty = ! $post_content && ! $post_title && ! $post_excerpt && post_type_supports ( $post_type , 'editor' )
2013-05-30 17:33:46 -04:00
&& post_type_supports ( $post_type , 'title' ) && post_type_supports ( $post_type , 'excerpt' );
2013-04-13 21:43:01 -04:00
2014-04-08 02:49:14 -04:00
/**
* Filter whether the post should be considered " empty " .
*
* The post is considered " empty " if both :
* 1. The post type supports the title , editor , and excerpt fields
* 2. The title , editor , and excerpt fields are all empty
*
* Returning a truthy value to the filter will effectively short - circuit
* the new post being inserted , returning 0. If $wp_error is true , a WP_Error
* will be returned instead .
*
* @ since 3.3 . 0
*
* @ param bool $maybe_empty Whether the post should be considered " empty " .
* @ param array $postarr Array of post data .
*/
2011-11-15 16:19:29 -05:00
if ( apply_filters ( 'wp_insert_post_empty_content' , $maybe_empty , $postarr ) ) {
2008-05-05 19:19:27 -04:00
if ( $wp_error )
2011-11-15 16:19:29 -05:00
return new WP_Error ( 'empty_content' , __ ( 'Content, title, and excerpt are empty.' ) );
2008-05-05 19:19:27 -04:00
else
return 0 ;
}
2006-08-24 20:27:15 -04:00
2010-02-17 15:33:29 -05:00
if ( empty ( $post_type ) )
$post_type = 'post' ;
2010-05-25 10:43:39 -04:00
if ( empty ( $post_status ) )
$post_status = 'draft' ;
2010-05-03 19:35:22 -04:00
if ( ! empty ( $post_category ) )
$post_category = array_filter ( $post_category ); // Filter out empty terms
2010-02-17 15:33:29 -05:00
// Make sure we set a valid category.
2008-08-25 17:50:11 -04:00
if ( empty ( $post_category ) || 0 == count ( $post_category ) || ! is_array ( $post_category ) ) {
2010-02-17 15:33:29 -05:00
// 'post' requires at least one category.
2010-05-25 10:43:39 -04:00
if ( 'post' == $post_type && 'auto-draft' != $post_status )
2010-02-17 15:33:29 -05:00
$post_category = array ( get_option ( 'default_category' ) );
else
$post_category = array ();
2004-05-23 21:34:57 -04:00
}
2005-06-18 15:08:38 -04:00
if ( empty ( $post_author ) )
2013-10-02 17:10:09 -04:00
$post_author = $user_id ;
2005-06-18 15:08:38 -04:00
2011-04-25 10:33:27 -04:00
// Don't allow contributors to set the post slug for pending review posts
2008-10-02 00:10:54 -04:00
if ( 'pending' == $post_status && ! current_user_can ( 'publish_posts' ) )
$post_name = '' ;
2011-12-13 18:45:31 -05:00
// Create a valid post name. Drafts and pending posts are allowed to have an empty
2005-06-18 15:08:38 -04:00
// post name.
2010-03-19 17:29:21 -04:00
if ( empty ( $post_name ) ) {
2010-02-06 05:07:57 -05:00
if ( ! in_array ( $post_status , array ( 'draft' , 'pending' , 'auto-draft' ) ) )
2005-10-13 15:06:31 -04:00
$post_name = sanitize_title ( $post_title );
2009-04-23 16:21:18 -04:00
else
$post_name = '' ;
2005-06-18 15:08:38 -04:00
} else {
2011-11-23 19:20:21 -05:00
// On updates, we need to check to see if it's using the old, fixed sanitization context.
$check_name = sanitize_title ( $post_name , '' , 'old-save' );
if ( $update && strtolower ( urlencode ( $post_name ) ) == $check_name && get_post_field ( 'post_name' , $ID ) == $check_name )
$post_name = $check_name ;
else // new post, or slug has changed.
$post_name = sanitize_title ( $post_name );
2005-06-18 15:08:38 -04:00
}
2006-02-12 02:53:23 -05:00
2008-10-02 00:10:54 -04:00
// If the post date is empty (due to having been new or a draft) and status is not 'draft' or 'pending', set date to now
2008-09-17 16:19:29 -04:00
if ( empty ( $post_date ) || '0000-00-00 00:00:00' == $post_date )
$post_date = current_time ( 'mysql' );
2005-11-14 04:56:41 -05:00
2012-09-19 17:43:35 -04:00
// validate the date
$mm = substr ( $post_date , 5 , 2 );
$jj = substr ( $post_date , 8 , 2 );
$aa = substr ( $post_date , 0 , 4 );
2012-09-20 06:46:50 -04:00
$valid_date = wp_checkdate ( $mm , $jj , $aa , $post_date );
2012-09-19 17:43:35 -04:00
if ( ! $valid_date ) {
2012-09-20 06:46:50 -04:00
if ( $wp_error )
return new WP_Error ( 'invalid_date' , __ ( 'Whoops, the provided date is invalid.' ) );
else
return 0 ;
2012-09-19 17:43:35 -04:00
}
2008-08-13 12:01:01 -04:00
if ( empty ( $post_date_gmt ) || '0000-00-00 00:00:00' == $post_date_gmt ) {
2010-02-06 05:07:57 -05:00
if ( ! in_array ( $post_status , array ( 'draft' , 'pending' , 'auto-draft' ) ) )
2005-11-14 04:56:41 -05:00
$post_date_gmt = get_gmt_from_date ( $post_date );
2008-01-04 03:46:33 -05:00
else
$post_date_gmt = '0000-00-00 00:00:00' ;
2005-11-14 04:56:41 -05:00
}
2007-02-27 10:24:54 -05:00
2008-01-22 14:35:19 -05:00
if ( $update || '0000-00-00 00:00:00' == $post_date ) {
2007-10-12 20:48:52 -04:00
$post_modified = current_time ( 'mysql' );
$post_modified_gmt = current_time ( 'mysql' , 1 );
} else {
$post_modified = $post_date ;
$post_modified_gmt = $post_date_gmt ;
}
2006-02-13 19:12:09 -05:00
if ( 'publish' == $post_status ) {
$now = gmdate ( 'Y-m-d H:i:59' );
2009-05-13 22:00:32 -04:00
if ( mysql2date ( 'U' , $post_date_gmt , false ) > mysql2date ( 'U' , $now , false ) )
2006-02-13 19:12:09 -05:00
$post_status = 'future' ;
2010-04-10 10:00:30 -04:00
} elseif ( 'future' == $post_status ) {
$now = gmdate ( 'Y-m-d H:i:59' );
if ( mysql2date ( 'U' , $post_date_gmt , false ) <= mysql2date ( 'U' , $now , false ) )
$post_status = 'publish' ;
2006-02-13 19:12:09 -05:00
}
2006-02-12 02:41:56 -05:00
2005-08-05 16:44:18 -04:00
if ( empty ( $comment_status ) ) {
if ( $update )
$comment_status = 'closed' ;
else
2010-05-15 00:56:56 -04:00
$comment_status = get_option ( 'default_comment_status' );
2005-08-05 16:44:18 -04:00
}
if ( empty ( $ping_status ) )
2006-08-30 17:46:31 -04:00
$ping_status = get_option ( 'default_ping_status' );
2005-06-18 15:08:38 -04:00
2005-06-18 21:33:38 -04:00
if ( isset ( $to_ping ) )
2012-01-04 14:45:13 -05:00
$to_ping = sanitize_trackback_urls ( $to_ping );
2005-06-18 15:08:38 -04:00
else
2005-06-18 21:33:38 -04:00
$to_ping = '' ;
2005-12-10 18:22:47 -05:00
if ( ! isset ( $pinged ) )
$pinged = '' ;
2005-06-18 15:08:38 -04:00
if ( isset ( $post_parent ) )
$post_parent = ( int ) $post_parent ;
else
2005-02-10 22:36:49 -05:00
$post_parent = 0 ;
2005-02-13 23:51:14 -05:00
2014-04-13 19:06:14 -04:00
/**
* Filter the post parent -- used to check for and prevent hierarchy loops .
*
* @ since 3.1 . 0
*
* @ param int $post_parent Post parent ID .
* @ param int $post_ID Post ID .
* @ param array $new_postarr Array of parsed post data .
* @ param array $postarr Array of sanitized , but otherwise unmodified post data .
*/
2010-10-14 11:09:04 -04:00
$post_parent = apply_filters ( 'wp_insert_post_parent' , $post_parent , $post_ID , compact ( array_keys ( $postarr ) ), $postarr );
2008-12-08 14:29:42 -05:00
2005-06-18 15:08:38 -04:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
2008-12-06 06:10:24 -05:00
if ( ! isset ( $post_password ) || 'private' == $post_status )
2005-06-18 15:08:38 -04:00
$post_password = '' ;
2009-04-23 16:21:18 -04:00
$post_name = wp_unique_post_slug ( $post_name , $post_ID , $post_status , $post_type , $post_parent );
2005-02-13 23:51:14 -05:00
2013-03-01 11:28:40 -05:00
// expected_slashed (everything!)
2009-03-05 19:50:19 -05:00
$data = compact ( array ( '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' , 'guid' ) );
2014-04-13 19:06:14 -04:00
/**
* Filter slashed post data just before it is inserted into the database .
*
* @ since 2.7 . 0
*
* @ param array $data Array of slashed post data .
* @ param array $postarr Array of sanitized , but otherwise unmodified post data .
*/
$data = apply_filters ( 'wp_insert_post_data' , $data , $postarr );
2013-03-03 16:11:40 -05:00
$data = wp_unslash ( $data );
2007-10-12 22:36:38 -04:00
$where = array ( 'ID' => $post_ID );
2007-10-12 20:48:52 -04:00
2010-04-26 21:05:58 -04:00
if ( $update ) {
2014-04-13 19:06:14 -04:00
/**
* Fires immediately before an existing post is updated in the database .
*
* @ since 2.5 . 0
*
* @ param int $post_ID Post ID .
* @ param array $data Array of unslashed post data .
*/
2013-02-14 06:36:32 -05:00
do_action ( 'pre_post_update' , $post_ID , $data );
2009-03-05 19:50:19 -05:00
if ( false === $wpdb -> update ( $wpdb -> posts , $data , $where ) ) {
2008-05-05 19:19:27 -04:00
if ( $wp_error )
return new WP_Error ( 'db_update_error' , __ ( 'Could not update post in the database' ), $wpdb -> last_error );
else
return 0 ;
}
2005-06-18 21:33:38 -04:00
} else {
2008-08-25 17:50:11 -04:00
if ( isset ( $post_mime_type ) )
2013-03-03 16:11:40 -05:00
$data [ 'post_mime_type' ] = wp_unslash ( $post_mime_type ); // This isn't in the update
2008-10-08 17:42:52 -04:00
// If there is a suggested ID, use it if not already present
if ( ! empty ( $import_id ) ) {
$import_id = ( int ) $import_id ;
if ( ! $wpdb -> get_var ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE ID = %d " , $import_id ) ) ) {
$data [ 'ID' ] = $import_id ;
}
}
2009-03-05 19:50:19 -05:00
if ( false === $wpdb -> insert ( $wpdb -> posts , $data ) ) {
2008-05-05 19:19:27 -04:00
if ( $wp_error )
return new WP_Error ( 'db_insert_error' , __ ( 'Could not insert post into the database' ), $wpdb -> last_error );
else
2008-08-09 01:36:14 -04:00
return 0 ;
2008-05-05 19:19:27 -04:00
}
2007-10-12 20:48:52 -04:00
$post_ID = ( int ) $wpdb -> insert_id ;
2007-12-27 03:09:31 -05:00
2007-11-01 20:58:15 -04:00
// use the newly generated $post_ID
2007-11-01 20:47:04 -04:00
$where = array ( 'ID' => $post_ID );
2005-10-13 15:06:31 -04:00
}
2010-02-06 05:07:57 -05:00
if ( empty ( $data [ 'post_name' ]) && ! in_array ( $data [ 'post_status' ], array ( 'draft' , 'pending' , 'auto-draft' ) ) ) {
2009-05-19 11:54:19 -04:00
$data [ 'post_name' ] = sanitize_title ( $data [ 'post_title' ], $post_ID );
$wpdb -> update ( $wpdb -> posts , array ( 'post_name' => $data [ 'post_name' ] ), $where );
2005-06-18 21:33:38 -04:00
}
2005-09-13 20:34:04 -04:00
2010-05-11 12:28:00 -04:00
if ( is_object_in_taxonomy ( $post_type , 'category' ) )
wp_set_post_categories ( $post_ID , $post_category );
if ( isset ( $tags_input ) && is_object_in_taxonomy ( $post_type , 'post_tag' ) )
2008-12-18 14:12:26 -05:00
wp_set_post_tags ( $post_ID , $tags_input );
2010-05-04 01:48:08 -04:00
2010-05-03 19:35:22 -04:00
// new-style support for all custom taxonomies
2010-04-26 20:44:38 -04:00
if ( ! empty ( $tax_input ) ) {
foreach ( $tax_input as $taxonomy => $tags ) {
$taxonomy_obj = get_taxonomy ( $taxonomy );
2010-05-03 19:35:22 -04:00
if ( is_array ( $tags ) ) // array = hierarchical, string = non-hierarchical.
$tags = array_filter ( $tags );
2010-05-13 00:10:17 -04:00
if ( current_user_can ( $taxonomy_obj -> cap -> assign_terms ) )
2010-04-26 20:44:38 -04:00
wp_set_post_terms ( $post_ID , $tags , $taxonomy );
}
2008-12-18 14:12:26 -05:00
}
2005-09-13 20:34:04 -04:00
2008-01-10 16:27:08 -05:00
$current_guid = get_post_field ( 'guid' , $post_ID );
2004-09-04 22:03:51 -04:00
// Set GUID
2008-01-10 16:27:08 -05:00
if ( ! $update && '' == $current_guid )
2007-10-12 22:36:38 -04:00
$wpdb -> update ( $wpdb -> posts , array ( 'guid' => get_permalink ( $post_ID ) ), $where );
2005-06-18 15:08:38 -04:00
2012-09-21 14:52:15 -04:00
clean_post_cache ( $post_ID );
2007-07-12 12:00:51 -04:00
$post = get_post ( $post_ID );
2008-05-05 19:19:27 -04:00
2009-05-19 11:54:19 -04:00
if ( ! empty ( $page_template ) && 'page' == $data [ 'post_type' ] ) {
2007-07-12 12:00:51 -04:00
$post -> page_template = $page_template ;
2014-03-07 23:19:16 -05:00
$page_templates = wp_get_theme () -> get_page_templates ( $post );
2012-09-14 14:36:08 -04:00
if ( 'default' != $page_template && ! isset ( $page_templates [ $page_template ] ) ) {
2008-05-05 19:19:27 -04:00
if ( $wp_error )
return new WP_Error ( 'invalid_page_template' , __ ( 'The page template is invalid.' ));
else
return 0 ;
}
2013-03-01 11:28:40 -05:00
update_post_meta ( $post_ID , '_wp_page_template' , $page_template );
2008-05-05 19:19:27 -04:00
}
2006-11-19 02:56:05 -05:00
2009-05-19 11:54:19 -04:00
wp_transition_post_status ( $data [ 'post_status' ], $previous_status , $post );
2004-05-23 21:34:57 -04:00
2010-05-23 03:49:21 -04:00
if ( $update ) {
2014-04-13 19:06:14 -04:00
/**
* Fires once an existing post has been updated .
*
* @ since 1.2 . 0
*
* @ param int $post_ID Post ID .
* @ param WP_Post $post Post object .
*/
do_action ( 'edit_post' , $post_ID , $post );
2010-05-23 03:49:21 -04:00
$post_after = get_post ( $post_ID );
2014-04-13 19:06:14 -04:00
/**
* Fires once an existing post has been updated .
*
* @ since 3.0 . 0
*
* @ param int $post_ID Post ID .
* @ param WP_Post $post_after Post object following the update .
* @ param WP_Post $post_before Post object before the update .
*/
2010-05-23 03:49:21 -04:00
do_action ( 'post_updated' , $post_ID , $post_after , $post_before );
}
2006-08-07 00:43:38 -04:00
2014-04-13 19:06:14 -04:00
/**
* Fires once a post has been saved .
*
* The dynamic portion of the hook name , $post -> post_type , refers to
* the post type slug .
*
* @ since 3.7 . 0
*
* @ param int $post_ID Post ID .
* @ param WP_Post $post Post object .
* @ param bool $update Whether this is an existing post being updated or not .
*/
2013-08-17 16:21:09 -04:00
do_action ( " save_post_ { $post -> post_type } " , $post_ID , $post , $update );
2014-04-13 19:06:14 -04:00
/**
* Fires once a post has been saved .
*
* @ since 1.5 . 0
*
* @ param int $post_ID Post ID .
* @ param WP_Post $post Post object .
* @ param bool $update Whether this is an existing post being updated or not .
*/
2013-07-28 17:05:25 -04:00
do_action ( 'save_post' , $post_ID , $post , $update );
2014-04-13 19:06:14 -04:00
/**
* Fires once a post has been saved .
*
* @ since 2.0 . 0
*
* @ param int $post_ID Post ID .
* @ param WP_Post $post Post object .
* @ param bool $update Whether this is an existing post being updated or not .
*/
2013-07-28 17:05:25 -04:00
do_action ( 'wp_insert_post' , $post_ID , $post , $update );
2005-09-16 13:27:09 -04:00
2005-09-15 19:34:54 -04:00
return $post_ID ;
2004-05-23 21:34:57 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Update a post with new post data .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* The date does not have to be set for drafts . You can set the date and it will
* not be overridden .
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* @ since 1.0 . 0
2007-12-13 19:28:34 -05:00
*
2009-05-15 17:27:39 -04:00
* @ param array | object $postarr Post data . Arrays are expected to be escaped , objects are not .
2012-07-05 15:21:57 -04:00
* @ param bool $wp_error Optional . Allow return of WP_Error on failure .
* @ return int | WP_Error The value 0 or WP_Error on failure . The post ID on success .
2007-12-13 19:28:34 -05:00
*/
2012-07-05 15:21:57 -04:00
function wp_update_post ( $postarr = array (), $wp_error = false ) {
2009-05-15 17:27:39 -04:00
if ( is_object ( $postarr ) ) {
// non-escaped post was passed
2006-06-07 19:17:59 -04:00
$postarr = get_object_vars ( $postarr );
2013-03-03 16:11:40 -05:00
$postarr = wp_slash ( $postarr );
2009-05-15 17:27:39 -04:00
}
2005-12-13 14:19:56 -05:00
2006-06-07 19:17:59 -04:00
// First, get all of the original fields
2012-08-28 15:08:28 -04:00
$post = get_post ( $postarr [ 'ID' ], ARRAY_A );
2005-01-06 20:21:12 -05:00
2013-03-18 10:33:09 -04:00
if ( is_null ( $post ) ) {
if ( $wp_error )
return new WP_Error ( 'invalid_post' , __ ( 'Invalid post ID.' ) );
return 0 ;
}
2013-03-01 11:28:40 -05:00
// Escape data pulled from DB.
2013-03-03 16:11:40 -05:00
$post = wp_slash ( $post );
2013-03-01 11:28:40 -05:00
2005-07-03 14:33:03 -04:00
// Passed post category list overwrites existing category list if not empty.
2006-11-19 02:56:05 -05:00
if ( isset ( $postarr [ 'post_category' ]) && is_array ( $postarr [ 'post_category' ])
2005-07-03 14:33:03 -04:00
&& 0 != count ( $postarr [ 'post_category' ]) )
2006-11-19 02:56:05 -05:00
$post_cats = $postarr [ 'post_category' ];
else
$post_cats = $post [ 'post_category' ];
2005-01-06 20:21:12 -05:00
2005-11-14 04:56:41 -05:00
// Drafts shouldn't be assigned a date unless explicitly done so by the user
2010-07-13 17:30:09 -04:00
if ( isset ( $post [ 'post_status' ] ) && in_array ( $post [ 'post_status' ], array ( 'draft' , 'pending' , 'auto-draft' )) && empty ( $postarr [ 'edit_date' ]) &&
2008-09-17 16:19:29 -04:00
( '0000-00-00 00:00:00' == $post [ 'post_date_gmt' ]) )
2005-11-14 04:56:41 -05:00
$clear_date = true ;
else
$clear_date = false ;
2006-11-19 02:56:05 -05:00
// Merge old and new fields with new fields overwriting old ones.
$postarr = array_merge ( $post , $postarr );
$postarr [ 'post_category' ] = $post_cats ;
2005-11-14 04:56:41 -05:00
if ( $clear_date ) {
2008-10-05 00:43:52 -04:00
$postarr [ 'post_date' ] = current_time ( 'mysql' );
2005-11-14 04:56:41 -05:00
$postarr [ 'post_date_gmt' ] = '' ;
}
2010-04-26 20:44:38 -04:00
if ( $postarr [ 'post_type' ] == 'attachment' )
2005-12-13 14:19:56 -05:00
return wp_insert_attachment ( $postarr );
2012-07-05 15:21:57 -04:00
return wp_insert_post ( $postarr , $wp_error );
2004-05-23 21:34:57 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Publish a post by transitioning the post status .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2012-12-27 10:14:43 -05:00
* @ uses $wpdb
2007-12-13 19:28:34 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Post ID or post object .
2007-12-13 19:28:34 -05:00
*/
2012-09-21 14:49:45 -04:00
function wp_publish_post ( $post ) {
2012-12-27 10:14:43 -05:00
global $wpdb ;
2012-09-21 14:49:45 -04:00
if ( ! $post = get_post ( $post ) )
2006-02-12 02:41:56 -05:00
return ;
2012-12-27 10:14:43 -05:00
2006-08-06 23:50:55 -04:00
if ( 'publish' == $post -> post_status )
2006-02-12 02:41:56 -05:00
return ;
2012-12-27 10:14:43 -05:00
$wpdb -> update ( $wpdb -> posts , array ( 'post_status' => 'publish' ), array ( 'ID' => $post -> ID ) );
clean_post_cache ( $post -> ID );
$old_status = $post -> post_status ;
2007-07-12 12:00:51 -04:00
$post -> post_status = 'publish' ;
2012-12-27 10:14:43 -05:00
wp_transition_post_status ( 'publish' , $old_status , $post );
2014-04-13 19:06:14 -04:00
/** This action is documented in wp-includes/post.php */
2012-12-27 10:14:43 -05:00
do_action ( 'edit_post' , $post -> ID , $post );
2014-04-13 19:06:14 -04:00
/** This action is documented in wp-includes/post.php */
2013-08-17 16:21:09 -04:00
do_action ( " save_post_ { $post -> post_type } " , $post -> ID , $post , true );
2014-04-13 19:06:14 -04:00
/** This action is documented in wp-includes/post.php */
2013-08-05 17:41:51 -04:00
do_action ( 'save_post' , $post -> ID , $post , true );
2014-04-13 19:06:14 -04:00
/** This action is documented in wp-includes/post.php */
2013-08-05 17:41:51 -04:00
do_action ( 'wp_insert_post' , $post -> ID , $post , true );
2006-02-12 02:41:56 -05:00
}
2008-02-22 14:59:12 -05:00
/**
2008-08-19 12:38:06 -04:00
* Publish future post and make sure post ID has future post status .
2008-03-02 15:17:30 -05:00
*
2008-08-19 12:38:06 -04:00
* Invoked by cron 'publish_future_post' event . This safeguard prevents cron
* from publishing drafts , etc .
2008-02-22 14:59:12 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.5 . 0
2008-02-22 14:59:12 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post_id Post ID or post object .
2008-08-19 12:38:06 -04:00
* @ return null Nothing is returned . Which can mean that no action is required or post was published .
2008-02-22 14:59:12 -05:00
*/
function check_and_publish_future_post ( $post_id ) {
2008-03-02 15:17:30 -05:00
2008-02-22 14:59:12 -05:00
$post = get_post ( $post_id );
if ( empty ( $post ) )
return ;
if ( 'future' != $post -> post_status )
return ;
2008-10-11 01:46:20 -04:00
$time = strtotime ( $post -> post_date_gmt . ' GMT' );
if ( $time > time () ) { // Uh oh, someone jumped the gun!
2009-12-24 06:24:32 -05:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $post_id ) ); // clear anything else in the system
2008-10-11 01:46:20 -04:00
wp_schedule_single_event ( $time , 'publish_future_post' , array ( $post_id ) );
return ;
}
2008-03-02 15:17:30 -05:00
return wp_publish_post ( $post_id );
2008-02-22 14:59:12 -05:00
}
2009-04-23 16:21:18 -04:00
/**
2010-02-12 21:42:17 -05:00
* Computes a unique slug for the post , when given the desired slug and some post details .
2009-04-23 16:21:18 -04:00
*
2010-11-16 08:16:13 -05:00
* @ since 2.8 . 0
*
2010-01-15 17:11:12 -05:00
* @ global wpdb $wpdb
* @ global WP_Rewrite $wp_rewrite
2009-04-23 16:21:18 -04:00
* @ param string $slug the desired slug ( post_name )
* @ param integer $post_ID
* @ param string $post_status no uniqueness checks are made if the post is still draft or pending
* @ param string $post_type
* @ param integer $post_parent
2009-05-24 19:47:49 -04:00
* @ return string unique slug for the post , based on $post_name ( with a - 1 , - 2 , etc . suffix )
2009-04-23 16:21:18 -04:00
*/
2010-02-12 21:42:17 -05:00
function wp_unique_post_slug ( $slug , $post_ID , $post_status , $post_type , $post_parent ) {
2013-03-27 16:21:38 -04:00
if ( in_array ( $post_status , array ( 'draft' , 'pending' , 'auto-draft' ) ) || ( 'inherit' == $post_status && 'revision' == $post_type ) )
2009-05-27 12:21:53 -04:00
return $slug ;
2009-09-14 10:03:32 -04:00
2009-04-23 16:21:18 -04:00
global $wpdb , $wp_rewrite ;
2009-11-26 06:29:54 -05:00
2012-06-29 09:57:02 -04:00
$original_slug = $slug ;
2009-11-26 06:29:54 -05:00
$feeds = $wp_rewrite -> feeds ;
2010-02-12 21:42:17 -05:00
if ( ! is_array ( $feeds ) )
2009-11-26 06:29:54 -05:00
$feeds = array ();
2010-06-29 10:10:54 -04:00
$hierarchical_post_types = get_post_types ( array ( 'hierarchical' => true ) );
2009-05-27 12:21:53 -04:00
if ( 'attachment' == $post_type ) {
// Attachment slugs must be unique across all types.
$check_sql = " SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND ID != %d LIMIT 1 " ;
2010-02-12 21:42:17 -05:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $slug , $post_ID ) );
2009-09-14 10:03:32 -04:00
2014-04-13 19:06:14 -04:00
/**
* Filter whether the post slug would make a bad attachment slug .
*
* @ since 3.1 . 0
*
* @ param bool $bad_slug Whether the slug would be bad as an attachment slug .
* @ param string $slug The post slug .
*/
2010-12-15 12:56:25 -05:00
if ( $post_name_check || in_array ( $slug , $feeds ) || apply_filters ( 'wp_unique_post_slug_is_bad_attachment_slug' , false , $slug ) ) {
2009-05-27 12:21:53 -04:00
$suffix = 2 ;
do {
2013-02-15 09:35:41 -05:00
$alt_post_name = _truncate_post_slug ( $slug , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $alt_post_name , $post_ID ) );
2009-05-27 12:21:53 -04:00
$suffix ++ ;
2010-02-12 21:42:17 -05:00
} while ( $post_name_check );
2009-05-27 12:21:53 -04:00
$slug = $alt_post_name ;
2009-04-29 15:04:27 -04:00
}
2010-02-12 21:42:17 -05:00
} elseif ( in_array ( $post_type , $hierarchical_post_types ) ) {
2012-10-15 10:13:57 -04:00
if ( 'nav_menu_item' == $post_type )
return $slug ;
2014-04-13 19:06:14 -04:00
/*
* Page slugs must be unique within their own trees . Pages are in a separate
* namespace than posts so page slugs are allowed to overlap post slugs .
*/
2010-02-12 21:42:17 -05:00
$check_sql = " SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND post_type IN ( ' " . implode ( " ', ' " , esc_sql ( $hierarchical_post_types ) ) . " ' ) AND ID != %d AND post_parent = %d LIMIT 1 " ;
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $slug , $post_ID , $post_parent ) );
2009-09-14 10:03:32 -04:00
2014-04-13 19:06:14 -04:00
/**
* Filter whether the post slug would make a bad hierarchical post slug .
*
* @ since 3.1 . 0
*
* @ param bool $bad_slug Whether the post slug would be bad in a hierarchical post context .
* @ param string $slug The post slug .
* @ param string $post_type Post type .
* @ param int $post_parent Post parent ID .
*/
2010-12-15 12:56:25 -05:00
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 ) ) {
2009-05-27 12:21:53 -04:00
$suffix = 2 ;
do {
2013-02-15 09:35:41 -05:00
$alt_post_name = _truncate_post_slug ( $slug , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
2010-02-12 21:42:17 -05:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $alt_post_name , $post_ID , $post_parent ) );
2009-05-27 12:21:53 -04:00
$suffix ++ ;
2010-02-12 21:42:17 -05:00
} while ( $post_name_check );
2009-05-27 12:21:53 -04:00
$slug = $alt_post_name ;
}
} else {
// Post slugs must be unique across all posts.
$check_sql = " SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND post_type = %s AND ID != %d LIMIT 1 " ;
2010-02-12 21:42:17 -05:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $slug , $post_type , $post_ID ) );
2009-09-14 10:03:32 -04:00
2014-04-13 19:06:14 -04:00
/**
* Filter whether the post slug would be bad as a flat slug .
*
* @ since 3.1 . 0
*
* @ param bool $bad_slug Whether the post slug would be bad as a flat slug .
* @ param string $slug The post slug .
* @ param string $post_type Post type .
*/
2010-12-15 12:56:25 -05:00
if ( $post_name_check || in_array ( $slug , $feeds ) || apply_filters ( 'wp_unique_post_slug_is_bad_flat_slug' , false , $slug , $post_type ) ) {
2009-04-23 16:21:18 -04:00
$suffix = 2 ;
do {
2013-02-15 09:35:41 -05:00
$alt_post_name = _truncate_post_slug ( $slug , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
2010-02-12 21:42:17 -05:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $alt_post_name , $post_type , $post_ID ) );
2009-04-23 16:21:18 -04:00
$suffix ++ ;
2010-02-12 21:42:17 -05:00
} while ( $post_name_check );
2009-04-23 16:21:18 -04:00
$slug = $alt_post_name ;
}
}
2009-05-27 12:21:53 -04:00
2014-04-13 19:06:14 -04:00
/**
* Filter the unique post slug .
*
* @ since 3.3 . 0
*
* @ param string $slug The post slug .
* @ param int $post_ID Post ID .
* @ param string $post_status The post status .
* @ param string $post_type Post type .
* @ param int $post_parent Post parent ID
* @ param string $original_slug The original post slug .
*/
2012-06-29 09:57:02 -04:00
return apply_filters ( 'wp_unique_post_slug' , $slug , $post_ID , $post_status , $post_type , $post_parent , $original_slug );
2009-04-23 16:21:18 -04:00
}
2013-02-15 09:35:41 -05:00
/**
* Truncates a post slug .
*
* @ since 3.6 . 0
* @ access private
* @ uses utf8_uri_encode () Makes sure UTF - 8 characters are properly cut and encoded .
*
* @ param string $slug The slug to truncate .
* @ param int $length Max length of the slug .
* @ return string The truncated slug .
*/
function _truncate_post_slug ( $slug , $length = 200 ) {
if ( strlen ( $slug ) > $length ) {
$decoded_slug = urldecode ( $slug );
if ( $decoded_slug === $slug )
$slug = substr ( $slug , 0 , $length );
else
$slug = utf8_uri_encode ( $decoded_slug , $length );
}
return rtrim ( $slug , '-' );
}
2008-06-27 11:32:57 -04:00
/**
2008-08-19 12:38:06 -04:00
* Adds tags to a post .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ uses wp_set_post_tags () Same first two parameters , but the last parameter is always set to true .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID
* @ param string $tags The tags to set for the post , separated by commas .
2008-06-27 11:32:57 -04:00
* @ return bool | null Will return false if $post_id is not an integer or is 0. Will return null otherwise
*/
2007-04-07 15:00:19 -04:00
function wp_add_post_tags ( $post_id = 0 , $tags = '' ) {
return wp_set_post_tags ( $post_id , $tags , true );
}
2008-06-27 11:32:57 -04:00
/**
2008-08-19 12:38:06 -04:00
* Set the tags for a post .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
* @ uses wp_set_object_terms () Sets the tags for the post .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
* @ param string $tags The tags to set for the post , separated by commas .
2008-06-27 11:32:57 -04:00
* @ param bool $append If true , don ' t delete existing tags , just add on . If false , replace the tags with the new tags .
2010-07-20 20:50:01 -04:00
* @ return mixed Array of affected term IDs . WP_Error or false on failure .
2008-06-27 11:32:57 -04:00
*/
2007-04-07 15:00:19 -04:00
function wp_set_post_tags ( $post_id = 0 , $tags = '' , $append = false ) {
2008-12-18 14:12:26 -05:00
return wp_set_post_terms ( $post_id , $tags , 'post_tag' , $append );
}
2007-06-13 22:25:30 -04:00
2008-12-18 14:12:26 -05:00
/**
* Set the terms for a post .
*
* @ since 2.8 . 0
* @ uses wp_set_object_terms () Sets the tags for the post .
*
* @ param int $post_id Post ID .
* @ param string $tags The tags to set for the post , separated by commas .
2012-01-06 13:31:43 -05:00
* @ param string $taxonomy Taxonomy name . Defaults to 'post_tag' .
2008-12-18 14:12:26 -05:00
* @ param bool $append If true , don ' t delete existing tags , just add on . If false , replace the tags with the new tags .
2010-07-20 20:50:01 -04:00
* @ return mixed Array of affected term IDs . WP_Error or false on failure .
2008-12-18 14:12:26 -05:00
*/
function wp_set_post_terms ( $post_id = 0 , $tags = '' , $taxonomy = 'post_tag' , $append = false ) {
2007-03-26 03:28:29 -04:00
$post_id = ( int ) $post_id ;
2007-06-13 22:25:30 -04:00
2007-03-26 03:28:29 -04:00
if ( ! $post_id )
return false ;
2007-04-11 14:04:49 -04:00
if ( empty ( $tags ) )
$tags = array ();
2008-12-18 14:12:26 -05:00
2012-02-07 13:06:12 -05:00
if ( ! is_array ( $tags ) ) {
$comma = _x ( ',' , 'tag delimiter' );
if ( ',' !== $comma )
$tags = str_replace ( $comma , ',' , $tags );
$tags = explode ( ',' , trim ( $tags , " \n \t \r \0 \x0B , " ) );
}
2009-12-23 09:25:09 -05:00
// Hierarchical taxonomies must always pass IDs rather than names so that children with the same
// names but different parents aren't confused.
2010-04-18 11:54:45 -04:00
if ( is_taxonomy_hierarchical ( $taxonomy ) ) {
2012-09-24 16:35:56 -04:00
$tags = array_unique ( array_map ( 'intval' , $tags ) );
2009-12-23 09:25:09 -05:00
}
2012-11-27 14:42:38 -05:00
return wp_set_object_terms ( $post_id , $tags , $taxonomy , $append );
2007-03-26 03:28:29 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Set categories for a post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* If the post categories parameter is not set , then the default category is
* going used .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_ID Post ID .
2013-09-04 13:42:10 -04:00
* @ param array | int $post_categories Optional . List of categories or ID of category .
* @ param bool $append If true , don ' t delete existing categories , just add on . If false , replace the categories with the new categories .
2008-08-19 12:38:06 -04:00
* @ return bool | mixed
2007-12-13 19:28:34 -05:00
*/
2013-09-04 13:42:10 -04:00
function wp_set_post_categories ( $post_ID = 0 , $post_categories = array (), $append = false ) {
2007-03-22 19:03:07 -04:00
$post_ID = ( int ) $post_ID ;
2010-02-17 15:33:29 -05:00
$post_type = get_post_type ( $post_ID );
2010-05-25 10:43:39 -04:00
$post_status = get_post_status ( $post_ID );
2004-05-23 21:34:57 -04:00
// If $post_categories isn't already an array, make it one:
2013-09-04 13:42:10 -04:00
$post_categories = ( array ) $post_categories ;
if ( empty ( $post_categories ) ) {
if ( 'post' == $post_type && 'auto-draft' != $post_status ) {
2010-02-17 15:33:29 -05:00
$post_categories = array ( get_option ( 'default_category' ) );
2013-09-04 13:42:10 -04:00
$append = false ;
} else {
2010-02-17 15:33:29 -05:00
$post_categories = array ();
2013-09-04 13:42:10 -04:00
}
2010-05-04 14:41:38 -04:00
} else if ( 1 == count ( $post_categories ) && '' == reset ( $post_categories ) ) {
2007-06-20 18:06:29 -04:00
return true ;
2010-02-17 15:33:29 -05:00
}
2006-02-12 02:53:23 -05:00
2013-09-04 13:42:10 -04:00
return wp_set_post_terms ( $post_ID , $post_categories , 'category' , $append );
2008-08-19 12:38:06 -04:00
}
2004-05-23 21:34:57 -04:00
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Transition the post status of a post .
2007-12-13 19:28:34 -05:00
*
2009-05-05 01:53:55 -04:00
* Calls hooks to transition post status .
*
* The first is 'transition_post_status' with new status , old status , and post data .
*
2009-05-06 16:49:36 -04:00
* The next action called is 'OLDSTATUS_to_NEWSTATUS' the 'NEWSTATUS' is the
* $new_status parameter and the 'OLDSTATUS' is $old_status parameter ; it has the
2008-08-19 12:38:06 -04:00
* post data .
2007-12-13 19:28:34 -05:00
*
2009-05-06 16:49:36 -04:00
* The final action is named 'NEWSTATUS_POSTTYPE' , 'NEWSTATUS' is from the $new_status
2008-08-19 12:38:06 -04:00
* parameter and POSTTYPE is post_type post data .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2009-05-06 16:49:36 -04:00
*
2014-04-13 19:06:14 -04:00
* @ link http :// codex . wordpress . org / Post_Status_Transitions
2008-08-19 12:38:06 -04:00
*
* @ param string $new_status Transition to this post status .
* @ param string $old_status Previous post status .
* @ param object $post Post data .
2007-12-13 19:28:34 -05:00
*/
2007-07-12 12:00:51 -04:00
function wp_transition_post_status ( $new_status , $old_status , $post ) {
2014-04-13 19:06:14 -04:00
/**
* Fires when a post is transitioned from one status to another .
*
* @ since 2.3 . 0
*
* @ param string $new_status New post status .
* @ param string $old_status Old post status .
* @ param WP_Post $post Post object .
*/
do_action ( 'transition_post_status' , $new_status , $old_status , $post );
/**
* Fires when a post is transitioned from one status to another .
*
* The dynamic portions of the hook name , $new_status and $old status ,
* refer to the old and new post statuses , respectively .
*
* @ since 2.3 . 0
*
* @ param WP_Post $post Post object .
*/
do_action ( " { $old_status } _to_ { $new_status } " , $post );
/**
* Fires when a post is transitioned from one status to another .
*
* The dynamic portions of the hook name , $new_status and $post -> post_type ,
* refer to the new post status and post type , respectively .
*
* @ since 2.3 . 0
*
* @ param int $post_id Post ID .
* @ param WP_Post $post Post object .
*/
do_action ( " { $new_status } _ { $post -> post_type } " , $post -> ID , $post );
2007-07-12 12:00:51 -04:00
}
2006-06-07 19:17:59 -04:00
//
// Trackback and ping functions
//
2004-11-26 23:47:54 -05:00
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Add a URL to those already pung .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
* @ param string $uri Ping URI .
* @ return int How many rows were updated .
2007-12-13 19:28:34 -05:00
*/
function add_ping ( $post_id , $uri ) {
2006-06-07 19:17:59 -04:00
global $wpdb ;
2007-10-02 14:45:47 -04:00
$pung = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT pinged FROM $wpdb->posts WHERE ID = %d " , $post_id ));
2006-06-07 19:17:59 -04:00
$pung = trim ( $pung );
$pung = preg_split ( '/\s/' , $pung );
$pung [] = $uri ;
$new = implode ( " \n " , $pung );
2014-04-13 19:06:14 -04:00
/**
* Filter the new ping URL to add for the given post .
*
* @ since 2.0 . 0
*
* @ param string $new New ping URL to add .
*/
$new = apply_filters ( 'add_ping' , $new );
2007-10-02 14:45:47 -04:00
// expected_slashed ($new)
2013-03-03 16:11:40 -05:00
$new = wp_unslash ( $new );
2007-10-12 22:36:38 -04:00
return $wpdb -> update ( $wpdb -> posts , array ( 'pinged' => $new ), array ( 'ID' => $post_id ) );
2006-06-07 19:17:59 -04:00
}
2005-12-13 14:19:56 -05:00
2008-06-27 11:32:57 -04:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve enclosures already enclosed for a post .
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2008-06-27 11:32:57 -04:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
* @ return array List of enclosures
2008-06-27 11:32:57 -04:00
*/
function get_enclosed ( $post_id ) {
2006-06-07 19:17:59 -04:00
$custom_fields = get_post_custom ( $post_id );
$pung = array ();
if ( ! is_array ( $custom_fields ) )
return $pung ;
2005-10-14 14:06:23 -04:00
2006-06-07 19:17:59 -04:00
foreach ( $custom_fields as $key => $val ) {
if ( 'enclosure' != $key || ! is_array ( $val ) )
continue ;
foreach ( $val as $enc ) {
2012-01-09 16:20:51 -05:00
$enclosure = explode ( " \n " , $enc );
2006-06-07 19:17:59 -04:00
$pung [] = trim ( $enclosure [ 0 ] );
2005-11-15 11:31:24 -05:00
}
}
2014-04-13 19:06:14 -04:00
/**
* Filter the list of enclosures already enclosed for the given post .
*
* @ since 2.0 . 0
*
* @ param array $pung Array of enclosures for the given post .
* @ param int $post_id Post ID .
*/
$pung = apply_filters ( 'get_enclosed' , $pung , $post_id );
2006-06-07 19:17:59 -04:00
return $pung ;
2004-05-23 21:34:57 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve URLs already pinged for a post .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
* @ return array
2007-12-13 19:28:34 -05:00
*/
function get_pung ( $post_id ) {
2006-06-07 19:17:59 -04:00
global $wpdb ;
2007-10-02 14:45:47 -04:00
$pung = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT pinged FROM $wpdb->posts WHERE ID = %d " , $post_id ));
2006-06-07 19:17:59 -04:00
$pung = trim ( $pung );
$pung = preg_split ( '/\s/' , $pung );
2014-04-13 19:06:14 -04:00
/**
* Filter the list of already - pinged URLs for the given post .
*
* @ since 2.0 . 0
*
* @ param array $pung Array of URLs already pinged for the given post .
*/
$pung = apply_filters ( 'get_pung' , $pung );
2006-06-07 19:17:59 -04:00
return $pung ;
2004-05-23 21:34:57 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve URLs that need to be pinged .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID
* @ return array
2007-12-13 19:28:34 -05:00
*/
function get_to_ping ( $post_id ) {
2006-06-07 19:17:59 -04:00
global $wpdb ;
2007-10-02 14:45:47 -04:00
$to_ping = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT to_ping FROM $wpdb->posts WHERE ID = %d " , $post_id ));
2012-01-04 14:45:13 -05:00
$to_ping = sanitize_trackback_urls ( $to_ping );
2006-06-07 19:17:59 -04:00
$to_ping = preg_split ( '/\s/' , $to_ping , - 1 , PREG_SPLIT_NO_EMPTY );
2014-04-13 19:06:14 -04:00
/**
* Filter the list of URLs yet to ping for the given post .
*
* @ since 2.0 . 0
*
* @ param array $to_ping List of URLs yet to ping .
*/
$to_ping = apply_filters ( 'get_to_ping' , $to_ping );
2006-06-07 19:17:59 -04:00
return $to_ping ;
2004-05-23 21:34:57 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Do trackbacks for a list of URLs .
2007-12-13 19:28:34 -05:00
*
2008-06-27 11:32:57 -04:00
* @ since 1.0 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param string $tb_list Comma separated list of URLs
* @ param int $post_id Post ID
2007-12-13 19:28:34 -05:00
*/
2004-05-23 21:34:57 -04:00
function trackback_url_list ( $tb_list , $post_id ) {
2008-08-19 12:38:06 -04:00
if ( ! empty ( $tb_list ) ) {
2004-05-23 21:34:57 -04:00
// get post data
2012-08-28 15:08:28 -04:00
$postdata = get_post ( $post_id , ARRAY_A );
2004-05-23 21:34:57 -04:00
// import postdata as variables
2007-06-14 18:45:40 -04:00
extract ( $postdata , EXTR_SKIP );
2006-02-12 02:53:23 -05:00
2004-05-23 21:34:57 -04:00
// form an excerpt
2008-08-19 12:38:06 -04:00
$excerpt = strip_tags ( $post_excerpt ? $post_excerpt : $post_content );
2006-02-12 02:53:23 -05:00
2004-05-23 21:34:57 -04:00
if ( strlen ( $excerpt ) > 255 ) {
2013-05-08 17:27:31 -04:00
$excerpt = substr ( $excerpt , 0 , 252 ) . '…' ;
2004-05-23 21:34:57 -04:00
}
2006-02-12 02:53:23 -05:00
2004-05-23 21:34:57 -04:00
$trackback_urls = explode ( ',' , $tb_list );
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $trackback_urls as $tb_url ) {
2008-08-19 12:38:06 -04:00
$tb_url = trim ( $tb_url );
2013-03-03 16:11:40 -05:00
trackback ( $tb_url , wp_unslash ( $post_title ), $excerpt , $post_id );
2004-05-23 21:34:57 -04:00
}
2008-08-19 12:38:06 -04:00
}
2004-05-23 21:34:57 -04:00
}
2006-06-07 19:17:59 -04:00
//
// Page functions
//
2005-01-10 15:21:06 -05:00
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Get a list of page IDs .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ return array List of page IDs .
2007-12-13 19:28:34 -05:00
*/
2006-06-07 19:17:59 -04:00
function get_all_page_ids () {
2004-10-14 03:26:41 -04:00
global $wpdb ;
2012-03-19 15:09:03 -04:00
$page_ids = wp_cache_get ( 'all_page_ids' , 'posts' );
if ( ! is_array ( $page_ids ) ) {
2006-06-07 19:17:59 -04:00
$page_ids = $wpdb -> get_col ( " SELECT ID FROM $wpdb->posts WHERE post_type = 'page' " );
2007-10-15 16:11:30 -04:00
wp_cache_add ( 'all_page_ids' , $page_ids , 'posts' );
2006-06-07 19:17:59 -04:00
}
return $page_ids ;
2004-10-14 03:26:41 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieves page data given a page ID or page object .
2007-12-13 19:28:34 -05:00
*
2012-08-23 17:15:40 -04:00
* Use get_post () instead of get_page () .
2012-08-23 16:34:41 -04:00
*
2007-12-13 19:28:34 -05:00
* @ since 1.5 . 1
2012-08-23 16:34:41 -04:00
* @ deprecated 3.5 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param mixed $page Page object or page ID . Passed by reference .
* @ param string $output What to output . OBJECT , ARRAY_A , or ARRAY_N .
2007-12-13 19:28:34 -05:00
* @ param string $filter How the return value should be filtered .
2012-08-23 16:34:41 -04:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-13 19:28:34 -05:00
*/
2012-08-21 11:42:28 -04:00
function get_page ( $page , $output = OBJECT , $filter = 'raw' ) {
return get_post ( $page , $output , $filter );
2005-02-12 03:58:10 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieves a page given its path .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param string $page_path Page path
2010-03-31 04:20:28 -04:00
* @ param string $output Optional . Output type . OBJECT , ARRAY_N , or ARRAY_A . Default OBJECT .
2014-03-05 17:26:15 -05:00
* @ param string | array $post_type Optional . Post type or array of post types . Default page .
2012-08-23 16:34:41 -04:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-13 19:28:34 -05:00
*/
2014-03-05 17:26:15 -05:00
function get_page_by_path ( $page_path , $output = OBJECT , $post_type = 'page' ) {
2004-10-14 03:26:41 -04:00
global $wpdb ;
2011-08-11 21:55:08 -04:00
2006-06-07 19:17:59 -04:00
$page_path = rawurlencode ( urldecode ( $page_path ));
$page_path = str_replace ( '%2F' , '/' , $page_path );
$page_path = str_replace ( '%20' , ' ' , $page_path );
2011-08-11 21:55:08 -04:00
$parts = explode ( '/' , trim ( $page_path , '/' ) );
2013-07-16 10:23:29 -04:00
$parts = esc_sql ( $parts );
2011-11-23 19:20:21 -05:00
$parts = array_map ( 'sanitize_title_for_query' , $parts );
2006-06-07 19:17:59 -04:00
2014-03-05 17:26:15 -05:00
$in_string = " ' " . implode ( " ',' " , $parts ) . " ' " ;
if ( is_array ( $post_type ) ) {
$post_types = $post_type ;
} else {
$post_types = array ( $post_type , 'attachment' );
}
$post_types = esc_sql ( $post_types );
$post_type_in_string = " ' " . implode ( " ',' " , $post_types ) . " ' " ;
$sql = "
SELECT ID , post_name , post_parent , post_type
FROM $wpdb -> posts
WHERE post_name IN ( $in_string )
AND post_type IN ( $post_type_in_string )
" ;
$pages = $wpdb -> get_results ( $sql , OBJECT_K );
2006-06-07 19:17:59 -04:00
2011-08-11 21:55:08 -04:00
$revparts = array_reverse ( $parts );
2006-06-07 19:17:59 -04:00
2011-08-11 21:55:08 -04:00
$foundid = 0 ;
2011-08-31 02:46:16 -04:00
foreach ( ( array ) $pages as $page ) {
2011-08-11 21:55:08 -04:00
if ( $page -> post_name == $revparts [ 0 ] ) {
$count = 0 ;
2011-10-28 15:32:19 -04:00
$p = $page ;
while ( $p -> post_parent != 0 && isset ( $pages [ $p -> post_parent ] ) ) {
$count ++ ;
$parent = $pages [ $p -> post_parent ];
if ( ! isset ( $revparts [ $count ] ) || $parent -> post_name != $revparts [ $count ] )
2011-08-11 21:55:08 -04:00
break ;
2011-10-28 15:32:19 -04:00
$p = $parent ;
}
if ( $p -> post_parent == 0 && $count + 1 == count ( $revparts ) && $p -> post_name == $revparts [ $count ] ) {
2011-08-11 21:55:08 -04:00
$foundid = $page -> ID ;
2012-09-14 13:19:25 -04:00
if ( $page -> post_type == $post_type )
break ;
2011-08-11 21:55:08 -04:00
}
2006-06-07 19:17:59 -04:00
}
}
2011-08-11 21:55:08 -04:00
if ( $foundid )
2012-08-23 16:01:10 -04:00
return get_post ( $foundid , $output );
2011-08-11 21:55:08 -04:00
return null ;
2004-10-14 03:26:41 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve a page given its title .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param string $page_title Page title
2010-03-31 04:20:28 -04:00
* @ param string $output Optional . Output type . OBJECT , ARRAY_N , or ARRAY_A . Default OBJECT .
2014-03-05 17:26:15 -05:00
* @ param string | array $post_type Optional . Post type or array of post types . Default page .
2012-08-23 16:34:41 -04:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-13 19:28:34 -05:00
*/
2014-03-05 17:26:15 -05:00
function get_page_by_title ( $page_title , $output = OBJECT , $post_type = 'page' ) {
2006-10-26 15:55:10 -04:00
global $wpdb ;
2014-03-05 17:26:15 -05:00
if ( is_array ( $post_type ) ) {
$post_type = esc_sql ( $post_type );
$post_type_in_string = " ' " . implode ( " ',' " , $post_type ) . " ' " ;
$sql = $wpdb -> prepare ( "
SELECT ID
FROM $wpdb -> posts
WHERE post_title = % s
AND post_type IN ( $post_type_in_string )
" , $page_title );
} else {
$sql = $wpdb -> prepare ( "
SELECT ID
FROM $wpdb -> posts
WHERE post_title = % s
AND post_type = % s
" , $page_title , $post_type );
}
$page = $wpdb -> get_var ( $sql );
2006-10-26 15:55:10 -04:00
if ( $page )
2012-08-23 16:01:10 -04:00
return get_post ( $page , $output );
2006-10-26 15:55:10 -04:00
2008-08-19 12:38:06 -04:00
return null ;
2006-10-26 15:55:10 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve child pages from list of pages matching page ID .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* Matches against the pages parameter against the page ID . Also matches all
* children for the same to retrieve all children of a page . Does not make any
* SQL queries to get the children .
2007-12-13 19:28:34 -05:00
*
* @ since 1.5 . 1
*
2008-08-19 12:38:06 -04:00
* @ param int $page_id Page ID .
* @ param array $pages List of pages ' objects .
* @ return array
2007-12-13 19:28:34 -05:00
*/
2012-09-10 13:00:11 -04:00
function get_page_children ( $page_id , $pages ) {
2006-06-07 19:17:59 -04:00
$page_list = array ();
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $pages as $page ) {
2006-06-07 19:17:59 -04:00
if ( $page -> post_parent == $page_id ) {
$page_list [] = $page ;
if ( $children = get_page_children ( $page -> ID , $pages ) )
$page_list = array_merge ( $page_list , $children );
}
}
return $page_list ;
2004-10-14 03:26:41 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Order the pages with children under parents in a flat list .
2007-12-13 19:28:34 -05:00
*
2009-09-26 18:45:52 -04:00
* It uses auxiliary structure to hold parent - children relationships and
* runs in O ( N ) complexity
2009-10-15 16:26:21 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
2010-09-07 07:21:11 -04:00
* @ param array $pages Posts array .
* @ param int $page_id Parent page ID .
2009-05-06 16:49:36 -04:00
* @ return array A list arranged by hierarchy . Children immediately follow their parents .
2007-12-13 19:28:34 -05:00
*/
2012-09-10 13:00:11 -04:00
function get_page_hierarchy ( & $pages , $page_id = 0 ) {
2009-12-23 11:03:04 -05:00
if ( empty ( $pages ) ) {
2009-12-29 16:11:18 -05:00
$result = array ();
2009-12-23 11:03:04 -05:00
return $result ;
}
2009-10-15 16:26:21 -04:00
2009-09-26 18:45:52 -04:00
$children = array ();
foreach ( ( array ) $pages as $p ) {
$parent_id = intval ( $p -> post_parent );
$children [ $parent_id ][] = $p ;
2010-09-07 07:21:11 -04:00
}
2009-10-15 16:26:21 -04:00
2010-09-07 07:21:11 -04:00
$result = array ();
_page_traverse_name ( $page_id , $children , $result );
2009-10-15 16:26:21 -04:00
2005-12-24 11:26:55 -05:00
return $result ;
}
2009-09-26 18:45:52 -04:00
/**
* function to traverse and return all the nested children post names of a root page .
2011-09-05 15:08:15 -04:00
* $children contains parent - children relations
2009-10-15 16:26:21 -04:00
*
2010-11-16 08:16:13 -05:00
* @ since 2.9 . 0
2009-09-26 18:45:52 -04:00
*/
2009-10-15 16:26:21 -04:00
function _page_traverse_name ( $page_id , & $children , & $result ){
2009-09-26 18:45:52 -04:00
if ( isset ( $children [ $page_id ] ) ){
foreach ( ( array ) $children [ $page_id ] as $child ) {
$result [ $child -> ID ] = $child -> post_name ;
_page_traverse_name ( $child -> ID , $children , $result );
}
}
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Builds URI for a page .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* Sub pages will be in the " directory " under the parent page post name .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
*
2010-05-03 16:10:26 -04:00
* @ param mixed $page Page object or page ID .
2013-09-05 17:42:10 -04:00
* @ return string | false Page URI , false on error .
2007-12-13 19:28:34 -05:00
*/
2013-09-05 17:42:10 -04:00
function get_page_uri ( $page ) {
2012-12-27 10:26:05 -05:00
$page = get_post ( $page );
2013-09-05 17:42:10 -04:00
if ( ! $page )
return false ;
2008-06-16 14:40:47 -04:00
$uri = $page -> post_name ;
2006-06-07 22:22:16 -04:00
2012-08-20 15:47:52 -04:00
foreach ( $page -> ancestors as $parent ) {
2013-09-05 17:42:10 -04:00
$uri = get_post ( $parent ) -> post_name . '/' . $uri ;
2006-06-07 22:22:16 -04:00
}
return $uri ;
}
2007-12-13 19:28:34 -05:00
/**
2013-09-05 21:21:09 -04:00
* Retrieve a list of pages .
2007-12-13 19:28:34 -05:00
*
2013-09-05 18:13:09 -04:00
* @ global wpdb $wpdb WordPress database abstraction object
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
*
2013-09-05 21:21:09 -04:00
* @ param mixed $args {
* Array or string of arguments . Optional .
*
* @ type int 'child_of' Page ID to return child and grandchild pages of . Default 0 , or no restriction .
* @ type string 'sort_order' How to sort retrieved pages .
* Default 'ASC' . Accepts 'ASC' , 'DESC' .
* @ type string 'sort_column' What columns to sort pages by , comma - separated .
* Default 'post_title' . Accepts 'post_author' , 'post_date' , 'post_title' , 'post_name' ,
* 'post_modified' , 'post_modified_gmt' , 'menu_order' , 'post_parent' , 'ID' , 'rand' ,
* 'comment_count' . 'post_' can be omitted for any values that start with it .
* @ type bool 'hierarchical' Whether to return pages hierarchically . Default true .
* @ type array 'exclude' Array of page IDs to exclude .
* @ type array 'include' Array of page IDs to include . Cannot be used with 'child_of' , 'parent' , 'exclude' ,
* 'meta_key' , 'meta_value' , or 'hierarchical' .
* @ type string 'meta_key' Only include pages with this meta key .
* @ type string 'meta_value' Only include pages with this meta value .
* @ type string 'authors' A comma - separated list of author IDs .
* @ type int 'parent' Page ID to return direct children of . 'hierarchical' must be false .
* Default - 1 , or no restriction .
* @ type int 'exclude_tree' Remove all children of the given ID from returned pages .
* @ type int 'number' The number of pages to return . Default 0 , or all pages .
* @ type int 'offset' The number of pages to skip before returning . Requires 'number' .
* Default 0.
* @ type string 'post_type' The post type to query .
* Default 'page' .
* @ type string 'post_status' A comma - separated list of post status types to include .
* Default 'publish' .
2013-09-05 18:13:09 -04:00
* }
2013-09-05 19:21:10 -04:00
* @ return array List of pages matching defaults or $args .
2007-12-13 19:28:34 -05:00
*/
2013-09-05 21:21:09 -04:00
function get_pages ( $args = array () ) {
2006-06-07 19:17:59 -04:00
global $wpdb ;
2007-06-13 22:25:30 -04:00
2012-08-20 12:38:43 -04:00
$pages = false ;
2007-05-10 23:10:05 -04:00
$defaults = array (
2007-09-03 19:32:58 -04:00
'child_of' => 0 , 'sort_order' => 'ASC' ,
'sort_column' => 'post_title' , 'hierarchical' => 1 ,
2010-04-18 00:54:19 -04:00
'exclude' => array (), 'include' => array (),
2007-09-03 19:32:58 -04:00
'meta_key' => '' , 'meta_value' => '' ,
2014-03-26 21:18:14 -04:00
'authors' => '' , 'parent' => - 1 , 'exclude_tree' => array (),
2010-03-13 15:01:02 -05:00
'number' => '' , 'offset' => 0 ,
'post_type' => 'page' , 'post_status' => 'publish' ,
2007-05-10 23:10:05 -04:00
);
2007-06-13 22:25:30 -04:00
2007-05-10 23:10:05 -04:00
$r = wp_parse_args ( $args , $defaults );
2007-06-14 18:45:40 -04:00
extract ( $r , EXTR_SKIP );
2009-05-10 04:55:49 -04:00
$number = ( int ) $number ;
$offset = ( int ) $offset ;
2010-03-17 12:27:25 -04:00
2010-03-13 15:01:02 -05:00
// Make sure the post type is hierarchical
$hierarchical_post_types = get_post_types ( array ( 'hierarchical' => true ) );
if ( ! in_array ( $post_type , $hierarchical_post_types ) )
2012-08-20 12:38:43 -04:00
return $pages ;
2010-03-17 12:27:25 -04:00
2013-10-30 10:39:10 -04:00
if ( $parent > 0 && ! $child_of )
2013-09-04 17:00:09 -04:00
$hierarchical = false ;
2010-03-13 15:01:02 -05:00
// Make sure we have a valid post status
2011-05-11 23:53:46 -04:00
if ( ! is_array ( $post_status ) )
$post_status = explode ( ',' , $post_status );
if ( array_diff ( $post_status , get_post_stati () ) )
2012-08-20 12:38:43 -04:00
return $pages ;
2006-06-07 19:17:59 -04:00
2013-01-15 12:32:35 -05:00
// $args can be whatever, only use the args defined in defaults to compute the key
2008-12-05 14:19:24 -05:00
$key = md5 ( serialize ( compact ( array_keys ( $defaults )) ) );
2013-01-15 12:32:35 -05:00
$last_changed = wp_cache_get ( 'last_changed' , 'posts' );
2013-01-22 10:46:16 -05:00
if ( ! $last_changed ) {
2014-02-26 17:05:13 -05:00
$last_changed = microtime ();
2013-01-22 10:52:13 -05:00
wp_cache_set ( 'last_changed' , $last_changed , 'posts' );
2013-01-22 10:46:16 -05:00
}
2013-01-15 12:32:35 -05:00
$cache_key = " get_pages: $key : $last_changed " ;
if ( $cache = wp_cache_get ( $cache_key , 'posts' ) ) {
// Convert to WP_Post instances
$pages = array_map ( 'get_post' , $cache );
2014-04-13 19:06:14 -04:00
/** This filter is documented in wp-includes/post.php */
$pages = apply_filters ( 'get_pages' , $pages , $r );
2013-01-15 12:32:35 -05:00
return $pages ;
2008-10-17 18:55:30 -04:00
}
2006-11-23 12:21:08 -05:00
2008-12-18 17:26:57 -05:00
if ( ! is_array ( $cache ) )
$cache = array ();
2006-06-07 19:17:59 -04:00
$inclusions = '' ;
2013-08-29 14:49:09 -04:00
if ( ! empty ( $include ) ) {
2008-10-13 20:15:59 -04:00
$child_of = 0 ; //ignore child_of, parent, exclude, meta_key, and meta_value params if using include
$parent = - 1 ;
2006-11-24 17:55:28 -05:00
$exclude = '' ;
2006-06-07 19:17:59 -04:00
$meta_key = '' ;
$meta_value = '' ;
2007-12-24 16:24:03 -05:00
$hierarchical = false ;
2010-04-18 00:54:19 -04:00
$incpages = wp_parse_id_list ( $include );
2013-08-29 14:49:09 -04:00
if ( ! empty ( $incpages ) )
2013-08-29 14:54:09 -04:00
$inclusions = ' AND ID IN (' . implode ( ',' , $incpages ) . ')' ;
2006-06-07 19:17:59 -04:00
}
$exclusions = '' ;
2013-08-29 14:49:09 -04:00
if ( ! empty ( $exclude ) ) {
2010-04-18 00:54:19 -04:00
$expages = wp_parse_id_list ( $exclude );
2013-08-29 14:49:09 -04:00
if ( ! empty ( $expages ) )
2013-08-29 14:54:09 -04:00
$exclusions = ' AND ID NOT IN (' . implode ( ',' , $expages ) . ')' ;
2006-06-07 19:17:59 -04:00
}
2006-09-10 13:47:49 -04:00
$author_query = '' ;
if ( ! empty ( $authors )) {
$post_authors = preg_split ( '/[\s,]+/' , $authors );
2007-02-27 10:24:54 -05:00
2010-04-18 00:54:19 -04:00
if ( ! empty ( $post_authors ) ) {
2006-09-10 13:47:49 -04:00
foreach ( $post_authors as $post_author ) {
//Do we have an author id or an author login?
if ( 0 == intval ( $post_author ) ) {
2011-08-05 12:57:31 -04:00
$post_author = get_user_by ( 'login' , $post_author );
2006-09-10 13:47:49 -04:00
if ( empty ( $post_author ) )
continue ;
if ( empty ( $post_author -> ID ) )
continue ;
$post_author = $post_author -> ID ;
}
if ( '' == $author_query )
2007-10-02 14:45:47 -04:00
$author_query = $wpdb -> prepare ( ' post_author = %d ' , $post_author );
2006-09-10 13:47:49 -04:00
else
2007-10-02 14:45:47 -04:00
$author_query .= $wpdb -> prepare ( ' OR post_author = %d ' , $post_author );
2006-09-10 13:47:49 -04:00
}
if ( '' != $author_query )
$author_query = " AND ( $author_query ) " ;
}
}
2008-04-18 18:29:43 -04:00
$join = '' ;
$where = " $exclusions $inclusions " ;
2013-05-10 15:18:54 -04:00
if ( '' !== $meta_key || '' !== $meta_value ) {
2008-04-18 18:29:43 -04:00
$join = " LEFT JOIN $wpdb->postmeta ON ( $wpdb->posts .ID = $wpdb->postmeta .post_id ) " ;
2008-08-09 01:36:14 -04:00
2013-03-01 11:28:40 -05:00
// meta_key and meta_value might be slashed
2013-03-03 16:11:40 -05:00
$meta_key = wp_unslash ( $meta_key );
$meta_value = wp_unslash ( $meta_value );
2013-05-10 15:18:54 -04:00
if ( '' !== $meta_key )
2008-04-18 18:29:43 -04:00
$where .= $wpdb -> prepare ( " AND $wpdb->postmeta .meta_key = %s " , $meta_key );
2013-05-10 15:18:54 -04:00
if ( '' !== $meta_value )
2008-04-18 18:29:43 -04:00
$where .= $wpdb -> prepare ( " AND $wpdb->postmeta .meta_value = %s " , $meta_value );
}
2008-12-09 13:03:31 -05:00
2013-09-04 16:56:09 -04:00
if ( is_array ( $parent ) ) {
$post_parent__in = implode ( ',' , array_map ( 'absint' , ( array ) $parent ) );
if ( ! empty ( $post_parent__in ) )
$where .= " AND post_parent IN ( $post_parent__in ) " ;
} elseif ( $parent >= 0 ) {
2008-12-09 13:03:31 -05:00
$where .= $wpdb -> prepare ( ' AND post_parent = %d ' , $parent );
2013-09-04 16:56:09 -04:00
}
2010-03-17 12:27:25 -04:00
2011-05-11 23:53:46 -04:00
if ( 1 == count ( $post_status ) ) {
$where_post_type = $wpdb -> prepare ( " post_type = %s AND post_status = %s " , $post_type , array_shift ( $post_status ) );
} else {
$post_status = implode ( " ', ' " , $post_status );
$where_post_type = $wpdb -> prepare ( " post_type = %s AND post_status IN (' $post_status ') " , $post_type );
}
2008-12-09 13:03:31 -05:00
2011-06-27 16:47:04 -04:00
$orderby_array = array ();
2011-09-30 14:12:14 -04:00
$allowed_keys = array ( 'author' , 'post_author' , 'date' , 'post_date' , 'title' , 'post_title' , 'name' , 'post_name' , 'modified' ,
2011-06-27 16:47:04 -04:00
'post_modified' , 'modified_gmt' , 'post_modified_gmt' , 'menu_order' , 'parent' , 'post_parent' ,
'ID' , 'rand' , 'comment_count' );
foreach ( explode ( ',' , $sort_column ) as $orderby ) {
$orderby = trim ( $orderby );
if ( ! in_array ( $orderby , $allowed_keys ) )
continue ;
switch ( $orderby ) {
case 'menu_order' :
break ;
case 'ID' :
$orderby = " $wpdb->posts .ID " ;
break ;
case 'rand' :
$orderby = 'RAND()' ;
break ;
case 'comment_count' :
$orderby = " $wpdb->posts .comment_count " ;
break ;
default :
if ( 0 === strpos ( $orderby , 'post_' ) )
$orderby = " $wpdb->posts . " . $orderby ;
else
$orderby = " $wpdb->posts .post_ " . $orderby ;
}
$orderby_array [] = $orderby ;
}
$sort_column = ! empty ( $orderby_array ) ? implode ( ',' , $orderby_array ) : " $wpdb->posts .post_title " ;
$sort_order = strtoupper ( $sort_order );
if ( '' !== $sort_order && ! in_array ( $sort_order , array ( 'ASC' , 'DESC' ) ) )
$sort_order = 'ASC' ;
2010-03-13 15:01:02 -05:00
$query = " SELECT * FROM $wpdb->posts $join WHERE ( $where_post_type ) $where " ;
2006-09-10 13:47:49 -04:00
$query .= $author_query ;
2006-06-07 19:17:59 -04:00
$query .= " ORDER BY " . $sort_column . " " . $sort_order ;
2009-05-10 04:55:49 -04:00
if ( ! empty ( $number ) )
$query .= ' LIMIT ' . $offset . ',' . $number ;
2006-06-07 19:17:59 -04:00
$pages = $wpdb -> get_results ( $query );
2008-11-14 18:01:16 -05:00
if ( empty ( $pages ) ) {
2014-04-13 19:06:14 -04:00
/** This filter is documented in wp-includes/post.php */
$pages = apply_filters ( 'get_pages' , array (), $r );
2008-11-14 18:01:16 -05:00
return $pages ;
}
2006-06-07 19:17:59 -04:00
2009-10-19 17:28:44 -04:00
// Sanitize before caching so it'll only get done once
$num_pages = count ( $pages );
for ( $i = 0 ; $i < $num_pages ; $i ++ ) {
$pages [ $i ] = sanitize_post ( $pages [ $i ], 'raw' );
}
2006-06-07 19:17:59 -04:00
// Update cache.
2012-04-10 12:09:44 -04:00
update_post_cache ( $pages );
2006-06-07 19:17:59 -04:00
if ( $child_of || $hierarchical )
2012-10-04 14:21:47 -04:00
$pages = get_page_children ( $child_of , $pages );
2006-06-07 19:17:59 -04:00
2014-03-26 21:18:14 -04:00
if ( ! empty ( $exclude_tree ) ) {
$exclude = wp_parse_id_list ( $exclude_tree );
foreach ( $exclude as $id ) {
$children = get_page_children ( $id , $pages );
foreach ( $children as $child ) {
$exclude [] = $child -> ID ;
}
}
$num_pages = count ( $pages );
2009-10-19 17:28:44 -04:00
for ( $i = 0 ; $i < $num_pages ; $i ++ ) {
2014-03-26 21:18:14 -04:00
if ( in_array ( $pages [ $i ] -> ID , $exclude ) ) {
unset ( $pages [ $i ] );
}
2008-12-08 14:29:42 -05:00
}
}
2013-01-15 12:32:35 -05:00
$page_structure = array ();
foreach ( $pages as $page )
$page_structure [] = $page -> ID ;
wp_cache_set ( $cache_key , $page_structure , 'posts' );
2006-11-23 12:21:08 -05:00
2012-08-20 15:47:52 -04:00
// Convert to WP_Post instances
$pages = array_map ( 'get_post' , $pages );
2014-04-13 19:06:14 -04:00
/**
* Filter the retrieved list of pages .
*
* @ since 2.1 . 0
*
* @ param array $pages List of pages to retrieve .
* @ param array $r Array of get_pages () arguments .
*/
$pages = apply_filters ( 'get_pages' , $pages , $r );
2007-08-08 00:24:44 -04:00
2006-06-07 19:17:59 -04:00
return $pages ;
}
//
// Attachment functions
//
2005-10-17 19:45:50 -04:00
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Check if the attachment URI is local one and is really an attachment .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
* @ param string $url URL to check
2008-08-19 12:38:06 -04:00
* @ return bool True on success , false on failure .
2007-12-13 19:28:34 -05:00
*/
2006-06-22 15:44:36 -04:00
function is_local_attachment ( $url ) {
2010-05-03 20:28:29 -04:00
if ( strpos ( $url , home_url ()) === false )
2006-06-22 15:44:36 -04:00
return false ;
2010-05-03 20:28:29 -04:00
if ( strpos ( $url , home_url ( '/?attachment_id=' )) !== false )
2006-06-22 15:44:36 -04:00
return true ;
if ( $id = url_to_postid ( $url ) ) {
2012-08-23 16:01:10 -04:00
$post = get_post ( $id );
2006-06-22 15:44:36 -04:00
if ( 'attachment' == $post -> post_type )
return true ;
}
return false ;
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Insert an attachment .
*
* If you set the 'ID' in the $object parameter , it will mean that you are
* updating and attempt to update the attachment . You can also set the
* attachment name or title by setting the key 'post_name' or 'post_title' .
*
* You can set the dates for the attachment manually by setting the 'post_date'
* and 'post_date_gmt' keys ' values .
*
* By default , the comments will use the default settings for whether the
* comments are allowed . You can close them manually or keep them open by
* setting the value for the 'comment_status' key .
*
* The $object parameter can have the following :
2009-05-06 16:49:36 -04:00
* 'post_status' - Default is 'draft' . Can not be overridden , set the same as parent post .
* 'post_type' - Default is 'post' , will be set to attachment . Can not override .
* 'post_author' - Default is current user ID . The ID of the user , who added the attachment .
* 'ping_status' - Default is the value in default ping status option . Whether the attachment
* can accept pings .
* 'post_parent' - Default is 0. Can use $parent parameter or set this for the post it belongs
* to , if any .
* 'menu_order' - Default is 0. The order it is displayed .
* 'to_ping' - Whether to ping .
* 'pinged' - Default is empty string .
* 'post_password' - Default is empty string . The password to access the attachment .
* 'guid' - Global Unique ID for referencing the attachment .
2008-08-19 12:38:06 -04:00
* 'post_content_filtered' - Attachment post content filtered .
2009-05-06 16:49:36 -04:00
* 'post_excerpt' - Attachment excerpt .
2008-08-19 12:38:06 -04:00
*
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2008-08-19 12:38:06 -04:00
* @ param string | array $object Arguments to override defaults .
* @ param string $file Optional filename .
2010-09-07 07:21:11 -04:00
* @ param int $parent Parent post ID .
2008-08-19 12:38:06 -04:00
* @ return int Attachment ID .
2007-12-13 19:28:34 -05:00
*/
2007-09-22 12:30:40 -04:00
function wp_insert_attachment ( $object , $file = false , $parent = 0 ) {
2013-10-02 17:10:09 -04:00
global $wpdb ;
2005-10-17 19:45:50 -04:00
2013-10-02 17:10:09 -04:00
$user_id = get_current_user_id ();
$defaults = array ( 'post_status' => 'inherit' , 'post_type' => 'post' , 'post_author' => $user_id ,
2013-07-20 16:20:47 -04:00
'ping_status' => get_option ( 'default_ping_status' ), 'post_parent' => 0 , 'post_title' => '' ,
2013-10-02 15:52:09 -04:00
'menu_order' => 0 , 'to_ping' => '' , 'pinged' => '' , 'post_password' => '' , 'post_content' => '' ,
2011-05-22 19:25:28 -04:00
'guid' => '' , 'post_content_filtered' => '' , 'post_excerpt' => '' , 'import_id' => 0 , 'context' => '' );
2005-11-19 15:08:21 -05:00
2007-09-11 18:27:36 -04:00
$object = wp_parse_args ( $object , $defaults );
2007-09-22 12:30:40 -04:00
if ( ! empty ( $parent ) )
$object [ 'post_parent' ] = $parent ;
2011-06-28 17:46:18 -04:00
unset ( $object [ 'filter' ] );
2007-09-11 18:27:36 -04:00
$object = sanitize_post ( $object , 'db' );
2006-02-09 05:03:48 -05:00
2007-09-11 18:27:36 -04:00
// export array as variables
extract ( $object , EXTR_SKIP );
2006-02-09 05:03:48 -05:00
2006-06-07 19:17:59 -04:00
if ( empty ( $post_author ) )
2013-10-02 17:10:09 -04:00
$post_author = $user_id ;
2006-02-09 05:03:48 -05:00
2006-06-07 19:17:59 -04:00
$post_type = 'attachment' ;
2011-05-22 19:25:28 -04:00
if ( ! in_array ( $post_status , array ( 'inherit' , 'private' ) ) )
$post_status = 'inherit' ;
2010-02-22 18:12:48 -05:00
2012-09-21 18:52:54 -04:00
if ( ! empty ( $post_category ) )
$post_category = array_filter ( $post_category ); // Filter out empty terms
2010-02-22 12:19:54 -05:00
// Make sure we set a valid category.
2012-09-21 18:52:54 -04:00
if ( empty ( $post_category ) || 0 == count ( $post_category ) || ! is_array ( $post_category ) ) {
$post_category = array ();
2010-03-17 12:27:25 -04:00
}
2005-11-19 15:08:21 -05:00
2006-06-07 19:17:59 -04:00
// Are we updating or creating?
if ( ! empty ( $ID ) ) {
$update = true ;
2007-03-22 20:59:21 -04:00
$post_ID = ( int ) $ID ;
2008-11-14 18:01:16 -05:00
} else {
$update = false ;
$post_ID = 0 ;
2006-06-07 19:17:59 -04:00
}
2005-11-19 15:08:21 -05:00
2006-06-07 19:17:59 -04:00
// Create a valid post name.
if ( empty ( $post_name ) )
$post_name = sanitize_title ( $post_title );
else
$post_name = sanitize_title ( $post_name );
2005-11-19 15:08:21 -05:00
2013-03-01 11:28:40 -05:00
// expected_slashed ($post_name)
2009-05-27 12:21:53 -04:00
$post_name = wp_unique_post_slug ( $post_name , $post_ID , $post_status , $post_type , $post_parent );
2006-11-30 18:09:27 -05:00
2007-09-11 18:27:36 -04:00
if ( empty ( $post_date ) )
2006-06-07 19:17:59 -04:00
$post_date = current_time ( 'mysql' );
2007-09-11 18:27:36 -04:00
if ( empty ( $post_date_gmt ) )
2006-06-07 19:17:59 -04:00
$post_date_gmt = current_time ( 'mysql' , 1 );
2005-12-01 17:51:40 -05:00
2008-01-23 15:25:08 -05:00
if ( empty ( $post_modified ) )
2008-08-19 12:38:06 -04:00
$post_modified = $post_date ;
2008-01-23 15:25:08 -05:00
if ( empty ( $post_modified_gmt ) )
2008-08-19 12:38:06 -04:00
$post_modified_gmt = $post_date_gmt ;
2008-01-23 15:25:08 -05:00
2006-06-07 19:17:59 -04:00
if ( empty ( $comment_status ) ) {
if ( $update )
$comment_status = 'closed' ;
2006-01-01 23:33:27 -05:00
else
2006-08-30 17:46:31 -04:00
$comment_status = get_option ( 'default_comment_status' );
2006-01-01 23:33:27 -05:00
}
2006-06-07 19:17:59 -04:00
if ( empty ( $ping_status ) )
2006-08-30 17:46:31 -04:00
$ping_status = get_option ( 'default_ping_status' );
2006-01-01 23:33:27 -05:00
2006-06-07 19:17:59 -04:00
if ( isset ( $to_ping ) )
$to_ping = preg_replace ( '|\s+|' , " \n " , $to_ping );
else
$to_ping = '' ;
2006-01-01 23:33:27 -05:00
2006-06-07 19:17:59 -04:00
if ( isset ( $post_parent ) )
$post_parent = ( int ) $post_parent ;
else
$post_parent = 0 ;
2006-01-01 23:33:27 -05:00
2006-06-07 19:17:59 -04:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
2006-01-01 23:33:27 -05:00
2006-06-07 19:17:59 -04:00
if ( ! isset ( $post_password ) )
$post_password = '' ;
2005-12-04 22:17:03 -05:00
2006-06-07 19:17:59 -04:00
if ( ! isset ( $pinged ) )
$pinged = '' ;
2005-12-04 22:17:03 -05:00
2013-03-01 11:28:40 -05:00
// expected_slashed (everything!)
2007-10-12 20:48:52 -04:00
$data = compact ( array ( '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' ) );
2014-02-08 17:47:12 -05:00
/**
* Filter attachment post data before it is updated in or added
* to the database .
*
* @ since 3.9 . 0
*
* @ param array $data Array of sanitized attachment post data .
* @ param array $object Array of un - sanitized attachment post data .
*/
2014-02-07 19:44:13 -05:00
$data = apply_filters ( 'wp_insert_attachment_data' , $data , $object );
2013-03-03 16:11:40 -05:00
$data = wp_unslash ( $data );
2007-10-10 18:01:40 -04:00
2007-10-12 22:36:38 -04:00
if ( $update ) {
$wpdb -> update ( $wpdb -> posts , $data , array ( 'ID' => $post_ID ) );
2006-06-07 19:17:59 -04:00
} else {
2008-10-26 13:05:56 -04:00
// If there is a suggested ID, use it if not already present
2008-12-09 13:03:31 -05:00
if ( ! empty ( $import_id ) ) {
$import_id = ( int ) $import_id ;
if ( ! $wpdb -> get_var ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE ID = %d " , $import_id ) ) ) {
$data [ 'ID' ] = $import_id ;
}
}
2008-10-26 13:05:56 -04:00
2007-10-12 22:36:38 -04:00
$wpdb -> insert ( $wpdb -> posts , $data );
2007-10-10 18:01:40 -04:00
$post_ID = ( int ) $wpdb -> insert_id ;
2005-12-04 22:17:03 -05:00
}
2006-06-07 19:17:59 -04:00
if ( empty ( $post_name ) ) {
$post_name = sanitize_title ( $post_title , $post_ID );
2007-11-01 12:20:16 -04:00
$wpdb -> update ( $wpdb -> posts , compact ( " post_name " ), array ( 'ID' => $post_ID ) );
2005-12-04 22:17:03 -05:00
}
2012-09-21 18:52:54 -04:00
if ( is_object_in_taxonomy ( $post_type , 'category' ) )
wp_set_post_categories ( $post_ID , $post_category );
if ( isset ( $tags_input ) && is_object_in_taxonomy ( $post_type , 'post_tag' ) )
wp_set_post_tags ( $post_ID , $tags_input );
// support for all custom taxonomies
if ( ! empty ( $tax_input ) ) {
foreach ( $tax_input as $taxonomy => $tags ) {
$taxonomy_obj = get_taxonomy ( $taxonomy );
if ( is_array ( $tags ) ) // array = hierarchical, string = non-hierarchical.
$tags = array_filter ( $tags );
if ( current_user_can ( $taxonomy_obj -> cap -> assign_terms ) )
wp_set_post_terms ( $post_ID , $tags , $taxonomy );
}
}
2005-12-01 17:51:40 -05:00
2006-06-07 19:17:59 -04:00
if ( $file )
2006-12-05 17:37:19 -05:00
update_attached_file ( $post_ID , $file );
2008-08-09 01:36:14 -04:00
2012-04-23 18:04:35 -04:00
clean_post_cache ( $post_ID );
2005-12-01 17:51:40 -05:00
2011-05-22 19:25:28 -04:00
if ( ! empty ( $context ) )
2013-03-01 11:28:40 -05:00
add_post_meta ( $post_ID , '_wp_attachment_context' , $context , true );
2011-05-22 19:25:28 -04:00
2006-06-07 19:17:59 -04:00
if ( $update ) {
2014-04-13 19:06:14 -04:00
/**
* Fires once an existing attachment has been updated .
*
* @ since 2.0 . 0
*
* @ param int $post_ID Attachment ID .
*/
do_action ( 'edit_attachment' , $post_ID );
2006-06-07 19:17:59 -04:00
} else {
2014-04-13 19:06:14 -04:00
/**
* Fires once an attachment has been added .
*
* @ since 2.0 . 0
*
* @ param int $post_ID Attachment ID .
*/
do_action ( 'add_attachment' , $post_ID );
2005-12-28 20:46:32 -05:00
}
2006-02-12 02:53:23 -05:00
2006-06-07 19:17:59 -04:00
return $post_ID ;
}
2007-12-13 19:28:34 -05:00
/**
2010-04-04 08:20:19 -04:00
* Trashes or deletes an attachment .
*
* When an attachment is permanently deleted , the file will also be removed .
* Deletion removes all post meta fields , taxonomy , comments , etc . associated
* with the attachment ( except the main post ) .
2007-12-13 19:28:34 -05:00
*
2010-04-04 08:20:19 -04:00
* The attachment is moved to the trash instead of permanently deleted unless trash
* for media is disabled , item is already in the trash , or $force_delete is true .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
*
2010-09-07 07:21:11 -04:00
* @ param int $post_id Attachment ID .
2010-04-04 08:20:19 -04:00
* @ param bool $force_delete Whether to bypass trash and force deletion . Defaults to false .
2008-08-19 12:38:06 -04:00
* @ return mixed False on failure . Post data on success .
2007-12-13 19:28:34 -05:00
*/
2009-11-09 15:12:07 -05:00
function wp_delete_attachment ( $post_id , $force_delete = false ) {
2006-06-07 19:17:59 -04:00
global $wpdb ;
2009-09-10 18:07:33 -04:00
if ( ! $post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d " , $post_id ) ) )
2006-06-07 19:17:59 -04:00
return $post ;
2006-01-01 23:59:39 -05:00
2006-06-07 19:17:59 -04:00
if ( 'attachment' != $post -> post_type )
return false ;
2009-07-30 10:55:07 -04:00
2009-12-16 12:14:21 -05:00
if ( ! $force_delete && EMPTY_TRASH_DAYS && MEDIA_TRASH && 'trash' != $post -> post_status )
2009-11-09 15:12:07 -05:00
return wp_trash_post ( $post_id );
2009-07-30 09:39:34 -04:00
2009-09-10 18:07:33 -04:00
delete_post_meta ( $post_id , '_wp_trash_meta_status' );
delete_post_meta ( $post_id , '_wp_trash_meta_time' );
2006-02-12 02:53:23 -05:00
2009-09-23 21:54:07 -04:00
$meta = wp_get_attachment_metadata ( $post_id );
$backup_sizes = get_post_meta ( $post -> ID , '_wp_attachment_backup_sizes' , true );
2009-09-10 18:07:33 -04:00
$file = get_attached_file ( $post_id );
2005-12-01 17:51:40 -05:00
2012-05-11 14:47:32 -04:00
$intermediate_sizes = array ();
foreach ( get_intermediate_image_sizes () as $size ) {
if ( $intermediate = image_get_intermediate_size ( $post_id , $size ) )
$intermediate_sizes [] = $intermediate ;
}
2010-02-04 13:57:32 -05:00
if ( is_multisite () )
delete_transient ( 'dirsize_cache' );
2014-04-13 19:06:14 -04:00
/**
* Fires before an attachment is deleted , at the start of wp_delete_attachment () .
*
* @ since 2.0 . 0
*
* @ param int $post_id Attachment ID .
*/
do_action ( 'delete_attachment' , $post_id );
2009-01-21 16:19:22 -05:00
2009-09-10 18:07:33 -04:00
wp_delete_object_term_relationships ( $post_id , array ( 'category' , 'post_tag' ));
2009-12-01 14:41:41 -05:00
wp_delete_object_term_relationships ( $post_id , get_object_taxonomies ( $post -> post_type ));
2007-05-29 00:26:36 -04:00
2012-04-11 16:02:39 -04:00
delete_metadata ( 'post' , null , '_thumbnail_id' , $post_id , true ); // delete all for any posts.
2009-10-18 09:58:44 -04:00
2009-11-04 12:39:53 -05:00
$comment_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d " , $post_id ));
2012-04-11 16:02:39 -04:00
foreach ( $comment_ids as $comment_id )
wp_delete_comment ( $comment_id , true );
2005-12-01 17:51:40 -05:00
2009-11-04 12:39:53 -05:00
$post_meta_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d " , $post_id ));
2012-04-11 16:02:39 -04:00
foreach ( $post_meta_ids as $mid )
delete_metadata_by_mid ( 'post' , $mid );
2009-03-31 15:16:53 -04:00
2014-04-13 19:06:14 -04:00
/** This action is documented in wp-includes/post.php */
2009-09-24 13:10:28 -04:00
do_action ( 'delete_post' , $post_id );
2013-12-02 17:59:10 -05:00
$result = $wpdb -> delete ( $wpdb -> posts , array ( 'ID' => $post_id ) );
if ( ! $result ) {
return false ;
}
2014-04-13 19:06:14 -04:00
/** This action is documented in wp-includes/post.php */
2009-09-24 13:10:28 -04:00
do_action ( 'deleted_post' , $post_id );
2006-03-30 02:36:54 -05:00
2009-09-10 18:07:33 -04:00
$uploadpath = wp_upload_dir ();
2008-11-22 18:01:28 -05:00
2006-06-07 19:17:59 -04:00
if ( ! empty ( $meta [ 'thumb' ]) ) {
// Don't delete the thumb if another attachment uses it
2009-09-10 18:07:33 -04:00
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 " , '%' . $meta [ 'thumb' ] . '%' , $post_id )) ) {
2006-06-07 19:17:59 -04:00
$thumbfile = str_replace ( basename ( $file ), $meta [ 'thumb' ], $file );
2013-10-24 18:59:20 -04:00
/** This filter is documented in wp-admin/custom-header.php */
2014-04-13 19:06:14 -04:00
$thumbfile = apply_filters ( 'wp_delete_file' , $thumbfile );
2009-09-10 18:07:33 -04:00
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $thumbfile ) );
2006-03-30 02:36:54 -05:00
}
}
2009-09-10 18:07:33 -04:00
// remove intermediate and backup images if there are any
2012-05-11 14:47:32 -04:00
foreach ( $intermediate_sizes as $intermediate ) {
2013-10-24 18:59:20 -04:00
/** This filter is documented in wp-admin/custom-header.php */
2012-05-11 14:47:32 -04:00
$intermediate_file = apply_filters ( 'wp_delete_file' , $intermediate [ 'path' ] );
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $intermediate_file ) );
2009-09-10 18:07:33 -04:00
}
2009-09-23 21:54:07 -04:00
if ( is_array ( $backup_sizes ) ) {
foreach ( $backup_sizes as $size ) {
$del_file = path_join ( dirname ( $meta [ 'file' ]), $size [ 'file' ] );
2013-10-24 18:59:20 -04:00
/** This filter is documented in wp-admin/custom-header.php */
2014-04-13 19:06:14 -04:00
$del_file = apply_filters ( 'wp_delete_file' , $del_file );
2010-06-29 20:05:18 -04:00
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $del_file ) );
2008-03-12 19:15:31 -04:00
}
}
2013-10-24 18:59:20 -04:00
/** This filter is documented in wp-admin/custom-header.php */
2014-04-13 19:06:14 -04:00
$file = apply_filters ( 'wp_delete_file' , $file );
2006-03-30 02:50:33 -05:00
2006-06-07 19:17:59 -04:00
if ( ! empty ( $file ) )
@ unlink ( $file );
2012-04-23 18:04:35 -04:00
clean_post_cache ( $post );
2007-10-14 00:55:33 -04:00
2006-06-07 19:17:59 -04:00
return $post ;
2006-03-30 02:50:33 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve attachment meta field for attachment ID .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Attachment ID
* @ param bool $unfiltered Optional , default is false . If true , filters are not run .
* @ return string | bool Attachment meta field . False on failure .
2007-12-13 19:28:34 -05:00
*/
2010-05-16 17:00:00 -04:00
function wp_get_attachment_metadata ( $post_id = 0 , $unfiltered = false ) {
2006-12-05 17:37:19 -05:00
$post_id = ( int ) $post_id ;
2012-08-23 16:01:10 -04:00
if ( ! $post = get_post ( $post_id ) )
2007-01-05 15:54:55 -05:00
return false ;
2006-12-05 17:37:19 -05:00
2007-01-05 15:54:55 -05:00
$data = get_post_meta ( $post -> ID , '_wp_attachment_metadata' , true );
2009-09-10 18:07:33 -04:00
2006-12-05 17:37:19 -05:00
if ( $unfiltered )
return $data ;
2009-09-10 18:07:33 -04:00
2014-04-13 19:06:14 -04:00
/**
* Filter the attachment meta data .
*
* @ since 2.1 . 0
*
* @ param array | bool $data Array of meta data for the given attachment , or false
* if the object does not exist .
* @ param int $post_id Attachment ID .
*/
2007-01-05 15:54:55 -05:00
return apply_filters ( 'wp_get_attachment_metadata' , $data , $post -> ID );
2006-12-05 17:37:19 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Update metadata for an attachment .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Attachment ID .
* @ param array $data Attachment data .
* @ return int
2007-12-13 19:28:34 -05:00
*/
2006-12-05 17:37:19 -05:00
function wp_update_attachment_metadata ( $post_id , $data ) {
2007-01-02 14:28:30 -05:00
$post_id = ( int ) $post_id ;
2012-08-23 16:01:10 -04:00
if ( ! $post = get_post ( $post_id ) )
2006-12-05 17:37:19 -05:00
return false ;
2014-04-13 19:06:14 -04:00
/**
* Filter the updated attachment meta data .
*
* @ since 2.1 . 0
*
* @ param array $data Array of updated attachment meta data .
* @ param int $post_id Attachment ID .
*/
2012-09-24 09:07:34 -04:00
if ( $data = apply_filters ( 'wp_update_attachment_metadata' , $data , $post -> ID ) )
return update_post_meta ( $post -> ID , '_wp_attachment_metadata' , $data );
else
return delete_post_meta ( $post -> ID , '_wp_attachment_metadata' );
2006-12-05 17:37:19 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve the URL for an attachment .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Attachment ID .
* @ return string
2007-12-13 19:28:34 -05:00
*/
2007-01-02 14:28:30 -05:00
function wp_get_attachment_url ( $post_id = 0 ) {
$post_id = ( int ) $post_id ;
2012-08-23 16:01:10 -04:00
if ( ! $post = get_post ( $post_id ) )
2007-01-02 14:28:30 -05:00
return false ;
2011-11-09 17:13:35 -05:00
if ( 'attachment' != $post -> post_type )
2011-11-09 14:20:33 -05:00
return false ;
2008-09-02 18:55:39 -04:00
$url = '' ;
if ( $file = get_post_meta ( $post -> ID , '_wp_attached_file' , true ) ) { //Get attached file
if ( ( $uploads = wp_upload_dir ()) && false === $uploads [ 'error' ] ) { //Get upload directory
if ( 0 === strpos ( $file , $uploads [ 'basedir' ]) ) //Check that the upload base exists in the file location
$url = str_replace ( $uploads [ 'basedir' ], $uploads [ 'baseurl' ], $file ); //replace file location with url location
2010-06-29 20:05:18 -04:00
elseif ( false !== strpos ( $file , 'wp-content/uploads' ) )
$url = $uploads [ 'baseurl' ] . substr ( $file , strpos ( $file , 'wp-content/uploads' ) + 18 );
else
$url = $uploads [ 'baseurl' ] . " / $file " ; //Its a newly uploaded file, therefor $file is relative to the basedir.
2008-09-02 18:55:39 -04:00
}
}
2011-09-05 15:08:15 -04:00
if ( empty ( $url ) ) //If any of the above options failed, Fallback on the GUID as used pre-2.7, not recommended to rely upon this.
2008-09-02 18:55:39 -04:00
$url = get_the_guid ( $post -> ID );
2007-01-02 14:28:30 -05:00
2014-04-13 19:06:14 -04:00
/**
* Filter the attachment URL .
*
* @ since 2.1 . 0
*
* @ param string $url URL for the given attachment .
* @ param int $post_id Attachment ID .
*/
2010-12-07 13:16:21 -05:00
$url = apply_filters ( 'wp_get_attachment_url' , $url , $post -> ID );
2007-01-02 14:28:30 -05:00
2011-11-09 14:20:33 -05:00
if ( empty ( $url ) )
2010-12-07 13:16:21 -05:00
return false ;
2010-12-13 16:21:50 -05:00
2010-12-07 13:16:21 -05:00
return $url ;
2007-01-02 14:28:30 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve thumbnail for an attachment .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Attachment ID .
* @ return mixed False on failure . Thumbnail file path on success .
2007-12-13 19:28:34 -05:00
*/
2007-01-05 15:54:55 -05:00
function wp_get_attachment_thumb_file ( $post_id = 0 ) {
2007-01-02 14:28:30 -05:00
$post_id = ( int ) $post_id ;
2012-08-23 16:01:10 -04:00
if ( ! $post = get_post ( $post_id ) )
2007-01-05 15:54:55 -05:00
return false ;
2008-07-06 12:40:15 -04:00
if ( ! is_array ( $imagedata = wp_get_attachment_metadata ( $post -> ID ) ) )
2007-01-02 14:28:30 -05:00
return false ;
2007-01-05 15:54:55 -05:00
$file = get_attached_file ( $post -> ID );
2007-01-02 14:28:30 -05:00
2014-04-13 19:06:14 -04:00
if ( ! empty ( $imagedata [ 'thumb' ]) && ( $thumbfile = str_replace ( basename ( $file ), $imagedata [ 'thumb' ], $file )) && file_exists ( $thumbfile ) ) {
/**
* Filter the attachment thumbnail file path .
*
* @ since 2.1 . 0
*
* @ param string $thumbfile File path to the attachment thumbnail .
* @ param int $post_id Attachment ID .
*/
2007-01-05 15:54:55 -05:00
return apply_filters ( 'wp_get_attachment_thumb_file' , $thumbfile , $post -> ID );
2014-04-13 19:06:14 -04:00
}
2007-01-02 14:28:30 -05:00
return false ;
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve URL for an attachment thumbnail .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Attachment ID
* @ return string | bool False on failure . Thumbnail URL on success .
2007-12-13 19:28:34 -05:00
*/
2007-01-02 14:28:30 -05:00
function wp_get_attachment_thumb_url ( $post_id = 0 ) {
$post_id = ( int ) $post_id ;
2012-08-23 16:01:10 -04:00
if ( ! $post = get_post ( $post_id ) )
2007-01-05 15:54:55 -05:00
return false ;
if ( ! $url = wp_get_attachment_url ( $post -> ID ) )
2007-01-02 14:28:30 -05:00
return false ;
2008-08-09 01:36:14 -04:00
2008-03-02 23:17:37 -05:00
$sized = image_downsize ( $post_id , 'thumbnail' );
if ( $sized )
return $sized [ 0 ];
2007-01-02 14:28:30 -05:00
2007-01-05 15:54:55 -05:00
if ( ! $thumb = wp_get_attachment_thumb_file ( $post -> ID ) )
2007-01-02 14:28:30 -05:00
return false ;
$url = str_replace ( basename ( $url ), basename ( $thumb ), $url );
2014-04-13 19:06:14 -04:00
/**
* Filter the attachment thumbnail URL .
*
* @ since 2.1 . 0
*
* @ param string $url URL for the attachment thumbnail .
* @ param int $post_id Attachment ID .
*/
2007-01-05 15:54:55 -05:00
return apply_filters ( 'wp_get_attachment_thumb_url' , $url , $post -> ID );
2007-01-02 14:28:30 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Check if the attachment is an image .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Attachment ID
* @ return bool
2007-12-13 19:28:34 -05:00
*/
2007-01-02 14:28:30 -05:00
function wp_attachment_is_image ( $post_id = 0 ) {
$post_id = ( int ) $post_id ;
2012-08-23 16:01:10 -04:00
if ( ! $post = get_post ( $post_id ) )
2007-01-02 14:28:30 -05:00
return false ;
if ( ! $file = get_attached_file ( $post -> ID ) )
return false ;
2007-01-02 14:51:36 -05:00
$ext = preg_match ( '/\.([^.]+)$/' , $file , $matches ) ? strtolower ( $matches [ 1 ]) : false ;
2007-01-02 14:28:30 -05:00
2012-07-05 16:51:55 -04:00
$image_exts = array ( 'jpg' , 'jpeg' , 'jpe' , 'gif' , 'png' );
2007-01-02 14:51:36 -05:00
if ( 'image/' == substr ( $post -> post_mime_type , 0 , 6 ) || $ext && 'import' == $post -> post_mime_type && in_array ( $ext , $image_exts ) )
2007-01-02 14:28:30 -05:00
return true ;
return false ;
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve the icon for a MIME type .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2012-02-14 13:12:01 -05:00
* @ param string | int $mime MIME type or attachment ID .
2008-08-19 12:38:06 -04:00
* @ return string | bool
2007-12-13 19:28:34 -05:00
*/
2007-01-02 14:28:30 -05:00
function wp_mime_type_icon ( $mime = 0 ) {
2008-02-26 03:54:11 -05:00
if ( ! is_numeric ( $mime ) )
$icon = wp_cache_get ( " mime_type_icon_ $mime " );
2012-09-07 17:04:58 -04:00
$post_id = 0 ;
2008-02-22 00:53:47 -05:00
if ( empty ( $icon ) ) {
2008-02-26 03:54:11 -05:00
$post_mimes = array ();
2008-02-22 00:53:47 -05:00
if ( is_numeric ( $mime ) ) {
$mime = ( int ) $mime ;
2012-08-23 16:01:10 -04:00
if ( $post = get_post ( $mime ) ) {
2008-02-26 03:54:11 -05:00
$post_id = ( int ) $post -> ID ;
$ext = preg_replace ( '/^.+?\.([^.]+)$/' , '$1' , $post -> guid );
2008-02-29 01:54:15 -05:00
if ( ! empty ( $ext ) ) {
2008-02-26 03:54:11 -05:00
$post_mimes [] = $ext ;
2008-02-29 01:54:15 -05:00
if ( $ext_type = wp_ext2type ( $ext ) )
$post_mimes [] = $ext_type ;
}
2008-02-26 03:54:11 -05:00
$mime = $post -> post_mime_type ;
} else {
$mime = 0 ;
}
} else {
$post_mimes [] = $mime ;
2008-02-22 00:53:47 -05:00
}
2008-02-26 03:54:11 -05:00
$icon_files = wp_cache_get ( 'icon_files' );
if ( ! is_array ( $icon_files ) ) {
2014-04-13 19:06:14 -04:00
/**
* Filter the icon directory path .
*
* @ since 2.0 . 0
*
* @ param string $path Icon directory absolute path .
*/
2014-03-25 17:10:15 -04:00
$icon_dir = apply_filters ( 'icon_dir' , ABSPATH . WPINC . '/images/media' );
2014-04-13 19:06:14 -04:00
/**
* Filter the icon directory URI .
*
* @ since 2.0 . 0
*
* @ param string $uri Icon directory URI .
*/
$icon_dir_uri = apply_filters ( 'icon_dir_uri' , includes_url ( 'images/media' ) );
/**
* Filter the list of icon directory URIs .
*
* @ since 2.5 . 0
*
* @ param array $uris List of icon directory URIs .
*/
$dirs = apply_filters ( 'icon_dirs' , array ( $icon_dir => $icon_dir_uri ) );
2008-02-26 03:54:11 -05:00
$icon_files = array ();
2008-02-29 01:54:15 -05:00
while ( $dirs ) {
2011-10-31 15:38:46 -04:00
$keys = array_keys ( $dirs );
$dir = array_shift ( $keys );
2008-02-29 01:54:15 -05:00
$uri = array_shift ( $dirs );
2008-02-26 03:54:11 -05:00
if ( $dh = opendir ( $dir ) ) {
while ( false !== $file = readdir ( $dh ) ) {
$file = basename ( $file );
2008-02-29 01:54:15 -05:00
if ( substr ( $file , 0 , 1 ) == '.' )
continue ;
2008-02-26 03:54:11 -05:00
if ( ! in_array ( strtolower ( substr ( $file , - 4 )), array ( '.png' , '.gif' , '.jpg' ) ) ) {
2008-02-29 01:54:15 -05:00
if ( is_dir ( " $dir / $file " ) )
2008-02-26 03:54:11 -05:00
$dirs [ " $dir / $file " ] = " $uri / $file " ;
continue ;
}
$icon_files [ " $dir / $file " ] = " $uri / $file " ;
2008-02-22 00:53:47 -05:00
}
2008-02-26 03:54:11 -05:00
closedir ( $dh );
2008-02-22 00:53:47 -05:00
}
2007-01-02 14:28:30 -05:00
}
2012-11-19 03:39:52 -05:00
wp_cache_add ( 'icon_files' , $icon_files , 'default' , 600 );
2008-02-26 03:54:11 -05:00
}
// Icon basename - extension = MIME wildcard
foreach ( $icon_files as $file => $uri )
$types [ preg_replace ( '/^([^.]*).*$/' , '$1' , basename ( $file )) ] =& $icon_files [ $file ];
if ( ! empty ( $mime ) ) {
$post_mimes [] = substr ( $mime , 0 , strpos ( $mime , '/' ));
$post_mimes [] = substr ( $mime , strpos ( $mime , '/' ) + 1 );
$post_mimes [] = str_replace ( '/' , '_' , $mime );
}
$matches = wp_match_mime_types ( array_keys ( $types ), $post_mimes );
2008-02-26 14:57:00 -05:00
$matches [ 'default' ] = array ( 'default' );
2008-02-26 03:54:11 -05:00
foreach ( $matches as $match => $wilds ) {
if ( isset ( $types [ $wilds [ 0 ]])) {
$icon = $types [ $wilds [ 0 ]];
if ( ! is_numeric ( $mime ) )
2012-09-07 17:10:43 -04:00
wp_cache_add ( " mime_type_icon_ $mime " , $icon );
2008-02-26 03:54:11 -05:00
break ;
}
2007-01-02 14:28:30 -05:00
}
}
2014-04-13 19:06:14 -04:00
/**
* Filter the mime type icon .
*
* @ since 2.1 . 0
*
* @ param string $icon Path to the mime type icon .
* @ param string $mime Mime type .
* @ param int $post_id Attachment ID . Will equal 0 if the function passed
* the mime type .
*/
return apply_filters ( 'wp_mime_type_icon' , $icon , $mime , $post_id );
2007-01-02 14:28:30 -05:00
}
2007-12-13 19:28:34 -05:00
/**
2010-10-18 07:24:29 -04:00
* Checked for changed slugs for published post objects and save the old slug .
2007-12-13 19:28:34 -05:00
*
2010-10-19 03:48:22 -04:00
* The function is used when a post object of any type is updated ,
2010-10-18 07:24:29 -04:00
* by comparing the current and previous post objects .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* If the slug was changed and not already part of the old slugs then it will be
* added to the post meta field ( '_wp_old_slug' ) for storing old slugs for that
* post .
*
2010-10-18 07:24:29 -04:00
* The most logically usage of this function is redirecting changed post objects , so
2008-08-19 12:38:06 -04:00
* that those that linked to an changed post will be redirected to the new post .
*
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param int $post_id Post ID .
2010-10-18 07:24:29 -04:00
* @ param object $post The Post Object
* @ param object $post_before The Previous Post Object
2007-12-13 19:28:34 -05:00
* @ return int Same as $post_id
*/
2010-05-23 03:49:21 -04:00
function wp_check_for_changed_slugs ( $post_id , $post , $post_before ) {
// dont bother if it hasnt changed
if ( $post -> post_name == $post_before -> post_name )
return ;
2006-12-10 12:17:39 -05:00
2010-12-08 16:10:38 -05:00
// we're only concerned with published, non-hierarchical objects
2010-12-08 16:17:01 -05:00
if ( $post -> post_status != 'publish' || is_post_type_hierarchical ( $post -> post_type ) )
2010-05-23 03:49:21 -04:00
return ;
2006-12-10 12:17:39 -05:00
$old_slugs = ( array ) get_post_meta ( $post_id , '_wp_old_slug' );
// if we haven't added this old slug before, add it now
2010-12-08 16:22:16 -05:00
if ( ! empty ( $post_before -> post_name ) && ! in_array ( $post_before -> post_name , $old_slugs ) )
2013-03-01 11:28:40 -05:00
add_post_meta ( $post_id , '_wp_old_slug' , $post_before -> post_name );
2006-12-10 12:17:39 -05:00
// if the new slug was used previously, delete it from the list
if ( in_array ( $post -> post_name , $old_slugs ) )
delete_post_meta ( $post_id , '_wp_old_slug' , $post -> post_name );
}
2007-04-05 23:25:41 -04:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve the private post SQL based on capability .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* This function provides a standardized way to appropriately select on the
2011-04-28 07:27:39 -04:00
* post_status of a post type . The function will return a piece of SQL code
* that can be added to a WHERE clause ; this SQL is constructed to allow all
2008-08-19 12:38:06 -04:00
* published posts , and all private posts to which the user has access .
2007-09-03 19:32:58 -04:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.2 . 0
2007-12-13 19:28:34 -05:00
*
2007-04-05 23:25:41 -04:00
* @ param string $post_type currently only supports 'post' or 'page' .
* @ return string SQL code that can be added to a where clause .
*/
2011-04-28 07:27:39 -04:00
function get_private_posts_cap_sql ( $post_type ) {
return get_posts_by_author_sql ( $post_type , false );
2010-03-03 14:08:30 -05:00
}
/**
* Retrieve the post SQL based on capability , author , and type .
*
2011-04-28 07:27:39 -04:00
* @ see get_private_posts_cap_sql () for full description .
2010-03-03 14:08:30 -05:00
*
* @ since 3.0 . 0
2011-04-28 07:27:39 -04:00
* @ param string $post_type Post type .
2011-12-13 18:45:31 -05:00
* @ param bool $full Optional . Returns a full WHERE statement instead of just an 'andalso' term .
* @ param int $post_author Optional . Query posts having a single author ID .
2012-11-05 18:11:25 -05:00
* @ param bool $public_only Optional . Only return public posts . Skips cap checks for $current_user . Default is false .
2010-03-03 14:08:30 -05:00
* @ return string SQL WHERE code that can be added to a query .
*/
2012-11-05 18:11:25 -05:00
function get_posts_by_author_sql ( $post_type , $full = true , $post_author = null , $public_only = false ) {
2013-10-02 17:10:09 -04:00
global $wpdb ;
2007-04-05 23:25:41 -04:00
// Private posts
2011-04-28 07:27:39 -04:00
$post_type_obj = get_post_type_object ( $post_type );
if ( ! $post_type_obj )
2011-11-02 13:06:34 -04:00
return $full ? 'WHERE 1 = 0' : ' 1 = 0 ' ;
2007-04-05 23:25:41 -04:00
2014-04-13 19:06:14 -04:00
/**
* Filter the capability to read private posts for a custom post type
* when generating SQL for getting posts by author .
*
* @ since 2.2 . 0
* @ deprecated 3.2 . 0 The hook transitioned from " somewhat useless " to " totally useless " .
*
* @ param string $cap Capability .
*/
if ( ! $cap = apply_filters ( 'pub_priv_sql_capability' , '' ) ) {
2011-04-28 07:27:39 -04:00
$cap = $post_type_obj -> cap -> read_private_posts ;
2014-04-13 19:06:14 -04:00
}
2007-04-05 23:25:41 -04:00
2011-04-28 07:27:39 -04:00
if ( $full ) {
if ( null === $post_author ) {
$sql = $wpdb -> prepare ( 'WHERE post_type = %s AND ' , $post_type );
2010-03-03 14:08:30 -05:00
} else {
2011-04-28 07:27:39 -04:00
$sql = $wpdb -> prepare ( 'WHERE post_author = %d AND post_type = %s AND ' , $post_author , $post_type );
2010-03-03 14:08:30 -05:00
}
} else {
$sql = '' ;
}
$sql .= " (post_status = 'publish' " ;
2007-04-05 23:25:41 -04:00
2012-11-05 18:11:25 -05:00
// Only need to check the cap if $public_only is false
if ( false === $public_only ) {
if ( current_user_can ( $cap ) ) {
// Does the user have the capability to view private posts? Guess so.
2010-03-03 14:08:30 -05:00
$sql .= " OR post_status = 'private' " ;
2012-11-05 18:11:25 -05:00
} elseif ( is_user_logged_in () ) {
// Users can view their own private posts.
2013-10-02 17:10:09 -04:00
$id = get_current_user_id ();
2012-11-05 18:11:25 -05:00
if ( null === $post_author || ! $full ) {
$sql .= " OR post_status = 'private' AND post_author = $id " ;
} elseif ( $id == ( int ) $post_author ) {
$sql .= " OR post_status = 'private' " ;
} // else none
2010-03-03 14:08:30 -05:00
} // else none
2012-11-05 18:11:25 -05:00
}
2007-04-05 23:25:41 -04:00
$sql .= ')' ;
return $sql ;
}
2007-12-13 19:28:34 -05:00
/**
2010-03-10 16:32:03 -05:00
* Retrieve the date that the last post was published .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* The server timezone is the default and is the difference between GMT and
* server time . The 'blog' value is the date when the last post was posted . The
* 'gmt' is when the last post was posted in GMT formatted date .
2007-12-13 19:28:34 -05:00
*
* @ since 0.71
*
* @ param string $timezone The location to get the time . Can be 'gmt' , 'blog' , or 'server' .
* @ return string The date of the last post .
*/
2007-05-26 19:32:06 -04:00
function get_lastpostdate ( $timezone = 'server' ) {
2014-04-13 19:06:14 -04:00
/**
* Filter the date the last post was published .
*
* @ since 2.3 . 0
*
* @ param string $date Date the last post was published . Likely values are 'gmt' ,
* 'blog' , or 'server' .
* @ param string $timezone Location to use for getting the post published date .
*/
2010-10-18 17:06:49 -04:00
return apply_filters ( 'get_lastpostdate' , _get_last_post_time ( $timezone , 'date' ), $timezone );
2007-05-26 19:32:06 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Retrieve last post modified date depending on timezone .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* The server timezone is the default and is the difference between GMT and
* server time . The 'blog' value is just when the last post was modified . The
* 'gmt' is when the last post was modified in GMT time .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.2 . 0
2007-12-13 19:28:34 -05:00
*
* @ param string $timezone The location to get the time . Can be 'gmt' , 'blog' , or 'server' .
* @ return string The date the post was last modified .
*/
2007-05-26 19:32:06 -04:00
function get_lastpostmodified ( $timezone = 'server' ) {
2010-10-18 17:06:49 -04:00
$lastpostmodified = _get_last_post_time ( $timezone , 'modified' );
2010-03-17 12:27:25 -04:00
2010-03-10 16:32:03 -05:00
$lastpostdate = get_lastpostdate ( $timezone );
if ( $lastpostdate > $lastpostmodified )
$lastpostmodified = $lastpostdate ;
2014-04-13 19:06:14 -04:00
/**
* Filter the date the last post was modified .
*
* @ since 2.3 . 0
*
* @ param string $lastpostmodified Date the last post was modified .
* @ param string $timezone Location to use for getting the post modified date .
*/
2007-10-31 12:59:05 -04:00
return apply_filters ( 'get_lastpostmodified' , $lastpostmodified , $timezone );
2007-05-26 19:32:06 -04:00
}
2010-10-19 03:35:12 -04:00
/**
* Retrieve latest post date data based on timezone .
*
* @ access private
* @ since 3.1 . 0
*
* @ param string $timezone The location to get the time . Can be 'gmt' , 'blog' , or 'server' .
* @ param string $field Field to check . Can be 'date' or 'modified' .
* @ return string The date .
*/
2010-10-18 17:06:49 -04:00
function _get_last_post_time ( $timezone , $field ) {
2010-10-28 11:46:11 -04:00
global $wpdb ;
2010-10-18 17:06:49 -04:00
if ( ! in_array ( $field , array ( 'date' , 'modified' ) ) )
return false ;
2010-11-22 16:45:45 -05:00
$timezone = strtolower ( $timezone );
2010-10-18 17:06:49 -04:00
2010-11-22 16:45:45 -05:00
$key = " lastpost { $field } : $timezone " ;
2010-10-18 17:06:49 -04:00
$date = wp_cache_get ( $key , 'timeinfo' );
if ( ! $date ) {
$add_seconds_server = date ( 'Z' );
2011-06-10 13:02:03 -04:00
$post_types = get_post_types ( array ( 'public' => true ) );
2010-10-18 17:06:49 -04:00
array_walk ( $post_types , array ( & $wpdb , 'escape_by_ref' ) );
$post_types = " ' " . implode ( " ', ' " , $post_types ) . " ' " ;
2010-11-22 16:45:45 -05:00
switch ( $timezone ) {
2010-10-18 17:06:49 -04:00
case 'gmt' :
$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 " );
break ;
case 'blog' :
$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 " );
break ;
case 'server' :
$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 " );
break ;
}
if ( $date )
wp_cache_set ( $key , $date , 'timeinfo' );
}
return $date ;
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Updates posts in cache .
2007-12-13 19:28:34 -05:00
*
* @ since 1.5 . 1
*
* @ param array $posts Array of post objects
*/
2012-04-10 12:09:44 -04:00
function update_post_cache ( & $posts ) {
if ( ! $posts )
2007-05-26 19:32:06 -04:00
return ;
2007-10-12 17:12:34 -04:00
foreach ( $posts as $post )
2012-04-10 12:09:44 -04:00
wp_cache_add ( $post -> ID , $post , 'posts' );
2007-05-26 19:32:06 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Will clean the post in the cache .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* Cleaning means delete from the cache of the post . Will call to clean the term
* object cache associated with the post ID .
2007-12-13 19:28:34 -05:00
*
2009-05-06 16:49:36 -04:00
* This function not run if $_wp_suspend_cache_invalidation is not empty . See
* wp_suspend_cache_invalidation () .
*
2008-08-19 12:38:06 -04:00
* @ since 2.0 . 0
2007-12-13 19:28:34 -05:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Post ID or post object to remove from the cache .
2007-12-13 19:28:34 -05:00
*/
2012-04-23 18:04:35 -04:00
function clean_post_cache ( $post ) {
2008-10-08 20:50:52 -04:00
global $_wp_suspend_cache_invalidation , $wpdb ;
2012-04-10 12:09:44 -04:00
if ( ! empty ( $_wp_suspend_cache_invalidation ) )
2008-10-08 20:50:52 -04:00
return ;
2012-04-23 18:04:35 -04:00
$post = get_post ( $post );
if ( empty ( $post ) )
2010-08-18 02:50:53 -04:00
return ;
2012-04-23 18:04:35 -04:00
wp_cache_delete ( $post -> ID , 'posts' );
wp_cache_delete ( $post -> ID , 'post_meta' );
2007-05-26 19:32:06 -04:00
2012-04-23 18:04:35 -04:00
clean_object_term_cache ( $post -> ID , $post -> post_type );
2007-10-14 00:55:33 -04:00
2007-10-30 02:03:11 -04:00
wp_cache_delete ( 'wp_get_archives' , 'general' );
2014-04-13 19:06:14 -04:00
/**
* Fires immediately after the given post ' s cache is cleaned .
*
* @ since 2.5 . 0
*
* @ param int $post_id Post ID .
* @ param WP_Post $post Post object .
*/
2012-04-23 18:04:35 -04:00
do_action ( 'clean_post_cache' , $post -> ID , $post );
2012-04-10 12:09:44 -04:00
2012-07-20 00:35:51 -04:00
if ( is_post_type_hierarchical ( $post -> post_type ) )
wp_cache_delete ( 'get_pages' , 'posts' );
2012-04-23 18:04:35 -04:00
if ( 'page' == $post -> post_type ) {
2012-04-10 12:09:44 -04:00
wp_cache_delete ( 'all_page_ids' , 'posts' );
2014-04-13 19:06:14 -04:00
/**
* Fires immediately after the given page ' s cache is cleaned .
*
* @ since 2.5 . 0
*
* @ param int $post_id Post ID .
*/
2012-04-23 18:04:35 -04:00
do_action ( 'clean_page_cache' , $post -> ID );
2012-04-10 12:09:44 -04:00
}
2013-01-15 12:32:35 -05:00
2014-02-26 17:05:13 -05:00
wp_cache_set ( 'last_changed' , microtime (), 'posts' );
2007-05-26 19:32:06 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Call major cache updating functions for list of Post objects .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 1.5 . 0
2007-12-13 19:28:34 -05:00
*
* @ uses update_post_cache ()
* @ uses update_object_term_cache ()
* @ uses update_postmeta_cache ()
*
* @ param array $posts Array of Post objects
2010-05-09 20:58:39 -04:00
* @ param string $post_type The post type of the posts in $posts . Default is 'post' .
* @ param bool $update_term_cache Whether to update the term cache . Default is true .
* @ param bool $update_meta_cache Whether to update the meta cache . Default is true .
2007-12-13 19:28:34 -05:00
*/
2010-05-09 20:58:39 -04:00
function update_post_caches ( & $posts , $post_type = 'post' , $update_term_cache = true , $update_meta_cache = true ) {
2007-05-26 19:32:06 -04:00
// No point in doing all this work if we didn't match any posts.
if ( ! $posts )
return ;
2007-10-12 17:12:34 -04:00
update_post_cache ( $posts );
2007-05-26 19:32:06 -04:00
2007-10-12 17:12:34 -04:00
$post_ids = array ();
2010-04-29 16:43:59 -04:00
foreach ( $posts as $post )
$post_ids [] = $post -> ID ;
2007-05-26 19:32:06 -04:00
2012-09-14 12:26:05 -04:00
if ( ! $post_type )
$post_type = 'any' ;
2007-05-26 19:32:06 -04:00
2010-10-04 04:56:04 -04:00
if ( $update_term_cache ) {
if ( is_array ( $post_type ) ) {
$ptypes = $post_type ;
} elseif ( 'any' == $post_type ) {
// Just use the post_types in the supplied posts.
foreach ( $posts as $post )
$ptypes [] = $post -> post_type ;
$ptypes = array_unique ( $ptypes );
} else {
$ptypes = array ( $post_type );
}
if ( ! empty ( $ptypes ) )
update_object_term_cache ( $post_ids , $ptypes );
}
2007-05-26 19:32:06 -04:00
2010-05-09 20:58:39 -04:00
if ( $update_meta_cache )
update_postmeta_cache ( $post_ids );
2007-10-12 17:12:34 -04:00
}
2007-05-26 19:32:06 -04:00
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Updates metadata cache for list of post IDs .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* Performs SQL query to retrieve the metadata for the post IDs and updates the
* metadata cache for the posts . Therefore , the functions , which call this
* function , do not need to perform SQL queries on their own .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.1 . 0
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param array $post_ids List of post IDs .
* @ return bool | array Returns false if there is nothing to update or an array of metadata .
2007-12-13 19:28:34 -05:00
*/
2007-10-12 17:12:34 -04:00
function update_postmeta_cache ( $post_ids ) {
2009-09-17 16:17:33 -04:00
return update_meta_cache ( 'post' , $post_ids );
2007-05-26 19:32:06 -04:00
}
2010-02-18 02:43:35 -05:00
/**
* Will clean the attachment in the cache .
*
2011-09-05 15:08:15 -04:00
* Cleaning means delete from the cache . Optionally will clean the term
2010-02-18 02:43:35 -05:00
* object cache associated with the attachment ID .
*
* This function will not run if $_wp_suspend_cache_invalidation is not empty . See
* wp_suspend_cache_invalidation () .
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-02-18 02:43:35 -05:00
*
* @ param int $id The attachment ID in the cache to clean
* @ param bool $clean_terms optional . Whether to clean terms cache
*/
function clean_attachment_cache ( $id , $clean_terms = false ) {
2010-02-19 19:50:29 -05:00
global $_wp_suspend_cache_invalidation ;
2010-02-18 02:43:35 -05:00
if ( ! empty ( $_wp_suspend_cache_invalidation ) )
return ;
$id = ( int ) $id ;
wp_cache_delete ( $id , 'posts' );
wp_cache_delete ( $id , 'post_meta' );
if ( $clean_terms )
clean_object_term_cache ( $id , 'attachment' );
2014-04-13 19:06:14 -04:00
/**
* Fires after the given attachment ' s cache is cleaned .
*
* @ since 3.0 . 0
*
* @ param int $id Attachment ID .
*/
do_action ( 'clean_attachment_cache' , $id );
2010-02-18 02:43:35 -05:00
}
2007-07-12 12:00:51 -04:00
//
// Hooks
//
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Hook for managing future post transitions to published .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
* @ access private
2007-12-13 19:28:34 -05:00
* @ uses $wpdb
2009-05-06 16:49:36 -04:00
* @ uses wp_clear_scheduled_hook () with 'publish_future_post' and post ID .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ param string $new_status New post status
* @ param string $old_status Previous post status
2007-12-13 19:28:34 -05:00
* @ param object $post Object type containing the post information
*/
2007-07-12 12:00:51 -04:00
function _transition_post_status ( $new_status , $old_status , $post ) {
global $wpdb ;
if ( $old_status != 'publish' && $new_status == 'publish' ) {
2008-01-10 16:27:08 -05:00
// Reset GUID if transitioning to publish and it is empty
if ( '' == get_the_guid ( $post -> ID ) )
2007-10-12 22:36:38 -04:00
$wpdb -> update ( $wpdb -> posts , array ( 'guid' => get_permalink ( $post -> ID ) ), array ( 'ID' => $post -> ID ) );
2014-04-13 19:06:14 -04:00
/**
* Fires when a post ' s status is transitioned from private to published .
*
* @ since 1.5 . 0
* @ deprecated 2.3 . 0 Use 'private_to_publish' instead .
*
* @ param int $post_id Post ID .
*/
do_action ( 'private_to_published' , $post -> ID );
2007-07-12 12:00:51 -04:00
}
2010-03-10 16:32:03 -05:00
// If published posts changed clear the lastpostmodified cache
if ( 'publish' == $new_status || 'publish' == $old_status ) {
2010-11-22 16:45:45 -05:00
foreach ( array ( 'server' , 'gmt' , 'blog' ) as $timezone ) {
wp_cache_delete ( " lastpostmodified: $timezone " , 'timeinfo' );
wp_cache_delete ( " lastpostdate: $timezone " , 'timeinfo' );
}
2010-03-10 16:32:03 -05:00
}
2014-02-03 14:42:13 -05:00
if ( $new_status !== $old_status ) {
wp_cache_delete ( _count_posts_cache_key ( $post -> post_type ), 'counts' );
wp_cache_delete ( _count_posts_cache_key ( $post -> post_type , 'readable' ), 'counts' );
}
2007-07-12 12:00:51 -04:00
// Always clears the hook in case the post status bounced from future to draft.
2009-12-24 06:24:32 -05:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $post -> ID ) );
2007-07-12 12:00:51 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Hook used to schedule publication for a post marked for the future .
2007-12-13 19:28:34 -05:00
*
* The $post properties used and must exist are 'ID' and 'post_date_gmt' .
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2009-05-06 16:49:36 -04:00
* @ access private
2007-12-13 19:28:34 -05:00
*
2010-01-09 04:55:41 -05:00
* @ param int $deprecated Not used . Can be set to null . Never implemented .
* Not marked as deprecated with _deprecated_argument () as it conflicts with
* wp_transition_post_status () and the default filter for _future_post_hook () .
2007-12-13 19:28:34 -05:00
* @ param object $post Object type containing the post information
*/
2013-04-29 09:26:31 -04:00
function _future_post_hook ( $deprecated , $post ) {
2009-12-24 06:24:32 -05:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $post -> ID ) );
2010-05-07 16:57:23 -04:00
wp_schedule_single_event ( strtotime ( get_gmt_from_date ( $post -> post_date ) . ' GMT' ) , 'publish_future_post' , array ( $post -> ID ) );
2007-07-12 12:00:51 -04:00
}
2007-12-13 19:28:34 -05:00
/**
2008-08-19 12:38:06 -04:00
* Hook to schedule pings and enclosures when a post is published .
2007-12-13 19:28:34 -05:00
*
2008-08-19 12:38:06 -04:00
* @ since 2.3 . 0
2009-05-06 16:49:36 -04:00
* @ access private
2013-02-05 10:45:37 -05:00
* @ uses XMLRPC_REQUEST and WP_IMPORTING constants .
2007-12-13 19:28:34 -05:00
*
* @ param int $post_id The ID in the database table of the post being published
*/
2007-07-12 12:00:51 -04:00
function _publish_post_hook ( $post_id ) {
2014-04-13 19:06:14 -04:00
if ( defined ( 'XMLRPC_REQUEST' ) ) {
/**
* Fires when _publish_post_hook () is called during an XML - RPC request .
*
* @ since 2.1 . 0
*
* @ param int $post_id Post ID .
*/
do_action ( 'xmlrpc_publish_post' , $post_id );
}
2007-07-12 12:00:51 -04:00
if ( defined ( 'WP_IMPORTING' ) )
return ;
2012-04-11 16:02:39 -04:00
if ( get_option ( 'default_pingback_flag' ) )
2013-03-01 11:28:40 -05:00
add_post_meta ( $post_id , '_pingme' , '1' );
add_post_meta ( $post_id , '_encloseme' , '1' );
2009-09-24 13:10:28 -04:00
2007-07-12 12:00:51 -04:00
wp_schedule_single_event ( time (), 'do_pings' );
}
2010-10-14 11:09:04 -04:00
/**
* Returns the post 's parent' s post_ID
*
2010-10-19 03:38:42 -04:00
* @ since 3.1 . 0
2010-10-14 11:09:04 -04:00
*
* @ param int $post_id
*
* @ return int | bool false on error
*/
function wp_get_post_parent_id ( $post_ID ) {
$post = get_post ( $post_ID );
if ( ! $post || is_wp_error ( $post ) )
return false ;
return ( int ) $post -> post_parent ;
}
/**
* Checks the given subset of the post hierarchy for hierarchy loops .
* Prevents loops from forming and breaks those that it finds .
*
* Attached to the wp_insert_post_parent filter .
*
2010-10-19 03:38:42 -04:00
* @ since 3.1 . 0
2010-10-14 11:09:04 -04:00
* @ uses wp_find_hierarchy_loop ()
*
* @ param int $post_parent ID of the parent for the post we ' re checking .
2012-01-24 16:52:49 -05:00
* @ param int $post_ID ID of the post we ' re checking .
2010-10-14 11:09:04 -04:00
*
* @ return int The new post_parent for the post .
*/
function wp_check_post_hierarchy_for_loops ( $post_parent , $post_ID ) {
// Nothing fancy here - bail
if ( ! $post_parent )
return 0 ;
// New post can't cause a loop
if ( empty ( $post_ID ) )
return $post_parent ;
// Can't be its own parent
if ( $post_parent == $post_ID )
return 0 ;
// Now look for larger loops
if ( ! $loop = wp_find_hierarchy_loop ( 'wp_get_post_parent_id' , $post_ID , $post_parent ) )
return $post_parent ; // No loop
// Setting $post_parent to the given value causes a loop
if ( isset ( $loop [ $post_ID ] ) )
return 0 ;
2011-12-13 18:45:31 -05:00
// There's a loop, but it doesn't contain $post_ID. Break the loop.
2010-10-14 11:09:04 -04:00
foreach ( array_keys ( $loop ) as $loop_member )
wp_update_post ( array ( 'ID' => $loop_member , 'post_parent' => 0 ) );
return $post_parent ;
}
2010-10-02 22:58:59 -04:00
2010-11-15 12:59:25 -05:00
/**
* Sets a post thumbnail .
*
* @ since 3.1 . 0
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Post ID or post object where thumbnail should be attached .
2010-11-15 12:59:25 -05:00
* @ param int $thumbnail_id Thumbnail to attach .
* @ return bool True on success , false on failure .
*/
function set_post_thumbnail ( $post , $thumbnail_id ) {
$post = get_post ( $post );
2010-11-15 13:06:57 -05:00
$thumbnail_id = absint ( $thumbnail_id );
2010-11-15 12:59:25 -05:00
if ( $post && $thumbnail_id && get_post ( $thumbnail_id ) ) {
2012-09-24 09:07:34 -04:00
if ( $thumbnail_html = wp_get_attachment_image ( $thumbnail_id , 'thumbnail' ) )
2013-03-01 11:28:40 -05:00
return update_post_meta ( $post -> ID , '_thumbnail_id' , $thumbnail_id );
2012-09-24 09:07:34 -04:00
else
return delete_post_meta ( $post -> ID , '_thumbnail_id' );
2010-11-15 12:59:25 -05:00
}
return false ;
}
2011-09-24 15:31:38 -04:00
/**
* Removes a post thumbnail .
*
* @ since 3.3 . 0
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Post ID or post object where thumbnail should be removed from .
2011-09-24 15:31:38 -04:00
* @ return bool True on success , false on failure .
*/
function delete_post_thumbnail ( $post ) {
$post = get_post ( $post );
if ( $post )
return delete_post_meta ( $post -> ID , '_thumbnail_id' );
return false ;
}
2012-04-12 14:49:48 -04:00
/**
* Deletes auto - drafts for new posts that are > 7 days old
*
* @ since 3.4 . 0
*/
function wp_delete_auto_drafts () {
global $wpdb ;
// Cleanup old auto-drafts more than 7 days old
$old_posts = $wpdb -> get_col ( " SELECT ID FROM $wpdb->posts WHERE post_status = 'auto-draft' AND DATE_SUB( NOW(), INTERVAL 7 DAY ) > post_date " );
foreach ( ( array ) $old_posts as $delete )
wp_delete_post ( $delete , true ); // Force delete
}
2011-10-10 16:52:44 -04:00
/**
* Update the custom taxonomies ' term counts when a post' s status is changed . For example , default posts term counts ( for custom taxonomies ) don ' t include private / draft posts .
2011-10-24 15:13:23 -04:00
*
2011-10-10 16:52:44 -04:00
* @ access private
* @ param string $new_status
* @ param string $old_status
* @ param object $post
* @ since 3.3 . 0
*/
function _update_term_count_on_transition_post_status ( $new_status , $old_status , $post ) {
// Update counts for the post's terms.
foreach ( ( array ) get_object_taxonomies ( $post -> post_type ) as $taxonomy ) {
$tt_ids = wp_get_object_terms ( $post -> ID , $taxonomy , array ( 'fields' => 'tt_ids' ) );
wp_update_term_count ( $tt_ids , $taxonomy );
}
}
2012-02-14 10:09:35 -05:00
/**
* Adds any posts from the given ids to the cache that do not already exist in cache
*
* @ since 3.4 . 0
*
* @ access private
*
* @ param array $post_ids ID list
* @ param bool $update_term_cache Whether to update the term cache . Default is true .
* @ param bool $update_meta_cache Whether to update the meta cache . Default is true .
*/
function _prime_post_caches ( $ids , $update_term_cache = true , $update_meta_cache = true ) {
global $wpdb ;
$non_cached_ids = _get_non_cached_ids ( $ids , 'posts' );
if ( ! empty ( $non_cached_ids ) ) {
$fresh_posts = $wpdb -> get_results ( sprintf ( " SELECT $wpdb->posts .* FROM $wpdb->posts WHERE ID IN (%s) " , join ( " , " , $non_cached_ids ) ) );
update_post_caches ( $fresh_posts , 'any' , $update_term_cache , $update_meta_cache );
}
2012-04-10 12:09:44 -04:00
}