2004-05-24 03:34:57 +02:00
< ? php
2007-12-14 01:28:34 +01:00
/**
2008-06-14 18:31:08 +02:00
* Post functions and post utility function .
*
2007-12-14 01:28:34 +01:00
* @ package WordPress
* @ subpackage Post
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
*/
2004-05-24 03:34:57 +02:00
2009-10-06 16:43:05 +02:00
//
// Post Type Registration
//
/**
* Creates the initial post types when 'init' action is fired .
2010-11-16 14:16:13 +01:00
*
* @ since 2.9 . 0
2009-10-06 16:43:05 +02:00
*/
function create_initial_post_types () {
2010-05-04 08:13:28 +02:00
register_post_type ( 'post' , array (
2011-06-11 04:20:18 +02:00
'labels' => array (
'name_admin_bar' => _x ( 'Post' , 'add new on admin bar' ),
),
2010-05-04 08:13:28 +02: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 16:40:04 +02:00
'map_meta_cap' => true ,
2010-05-04 08:13:28 +02:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2012-05-08 19:01:50 +02:00
'delete_with_user' => true ,
2010-12-03 00:16:04 +01:00
'supports' => array ( 'title' , 'editor' , 'author' , 'thumbnail' , 'excerpt' , 'trackbacks' , 'custom-fields' , 'comments' , 'revisions' , 'post-formats' ),
2010-05-04 08:13:28 +02:00
) );
2010-01-18 12:44:51 +01:00
2010-05-04 08:13:28 +02:00
register_post_type ( 'page' , array (
2011-06-11 04:20:18 +02:00
'labels' => array (
'name_admin_bar' => _x ( 'Page' , 'add new on admin bar' ),
),
2010-05-04 08:13:28 +02:00
'public' => true ,
2011-06-10 19:02:03 +02:00
'publicly_queryable' => false ,
2010-05-04 08:13:28 +02: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 16:40:04 +02:00
'map_meta_cap' => true ,
2010-05-04 08:13:28 +02:00
'hierarchical' => true ,
'rewrite' => false ,
'query_var' => false ,
2012-05-08 19:01:50 +02:00
'delete_with_user' => true ,
2010-05-04 08:13:28 +02:00
'supports' => array ( 'title' , 'editor' , 'author' , 'thumbnail' , 'page-attributes' , 'custom-fields' , 'comments' , 'revisions' ),
) );
2010-01-18 12:44:51 +01:00
2010-05-04 08:13:28 +02:00
register_post_type ( 'attachment' , array (
2010-05-14 02:34:04 +02:00
'labels' => array (
2012-09-22 00:52:54 +02: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-14 02:34:04 +02:00
),
2010-05-04 08:13:28 +02:00
'public' => true ,
2012-09-22 00:52:54 +02:00
'show_ui' => true ,
2010-05-04 08:13:28 +02:00
'_builtin' => true , /* internal use only. don't use this when registering your own post type. */
2012-09-22 00:52:54 +02:00
'_edit_link' => 'post.php?post=%d' , /* internal use only. don't use this when registering your own post type. */
2010-05-04 08:13:28 +02:00
'capability_type' => 'post' ,
2012-11-29 17:14:07 +01:00
'capabilities' => array (
'create_posts' => 'upload_files' ,
),
2010-10-22 02:25:14 +02:00
'map_meta_cap' => true ,
2010-05-04 08:13:28 +02:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2010-05-29 18:46:46 +02:00
'show_in_nav_menus' => false ,
2012-05-08 19:01:50 +02:00
'delete_with_user' => true ,
2012-09-22 00:52:54 +02:00
'supports' => array ( 'title' , 'author' , 'comments' ),
2010-05-04 08:13:28 +02:00
) );
2010-01-18 12:44:51 +01:00
2010-05-04 08:13:28 +02:00
register_post_type ( 'revision' , array (
2010-05-14 02:34:04 +02:00
'labels' => array (
'name' => __ ( 'Revisions' ),
'singular_name' => __ ( 'Revision' ),
),
2010-05-04 08:13:28 +02: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-22 02:25:14 +02:00
'map_meta_cap' => true ,
2010-05-04 08:13:28 +02:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2010-12-01 18:21:58 +01:00
'can_export' => false ,
2012-05-08 19:01:50 +02:00
'delete_with_user' => true ,
'supports' => array ( 'author' ),
2010-05-04 08:13:28 +02:00
) );
2010-01-18 12:44:51 +01:00
2010-05-04 08:13:28 +02:00
register_post_type ( 'nav_menu_item' , array (
2010-05-14 02:34:04 +02:00
'labels' => array (
'name' => __ ( 'Navigation Menu Items' ),
'singular_name' => __ ( 'Navigation Menu Item' ),
),
2010-05-04 08:13:28 +02: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 19:01:50 +02:00
'delete_with_user' => false ,
2010-05-04 08:13:28 +02:00
'query_var' => false ,
) );
2010-02-20 23:35:39 +01:00
2010-05-04 08:13:28 +02: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 12:44:51 +01:00
2010-05-04 08:13:28 +02: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 12:44:51 +01:00
2010-05-04 08:13:28 +02: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 12:44:51 +01:00
2010-05-04 08:13:28 +02: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 22:13:44 +01:00
2010-05-04 08:13:28 +02: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 12:44:51 +01:00
2010-05-04 08:13:28 +02: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 18:09:34 +01:00
2010-05-04 08:13:28 +02:00
register_post_status ( 'auto-draft' , array (
'label' => 'auto-draft' ,
'internal' => true ,
'_builtin' => true , /* internal use only. */
) );
2010-04-14 16:07:48 +02:00
2010-05-04 08:13:28 +02:00
register_post_status ( 'inherit' , array (
'label' => 'inherit' ,
'internal' => true ,
'_builtin' => true , /* internal use only. */
'exclude_from_search' => false ,
) );
2009-10-06 16:43:05 +02:00
}
add_action ( 'init' , 'create_initial_post_types' , 0 ); // highest priority
2007-12-14 01:28:34 +01:00
/**
2008-06-27 17:32:57 +02:00
* Retrieve attached file path based on attachment ID .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* You can optionally send it through the 'get_attached_file' filter , but by
* default it will just return the file path unfiltered .
*
* 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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
* @ uses apply_filters () Calls 'get_attached_file' on file path and attachment ID .
2007-12-14 01:28:34 +01:00
*
2008-11-23 00:01:28 +01:00
* @ param int $attachment_id Attachment ID .
2010-02-24 21:13:23 +01:00
* @ param bool $unfiltered Whether to apply filters .
2012-04-27 18:08:58 +02:00
* @ return string | bool The file path to the attached file , or false if the attachment does not exist .
2007-12-14 01:28:34 +01:00
*/
2006-12-05 23:37:19 +01:00
function get_attached_file ( $attachment_id , $unfiltered = false ) {
$file = get_post_meta ( $attachment_id , '_wp_attached_file' , true );
2008-09-03 00:55:39 +02:00
// If the file is relative, prepend upload dir
2012-04-27 18:08:58 +02:00
if ( $file && 0 !== strpos ( $file , '/' ) && ! preg_match ( '|^.:\\\|' , $file ) && ( ( $uploads = wp_upload_dir ()) && false === $uploads [ 'error' ] ) )
2008-09-03 00:55:39 +02:00
$file = $uploads [ 'basedir' ] . " / $file " ;
2006-12-05 23:37:19 +01:00
if ( $unfiltered )
return $file ;
return apply_filters ( 'get_attached_file' , $file , $attachment_id );
}
2007-12-14 01:28:34 +01:00
/**
2008-06-27 17:32:57 +02:00
* Update attachment file path based on attachment ID .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
* @ uses apply_filters () Calls 'update_attached_file' on file path and attachment ID .
2007-12-14 01:28:34 +01:00
*
* @ param int $attachment_id Attachment ID
2008-06-27 17:32:57 +02:00
* @ param string $file File path for the attachment
* @ return bool False on failure , true on success .
2007-12-14 01:28:34 +01:00
*/
2006-12-05 23:37:19 +01:00
function update_attached_file ( $attachment_id , $file ) {
if ( ! get_post ( $attachment_id ) )
return false ;
$file = apply_filters ( 'update_attached_file' , $file , $attachment_id );
2012-09-24 15:07:34 +02: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 12:24:01 +01:00
}
/**
* Return relative path to an uploaded file .
*
* The path is relative to the current upload dir .
*
2010-03-26 20:23:39 +01:00
* @ since 2.9 . 0
2009-11-11 12:24:01 +01:00
* @ uses apply_filters () Calls '_wp_relative_upload_path' on file path .
*
* @ 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-12 00:06:49 +02: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-03 00:55:39 +02:00
}
2009-11-11 12:24:01 +01:00
return apply_filters ( '_wp_relative_upload_path' , $new_path , $path );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-06-27 17:32:57 +02: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 18:38:06 +02: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 17:32:57 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02: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-14 01:28:34 +01:00
*/
2010-12-01 21:23:57 +01:00
function get_children ( $args = '' , $output = OBJECT ) {
2009-07-31 11:31:56 +02:00
$kids = array ();
2007-05-11 05:10:05 +02:00
if ( empty ( $args ) ) {
if ( isset ( $GLOBALS [ 'post' ] ) ) {
2008-05-05 18:03:27 +02:00
$args = array ( 'post_parent' => ( int ) $GLOBALS [ 'post' ] -> post_parent );
2007-05-11 05:10:05 +02:00
} else {
2009-07-31 11:31:56 +02:00
return $kids ;
2007-05-11 05:10:05 +02:00
}
} elseif ( is_object ( $args ) ) {
2008-05-05 18:03:27 +02:00
$args = array ( 'post_parent' => ( int ) $args -> post_parent );
2007-05-11 05:10:05 +02:00
} elseif ( is_numeric ( $args ) ) {
2008-05-05 18:03:27 +02:00
$args = array ( 'post_parent' => ( int ) $args );
2007-05-11 05:10:05 +02:00
}
2007-06-14 04:25:30 +02:00
2007-05-11 05:10:05 +02:00
$defaults = array (
2008-12-08 22:00:25 +01:00
'numberposts' => - 1 , 'post_type' => 'any' ,
'post_status' => 'any' , 'post_parent' => 0 ,
2007-05-11 05:10:05 +02:00
);
2007-06-14 04:25:30 +02:00
2007-05-11 05:10:05 +02:00
$r = wp_parse_args ( $args , $defaults );
2006-06-08 01:17:59 +02:00
2006-11-20 05:23:12 +01:00
$children = get_posts ( $r );
2009-09-14 16:03:32 +02:00
2009-07-31 11:31:56 +02:00
if ( ! $children )
2008-08-25 23:50:11 +02:00
return $kids ;
2007-10-12 23:12:34 +02:00
update_post_cache ( $children );
foreach ( $children as $key => $child )
2010-12-01 21:23:57 +01:00
$kids [ $child -> ID ] = $children [ $key ];
2006-06-08 01:17:59 +02:00
if ( $output == OBJECT ) {
return $kids ;
} elseif ( $output == ARRAY_A ) {
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $kids as $kid )
2006-06-08 01:17:59 +02:00
$weeuns [ $kid -> ID ] = get_object_vars ( $kids [ $kid -> ID ]);
return $weeuns ;
} elseif ( $output == ARRAY_N ) {
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $kids as $kid )
2006-06-08 01:17:59 +02:00
$babes [ $kid -> ID ] = array_values ( get_object_vars ( $kids [ $kid -> ID ]));
return $babes ;
} else {
return $kids ;
}
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Get extended entry info ( <!-- more --> ) .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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 13:50:21 +01:00
* The returned array has 'main' , 'extended' , and 'more_text' keys . Main has the text before
2008-08-19 18:38:06 +02:00
* the < code ><!-- more --></ code >. The 'extended' key has the content after the
2012-03-08 13:50:21 +01:00
* < code ><!-- more --></ code > comment . The 'more_text' key has the custom " Read More " text .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ since 1.0 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param string $post Post content .
2012-03-08 13:50:21 +01:00
* @ return array Post before ( 'main' ), after ( 'extended' ), and custom readmore ( 'more_text' ) .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function get_extended ( $post ) {
2006-08-05 06:11:51 +02:00
//Match the new style more links
2007-04-12 00:47:36 +02:00
if ( preg_match ( '/<!--more(.*?)?-->/' , $post , $matches ) ) {
2007-01-28 00:31:42 +01:00
list ( $main , $extended ) = explode ( $matches [ 0 ], $post , 2 );
2012-03-08 13:50:21 +01:00
$more_text = $matches [ 1 ];
2006-08-05 06:11:51 +02:00
} else {
$main = $post ;
$extended = '' ;
2012-03-08 13:50:21 +01:00
$more_text = '' ;
2006-08-05 06:11:51 +02:00
}
2007-02-27 16:24:54 +01:00
2006-06-08 01:17:59 +02:00
// Strip leading and trailing whitespace
2007-01-28 00:31:42 +01:00
$main = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $main );
$extended = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $extended );
2012-03-08 13:50:21 +01:00
$more_text = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $more_text );
2006-06-08 01:17:59 +02:00
2012-03-08 13:50:21 +01:00
return array ( 'main' => $main , 'extended' => $extended , 'more_text' => $more_text );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieves post data given a post ID or post object .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
* @ since 1.5 . 1
* @ uses $wpdb
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post
2007-12-14 01:28:34 +01:00
*
2012-09-04 18:29:28 +02:00
* @ param int | object $post Post ID or post object . Optional , default is the current post from the loop .
2008-08-19 18:38:06 +02:00
* @ param string $output Optional , default is Object . Either OBJECT , ARRAY_A , or ARRAY_N .
2008-12-09 19:03:31 +01:00
* @ param string $filter Optional , default is raw .
2012-08-23 22:34:41 +02:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-14 01:28:34 +01:00
*/
2012-09-04 18:29:28 +02:00
function get_post ( $post = null , $output = OBJECT , $filter = 'raw' ) {
2012-08-21 17:42:28 +02:00
if ( empty ( $post ) && isset ( $GLOBALS [ 'post' ] ) )
$post = $GLOBALS [ 'post' ];
2006-06-08 01:17:59 +02:00
2012-08-21 17:42:28 +02:00
if ( is_a ( $post , 'WP_Post' ) ) {
2011-09-30 21:06:18 +02:00
$_post = $post ;
2012-08-20 21:47:52 +02: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-08 01:17:59 +02:00
} else {
2012-08-20 21:47:52 +02:00
$_post = WP_Post :: get_instance ( $post );
}
2012-08-21 17:42:28 +02:00
if ( ! $_post )
return null ;
2012-08-20 21:47:52 +02:00
$_post = $_post -> filter ( $filter );
2012-08-21 17:42:28 +02:00
if ( $output == ARRAY_A )
return $_post -> to_array ();
elseif ( $output == ARRAY_N )
return array_values ( $_post -> to_array () );
2012-08-20 21:47:52 +02:00
return $_post ;
}
/**
* WordPress Post class .
*
* @ since 3.5 . 0
*
*/
final class WP_Post {
2012-10-19 23:53:17 +02:00
/**
*
* @ var int
*/
public $ID ;
/**
*
* @ var int
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_author = 0 ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_date = '0000-00-00 00:00:00' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_date_gmt = '0000-00-00 00:00:00' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_content = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_title = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_excerpt = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_status = 'publish' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $comment_status = 'open' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $ping_status = 'open' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_password = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_name = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $to_ping = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $pinged = '' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_modified = '0000-00-00 00:00:00' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_modified_gmt = '0000-00-00 00:00:00' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_content_filtered = '' ;
/**
*
* @ var int
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_parent = 0 ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $guid = '' ;
/**
*
* @ var int
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $menu_order = 0 ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_type = 'post' ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $post_mime_type = '' ;
/**
*
* @ var int
2012-11-02 17:13:53 +01:00
*/
2012-10-19 23:53:17 +02:00
public $comment_count = 0 ;
/**
*
* @ var string
2012-11-02 17:13:53 +01:00
*/
2012-08-20 21:47:52 +02:00
public $filter ;
public static function get_instance ( $post_id ) {
global $wpdb ;
2010-06-10 16:55:26 +02:00
$post_id = ( int ) $post_id ;
2012-11-17 16:14:48 +01:00
if ( ! $post_id )
2012-08-20 21:47:52 +02:00
return false ;
2012-11-17 16:14:48 +01:00
$_post = wp_cache_get ( $post_id , 'posts' );
if ( ! $_post ) {
2012-10-15 05:08:43 +02:00
$_post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $post_id ) );
2012-08-20 21:47:52 +02:00
2008-06-23 23:50:19 +02:00
if ( ! $_post )
2012-08-20 21:47:52 +02:00
return false ;
$_post = sanitize_post ( $_post , 'raw' );
wp_cache_add ( $_post -> ID , $_post , 'posts' );
2012-11-17 16:14:48 +01:00
} elseif ( empty ( $_post -> filter ) ) {
$_post = sanitize_post ( $_post , 'raw' );
2006-06-08 01:17:59 +02:00
}
2012-08-20 21:47:52 +02:00
return new WP_Post ( $_post );
2006-06-08 01:17:59 +02:00
}
2012-08-20 21:47:52 +02:00
public function __construct ( $post ) {
foreach ( get_object_vars ( $post ) as $key => $value )
$this -> $key = $value ;
}
2007-07-11 21:57:43 +02:00
2012-08-20 21:47:52 +02:00
public function __isset ( $key ) {
if ( 'ancestors' == $key )
return true ;
2012-08-28 21:08:28 +02: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 21:47:52 +02:00
return metadata_exists ( 'post' , $this -> ID , $key );
}
2012-08-29 15:23:54 +02:00
public function __get ( $key ) {
2012-08-28 21:08:28 +02:00
if ( 'page_template' == $key && $this -> __isset ( $key ) ) {
2012-08-29 15:42:11 +02:00
return get_post_meta ( $this -> ID , '_wp_page_template' , true );
2012-08-28 21:08:28 +02:00
}
if ( 'post_category' == $key ) {
2012-11-20 19:31:06 +01:00
if ( is_object_in_taxonomy ( $this -> post_type , 'category' ) )
$terms = get_the_terms ( $this , 'category' );
if ( empty ( $terms ) )
2012-08-29 15:42:11 +02:00
return array ();
2012-09-24 22:35:56 +02:00
return wp_list_pluck ( $terms , 'term_id' );
2012-08-28 21:08:28 +02:00
}
if ( 'tags_input' == $key ) {
2012-11-20 19:31:06 +01:00
if ( is_object_in_taxonomy ( $this -> post_type , 'post_tag' ) )
$terms = get_the_terms ( $this , 'post_tag' );
if ( empty ( $terms ) )
2012-08-29 15:42:11 +02:00
return array ();
2012-09-24 22:35:56 +02:00
return wp_list_pluck ( $terms , 'name' );
2012-08-28 21:08:28 +02:00
}
// Rest of the values need filtering
2012-08-29 15:42:11 +02:00
if ( 'ancestors' == $key )
2012-08-20 21:47:52 +02:00
$value = get_post_ancestors ( $this );
2012-08-29 15:42:11 +02:00
else
2012-08-20 21:47:52 +02:00
$value = get_post_meta ( $this -> ID , $key , true );
2012-08-29 15:42:11 +02:00
if ( $this -> filter )
2012-08-20 21:47:52 +02: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 21:08:28 +02:00
foreach ( array ( 'ancestors' , 'page_template' , 'post_category' , 'tags_input' ) as $key ) {
if ( $this -> __isset ( $key ) )
$post [ $key ] = $this -> __get ( $key );
}
2012-08-20 21:47:52 +02:00
return $post ;
2006-06-08 01:17:59 +02:00
}
}
2008-02-28 00:28:18 +01:00
/**
2008-06-27 17:32:57 +02:00
* Retrieve ancestors of a post .
2008-02-28 00:28:18 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-02-28 00:28:18 +01:00
*
2008-06-27 17:32:57 +02:00
* @ param int | object $post Post ID or post object
* @ return array Ancestor IDs or empty array if none are found .
2008-02-28 00:28:18 +01:00
*/
2012-08-20 21:47:52 +02:00
function get_post_ancestors ( $post ) {
if ( ! $post )
2012-12-27 16:48:18 +01:00
return array ();
2008-02-28 00:28:18 +01:00
2012-08-20 21:47:52 +02:00
$post = get_post ( $post );
2012-03-12 19:23:48 +01:00
2012-09-22 18:21:06 +02:00
if ( empty ( $post -> post_parent ) || $post -> post_parent == $post -> ID )
return array ();
2008-02-28 00:28:18 +01:00
2012-09-22 18:21:06 +02:00
$ancestors = array ();
2012-08-20 21:47:52 +02:00
2012-09-22 18:21:06 +02:00
$id = $ancestors [] = $post -> post_parent ;
2012-08-20 21:47:52 +02:00
2012-09-22 18:21:06 +02: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 21:47:52 +02:00
return $ancestors ;
2008-02-28 00:28:18 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2008-06-27 17:32:57 +02:00
* Retrieve data from a post field based on Post ID .
*
2011-10-21 19:13:26 +02:00
* Examples of the post field will be , 'post_type' , 'post_status' , 'post_content' ,
2008-06-27 17:32:57 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2008-06-27 17:32:57 +02:00
* @ uses sanitize_post_field () See for possible $context values .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ param string $field Post field name
2007-12-14 01:28:34 +01:00
* @ param id $post Post ID
2008-06-27 17:32:57 +02:00
* @ param string $context Optional . How to filter the field . Default is display .
2012-08-20 21:47:52 +02:00
* @ return bool | string False on failure or returns the value in post field
2007-12-14 01:28:34 +01:00
*/
2007-07-11 21:57:43 +02:00
function get_post_field ( $field , $post , $context = 'display' ) {
2007-07-12 18:00:51 +02:00
$post = get_post ( $post );
2007-07-11 21:57:43 +02:00
2012-08-20 21:47:52 +02:00
if ( ! $post )
2007-07-11 21:57:43 +02:00
return '' ;
if ( ! isset ( $post -> $field ) )
return '' ;
return sanitize_post_field ( $field , $post -> $field , $post -> ID , $context );
}
2007-12-14 01:28:34 +01:00
/**
2008-06-27 17:32:57 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ param int $ID Optional . Post ID .
2007-12-14 01:28:34 +01:00
* @ return bool | string False on failure or returns the mime type
*/
2006-06-08 01:17:59 +02:00
function get_post_mime_type ( $ID = '' ) {
2012-08-23 22:01:10 +02:00
$post = get_post ( $ID );
2006-06-08 01:17:59 +02:00
if ( is_object ( $post ) )
return $post -> post_mime_type ;
return false ;
}
2010-10-12 20:33:14 +02:00
/**
2010-12-20 22:59:16 +01:00
* Retrieve the format slug for a post
2010-10-12 20:33:14 +02:00
*
2010-11-16 14:16:13 +01:00
* @ since 3.1 . 0
*
2010-10-12 20:33:14 +02:00
* @ param int | object $post A post
*
2011-12-14 00:45:31 +01:00
* @ return mixed The format if successful . False if no format is set . WP_Error if errors .
2010-10-12 20:33:14 +02:00
*/
2010-11-05 10:40:36 +01:00
function get_post_format ( $post = null ) {
2010-10-12 20:33:14 +02:00
$post = get_post ( $post );
2011-02-09 18:13:28 +01:00
if ( ! post_type_supports ( $post -> post_type , 'post-formats' ) )
return false ;
2010-11-12 10:49:34 +01:00
$_format = get_the_terms ( $post -> ID , 'post_format' );
2010-10-12 20:33:14 +02:00
2010-11-12 10:49:34 +01:00
if ( empty ( $_format ) )
2010-10-12 20:33:14 +02:00
return false ;
2010-11-12 10:49:34 +01:00
$format = array_shift ( $_format );
2010-12-20 22:59:16 +01:00
return ( str_replace ( 'post-format-' , '' , $format -> slug ) );
2010-10-12 20:33:14 +02:00
}
2010-10-12 21:25:58 +02:00
/**
2010-11-16 14:16:13 +01:00
* Check if a post has a particular format
2010-10-12 21:25:58 +02:00
*
2010-10-19 09:38:42 +02:00
* @ since 3.1 . 0
2010-10-12 21:25:58 +02:00
* @ uses has_term ()
2010-10-19 09:48:22 +02:00
*
2010-10-12 21:25:58 +02:00
* @ param string $format The format to check for
* @ param object | id $post The post to check . If not supplied , defaults to the current post if used in the loop .
* @ return bool True if the post has the format , false otherwise .
*/
function has_post_format ( $format , $post = null ) {
return has_term ( 'post-format-' . sanitize_key ( $format ), 'post_format' , $post );
}
2010-10-12 20:33:14 +02:00
/**
* Assign a format to a post
*
2010-11-16 14:16:13 +01:00
* @ since 3.1 . 0
*
2010-10-12 20:33:14 +02:00
* @ param int | object $post The post for which to assign a format
2011-12-14 00:45:31 +01:00
* @ param string $format A format to assign . Use an empty string or array to remove all formats from the post .
2010-10-12 20:33:14 +02:00
* @ return mixed WP_Error on error . Array of affected term IDs on success .
*/
function set_post_format ( $post , $format ) {
$post = get_post ( $post );
if ( empty ( $post ) )
return new WP_Error ( 'invalid_post' , __ ( 'Invalid post' ));
2010-12-01 21:03:39 +01:00
if ( ! empty ( $format ) ) {
$format = sanitize_key ( $format );
2011-01-05 23:26:55 +01:00
if ( 'standard' == $format || ! in_array ( $format , array_keys ( get_post_format_slugs () ) ) )
2010-12-01 21:03:39 +01:00
$format = '' ;
else
$format = 'post-format-' . $format ;
}
2010-10-12 20:33:14 +02:00
2010-10-12 21:43:54 +02:00
return wp_set_post_terms ( $post -> ID , $format , 'post_format' );
2010-10-12 20:33:14 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-06-27 17:32:57 +02:00
* Retrieve the post status based on the Post ID .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* If the post ID is of an attachment , then the parent post status will be given
* instead .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ param int $ID Post ID
* @ return string | bool Post status or false on failure .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function get_post_status ( $ID = '' ) {
$post = get_post ( $ID );
2010-04-14 17:20:15 +02:00
if ( ! is_object ( $post ) )
return false ;
2006-06-08 01:17:59 +02:00
2011-05-23 01:25:28 +02:00
if ( 'attachment' == $post -> post_type ) {
if ( 'private' == $post -> post_status )
return 'private' ;
2010-04-14 17:20:15 +02:00
2011-05-23 01:25:28 +02: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 17:20:15 +02:00
return $post -> post_status ;
2006-06-08 01:17:59 +02:00
}
2008-01-10 22:46:25 +01:00
/**
2008-06-27 17:32:57 +02:00
* Retrieve all of the WordPress supported post statuses .
2008-01-10 22:46:25 +01:00
*
* Posts have a limited set of valid status values , this provides the
* post_status values and descriptions .
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-01-10 22:46:25 +01:00
*
2008-06-27 17:32:57 +02:00
* @ return array List of post statuses .
2008-01-10 22:46:25 +01:00
*/
2013-01-04 11:13:51 +01:00
function get_post_statuses () {
2008-01-10 22:46:25 +01:00
$status = array (
'draft' => __ ( 'Draft' ),
'pending' => __ ( 'Pending Review' ),
'private' => __ ( 'Private' ),
'publish' => __ ( 'Published' )
);
return $status ;
}
/**
2008-06-27 17:32:57 +02:00
* Retrieve all of the WordPress support page statuses .
2008-01-10 22:46:25 +01:00
*
* Pages have a limited set of valid status values , this provides the
* post_status values and descriptions .
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-01-10 22:46:25 +01:00
*
2008-06-27 17:32:57 +02:00
* @ return array List of page statuses .
2008-01-10 22:46:25 +01:00
*/
2013-01-04 11:13:51 +01:00
function get_page_statuses () {
2008-01-10 22:46:25 +01:00
$status = array (
'draft' => __ ( 'Draft' ),
'private' => __ ( 'Private' ),
'publish' => __ ( 'Published' )
);
return $status ;
}
2010-01-13 19:49:56 +01:00
/**
2012-05-05 21:04:34 +02:00
* Register a post status . Do not use before init .
2010-01-13 19:49:56 +01: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 23:45:34 +01:00
* public - Whether posts of this status should be shown in the front end of the site . Defaults to true .
2011-06-27 23:22:31 +02:00
* exclude_from_search - Whether to exclude posts with this post status from search results . Defaults to false .
2010-12-26 23:45:34 +01:00
* show_in_admin_all_list - Whether to include posts in the edit listing for their post type
2011-01-06 05:11:14 +01:00
* show_in_admin_status_list - Show in the list of statuses with post counts at the top of the edit
2010-12-26 23:45:34 +01:00
* listings , e . g . All ( 12 ) | Published ( 9 ) | My Custom Status ( 2 ) ...
2011-01-06 05:11:14 +01:00
*
2010-12-26 23:45:34 +01:00
* Arguments prefixed with an _underscore shouldn ' t be used by plugins and themes .
2010-01-13 19:49:56 +01:00
*
* @ package WordPress
* @ subpackage Post
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-01-13 19:49:56 +01: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 10:45:35 +02: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 19:49:56 +01:00
$args = wp_parse_args ( $args , $defaults );
$args = ( object ) $args ;
2010-09-20 17:28:58 +02:00
$post_status = sanitize_key ( $post_status );
2010-01-13 19:49:56 +01:00
$args -> name = $post_status ;
2010-02-16 22:13:44 +01: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 18:46:00 +01:00
if ( null === $args -> publicly_queryable )
$args -> publicly_queryable = $args -> public ;
if ( null === $args -> exclude_from_search )
2010-02-16 22:13:44 +01:00
$args -> exclude_from_search = $args -> internal ;
2010-02-06 18:46:00 +01:00
2010-02-16 22:13:44 +01: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 10:45:35 +02:00
$args -> show_in_admin_status_list = ! $args -> internal ;
2010-02-16 22:13:44 +01:00
2010-01-13 19:49:56 +01:00
if ( false === $args -> label )
$args -> label = $post_status ;
if ( false === $args -> label_count )
2010-04-28 00:36:46 +02:00
$args -> label_count = array ( $args -> label , $args -> label );
2010-01-13 19:49:56 +01:00
$wp_post_statuses [ $post_status ] = $args ;
return $args ;
}
/**
* Retrieve a post status object by name
*
* @ package WordPress
* @ subpackage Post
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-01-13 19:49:56 +01:00
* @ uses $wp_post_statuses
* @ see register_post_status
* @ see get_post_statuses
*
2010-09-07 13:21:11 +02:00
* @ param string $post_status The name of a registered post status
2010-01-13 19:49:56 +01: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 .
*
* @ package WordPress
* @ subpackage Post
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-01-13 19:49:56 +01:00
* @ uses $wp_post_statuses
* @ see register_post_status
* @ see get_post_status_object
*
2010-04-16 16:08:58 +02:00
* @ param array | string $args An array of key => value arguments to match against the post status objects .
2010-01-13 19:49:56 +01:00
* @ param string $output The type of output to return , either post status 'names' or 'objects' . 'names' is the default .
2010-05-03 22:26:11 +02:00
* @ param string $operator The logical operation to perform . 'or' means only one element
2010-04-16 16:08:58 +02:00
* from the array needs to match ; 'and' means all elements must match . The default is 'and' .
2012-05-13 09:41:47 +02:00
* @ return array A list of post status names or objects
2010-01-13 19:49:56 +01:00
*/
2010-04-16 16:08:58 +02:00
function get_post_stati ( $args = array (), $output = 'names' , $operator = 'and' ) {
2010-01-13 19:49:56 +01:00
global $wp_post_statuses ;
2010-04-16 16:08:58 +02:00
$field = ( 'names' == $output ) ? 'name' : false ;
2010-01-13 19:49:56 +01:00
2010-04-16 16:08:58 +02:00
return wp_filter_object_list ( $wp_post_statuses , $args , $operator , $field );
2010-01-13 19:49:56 +01:00
}
2010-04-10 13:42:45 +02: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 13:21:11 +02:00
* @ param string $post_type Post type name
2010-05-09 00:10:28 +02:00
* @ return bool Whether post type is hierarchical .
2010-04-10 13:42:45 +02:00
*/
2010-05-09 00:10:28 +02:00
function is_post_type_hierarchical ( $post_type ) {
2010-06-11 17:53:41 +02:00
if ( ! post_type_exists ( $post_type ) )
2010-05-09 00:10:28 +02:00
return false ;
2010-04-10 13:54:33 +02:00
2010-05-09 00:10:28 +02:00
$post_type = get_post_type_object ( $post_type );
return $post_type -> hierarchical ;
2010-04-10 13:42:45 +02:00
}
2010-04-18 19:40:50 +02:00
/**
2010-05-09 00:10:28 +02:00
* Checks if a post type is registered .
2010-04-18 19:40:50 +02:00
*
* @ since 3.0 . 0
2010-06-11 17:53:41 +02:00
* @ uses get_post_type_object ()
2010-04-18 19:40:50 +02:00
*
2010-09-07 13:21:11 +02:00
* @ param string $post_type Post type name
2010-05-09 00:10:28 +02:00
* @ return bool Whether post type is registered .
2010-04-18 19:40:50 +02:00
*/
2010-06-11 17:53:41 +02:00
function post_type_exists ( $post_type ) {
2010-05-09 00:10:28 +02:00
return ( bool ) get_post_type_object ( $post_type );
2010-04-18 19:40:50 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the post type of the current post or of a given post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2010-04-11 13:10:54 +02:00
* @ uses $post The Loop current post global
2007-12-14 01:28:34 +01:00
*
2012-09-04 18:29:28 +02:00
* @ param mixed $post Optional . Post object or post ID .
2008-08-19 18:38:06 +02:00
* @ return bool | string post type or false on failure .
2007-12-14 01:28:34 +01:00
*/
2012-09-04 18:29:28 +02:00
function get_post_type ( $post = null ) {
if ( $post = get_post ( $post ) )
return $post -> post_type ;
2006-06-08 01:17:59 +02:00
return false ;
}
2010-01-04 17:58:43 +01:00
/**
* Retrieve a post type object by name
*
* @ package WordPress
* @ subpackage Post
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-01-04 17:58:43 +01: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 16:43:05 +02:00
/**
* Get a list of all registered post type objects .
*
* @ package WordPress
* @ subpackage Post
* @ since 2.9 . 0
* @ uses $wp_post_types
* @ see register_post_type
*
2010-04-16 16:08:58 +02:00
* @ param array | string $args An array of key => value arguments to match against the post type objects .
2009-10-06 16:43:05 +02:00
* @ param string $output The type of output to return , either post type 'names' or 'objects' . 'names' is the default .
2010-05-03 22:26:11 +02:00
* @ param string $operator The logical operation to perform . 'or' means only one element
2010-04-16 16:08:58 +02:00
* from the array needs to match ; 'and' means all elements must match . The default is 'and' .
2009-10-06 16:43:05 +02:00
* @ return array A list of post type names or objects
*/
2010-04-16 16:08:58 +02:00
function get_post_types ( $args = array (), $output = 'names' , $operator = 'and' ) {
2009-10-06 16:43:05 +02:00
global $wp_post_types ;
2010-04-16 16:08:58 +02:00
$field = ( 'names' == $output ) ? 'name' : false ;
2009-10-06 16:43:05 +02:00
2010-04-16 16:08:58 +02:00
return wp_filter_object_list ( $wp_post_types , $args , $operator , $field );
2009-10-06 16:43:05 +02:00
}
/**
* Register a post type . Do not use before init .
*
2010-10-23 20:03:26 +02:00
* A function for creating or modifying a post type based on the
2009-10-06 16:43:05 +02: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-14 04:13:49 +02:00
* - label - Name of the post type shown in the menu . Usually plural . If not set , labels [ 'name' ] will be used .
2012-05-07 18:25:06 +02: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 21:52:50 +02:00
* - description - A short descriptive summary of what the post type is . Defaults to blank .
2012-05-07 18:25:06 +02: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 .
* - exclude_from_search - Whether to exclude posts with this post type from front end search results .
* * If not set , the the opposite of public ' s current value is used .
* - 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_nav_menus - Makes this post type available for selection in navigation menus .
* * 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
* - 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 21:52:50 +02:00
* - menu_icon - The url to the icon to be used for this menu . Defaults to use the posts icon .
2010-11-10 15:50:14 +01:00
* - capability_type - The string to use to build the read , edit , and delete capabilities . Defaults to 'post' .
2012-05-07 18:25:06 +02: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 16:40:04 +02:00
* - map_meta_cap - Whether to use the internal default meta capability handling . Defaults to false .
2012-05-07 18:25:06 +02:00
* - hierarchical - Whether the post type is hierarchical ( e . g . page ) . Defaults to false .
* - supports - An alias for calling add_post_type_support () directly . Defaults to title and editor .
* * See { @ link add_post_type_support ()} for documentation .
2010-10-23 20:03:26 +02:00
* - register_meta_box_cb - Provide a callback function that will be called when setting up the
2011-12-14 00:45:31 +01:00
* meta boxes for the edit form . Do remove_meta_box () and add_meta_box () calls in the callback .
2010-10-23 20:03:26 +02:00
* - taxonomies - An array of taxonomy identifiers that will be registered for the post type .
2012-05-07 18:25:06 +02: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 19:01:50 +02: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 20:03:26 +02: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-15 00:26:07 +02:00
*
2009-10-06 16:43:05 +02:00
* @ since 2.9 . 0
* @ uses $wp_post_types Inserts new post type object into the list
*
2012-05-07 18:25:06 +02:00
* @ param string $post_type Post type key , must not exceed 20 characters
* @ param array | string $args See optional args description above .
2010-12-01 21:43:39 +01:00
* @ return object | WP_Error the registered post type object , or an error object
2009-10-06 16:43:05 +02:00
*/
2012-05-07 18:25:06 +02:00
function register_post_type ( $post_type , $args = array () ) {
2010-02-02 00:12:26 +01:00
global $wp_post_types , $wp_rewrite , $wp ;
2009-10-06 16:43:05 +02:00
2010-02-02 00:12:26 +01:00
if ( ! is_array ( $wp_post_types ) )
2009-10-06 16:43:05 +02:00
$wp_post_types = array ();
2010-01-04 17:58:43 +01:00
// Args prefixed with an underscore are reserved for internal use.
2010-05-11 21:52:50 +02:00
$defaults = array (
'labels' => array (), 'description' => '' , 'publicly_queryable' => null , 'exclude_from_search' => null ,
2010-11-13 09:40:38 +01:00
'capability_type' => 'post' , 'capabilities' => array (), 'map_meta_cap' => null ,
2010-10-21 16:40:04 +02:00
'_builtin' => false , '_edit_link' => 'post.php?post=%d' , 'hierarchical' => false ,
2010-10-23 20:29:22 +02:00
'public' => false , 'rewrite' => true , 'has_archive' => false , 'query_var' => true ,
'supports' => array (), 'register_meta_box_cb' => null ,
2010-05-11 21:52:50 +02:00
'taxonomies' => array (), 'show_ui' => null , 'menu_position' => null , 'menu_icon' => null ,
2012-01-23 20:12:04 +01:00
'can_export' => true ,
2011-06-11 04:20:18 +02:00
'show_in_nav_menus' => null , 'show_in_menu' => null , 'show_in_admin_bar' => null ,
2012-05-08 19:01:50 +02:00
'delete_with_user' => null ,
2010-05-11 21:52:50 +02:00
);
2009-10-06 16:43:05 +02:00
$args = wp_parse_args ( $args , $defaults );
2010-01-04 17:58:43 +01:00
$args = ( object ) $args ;
2009-10-06 16:43:05 +02:00
2010-09-20 17:28:58 +02:00
$post_type = sanitize_key ( $post_type );
2010-01-04 17:58:43 +01:00
$args -> name = $post_type ;
2010-12-01 21:43:39 +01:00
if ( strlen ( $post_type ) > 20 )
return new WP_Error ( 'post_type_too_long' , __ ( 'Post types cannot exceed 20 characters in length' ) );
2010-02-02 00:12:26 +01:00
// If not set, default to the setting for public.
if ( null === $args -> publicly_queryable )
$args -> publicly_queryable = $args -> public ;
2010-02-06 18:27:30 +01:00
// If not set, default to the setting for public.
if ( null === $args -> show_ui )
$args -> show_ui = $args -> public ;
2010-10-19 09:58:02 +02: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-11 04:20:18 +02: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 ;
2011-12-14 00:45:31 +01:00
// Whether to show this type in nav-menus.php. Defaults to the setting for public.
2010-05-13 19:29:45 +02:00
if ( null === $args -> show_in_nav_menus )
$args -> show_in_nav_menus = $args -> public ;
2010-02-02 00:12:26 +01: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 09:40:38 +01:00
// Back compat with quirky handling in version 3.0. #14122
2010-11-15 18:11:34 +01:00
if ( empty ( $args -> capabilities ) && null === $args -> map_meta_cap && in_array ( $args -> capability_type , array ( 'post' , 'page' ) ) )
2010-11-13 09:40:38 +01:00
$args -> map_meta_cap = true ;
if ( null === $args -> map_meta_cap )
$args -> map_meta_cap = false ;
2010-05-12 22:45:18 +02:00
$args -> cap = get_post_type_capabilities ( $args );
2010-05-12 23:17:38 +02:00
unset ( $args -> capabilities );
2010-01-04 17:58:43 +01:00
2010-10-23 20:03:26 +02:00
if ( is_array ( $args -> capability_type ) )
$args -> capability_type = $args -> capability_type [ 0 ];
2010-01-18 12:44:51 +01:00
if ( ! empty ( $args -> supports ) ) {
add_post_type_support ( $post_type , $args -> supports );
unset ( $args -> supports );
2012-09-13 19:02:39 +02:00
} elseif ( false !== $args -> supports ) {
2010-03-15 22:16:41 +01:00
// Add default features
add_post_type_support ( $post_type , array ( 'title' , 'editor' ));
2010-01-18 12:44:51 +01:00
}
2010-02-02 00:12:26 +01:00
if ( false !== $args -> query_var && ! empty ( $wp ) ) {
if ( true === $args -> query_var )
$args -> query_var = $post_type ;
2012-08-20 19:25:06 +02:00
else
$args -> query_var = sanitize_title_with_dashes ( $args -> query_var );
2010-02-02 00:12:26 +01:00
$wp -> add_query_var ( $args -> query_var );
}
2011-07-15 17:49:42 +02:00
if ( false !== $args -> rewrite && ( is_admin () || '' != get_option ( 'permalink_structure' ) ) ) {
2010-10-23 20:29:22 +02:00
if ( ! is_array ( $args -> rewrite ) )
2010-02-02 00:12:26 +01:00
$args -> rewrite = array ();
2011-01-14 16:42:56 +01:00
if ( empty ( $args -> rewrite [ 'slug' ] ) )
2010-02-02 00:12:26 +01:00
$args -> rewrite [ 'slug' ] = $post_type ;
2010-10-23 20:29:22 +02:00
if ( ! isset ( $args -> rewrite [ 'with_front' ] ) )
2010-02-02 00:12:26 +01:00
$args -> rewrite [ 'with_front' ] = true ;
2010-10-26 09:12:06 +02:00
if ( ! isset ( $args -> rewrite [ 'pages' ] ) )
$args -> rewrite [ 'pages' ] = true ;
2010-10-23 20:29:22 +02:00
if ( ! isset ( $args -> rewrite [ 'feeds' ] ) || ! $args -> has_archive )
$args -> rewrite [ 'feeds' ] = ( bool ) $args -> has_archive ;
2012-01-23 20:12:04 +01:00
if ( ! isset ( $args -> rewrite [ 'ep_mask' ] ) ) {
2012-01-23 20:32:39 +01:00
if ( isset ( $args -> permalink_epmask ) )
$args -> rewrite [ 'ep_mask' ] = $args -> permalink_epmask ;
2012-01-23 20:12:04 +01:00
else
$args -> rewrite [ 'ep_mask' ] = EP_PERMALINK ;
}
2010-10-14 12:39:47 +02:00
2010-03-20 03:23:52 +01:00
if ( $args -> hierarchical )
2012-02-28 21:29:33 +01:00
add_rewrite_tag ( " % $post_type % " , '(.+?)' , $args -> query_var ? " { $args -> query_var } = " : " post_type= $post_type &name= " );
2010-03-20 03:23:52 +01:00
else
2012-02-28 21:29:33 +01:00
add_rewrite_tag ( " % $post_type % " , '([^/]+)' , $args -> query_var ? " { $args -> query_var } = " : " post_type= $post_type &name= " );
2010-10-14 12:39:47 +02:00
2010-10-23 20:29:22 +02:00
if ( $args -> has_archive ) {
$archive_slug = $args -> has_archive === true ? $args -> rewrite [ 'slug' ] : $args -> has_archive ;
2011-03-09 06:40:52 +01:00
if ( $args -> rewrite [ 'with_front' ] )
$archive_slug = substr ( $wp_rewrite -> front , 1 ) . $archive_slug ;
2011-03-10 05:24:48 +01:00
else
$archive_slug = $wp_rewrite -> root . $archive_slug ;
2011-03-09 06:40:52 +01:00
2012-02-28 21:29:33 +01:00
add_rewrite_rule ( " { $archive_slug } /? $ " , " index.php?post_type= $post_type " , 'top' );
2010-10-14 12:39:47 +02:00
if ( $args -> rewrite [ 'feeds' ] && $wp_rewrite -> feeds ) {
$feeds = '(' . trim ( implode ( '|' , $wp_rewrite -> feeds ) ) . ')' ;
2012-02-28 21:29:33 +01: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 12:39:47 +02:00
}
2010-10-26 09:12:06 +02:00
if ( $args -> rewrite [ 'pages' ] )
2012-02-28 21:29:33 +01: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 12:39:47 +02:00
}
2012-02-28 21:29:33 +01:00
add_permastruct ( $post_type , " { $args -> rewrite [ 'slug' ] } /% $post_type % " , $args -> rewrite );
2010-02-02 00:12:26 +01:00
}
2010-02-03 19:54:42 +01:00
if ( $args -> register_meta_box_cb )
add_action ( 'add_meta_boxes_' . $post_type , $args -> register_meta_box_cb , 10 , 1 );
2010-05-11 21:52:50 +02:00
$args -> labels = get_post_type_labels ( $args );
$args -> label = $args -> labels -> name ;
2010-01-04 17:58:43 +01:00
$wp_post_types [ $post_type ] = $args ;
2010-04-10 14:17:19 +02:00
add_action ( 'future_' . $post_type , '_future_post_hook' , 5 , 2 );
2010-02-03 20:50:37 +01:00
foreach ( $args -> taxonomies as $taxonomy ) {
register_taxonomy_for_object_type ( $taxonomy , $post_type );
}
2011-09-30 11:53:35 +02:00
do_action ( 'registered_post_type' , $post_type , $args );
2011-10-24 21:13:23 +02:00
2010-01-04 17:58:43 +01:00
return $args ;
2009-10-06 16:43:05 +02:00
}
2010-05-12 22:45:18 +02:00
/**
* Builds an object with all post type capabilities out of a post type object
2010-05-26 04:42:15 +02:00
*
2010-10-23 20:03:26 +02: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 21:02:04 +02:00
*
2010-10-23 20:03:26 +02: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 19:42:59 +01:00
* - edit_published_posts - Controls whether published objects can be edited .
2010-10-23 20:03:26 +02: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-26 04:42:15 +02:00
*
2010-10-21 16:40:04 +02:00
* @ see map_meta_cap ()
2010-05-12 22:45:18 +02:00
* @ since 3.0 . 0
2010-10-21 16:40:04 +02:00
*
2010-10-23 20:03:26 +02:00
* @ param object $args Post type registration arguments
2010-05-12 22:45:18 +02:00
* @ return object object with all the capabilities as member variables
*/
function get_post_type_capabilities ( $args ) {
2010-10-23 20:03:26 +02: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 16:40:04 +02:00
$default_capabilities = array (
2010-10-23 20:03:26 +02: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 22:45:18 +02:00
);
2010-10-21 17:05:10 +02:00
2010-10-23 20:03:26 +02:00
// Primitive capabilities used within map_meta_cap():
2010-10-21 16:40:04 +02:00
if ( $args -> map_meta_cap ) {
$default_capabilities_for_mapping = array (
'read' => 'read' ,
2010-10-23 20:03:26 +02: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 16:40:04 +02:00
);
$default_capabilities = array_merge ( $default_capabilities , $default_capabilities_for_mapping );
}
2010-10-21 17:05:10 +02:00
2010-10-21 16:40:04 +02:00
$capabilities = array_merge ( $default_capabilities , $args -> capabilities );
2010-10-21 17:05:10 +02:00
2012-10-25 00:15:43 +02: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 17:05:10 +02:00
// Remember meta capabilities for future reference.
2010-10-21 16:40:04 +02:00
if ( $args -> map_meta_cap )
_post_type_meta_capabilities ( $capabilities );
2010-10-21 17:05:10 +02:00
2010-10-21 16:40:04 +02: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 22:45:18 +02:00
}
2010-05-11 21:52:50 +02:00
/**
* Builds an object with all post type labels out of a post type object
2010-05-26 04:42:15 +02:00
*
2010-05-11 21:52:50 +02:00
* Accepted keys of the label array in the post type object :
2011-09-05 21:08:15 +02: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 21:52:50 +02: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-14 02:34:04 +02:00
* - parent_item_colon - This string isn ' t used on non - hierarchical types . In hierarchical ones the default is Parent Page :
2011-07-26 23:31:36 +02: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-26 04:42:15 +02:00
*
2010-11-10 01:42:43 +01: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-26 04:42:15 +02:00
*
2010-05-11 21:52:50 +02:00
* @ since 3.0 . 0
* @ 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-11-01 00:21:56 +01: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-09 03:09:00 +01:00
'parent_item_colon' => array ( null , __ ( 'Parent Page:' ) ),
2011-05-11 22:09:28 +02:00
'all_items' => array ( __ ( 'All Posts' ), __ ( 'All Pages' ) )
2010-05-11 21:52:50 +02:00
);
2010-11-09 03:09:00 +01:00
$nohier_vs_hier_defaults [ 'menu_name' ] = $nohier_vs_hier_defaults [ 'name' ];
2012-10-10 15:50:42 +02:00
$labels = _get_custom_object_labels ( $post_type_object , $nohier_vs_hier_defaults );
$post_type = $post_type_object -> name ;
return apply_filters ( " post_type_labels_ { $post_type } " , $labels );
2010-05-14 02:34:04 +02:00
}
/**
* Builds an object with custom - something object ( post type , taxonomy ) labels out of a custom - something object
2010-05-26 04:42:15 +02:00
*
2010-05-14 02:34:04 +02:00
* @ access private
2010-10-19 09:58:02 +02:00
* @ since 3.0 . 0
2010-05-14 02:34:04 +02:00
*/
function _get_custom_object_labels ( $object , $nohier_vs_hier_defaults ) {
2010-05-26 04:42:15 +02:00
2010-06-10 18:07:33 +02:00
if ( isset ( $object -> label ) && empty ( $object -> labels [ 'name' ] ) )
2010-05-14 02:34:04 +02:00
$object -> labels [ 'name' ] = $object -> label ;
2010-05-26 04:42:15 +02:00
2010-06-10 18:07:33 +02:00
if ( ! isset ( $object -> labels [ 'singular_name' ] ) && isset ( $object -> labels [ 'name' ] ) )
2010-05-14 02:34:04 +02:00
$object -> labels [ 'singular_name' ] = $object -> labels [ 'name' ];
2010-05-26 04:42:15 +02:00
2011-06-11 04:20:18 +02: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-10 01:42:43 +01:00
if ( ! isset ( $object -> labels [ 'menu_name' ] ) && isset ( $object -> labels [ 'name' ] ) )
$object -> labels [ 'menu_name' ] = $object -> labels [ 'name' ];
2011-05-11 22:09:28 +02:00
if ( ! isset ( $object -> labels [ 'all_items' ] ) && isset ( $object -> labels [ 'menu_name' ] ) )
$object -> labels [ 'all_items' ] = $object -> labels [ 'menu_name' ];
2010-11-11 23:50:36 +01:00
foreach ( $nohier_vs_hier_defaults as $key => $value )
$defaults [ $key ] = $object -> hierarchical ? $value [ 1 ] : $value [ 0 ];
2010-05-14 02:34:04 +02:00
$labels = array_merge ( $defaults , $object -> labels );
2010-05-26 04:42:15 +02:00
return ( object ) $labels ;
2010-05-11 21:52:50 +02:00
}
2010-10-19 09:58:02 +02:00
/**
* Adds submenus for post types .
*
* @ access private
* @ since 3.1 . 0
2010-10-21 21:55:28 +02:00
*/
2010-10-19 09:58:02 +02: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 22:09:28 +02: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 09:58:02 +02:00
}
}
add_action ( 'admin_menu' , '_add_post_type_submenus' );
2010-01-10 02:23:14 +01:00
/**
* Register support of certain features for a post type .
2010-01-15 23:11:12 +01:00
*
2010-04-04 06:14:17 +02:00
* All features are directly associated with a functional area of the edit screen , such as the
* editor or a meta box : 'title' , 'editor' , 'comments' , 'revisions' , 'trackbacks' , 'author' ,
* 'excerpt' , 'page-attributes' , 'thumbnail' , and 'custom-fields' .
*
* Additionally , the 'revisions' feature dictates whether the post type will store revisions ,
2011-09-05 21:08:15 +02:00
* and the 'comments' feature dictates whether the comments count will show on the edit screen .
2010-04-04 06:14:17 +02:00
*
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-01-10 02:23:14 +01:00
* @ param string $post_type The post type for which to add the feature
* @ param string | array $feature the feature being added , can be an array of feature strings or a single string
*/
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 22:16:41 +01:00
/**
* Remove support for a feature from a post type .
*
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-03-15 22:16:41 +01: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 ;
if ( ! isset ( $_wp_post_type_features [ $post_type ]) )
return ;
if ( isset ( $_wp_post_type_features [ $post_type ][ $feature ]) )
unset ( $_wp_post_type_features [ $post_type ][ $feature ]);
}
2012-03-23 18:53:14 +01: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-10 02:23:14 +01:00
/**
* Checks a post type ' s support for a given feature
*
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-01-10 02:23:14 +01: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 ;
if ( ! isset ( $_wp_post_type_features [ $post_type ][ $feature ] ) )
return false ;
// If no args passed then no extra checks need be performed
if ( func_num_args () <= 2 )
return true ;
// @todo Allow pluggable arg checking
//$args = array_slice( func_get_args(), 2 );
return true ;
}
2008-01-02 21:06:00 +01:00
/**
2008-08-19 18:38:06 +02:00
* Updates the post type for the post ID .
2008-01-02 21:06:00 +01:00
*
2008-08-19 18:38:06 +02:00
* The page or post cache will be cleaned for the post ID .
2008-01-02 21:06:00 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-01-02 21:06:00 +01:00
*
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID to change post type . Not actually optional .
2009-05-06 22:49:36 +02:00
* @ param string $post_type Optional , default is post . Supported values are 'post' or 'page' to
* name a few .
2008-08-19 18:38:06 +02:00
* @ return int Amount of rows changed . Should be 1 for success and 0 for failure .
2008-01-02 21:06:00 +01: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 18:09:44 +02:00
$return = $wpdb -> update ( $wpdb -> posts , array ( 'post_type' => $post_type ), array ( 'ID' => $post_id ) );
2008-01-02 21:06:00 +01:00
2012-04-24 00:04:35 +02:00
clean_post_cache ( $post_id );
2008-01-02 21:06:00 +01:00
return $return ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve list of latest posts or posts matching criteria .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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 .
* 'orderby' - Default is 'post_date' . How to order the posts .
* '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 17:23:21 +02:00
* 'post_status' - Default is 'publish' . Post status to retrieve .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.2 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-08-19 18:38:06 +02:00
* @ uses WP_Query :: query () See for more default arguments and information .
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Template_Tags / get_posts
2007-12-14 01:28:34 +01:00
*
2009-05-06 22:49:36 +02:00
* @ param array $args Optional . Overrides defaults .
2008-08-19 18:38:06 +02:00
* @ return array List of posts .
2007-12-14 01:28:34 +01:00
*/
2008-04-14 18:23:29 +02:00
function get_posts ( $args = null ) {
2007-05-11 05:10:05 +02:00
$defaults = array (
2007-09-04 01:32:58 +02:00
'numberposts' => 5 , 'offset' => 0 ,
'category' => 0 , 'orderby' => 'post_date' ,
2010-04-18 06:54:19 +02:00
'order' => 'DESC' , 'include' => array (),
'exclude' => array (), 'meta_key' => '' ,
2007-09-04 01:32:58 +02:00
'meta_value' => '' , 'post_type' => 'post' ,
2008-11-26 19:56:46 +01:00
'suppress_filters' => true
2007-05-11 05:10:05 +02:00
);
2007-06-14 04:25:30 +02:00
2007-05-11 05:10:05 +02:00
$r = wp_parse_args ( $args , $defaults );
2008-05-05 17:46:32 +02:00
if ( empty ( $r [ 'post_status' ] ) )
$r [ 'post_status' ] = ( 'attachment' == $r [ 'post_type' ] ) ? 'inherit' : 'publish' ;
2010-10-19 19:08:32 +02:00
if ( ! empty ( $r [ 'numberposts' ]) && empty ( $r [ 'posts_per_page' ]) )
2008-05-03 22:08:32 +02:00
$r [ 'posts_per_page' ] = $r [ 'numberposts' ];
if ( ! empty ( $r [ 'category' ]) )
$r [ 'cat' ] = $r [ 'category' ];
if ( ! empty ( $r [ 'include' ]) ) {
2010-04-18 06:54:19 +02:00
$incposts = wp_parse_id_list ( $r [ 'include' ] );
2008-05-03 22:08:32 +02:00
$r [ 'posts_per_page' ] = count ( $incposts ); // only the number of posts included
$r [ 'post__in' ] = $incposts ;
} elseif ( ! empty ( $r [ 'exclude' ]) )
2010-04-18 06:54:19 +02:00
$r [ 'post__not_in' ] = wp_parse_id_list ( $r [ 'exclude' ] );
2008-05-03 22:08:32 +02:00
2010-09-07 06:46:08 +02:00
$r [ 'ignore_sticky_posts' ] = true ;
2010-08-28 13:51:02 +02:00
$r [ 'no_found_rows' ] = true ;
2008-08-05 07:48:21 +02:00
2008-05-03 22:08:32 +02:00
$get_posts = new WP_Query ;
return $get_posts -> query ( $r );
2006-06-08 04:22:16 +02:00
}
2006-06-08 01:17:59 +02:00
//
// Post meta functions
//
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Add meta data field to a post .
2007-12-14 01:28:34 +01:00
*
2011-04-28 17:24:49 +02:00
* Post meta data is called " Custom Fields " on the Administration Screen .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / add_post_meta
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
2013-02-14 23:51:06 +01:00
* @ param string $meta_key Metadata name ( expected slashed ) .
* @ param mixed $meta_value Metadata value ( expected slashed ) .
2008-08-19 18:38:06 +02:00
* @ param bool $unique Optional , default is false . Whether the same key should not be added .
* @ return bool False for failure . True for success .
2007-12-14 01:28:34 +01:00
*/
2013-02-14 23:51:06 +01:00
function add_post_meta ( $post_id , $meta_key , $meta_value , $unique = false ) {
//_deprecated_function( __FUNCTION__, '3.6', 'wp_add_post_meta() (expects unslashed data)' );
// expected slashed
$meta_key = stripslashes ( $meta_key );
$meta_value = stripslashes_deep ( $meta_value );
return wp_add_post_meta ( $post_id , $meta_key , $meta_value , $unique );
}
/**
* Add meta data field to a post .
*
* Post meta data is called " Custom Fields " on the Administration Screen .
*
* @ since 3.6 . 0
* @ link http :// codex . wordpress . org / Function_Reference / wp_add_post_meta
*
* @ param int $post_id Post ID .
* @ param string $meta_key Metadata name ( clean , slashes already stripped ) .
* @ param mixed $meta_value Metadata value ( clean , slashes already stripped ) .
* @ param bool $unique Optional , default is false . Whether the same key should not be added .
* @ return bool False for failure . True for success .
*/
function wp_add_post_meta ( $post_id , $meta_key , $meta_value , $unique = false ) {
2008-08-01 05:50:20 +02:00
// make sure meta is added to the post, not a revision
2013-02-14 23:51:06 +01:00
if ( $the_post = wp_is_post_revision ( $post_id ) )
2008-08-01 05:50:20 +02:00
$post_id = $the_post ;
2013-02-14 23:51:06 +01:00
return add_metadata ( 'post' , $post_id , $meta_key , $meta_value , $unique );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Remove metadata matching criteria from a post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / delete_post_meta
2007-12-14 01:28:34 +01:00
*
* @ param int $post_id post ID
2008-10-13 04:48:45 +02:00
* @ param string $meta_key Metadata name .
* @ param mixed $meta_value Optional . Metadata value .
2008-08-19 18:38:06 +02:00
* @ return bool False for failure . True for success .
2007-12-14 01:28:34 +01:00
*/
2008-10-13 04:48:45 +02:00
function delete_post_meta ( $post_id , $meta_key , $meta_value = '' ) {
2008-10-20 07:47:13 +02: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-13 04:36:38 +02:00
2009-09-17 22:17:33 +02:00
return delete_metadata ( 'post' , $post_id , $meta_key , $meta_value );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve post meta field for a post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_meta
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
2012-02-10 23:49:56 +01:00
* @ param string $key Optional . The meta key to retrieve . By default , returns data for all keys .
2008-08-19 18:38:06 +02:00
* @ param bool $single Whether to return a single value .
2009-05-06 22:49:36 +02:00
* @ return mixed Will be an array if $single is false . Will be value of meta data field if $single
* is true .
2007-12-14 01:28:34 +01:00
*/
2012-02-10 23:42:54 +01:00
function get_post_meta ( $post_id , $key = '' , $single = false ) {
2009-09-17 22:17:33 +02:00
return get_metadata ( 'post' , $post_id , $key , $single );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Update post meta field based on post ID .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
2010-11-16 14:16:13 +01:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / update_post_meta
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
2013-02-14 23:51:06 +01:00
* @ param string $meta_key Metadata key ( expected slashed ) .
* @ param mixed $meta_value Metadata value ( expected slashed ) .
2008-08-19 18:38:06 +02:00
* @ param mixed $prev_value Optional . Previous value to check before removing .
* @ return bool False on failure , true if success .
2007-12-14 01:28:34 +01:00
*/
2013-02-14 23:51:06 +01:00
function update_post_meta ( $post_id , $meta_key , $meta_value , $prev_value = '' ) {
//_deprecated_function( __FUNCTION__, '3.6', 'wp_update_post_meta() (expects unslashed data)' );
// expected slashed
$meta_key = stripslashes ( $meta_key );
$meta_value = stripslashes_deep ( $meta_value );
return wp_update_post_meta ( $post_id , $meta_key , $meta_value , $prev_value );
}
/**
* Update post meta field based on post ID .
*
* 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 .
*
* @ since 3.6 . 0
* @ uses $wpdb
* @ link http :// codex . wordpress . org / Function_Reference / wp_update_post_meta
*
* @ param int $post_id Post ID .
* @ param string $meta_key Metadata key ( clean , slashes already stripped ) .
* @ param mixed $meta_value Metadata value ( clean , slashes already stripped ) .
* @ param mixed $prev_value Optional . Previous value to check before removing .
* @ return bool False on failure , true if success .
*/
function wp_update_post_meta ( $post_id , $meta_key , $meta_value , $prev_value = '' ) {
2008-10-20 07:47:13 +02:00
// make sure meta is added to the post, not a revision
2013-02-14 23:51:06 +01:00
if ( $the_post = wp_is_post_revision ( $post_id ) )
2008-10-20 07:47:13 +02:00
$post_id = $the_post ;
2013-02-14 23:51:06 +01:00
return update_metadata ( 'post' , $post_id , $meta_key , $meta_value , $prev_value );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Delete everything from post meta matching meta key .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param string $post_meta_key Key to search for when deleting .
2007-12-14 01:28:34 +01:00
* @ return bool Whether the post meta key was deleted from the database
*/
2007-08-29 21:12:20 +02:00
function delete_post_meta_by_key ( $post_meta_key ) {
2011-08-03 18:48:37 +02:00
return delete_metadata ( 'post' , null , $post_meta_key , '' , true );
2007-08-29 21:12:20 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve post meta fields , based on post ID .
2007-12-14 01:28:34 +01:00
*
2012-02-10 23:00:37 +01: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.2 . 0
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_custom
2007-12-14 01:28:34 +01:00
*
2012-02-10 23:00:37 +01:00
* @ param int $post_id Post ID .
2008-08-19 18:38:06 +02:00
* @ return array
2007-12-14 01:28:34 +01:00
*/
2010-09-04 17:51:04 +02:00
function get_post_custom ( $post_id = 0 ) {
$post_id = absint ( $post_id );
if ( ! $post_id )
$post_id = get_the_ID ();
2006-10-11 11:18:54 +02:00
2012-02-10 23:42:54 +01:00
return get_post_meta ( $post_id );
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve meta field names for a post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* If there are no meta fields , then nothing ( null ) will be returned .
*
* @ since 1.2 . 0
2008-06-27 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_custom_keys
2007-12-14 01:28:34 +01:00
*
* @ param int $post_id post ID
2008-08-19 18:38:06 +02:00
* @ return array | null Either array of the keys , or null if keys could not be retrieved .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function get_post_custom_keys ( $post_id = 0 ) {
$custom = get_post_custom ( $post_id );
2006-10-24 12:52:59 +02:00
if ( ! is_array ( $custom ) )
2006-06-08 01:17:59 +02:00
return ;
if ( $keys = array_keys ( $custom ) )
return $keys ;
}
2008-06-27 17:32:57 +02:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve values for a custom post field .
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02: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 17:32:57 +02:00
* @ link http :// codex . wordpress . org / Function_Reference / get_post_custom_values
*
2008-08-19 18:38:06 +02:00
* @ param string $key Meta field key .
* @ param int $post_id Post ID
* @ return array Meta field values .
2008-06-27 17:32:57 +02:00
*/
2006-06-08 01:17:59 +02:00
function get_post_custom_values ( $key = '' , $post_id = 0 ) {
2009-03-04 23:59:16 +01:00
if ( ! $key )
return null ;
2009-03-18 03:43:45 +01:00
2006-06-08 01:17:59 +02:00
$custom = get_post_custom ( $post_id );
2008-12-26 03:59:04 +01:00
return isset ( $custom [ $key ]) ? $custom [ $key ] : null ;
2006-06-08 01:17:59 +02:00
}
2013-02-18 20:11:24 +01:00
/**
* Retrieve post format metadata for a post
*
* @ since 3.6 . 0
*
* @ param int $post_id
* @ return null
*/
function get_post_format_meta ( $post_id = 0 ) {
$values = array (
'quote' => '' ,
'quote_source' => '' ,
'image' => '' ,
'url' => '' ,
'gallery' => '' ,
'media' => '' ,
);
foreach ( $values as $key => $value )
$values [ $key ] = get_post_meta ( $post_id , '_wp_format_' . $key , true );
return $values ;
}
2008-08-05 07:48:21 +02:00
/**
2008-08-19 18:38:06 +02:00
* Check if post is sticky .
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02: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 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.7 . 0
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Optional . Post ID .
2010-02-24 21:13:23 +01:00
* @ return bool Whether post is sticky .
2008-08-05 07:48:21 +02:00
*/
2010-09-04 17:51:04 +02:00
function is_sticky ( $post_id = 0 ) {
$post_id = absint ( $post_id );
2008-08-13 20:21:52 +02:00
2010-09-04 17:51:04 +02:00
if ( ! $post_id )
$post_id = get_the_ID ();
2008-08-13 20:21:52 +02:00
2010-09-04 17:51:04 +02:00
$stickies = get_option ( 'sticky_posts' );
2008-08-05 07:48:21 +02:00
2010-09-04 17:51:04 +02:00
if ( ! is_array ( $stickies ) )
2008-08-05 07:48:21 +02:00
return false ;
2010-09-04 17:51:04 +02:00
if ( in_array ( $post_id , $stickies ) )
2008-08-05 07:48:21 +02:00
return true ;
return false ;
}
2008-06-27 17:32:57 +02:00
/**
2008-08-19 18:38:06 +02:00
* Sanitize every post field .
2008-06-27 17:32:57 +02:00
*
2009-05-12 00:10:45 +02:00
* If the context is 'raw' , then the post object or array will get minimal santization of the int fields .
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
* @ uses sanitize_post_field () Used to sanitize the fields .
2008-06-27 17:32:57 +02:00
*
2012-08-23 22:34:41 +02:00
* @ param object | WP_Post | array $post The Post Object or Array
2008-08-19 18:38:06 +02:00
* @ param string $context Optional , default is 'display' . How to sanitize post fields .
2012-08-23 22:34:41 +02:00
* @ return object | WP_Post | array The now sanitized Post Object or Array ( will be the same type as $post )
2008-06-27 17:32:57 +02:00
*/
2007-07-11 21:57:43 +02:00
function sanitize_post ( $post , $context = 'display' ) {
2008-02-22 18:43:56 +01:00
if ( is_object ( $post ) ) {
2009-10-19 23:28:44 +02:00
// Check if post already filtered for this context
if ( isset ( $post -> filter ) && $context == $post -> filter )
return $post ;
2008-08-25 23:50:11 +02:00
if ( ! isset ( $post -> ID ) )
$post -> ID = 0 ;
2008-02-13 07:49:23 +01:00
foreach ( array_keys ( get_object_vars ( $post )) as $field )
2007-07-11 21:57:43 +02:00
$post -> $field = sanitize_post_field ( $field , $post -> $field , $post -> ID , $context );
2008-12-17 00:50:39 +01:00
$post -> filter = $context ;
2008-02-22 18:43:56 +01:00
} else {
2009-10-19 23:28:44 +02:00
// Check if post already filtered for this context
if ( isset ( $post [ 'filter' ]) && $context == $post [ 'filter' ] )
return $post ;
2008-08-25 23:50:11 +02:00
if ( ! isset ( $post [ 'ID' ]) )
$post [ 'ID' ] = 0 ;
2008-02-13 07:49:23 +01:00
foreach ( array_keys ( $post ) as $field )
2007-09-04 01:32:58 +02:00
$post [ $field ] = sanitize_post_field ( $field , $post [ $field ], $post [ 'ID' ], $context );
2008-12-17 00:50:39 +01:00
$post [ 'filter' ] = $context ;
2008-02-22 18:43:56 +01:00
}
2007-07-11 21:57:43 +02:00
return $post ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Sanitize post field based on context .
2007-12-14 01:28:34 +01:00
*
2009-05-06 22:49:36 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2010-11-14 16:50:02 +01:00
* @ uses apply_filters () Calls 'edit_$field' and '{$field_no_prefix}_edit_pre' passing $value and
2009-05-06 22:49:36 +02:00
* $post_id if $context == 'edit' and field name prefix == 'post_' .
*
* @ uses apply_filters () Calls 'edit_post_$field' passing $value and $post_id if $context == 'db' .
* @ uses apply_filters () Calls 'pre_$field' passing $value if $context == 'db' and field name prefix == 'post_' .
2010-11-14 16:50:02 +01:00
* @ uses apply_filters () Calls '{$field}_pre' passing $value if $context == 'db' and field name prefix != 'post_' .
2009-05-06 22:49:36 +02:00
*
* @ uses apply_filters () Calls '$field' passing $value , $post_id and $context if $context == anything
* other than 'raw' , 'edit' and 'db' and field name prefix == 'post_' .
* @ uses apply_filters () Calls 'post_$field' passing $value if $context == anything other than 'raw' ,
* 'edit' and 'db' and field name prefix != 'post_' .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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 22:49:36 +02:00
* @ param string $context How to sanitize post fields . Looks for 'raw' , 'edit' , 'db' , 'display' ,
* 'attribute' and 'js' .
2008-08-19 18:38:06 +02:00
* @ return mixed Sanitized value .
2007-12-14 01:28:34 +01:00
*/
2007-07-11 21:57:43 +02:00
function sanitize_post_field ( $field , $value , $post_id , $context ) {
2013-01-28 05:17:05 +01:00
$int_fields = array ( 'ID' , 'post_parent' , 'menu_order' , 'post_author' , 'comment_count' );
2007-07-11 21:57:43 +02:00
if ( in_array ( $field , $int_fields ) )
$value = ( int ) $value ;
2010-02-07 22:49:00 +01: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 18:00:51 +02:00
if ( 'raw' == $context )
return $value ;
2007-07-11 21:57:43 +02: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 ) {
2010-11-14 16:50:02 +01:00
$value = apply_filters ( " edit_ { $field } " , $value , $post_id );
2007-07-11 21:57:43 +02:00
// Old school
2010-11-14 16:50:02 +01:00
$value = apply_filters ( " { $field_no_prefix } _edit_pre " , $value , $post_id );
2007-07-11 21:57:43 +02:00
} else {
2010-11-14 16:50:02 +01:00
$value = apply_filters ( " edit_post_ { $field } " , $value , $post_id );
2007-07-11 21:57:43 +02: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 21:43:53 +02:00
$value = esc_attr ( $value );
2007-07-11 21:57:43 +02:00
}
} else if ( 'db' == $context ) {
if ( $prefixed ) {
2010-11-14 16:50:02 +01:00
$value = apply_filters ( " pre_ { $field } " , $value );
$value = apply_filters ( " { $field_no_prefix } _save_pre " , $value );
2007-07-11 21:57:43 +02:00
} else {
2010-11-14 16:50:02 +01:00
$value = apply_filters ( " pre_post_ { $field } " , $value );
$value = apply_filters ( " { $field } _pre " , $value );
2007-07-11 21:57:43 +02:00
}
} else {
// Use display filters by default.
2007-08-21 00:50:04 +02:00
if ( $prefixed )
$value = apply_filters ( $field , $value , $post_id , $context );
else
2010-11-14 16:50:02 +01:00
$value = apply_filters ( " post_ { $field } " , $value , $post_id , $context );
2007-07-11 21:57:43 +02:00
}
if ( 'attribute' == $context )
2009-05-05 21:43:53 +02:00
$value = esc_attr ( $value );
2007-07-11 21:57:43 +02:00
else if ( 'js' == $context )
2009-05-09 09:27:22 +02:00
$value = esc_js ( $value );
2007-07-11 21:57:43 +02:00
return $value ;
}
2008-08-05 07:48:21 +02:00
/**
2008-08-19 18:38:06 +02:00
* Make a post sticky .
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* Sticky posts should be displayed at the top of the front page .
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.7 . 0
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
2008-08-05 07:48:21 +02: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 18:38:06 +02:00
* Unstick a post .
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* Sticky posts should be displayed at the top of the front page .
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.7 . 0
2008-08-05 07:48:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
2008-08-05 07:48:21 +02: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 07:36:14 +02:00
2008-08-05 07:48:21 +02:00
update_option ( 'sticky_posts' , $stickies );
}
2008-02-05 20:08:14 +01:00
/**
2008-06-27 17:32:57 +02:00
* Count number of posts of a post type and is user has permissions to view .
2008-02-05 20:08:14 +01:00
*
2008-06-27 17:32:57 +02: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 18:31:08 +02:00
*
2008-06-27 17:32:57 +02: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 20:08:14 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-06-14 18:31:08 +02:00
* @ link http :// codex . wordpress . org / Template_Tags / wp_count_posts
2008-02-05 20:08:14 +01:00
*
2008-06-14 18:31:08 +02: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 20:08:14 +01:00
*/
2008-02-29 22:49:49 +01:00
function wp_count_posts ( $type = 'post' , $perm = '' ) {
2008-02-05 20:08:14 +01:00
global $wpdb ;
2008-02-29 22:49:49 +01:00
$user = wp_get_current_user ();
2008-04-09 22:09:45 +02:00
$cache_key = $type ;
2008-02-29 22:49:49 +01: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 17:58:43 +01:00
$post_type_object = get_post_type_object ( $type );
2010-05-12 22:45:18 +02:00
if ( ! current_user_can ( $post_type_object -> cap -> read_private_posts ) ) {
2008-04-20 23:26:10 +02:00
$cache_key .= '_' . $perm . '_' . $user -> ID ;
2008-02-29 22:49:49 +01:00
$query .= " AND (post_status != 'private' OR ( post_author = ' $user->ID ' AND post_status = 'private' )) " ;
2008-04-09 22:09:45 +02:00
}
2008-02-29 22:49:49 +01:00
}
$query .= ' GROUP BY post_status' ;
2008-04-09 22:09:45 +02:00
$count = wp_cache_get ( $cache_key , 'counts' );
if ( false !== $count )
return $count ;
2008-02-29 22:49:49 +01:00
$count = $wpdb -> get_results ( $wpdb -> prepare ( $query , $type ), ARRAY_A );
2008-02-13 10:30:26 +01:00
2010-02-18 21:03:04 +01:00
$stats = array ();
foreach ( get_post_stati () as $state )
$stats [ $state ] = 0 ;
2010-02-20 03:01:46 +01:00
foreach ( ( array ) $count as $row )
2008-02-13 10:30:26 +01:00
$stats [ $row [ 'post_status' ]] = $row [ 'num_posts' ];
2008-04-09 22:09:45 +02:00
$stats = ( object ) $stats ;
wp_cache_set ( $cache_key , $stats , 'counts' );
return $stats ;
2008-02-05 20:08:14 +01:00
}
2008-02-19 07:13:20 +01:00
/**
2008-08-19 18:38:06 +02:00
* Count number of attachments for the mime type ( s ) .
2008-02-19 07:13:20 +01:00
*
2008-08-19 18:38:06 +02: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 07:13:20 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-02-19 07:13:20 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param string | array $mime_type Optional . Array or comma - separated list of MIME patterns .
* @ return array Number of posts for each mime type .
2008-02-19 07:13:20 +01:00
*/
function wp_count_attachments ( $mime_type = '' ) {
global $wpdb ;
$and = wp_post_mime_type_where ( $mime_type );
2009-07-30 15:39:34 +02: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 07:13:20 +01:00
2013-01-04 11:13:51 +01:00
$stats = array ();
2008-02-19 07:13:20 +01:00
foreach ( ( array ) $count as $row ) {
$stats [ $row [ 'post_mime_type' ]] = $row [ 'num_posts' ];
}
2009-07-30 15:39:34 +02:00
$stats [ 'trash' ] = $wpdb -> get_var ( " SELECT COUNT( * ) FROM $wpdb->posts WHERE post_type = 'attachment' AND post_status = 'trash' $and " );
2008-02-19 07:13:20 +01:00
return ( object ) $stats ;
}
2012-11-21 11:18:59 +01: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>' )),
);
return apply_filters ( 'post_mime_types' , $post_mime_types );
}
2008-02-19 07:13:20 +01:00
/**
2008-08-19 18:38:06 +02:00
* Check a MIME - Type against a list .
2008-02-19 07:13:20 +01:00
*
2008-08-19 18:38:06 +02: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 07:13:20 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-02-19 07:13:20 +01:00
*
2009-05-06 22:49:36 +02:00
* @ param string | array $wildcard_mime_types e . g . audio / mpeg or image ( same as image /* ) or
* flash ( same as * flash * ) .
2008-02-19 07:13:20 +01: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 07:54:15 +01:00
$patternses [ 1 ][ $type ] = " ^ $type $ " ;
2008-02-19 07:13:20 +01:00
if ( false === strpos ( $type , '/' ) ) {
2008-02-29 07:54:15 +01:00
$patternses [ 2 ][ $type ] = " ^ $type / " ;
$patternses [ 3 ][ $type ] = $type ;
2008-02-19 07:13:20 +01: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 18:38:06 +02:00
* Convert MIME types into SQL .
2008-02-19 07:13:20 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-02-19 07:13:20 +01:00
*
2010-09-07 13:21:11 +02:00
* @ param string | array $post_mime_types List of mime types or comma separated string of mime types .
2010-05-23 09:49:21 +02:00
* @ param string $table_alias Optional . Specify a table alias , if needed .
2008-08-19 18:38:06 +02:00
* @ return string The SQL AND clause for mime searching .
2008-02-19 07:13:20 +01:00
*/
2010-05-06 20:03:05 +02:00
function wp_post_mime_type_where ( $post_mime_types , $table_alias = '' ) {
2008-02-19 07:13:20 +01: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 21:27:30 +01:00
$mime_subgroup = preg_replace ( '/[^-*.+a-zA-Z0-9]/' , '' , substr ( $mime_type , $slashpos + 1 ));
2008-02-19 07:13:20 +01: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 20:03:05 +02:00
$wheres [] = empty ( $table_alias ) ? " post_mime_type LIKE ' $mime_pattern ' " : " $table_alias .post_mime_type LIKE ' $mime_pattern ' " ;
2008-02-19 07:13:20 +01:00
else
2010-05-06 20:03:05 +02:00
$wheres [] = empty ( $table_alias ) ? " post_mime_type = ' $mime_pattern ' " : " $table_alias .post_mime_type = ' $mime_pattern ' " ;
2008-02-19 07:13:20 +01:00
}
if ( ! empty ( $wheres ) )
$where = ' AND (' . join ( ' OR ' , $wheres ) . ') ' ;
return $where ;
}
2007-12-14 01:28:34 +01:00
/**
2010-04-04 14:20:19 +02:00
* Trashes or deletes a post or page .
2007-12-14 01:28:34 +01:00
*
2010-04-04 14:20:19 +02:00
* When the post and page is permanently deleted , everything that is tied to it is deleted also .
2008-08-19 18:38:06 +02:00
* This includes comments , post meta fields , and terms associated with the post .
2007-12-14 01:28:34 +01:00
*
2010-04-04 14:20:19 +02: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 17:32:57 +02:00
* @ since 1.0 . 0
2009-05-06 22:49:36 +02:00
* @ uses do_action () on 'delete_post' before deletion unless post type is 'attachment' .
* @ uses do_action () on 'deleted_post' after deletion unless post type is 'attachment' .
* @ uses wp_delete_attachment () if post type is 'attachment' .
2010-04-04 14:20:19 +02:00
* @ uses wp_trash_post () if item should be trashed .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $postid Post ID .
2010-04-04 14:20:19 +02:00
* @ param bool $force_delete Whether to bypass trash and force deletion . Defaults to false .
2009-05-06 22:49:36 +02:00
* @ return mixed False on failure
2007-12-14 01:28:34 +01:00
*/
2009-11-09 21:12:07 +01:00
function wp_delete_post ( $postid = 0 , $force_delete = false ) {
2012-02-28 21:29:33 +01:00
global $wpdb ;
2006-06-08 01:17:59 +02:00
2007-10-02 20:45:47 +02:00
if ( ! $post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d " , $postid )) )
2006-06-08 01:17:59 +02:00
return $post ;
2010-04-04 14:20:19 +02:00
if ( ! $force_delete && ( $post -> post_type == 'post' || $post -> post_type == 'page' ) && get_post_status ( $postid ) != 'trash' && EMPTY_TRASH_DAYS )
2009-11-09 21:12:07 +01:00
return wp_trash_post ( $postid );
2009-09-14 16:03:32 +02:00
2009-07-30 15:39:34 +02:00
if ( $post -> post_type == 'attachment' )
2009-11-09 21:12:07 +01:00
return wp_delete_attachment ( $postid , $force_delete );
2006-06-08 01:17:59 +02:00
2011-05-24 01:43:14 +02:00
do_action ( 'before_delete_post' , $postid );
2009-09-14 16:03:32 +02:00
2009-08-26 00:05:15 +02:00
delete_post_meta ( $postid , '_wp_trash_meta_status' );
delete_post_meta ( $postid , '_wp_trash_meta_time' );
2006-06-08 01:17:59 +02:00
2009-12-01 19:01:24 +01:00
wp_delete_object_term_relationships ( $postid , get_object_taxonomies ( $post -> post_type ));
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
$parent_data = array ( 'post_parent' => $post -> post_parent );
$parent_where = array ( 'post_parent' => $postid );
2012-01-13 19:37:46 +01: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 ) );
}
2007-11-16 18:39:15 +01:00
if ( 'page' == $post -> post_type ) {
2007-12-27 09:09:31 +01:00
// if the page is defined in option page_on_front or post_for_posts,
2007-11-16 18:39:15 +01:00
// adjust the corresponding options
if ( get_option ( 'page_on_front' ) == $postid ) {
update_option ( 'show_on_front' , 'posts' );
delete_option ( 'page_on_front' );
}
if ( get_option ( 'page_for_posts' ) == $postid ) {
delete_option ( 'page_for_posts' );
}
2009-01-15 01:47:56 +01:00
} else {
unstick_post ( $postid );
2007-11-16 18:39:15 +01:00
}
2006-06-08 01:17:59 +02:00
2011-12-14 00:45:31 +01:00
// Do raw query. wp_get_post_revisions() is filtered
2008-05-09 17:59:17 +02:00
$revision_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE post_parent = %d AND post_type = 'revision' " , $postid ) );
2011-12-14 00:45:31 +01:00
// Use wp_delete_post (via wp_delete_post_revision) again. Ensures any meta/misplaced data gets cleaned up.
2008-05-09 17:59:17 +02:00
foreach ( $revision_ids as $revision_id )
2008-05-30 00:21:36 +02:00
wp_delete_post_revision ( $revision_id );
2008-05-09 17:59:17 +02:00
2007-11-16 18:39:15 +01:00
// Point all attachments to this post up one level
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , $parent_data , $parent_where + array ( 'post_type' => 'attachment' ) );
2006-12-04 15:25:21 +01:00
2009-11-04 18:39:53 +01:00
$comment_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d " , $postid ));
2012-04-11 22:02:39 +02:00
foreach ( $comment_ids as $comment_id )
wp_delete_comment ( $comment_id , true );
2006-06-08 01:17:59 +02:00
2009-11-04 18:39:53 +01:00
$post_meta_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d " , $postid ));
2012-04-11 22:02:39 +02:00
foreach ( $post_meta_ids as $mid )
delete_metadata_by_mid ( 'post' , $mid );
2006-06-08 01:17:59 +02:00
2009-11-19 18:55:23 +01:00
do_action ( 'delete_post' , $postid );
2012-03-24 16:24:31 +01:00
$wpdb -> delete ( $wpdb -> posts , array ( 'ID' => $postid ) );
2009-11-19 18:55:23 +01:00
do_action ( 'deleted_post' , $postid );
2009-03-31 21:16:53 +02:00
2012-04-24 00:04:35 +02:00
clean_post_cache ( $post );
2006-06-08 01:17:59 +02:00
2012-09-22 17:55:02 +02:00
if ( is_post_type_hierarchical ( $post -> post_type ) && $children ) {
foreach ( $children as $child )
2012-04-24 00:04:35 +02:00
clean_post_cache ( $child );
2012-01-13 19:37:46 +01:00
}
2009-12-24 12:24:32 +01:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $postid ) );
2009-05-25 01:47:49 +02:00
2011-05-24 01:43:14 +02:00
do_action ( 'after_delete_post' , $postid );
2009-04-01 18:10:14 +02:00
2006-06-08 01:17:59 +02:00
return $post ;
}
2009-07-30 15:39:34 +02:00
/**
* Moves a post or page to the Trash
*
2010-04-04 14:20:19 +02:00
* If trash is disabled , the post or page is permanently deleted .
*
2009-07-30 15:39:34 +02:00
* @ since 2.9 . 0
* @ uses do_action () on 'trash_post' before trashing
* @ uses do_action () on 'trashed_post' after trashing
2010-04-04 14:20:19 +02:00
* @ uses wp_delete_post () if trash is disabled
2009-07-30 15:39:34 +02:00
*
2010-09-07 13:21:11 +02:00
* @ param int $post_id Post ID .
2009-07-30 15:39:34 +02:00
* @ return mixed False on failure
*/
2009-08-26 00:05:15 +02:00
function wp_trash_post ( $post_id = 0 ) {
2010-04-04 14:20:19 +02:00
if ( ! EMPTY_TRASH_DAYS )
return wp_delete_post ( $post_id , true );
2009-07-30 15:39:34 +02:00
2012-08-28 21:08:28 +02:00
if ( ! $post = get_post ( $post_id , ARRAY_A ) )
2009-07-30 15:39:34 +02:00
return $post ;
2009-10-30 08:09:55 +01:00
if ( $post [ 'post_status' ] == 'trash' )
return false ;
2011-10-14 20:39:31 +02:00
do_action ( 'wp_trash_post' , $post_id );
2009-07-30 15:39:34 +02:00
2013-02-14 23:51:06 +01:00
wp_add_post_meta ( $post_id , '_wp_trash_meta_status' , $post [ 'post_status' ]);
wp_add_post_meta ( $post_id , '_wp_trash_meta_time' , time ());
2009-07-30 15:39:34 +02:00
$post [ 'post_status' ] = 'trash' ;
wp_insert_post ( $post );
2009-11-05 22:03:09 +01:00
wp_trash_post_comments ( $post_id );
2009-08-26 00:05:15 +02:00
do_action ( 'trashed_post' , $post_id );
2009-07-30 15:39:34 +02:00
return $post ;
}
/**
2009-07-30 16:55:07 +02:00
* Restores a post or page from the Trash
2009-07-30 15:39:34 +02:00
*
* @ since 2.9 . 0
* @ uses do_action () on 'untrash_post' before undeletion
* @ uses do_action () on 'untrashed_post' after undeletion
*
2010-09-07 13:21:11 +02:00
* @ param int $post_id Post ID .
2009-07-30 15:39:34 +02:00
* @ return mixed False on failure
*/
2009-08-26 00:05:15 +02:00
function wp_untrash_post ( $post_id = 0 ) {
2012-08-28 21:08:28 +02:00
if ( ! $post = get_post ( $post_id , ARRAY_A ) )
2009-07-30 15:39:34 +02:00
return $post ;
2009-10-30 08:09:55 +01:00
if ( $post [ 'post_status' ] != 'trash' )
return false ;
2009-08-26 00:05:15 +02:00
do_action ( 'untrash_post' , $post_id );
2009-07-30 16:55:07 +02:00
2009-08-26 06:57:29 +02:00
$post_status = get_post_meta ( $post_id , '_wp_trash_meta_status' , true );
2009-07-30 16:55:07 +02:00
2009-08-26 06:57:29 +02: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 16:55:07 +02:00
2009-07-30 15:39:34 +02:00
wp_insert_post ( $post );
2009-07-30 16:55:07 +02:00
2009-11-05 22:03:09 +01:00
wp_untrash_post_comments ( $post_id );
2009-08-26 00:05:15 +02:00
do_action ( 'untrashed_post' , $post_id );
2009-07-30 15:39:34 +02:00
return $post ;
}
2009-11-05 22:03:09 +01:00
/**
* Moves comments for a post to the trash
*
* @ since 2.9 . 0
* @ uses do_action () on 'trash_post_comments' before trashing
* @ uses do_action () on 'trashed_post_comments' after trashing
*
* @ param int $post Post ID or object .
* @ 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 ;
do_action ( 'trash_post_comments' , $post_id );
$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-02-14 23:51:06 +01:00
wp_add_post_meta ( $post_id , '_wp_trash_meta_comments_status' , $statuses );
2009-11-05 22:03:09 +01: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 ) );
do_action ( 'trashed_post_comments' , $post_id , $statuses );
return $result ;
}
/**
* Restore comments for a post from the trash
*
* @ since 2.9 . 0
* @ uses do_action () on 'untrash_post_comments' before trashing
* @ uses do_action () on 'untrashed_post_comments' after trashing
*
* @ param int $post Post ID or object .
* @ 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 ;
do_action ( 'untrash_post_comments' , $post_id );
// 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.
if ( 'post-trashed' == $status )
$status = '0' ;
$comments_in = implode ( " ', ' " , $comments );
$wpdb -> query ( " UPDATE $wpdb->comments SET comment_approved = ' $status ' WHERE comment_ID IN (' " . $comments_in . " ') " );
}
clean_comment_cache ( array_keys ( $statuses ) );
delete_post_meta ( $post_id , '_wp_trash_meta_comments_status' );
do_action ( 'untrashed_post_comments' , $post_id );
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the list of categories for a post .
2007-12-14 01:28:34 +01:00
*
* Compatibility layer for themes and plugins . Also an easy layer of abstraction
* away from the complexity of the taxonomy layer .
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ uses wp_get_object_terms () Retrieves the categories . Args details can be found here .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Optional . The Post ID .
* @ param array $args Optional . Overwrite the defaults .
* @ return array
2007-12-14 01:28:34 +01:00
*/
2007-05-27 07:15:18 +02:00
function wp_get_post_categories ( $post_id = 0 , $args = array () ) {
2007-03-22 21:52:29 +01:00
$post_id = ( int ) $post_id ;
2007-05-27 07:15:18 +02:00
$defaults = array ( 'fields' => 'ids' );
$args = wp_parse_args ( $args , $defaults );
2007-06-19 02:33:44 +02:00
$cats = wp_get_object_terms ( $post_id , 'category' , $args );
2007-05-23 20:07:53 +02:00
return $cats ;
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the tags for a post .
*
* There is only one default for this function , called 'fields' and by default
2009-05-06 22:49:36 +02:00
* is set to 'all' . There are other defaults that can be overridden in
2008-08-19 18:38:06 +02:00
* { @ link wp_get_object_terms ()} .
2007-12-14 01:28:34 +01:00
*
* @ package WordPress
* @ subpackage Post
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2007-12-14 01:28:34 +01: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 18:38:06 +02:00
* @ return array List of post tags .
2007-12-14 01:28:34 +01:00
*/
2007-05-27 07:15:18 +02:00
function wp_get_post_tags ( $post_id = 0 , $args = array () ) {
2008-12-18 20:12:26 +01: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 22:49:36 +02:00
* is set to 'all' . There are other defaults that can be overridden in
2008-12-18 20:12:26 +01:00
* { @ link wp_get_object_terms ()} .
*
* @ package WordPress
* @ subpackage Post
* @ 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 20:22:54 +02:00
$post_id = ( int ) $post_id ;
2007-05-27 07:15:18 +02:00
$defaults = array ( 'fields' => 'all' );
$args = wp_parse_args ( $args , $defaults );
2007-06-14 04:25:30 +02:00
2008-12-18 20:12:26 +01:00
$tags = wp_get_object_terms ( $post_id , $taxonomy , $args );
2007-05-27 07:15:18 +02:00
2007-05-22 07:12:38 +02:00
return $tags ;
2007-04-06 20:22:54 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve number of recent posts .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ since 1.0 . 0
2010-10-26 15:50:38 +02:00
* @ uses wp_parse_args ()
* @ uses get_posts ()
2007-12-14 01:28:34 +01:00
*
2010-10-26 15:50:38 +02:00
* @ param string $deprecated Deprecated .
* @ param array $args Optional . Overrides defaults .
* @ param string $output Optional .
* @ return unknown .
2007-12-14 01:28:34 +01:00
*/
2010-10-26 15:50:38 +02:00
function wp_get_recent_posts ( $args = array (), $output = ARRAY_A ) {
2010-11-09 11:14:38 +01:00
if ( is_numeric ( $args ) ) {
2010-11-09 21:37:47 +01:00
_deprecated_argument ( __FUNCTION__ , '3.1' , __ ( 'Passing an integer number of posts is deprecated. Pass an array of arguments instead.' ) );
2010-10-26 15:50:38 +02:00
$args = array ( 'numberposts' => absint ( $args ) );
2010-11-09 11:14:38 +01:00
}
2010-11-17 19:47:34 +01:00
2010-10-26 15:50:38 +02: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 17:46:11 +02:00
2010-10-26 15:50:38 +02:00
$r = wp_parse_args ( $args , $defaults );
2006-06-08 01:17:59 +02:00
2010-10-26 15:50:38 +02:00
$results = get_posts ( $r );
2010-10-28 17:46:11 +02:00
2010-10-26 15:50:38 +02: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-08 01:17:59 +02:00
}
2010-10-26 15:50:38 +02:00
return $results ? $results : false ;
2006-06-08 01:17:59 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Insert a post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* If the $postarr parameter has 'ID' set to a value , then post will be updated .
2007-12-14 01:28:34 +01:00
*
2013-01-22 15:44:04 +01:00
* You can set the post date manually , by setting the values for 'post_date'
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* The defaults for the parameter $postarr are :
2009-05-06 22:49:36 +02:00
* 'post_status' - Default is 'draft' .
* 'post_type' - Default is 'post' .
* 'post_author' - Default is current user ID ( $user_ID ) . The ID of the user who added the post .
* 'ping_status' - Default is the value in 'default_ping_status' option .
* Whether the attachment can accept pings .
* 'post_parent' - Default is 0. 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 18:38:06 +02:00
* 'post_content_filtered' - Post content filtered .
2009-05-06 22:49:36 +02:00
* 'post_excerpt' - Post excerpt .
2008-08-19 18:38:06 +02:00
*
* @ since 1.0 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
* @ uses $user_ID
2009-05-06 22:49:36 +02:00
* @ uses do_action () Calls 'pre_post_update' on post ID if this is an update .
* @ uses do_action () Calls 'edit_post' action on post ID and post data if this is an update .
2010-09-05 04:45:39 +02:00
* @ uses do_action () Calls 'save_post' and 'wp_insert_post' on post id and post data just before returning .
* @ uses apply_filters () Calls 'wp_insert_post_data' passing $data , $postarr prior to database update or insert .
2009-05-06 22:49:36 +02:00
* @ uses wp_transition_post_status ()
*
2010-09-05 04:45:39 +02:00
* @ param array $postarr Elements that make up post to insert .
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*/
2010-09-05 04:45:39 +02:00
function wp_insert_post ( $postarr , $wp_error = false ) {
2012-02-28 21:29:33 +01:00
global $wpdb , $user_ID ;
2005-06-19 03:33:38 +02:00
2007-07-11 21:57:43 +02:00
$defaults = array ( 'post_status' => 'draft' , 'post_type' => 'post' , 'post_author' => $user_ID ,
2007-07-17 01:11:51 +02:00
'ping_status' => get_option ( 'default_ping_status' ), 'post_parent' => 0 ,
2008-01-10 22:27:08 +01:00
'menu_order' => 0 , 'to_ping' => '' , 'pinged' => '' , 'post_password' => '' ,
2010-02-06 15:49:54 +01:00
'guid' => '' , 'post_content_filtered' => '' , 'post_excerpt' => '' , 'import_id' => 0 ,
'post_content' => '' , 'post_title' => '' );
2007-07-11 21:57:43 +02:00
$postarr = wp_parse_args ( $postarr , $defaults );
2011-06-28 23:46:18 +02:00
unset ( $postarr [ 'filter' ] );
2007-07-12 18:00:51 +02:00
$postarr = sanitize_post ( $postarr , 'db' );
2005-11-23 02:35:08 +01:00
2004-05-24 03:34:57 +02:00
// export array as variables
2007-06-15 00:45:40 +02:00
extract ( $postarr , EXTR_SKIP );
2004-05-24 03:34:57 +02:00
2005-06-19 03:33:38 +02:00
// Are we updating or creating?
$update = false ;
if ( ! empty ( $ID ) ) {
$update = true ;
2007-07-12 18:00:51 +02:00
$previous_status = get_post_field ( 'post_status' , $ID );
} else {
$previous_status = 'new' ;
2005-06-19 03:33:38 +02:00
}
2011-11-15 22:19:29 +01:00
$maybe_empty = ! $post_content && ! $post_title && ! $post_excerpt && post_type_supports ( $post_type , 'editor' )
&& post_type_supports ( $post_type , 'title' ) && post_type_supports ( $post_type , 'excerpt' );
if ( apply_filters ( 'wp_insert_post_empty_content' , $maybe_empty , $postarr ) ) {
2008-05-06 01:19:27 +02:00
if ( $wp_error )
2011-11-15 22:19:29 +01:00
return new WP_Error ( 'empty_content' , __ ( 'Content, title, and excerpt are empty.' ) );
2008-05-06 01:19:27 +02:00
else
return 0 ;
}
2006-08-25 02:27:15 +02:00
2010-02-17 21:33:29 +01:00
if ( empty ( $post_type ) )
$post_type = 'post' ;
2010-05-25 16:43:39 +02:00
if ( empty ( $post_status ) )
$post_status = 'draft' ;
2010-05-04 01:35:22 +02:00
if ( ! empty ( $post_category ) )
$post_category = array_filter ( $post_category ); // Filter out empty terms
2010-02-17 21:33:29 +01:00
// Make sure we set a valid category.
2008-08-25 23:50:11 +02:00
if ( empty ( $post_category ) || 0 == count ( $post_category ) || ! is_array ( $post_category ) ) {
2010-02-17 21:33:29 +01:00
// 'post' requires at least one category.
2010-05-25 16:43:39 +02:00
if ( 'post' == $post_type && 'auto-draft' != $post_status )
2010-02-17 21:33:29 +01:00
$post_category = array ( get_option ( 'default_category' ) );
else
$post_category = array ();
2004-05-24 03:34:57 +02:00
}
2005-06-18 21:08:38 +02:00
if ( empty ( $post_author ) )
$post_author = $user_ID ;
2008-08-25 23:50:11 +02:00
$post_ID = 0 ;
2008-01-10 22:27:08 +01:00
// Get the post ID and GUID
if ( $update ) {
2007-03-23 01:59:21 +01:00
$post_ID = ( int ) $ID ;
2008-01-10 22:27:08 +01:00
$guid = get_post_field ( 'guid' , $post_ID );
2010-05-23 09:49:21 +02:00
$post_before = get_post ( $post_ID );
2008-01-10 22:27:08 +01:00
}
2008-02-05 07:47:27 +01:00
2011-04-25 16:33:27 +02:00
// Don't allow contributors to set the post slug for pending review posts
2008-10-02 06:10:54 +02:00
if ( 'pending' == $post_status && ! current_user_can ( 'publish_posts' ) )
$post_name = '' ;
2011-12-14 00:45:31 +01:00
// Create a valid post name. Drafts and pending posts are allowed to have an empty
2005-06-18 21:08:38 +02:00
// post name.
2010-03-19 22:29:21 +01:00
if ( empty ( $post_name ) ) {
2010-02-06 11:07:57 +01:00
if ( ! in_array ( $post_status , array ( 'draft' , 'pending' , 'auto-draft' ) ) )
2005-10-13 21:06:31 +02:00
$post_name = sanitize_title ( $post_title );
2009-04-23 22:21:18 +02:00
else
$post_name = '' ;
2005-06-18 21:08:38 +02:00
} else {
2011-11-24 01:20:21 +01: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 21:08:38 +02:00
}
2006-02-12 08:53:23 +01:00
2008-10-02 06:10:54 +02: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 22:19:29 +02:00
if ( empty ( $post_date ) || '0000-00-00 00:00:00' == $post_date )
$post_date = current_time ( 'mysql' );
2005-11-14 10:56:41 +01:00
2012-09-19 23:43:35 +02: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 12:46:50 +02:00
$valid_date = wp_checkdate ( $mm , $jj , $aa , $post_date );
2012-09-19 23:43:35 +02:00
if ( ! $valid_date ) {
2012-09-20 12:46:50 +02:00
if ( $wp_error )
return new WP_Error ( 'invalid_date' , __ ( 'Whoops, the provided date is invalid.' ) );
else
return 0 ;
2012-09-19 23:43:35 +02:00
}
2008-08-13 18:01:01 +02:00
if ( empty ( $post_date_gmt ) || '0000-00-00 00:00:00' == $post_date_gmt ) {
2010-02-06 11:07:57 +01:00
if ( ! in_array ( $post_status , array ( 'draft' , 'pending' , 'auto-draft' ) ) )
2005-11-14 10:56:41 +01:00
$post_date_gmt = get_gmt_from_date ( $post_date );
2008-01-04 09:46:33 +01:00
else
$post_date_gmt = '0000-00-00 00:00:00' ;
2005-11-14 10:56:41 +01:00
}
2007-02-27 16:24:54 +01:00
2008-01-22 20:35:19 +01:00
if ( $update || '0000-00-00 00:00:00' == $post_date ) {
2007-10-13 02:48:52 +02: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-14 01:12:09 +01:00
if ( 'publish' == $post_status ) {
$now = gmdate ( 'Y-m-d H:i:59' );
2009-05-14 04:00:32 +02:00
if ( mysql2date ( 'U' , $post_date_gmt , false ) > mysql2date ( 'U' , $now , false ) )
2006-02-14 01:12:09 +01:00
$post_status = 'future' ;
2010-04-10 16:00:30 +02: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-14 01:12:09 +01:00
}
2006-02-12 08:41:56 +01:00
2005-08-05 22:44:18 +02:00
if ( empty ( $comment_status ) ) {
if ( $update )
$comment_status = 'closed' ;
else
2010-05-15 06:56:56 +02:00
$comment_status = get_option ( 'default_comment_status' );
2005-08-05 22:44:18 +02:00
}
if ( empty ( $ping_status ) )
2006-08-30 23:46:31 +02:00
$ping_status = get_option ( 'default_ping_status' );
2005-06-18 21:08:38 +02:00
2005-06-19 03:33:38 +02:00
if ( isset ( $to_ping ) )
2012-01-04 20:45:13 +01:00
$to_ping = sanitize_trackback_urls ( $to_ping );
2005-06-18 21:08:38 +02:00
else
2005-06-19 03:33:38 +02:00
$to_ping = '' ;
2005-12-11 00:22:47 +01:00
if ( ! isset ( $pinged ) )
$pinged = '' ;
2005-06-18 21:08:38 +02:00
if ( isset ( $post_parent ) )
$post_parent = ( int ) $post_parent ;
else
2005-02-11 04:36:49 +01:00
$post_parent = 0 ;
2005-02-14 05:51:14 +01:00
2010-10-14 17:09:04 +02:00
// Check the post_parent to see if it will cause a hierarchy loop
$post_parent = apply_filters ( 'wp_insert_post_parent' , $post_parent , $post_ID , compact ( array_keys ( $postarr ) ), $postarr );
2008-12-08 20:29:42 +01:00
2005-06-18 21:08:38 +02:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
2008-12-06 12:10:24 +01:00
if ( ! isset ( $post_password ) || 'private' == $post_status )
2005-06-18 21:08:38 +02:00
$post_password = '' ;
2009-04-23 22:21:18 +02:00
$post_name = wp_unique_post_slug ( $post_name , $post_ID , $post_status , $post_type , $post_parent );
2005-02-14 05:51:14 +01:00
2009-03-06 01:50:19 +01: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' ) );
2008-08-21 20:31:35 +02:00
$data = apply_filters ( 'wp_insert_post_data' , $data , $postarr );
2007-10-13 04:36:38 +02:00
$where = array ( 'ID' => $post_ID );
2007-10-13 02:48:52 +02:00
2010-04-27 03:05:58 +02:00
if ( $update ) {
2013-02-14 12:36:32 +01:00
do_action ( 'pre_post_update' , $post_ID , $data );
2009-03-06 01:50:19 +01:00
if ( false === $wpdb -> update ( $wpdb -> posts , $data , $where ) ) {
2008-05-06 01:19:27 +02: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-19 03:33:38 +02:00
} else {
2008-08-25 23:50:11 +02:00
if ( isset ( $post_mime_type ) )
2013-02-14 23:51:06 +01:00
$data [ 'post_mime_type' ] = $post_mime_type ; // This isn't in the update
2008-10-08 23:42:52 +02: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-06 01:50:19 +01:00
if ( false === $wpdb -> insert ( $wpdb -> posts , $data ) ) {
2008-05-06 01:19:27 +02: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 07:36:14 +02:00
return 0 ;
2008-05-06 01:19:27 +02:00
}
2007-10-13 02:48:52 +02:00
$post_ID = ( int ) $wpdb -> insert_id ;
2007-12-27 09:09:31 +01:00
2007-11-02 01:58:15 +01:00
// use the newly generated $post_ID
2007-11-02 01:47:04 +01:00
$where = array ( 'ID' => $post_ID );
2005-10-13 21:06:31 +02:00
}
2010-02-06 11:07:57 +01:00
if ( empty ( $data [ 'post_name' ]) && ! in_array ( $data [ 'post_status' ], array ( 'draft' , 'pending' , 'auto-draft' ) ) ) {
2009-05-19 17:54:19 +02:00
$data [ 'post_name' ] = sanitize_title ( $data [ 'post_title' ], $post_ID );
$wpdb -> update ( $wpdb -> posts , array ( 'post_name' => $data [ 'post_name' ] ), $where );
2005-06-19 03:33:38 +02:00
}
2005-09-14 02:34:04 +02:00
2010-05-11 18:28:00 +02: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 20:12:26 +01:00
wp_set_post_tags ( $post_ID , $tags_input );
2010-05-04 07:48:08 +02:00
2010-05-04 01:35:22 +02:00
// new-style support for all custom taxonomies
2010-04-27 02:44:38 +02:00
if ( ! empty ( $tax_input ) ) {
foreach ( $tax_input as $taxonomy => $tags ) {
$taxonomy_obj = get_taxonomy ( $taxonomy );
2010-05-04 01:35:22 +02:00
if ( is_array ( $tags ) ) // array = hierarchical, string = non-hierarchical.
$tags = array_filter ( $tags );
2010-05-13 06:10:17 +02:00
if ( current_user_can ( $taxonomy_obj -> cap -> assign_terms ) )
2010-04-27 02:44:38 +02:00
wp_set_post_terms ( $post_ID , $tags , $taxonomy );
}
2008-12-18 20:12:26 +01:00
}
2005-09-14 02:34:04 +02:00
2008-01-10 22:27:08 +01:00
$current_guid = get_post_field ( 'guid' , $post_ID );
2004-09-05 04:03:51 +02:00
// Set GUID
2008-01-10 22:27:08 +01:00
if ( ! $update && '' == $current_guid )
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , array ( 'guid' => get_permalink ( $post_ID ) ), $where );
2005-06-18 21:08:38 +02:00
2012-09-21 20:52:15 +02:00
clean_post_cache ( $post_ID );
2007-07-12 18:00:51 +02:00
$post = get_post ( $post_ID );
2008-05-06 01:19:27 +02:00
2009-05-19 17:54:19 +02:00
if ( ! empty ( $page_template ) && 'page' == $data [ 'post_type' ] ) {
2007-07-12 18:00:51 +02:00
$post -> page_template = $page_template ;
2012-09-14 20:36:08 +02:00
$page_templates = wp_get_theme () -> get_page_templates ();
if ( 'default' != $page_template && ! isset ( $page_templates [ $page_template ] ) ) {
2008-05-06 01:19:27 +02:00
if ( $wp_error )
return new WP_Error ( 'invalid_page_template' , __ ( 'The page template is invalid.' ));
else
return 0 ;
}
2013-02-14 23:51:06 +01:00
wp_update_post_meta ( $post_ID , '_wp_page_template' , $page_template );
2008-05-06 01:19:27 +02:00
}
2006-11-19 08:56:05 +01:00
2009-05-19 17:54:19 +02:00
wp_transition_post_status ( $data [ 'post_status' ], $previous_status , $post );
2004-05-24 03:34:57 +02:00
2010-05-23 09:49:21 +02:00
if ( $update ) {
2007-07-12 18:00:51 +02:00
do_action ( 'edit_post' , $post_ID , $post );
2010-05-23 09:49:21 +02:00
$post_after = get_post ( $post_ID );
do_action ( 'post_updated' , $post_ID , $post_after , $post_before );
}
2006-08-07 06:43:38 +02:00
2007-07-12 18:00:51 +02:00
do_action ( 'save_post' , $post_ID , $post );
do_action ( 'wp_insert_post' , $post_ID , $post );
2005-09-16 19:27:09 +02:00
2005-09-16 01:34:54 +02:00
return $post_ID ;
2004-05-24 03:34:57 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Update a post with new post data .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* The date does not have to be set for drafts . You can set the date and it will
* not be overridden .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ since 1.0 . 0
2007-12-14 01:28:34 +01:00
*
2009-05-15 23:27:39 +02:00
* @ param array | object $postarr Post data . Arrays are expected to be escaped , objects are not .
2012-07-05 21:21:57 +02: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-14 01:28:34 +01:00
*/
2012-07-05 21:21:57 +02:00
function wp_update_post ( $postarr = array (), $wp_error = false ) {
2009-05-15 23:27:39 +02:00
if ( is_object ( $postarr ) ) {
// non-escaped post was passed
2006-06-08 01:17:59 +02:00
$postarr = get_object_vars ( $postarr );
2009-05-15 23:27:39 +02:00
}
2005-12-13 20:19:56 +01:00
2006-06-08 01:17:59 +02:00
// First, get all of the original fields
2012-08-28 21:08:28 +02:00
$post = get_post ( $postarr [ 'ID' ], ARRAY_A );
2005-01-07 02:21:12 +01:00
2005-07-03 20:33:03 +02:00
// Passed post category list overwrites existing category list if not empty.
2006-11-19 08:56:05 +01:00
if ( isset ( $postarr [ 'post_category' ]) && is_array ( $postarr [ 'post_category' ])
2005-07-03 20:33:03 +02:00
&& 0 != count ( $postarr [ 'post_category' ]) )
2006-11-19 08:56:05 +01:00
$post_cats = $postarr [ 'post_category' ];
else
$post_cats = $post [ 'post_category' ];
2005-01-07 02:21:12 +01:00
2005-11-14 10:56:41 +01:00
// Drafts shouldn't be assigned a date unless explicitly done so by the user
2010-07-13 23:30:09 +02:00
if ( isset ( $post [ 'post_status' ] ) && in_array ( $post [ 'post_status' ], array ( 'draft' , 'pending' , 'auto-draft' )) && empty ( $postarr [ 'edit_date' ]) &&
2008-09-17 22:19:29 +02:00
( '0000-00-00 00:00:00' == $post [ 'post_date_gmt' ]) )
2005-11-14 10:56:41 +01:00
$clear_date = true ;
else
$clear_date = false ;
2006-11-19 08:56:05 +01: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 10:56:41 +01:00
if ( $clear_date ) {
2008-10-05 06:43:52 +02:00
$postarr [ 'post_date' ] = current_time ( 'mysql' );
2005-11-14 10:56:41 +01:00
$postarr [ 'post_date_gmt' ] = '' ;
}
2010-04-27 02:44:38 +02:00
if ( $postarr [ 'post_type' ] == 'attachment' )
2005-12-13 20:19:56 +01:00
return wp_insert_attachment ( $postarr );
2012-07-05 21:21:57 +02:00
return wp_insert_post ( $postarr , $wp_error );
2004-05-24 03:34:57 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Publish a post by transitioning the post status .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2012-12-27 16:14:43 +01:00
* @ uses $wpdb
* @ uses do_action () Calls 'edit_post' , 'save_post' , and 'wp_insert_post' on post_id and post data .
2007-12-14 01:28:34 +01:00
*
2012-09-21 20:49:45 +02:00
* @ param mixed $post Post ID or object .
2007-12-14 01:28:34 +01:00
*/
2012-09-21 20:49:45 +02:00
function wp_publish_post ( $post ) {
2012-12-27 16:14:43 +01:00
global $wpdb ;
2012-09-21 20:49:45 +02:00
if ( ! $post = get_post ( $post ) )
2006-02-12 08:41:56 +01:00
return ;
2012-12-27 16:14:43 +01:00
2006-08-07 05:50:55 +02:00
if ( 'publish' == $post -> post_status )
2006-02-12 08:41:56 +01:00
return ;
2012-12-27 16:14:43 +01: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 18:00:51 +02:00
$post -> post_status = 'publish' ;
2012-12-27 16:14:43 +01:00
wp_transition_post_status ( 'publish' , $old_status , $post );
do_action ( 'edit_post' , $post -> ID , $post );
do_action ( 'save_post' , $post -> ID , $post );
do_action ( 'wp_insert_post' , $post -> ID , $post );
2006-02-12 08:41:56 +01:00
}
2008-02-22 20:59:12 +01:00
/**
2008-08-19 18:38:06 +02:00
* Publish future post and make sure post ID has future post status .
2008-03-02 21:17:30 +01:00
*
2008-08-19 18:38:06 +02:00
* Invoked by cron 'publish_future_post' event . This safeguard prevents cron
* from publishing drafts , etc .
2008-02-22 20:59:12 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.5 . 0
2008-02-22 20:59:12 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
* @ return null Nothing is returned . Which can mean that no action is required or post was published .
2008-02-22 20:59:12 +01:00
*/
function check_and_publish_future_post ( $post_id ) {
2008-03-02 21:17:30 +01:00
2008-02-22 20:59:12 +01:00
$post = get_post ( $post_id );
if ( empty ( $post ) )
return ;
if ( 'future' != $post -> post_status )
return ;
2008-10-11 07:46:20 +02:00
$time = strtotime ( $post -> post_date_gmt . ' GMT' );
if ( $time > time () ) { // Uh oh, someone jumped the gun!
2009-12-24 12:24:32 +01:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $post_id ) ); // clear anything else in the system
2008-10-11 07:46:20 +02:00
wp_schedule_single_event ( $time , 'publish_future_post' , array ( $post_id ) );
return ;
}
2008-03-02 21:17:30 +01:00
return wp_publish_post ( $post_id );
2008-02-22 20:59:12 +01:00
}
2009-04-23 22:21:18 +02:00
/**
2010-02-13 03:42:17 +01:00
* Computes a unique slug for the post , when given the desired slug and some post details .
2009-04-23 22:21:18 +02:00
*
2010-11-16 14:16:13 +01:00
* @ since 2.8 . 0
*
2010-01-15 23:11:12 +01:00
* @ global wpdb $wpdb
* @ global WP_Rewrite $wp_rewrite
2009-04-23 22:21:18 +02: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-25 01:47:49 +02:00
* @ return string unique slug for the post , based on $post_name ( with a - 1 , - 2 , etc . suffix )
2009-04-23 22:21:18 +02:00
*/
2010-02-13 03:42:17 +01:00
function wp_unique_post_slug ( $slug , $post_ID , $post_status , $post_type , $post_parent ) {
2010-02-06 11:07:57 +01:00
if ( in_array ( $post_status , array ( 'draft' , 'pending' , 'auto-draft' ) ) )
2009-05-27 18:21:53 +02:00
return $slug ;
2009-09-14 16:03:32 +02:00
2009-04-23 22:21:18 +02:00
global $wpdb , $wp_rewrite ;
2009-11-26 12:29:54 +01:00
2012-06-29 15:57:02 +02:00
$original_slug = $slug ;
2009-11-26 12:29:54 +01:00
$feeds = $wp_rewrite -> feeds ;
2010-02-13 03:42:17 +01:00
if ( ! is_array ( $feeds ) )
2009-11-26 12:29:54 +01:00
$feeds = array ();
2010-06-29 16:10:54 +02:00
$hierarchical_post_types = get_post_types ( array ( 'hierarchical' => true ) );
2009-05-27 18:21:53 +02: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-13 03:42:17 +01:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $slug , $post_ID ) );
2009-09-14 16:03:32 +02:00
2010-12-15 18:56:25 +01:00
if ( $post_name_check || in_array ( $slug , $feeds ) || apply_filters ( 'wp_unique_post_slug_is_bad_attachment_slug' , false , $slug ) ) {
2009-05-27 18:21:53 +02:00
$suffix = 2 ;
do {
2013-02-15 15:35:41 +01: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 18:21:53 +02:00
$suffix ++ ;
2010-02-13 03:42:17 +01:00
} while ( $post_name_check );
2009-05-27 18:21:53 +02:00
$slug = $alt_post_name ;
2009-04-29 21:04:27 +02:00
}
2010-02-13 03:42:17 +01:00
} elseif ( in_array ( $post_type , $hierarchical_post_types ) ) {
2012-10-15 16:13:57 +02:00
if ( 'nav_menu_item' == $post_type )
return $slug ;
2010-02-13 03:42:17 +01: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.
$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 16:03:32 +02:00
2010-12-15 18:56:25 +01: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 18:21:53 +02:00
$suffix = 2 ;
do {
2013-02-15 15:35:41 +01:00
$alt_post_name = _truncate_post_slug ( $slug , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
2010-02-13 03:42:17 +01:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $alt_post_name , $post_ID , $post_parent ) );
2009-05-27 18:21:53 +02:00
$suffix ++ ;
2010-02-13 03:42:17 +01:00
} while ( $post_name_check );
2009-05-27 18:21:53 +02: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-13 03:42:17 +01:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $slug , $post_type , $post_ID ) );
2009-09-14 16:03:32 +02:00
2010-12-15 18:56:25 +01: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 22:21:18 +02:00
$suffix = 2 ;
do {
2013-02-15 15:35:41 +01:00
$alt_post_name = _truncate_post_slug ( $slug , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
2010-02-13 03:42:17 +01:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( $check_sql , $alt_post_name , $post_type , $post_ID ) );
2009-04-23 22:21:18 +02:00
$suffix ++ ;
2010-02-13 03:42:17 +01:00
} while ( $post_name_check );
2009-04-23 22:21:18 +02:00
$slug = $alt_post_name ;
}
}
2009-05-27 18:21:53 +02:00
2012-06-29 15:57:02 +02:00
return apply_filters ( 'wp_unique_post_slug' , $slug , $post_ID , $post_status , $post_type , $post_parent , $original_slug );
2009-04-23 22:21:18 +02:00
}
2013-02-15 15:35:41 +01: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 17:32:57 +02:00
/**
2008-08-19 18:38:06 +02:00
* Adds tags to a post .
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02:00
* @ uses wp_set_post_tags () Same first two parameters , but the last parameter is always set to true .
2008-06-27 17:32:57 +02:00
*
* @ package WordPress
* @ subpackage Post
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID
* @ param string $tags The tags to set for the post , separated by commas .
2008-06-27 17:32:57 +02:00
* @ return bool | null Will return false if $post_id is not an integer or is 0. Will return null otherwise
*/
2007-04-07 21:00:19 +02:00
function wp_add_post_tags ( $post_id = 0 , $tags = '' ) {
return wp_set_post_tags ( $post_id , $tags , true );
}
2008-06-27 17:32:57 +02:00
/**
2008-08-19 18:38:06 +02:00
* Set the tags for a post .
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
* @ uses wp_set_object_terms () Sets the tags for the post .
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
* @ param string $tags The tags to set for the post , separated by commas .
2008-06-27 17:32:57 +02: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-21 02:50:01 +02:00
* @ return mixed Array of affected term IDs . WP_Error or false on failure .
2008-06-27 17:32:57 +02:00
*/
2007-04-07 21:00:19 +02:00
function wp_set_post_tags ( $post_id = 0 , $tags = '' , $append = false ) {
2008-12-18 20:12:26 +01:00
return wp_set_post_terms ( $post_id , $tags , 'post_tag' , $append );
}
2007-06-14 04:25:30 +02:00
2008-12-18 20:12:26 +01: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 19:31:43 +01:00
* @ param string $taxonomy Taxonomy name . Defaults to 'post_tag' .
2008-12-18 20:12:26 +01: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-21 02:50:01 +02:00
* @ return mixed Array of affected term IDs . WP_Error or false on failure .
2008-12-18 20:12:26 +01:00
*/
function wp_set_post_terms ( $post_id = 0 , $tags = '' , $taxonomy = 'post_tag' , $append = false ) {
2007-03-26 09:28:29 +02:00
$post_id = ( int ) $post_id ;
2007-06-14 04:25:30 +02:00
2007-03-26 09:28:29 +02:00
if ( ! $post_id )
return false ;
2007-04-11 20:04:49 +02:00
if ( empty ( $tags ) )
$tags = array ();
2008-12-18 20:12:26 +01:00
2012-02-07 19:06:12 +01: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 15:25:09 +01: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 17:54:45 +02:00
if ( is_taxonomy_hierarchical ( $taxonomy ) ) {
2012-09-24 22:35:56 +02:00
$tags = array_unique ( array_map ( 'intval' , $tags ) );
2009-12-23 15:25:09 +01:00
}
2012-11-27 20:42:38 +01:00
return wp_set_object_terms ( $post_id , $tags , $taxonomy , $append );
2007-03-26 09:28:29 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Set categories for a post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* If the post categories parameter is not set , then the default category is
* going used .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_ID Post ID .
* @ param array $post_categories Optional . List of categories .
* @ return bool | mixed
2007-12-14 01:28:34 +01:00
*/
2006-06-06 07:04:41 +02:00
function wp_set_post_categories ( $post_ID = 0 , $post_categories = array ()) {
2007-03-23 00:03:07 +01:00
$post_ID = ( int ) $post_ID ;
2010-02-17 21:33:29 +01:00
$post_type = get_post_type ( $post_ID );
2010-05-25 16:43:39 +02:00
$post_status = get_post_status ( $post_ID );
2004-05-24 03:34:57 +02:00
// If $post_categories isn't already an array, make it one:
2010-05-04 20:41:38 +02:00
if ( ! is_array ( $post_categories ) || empty ( $post_categories ) ) {
2010-05-25 16:43:39 +02:00
if ( 'post' == $post_type && 'auto-draft' != $post_status )
2010-02-17 21:33:29 +01:00
$post_categories = array ( get_option ( 'default_category' ) );
else
$post_categories = array ();
2010-05-04 20:41:38 +02:00
} else if ( 1 == count ( $post_categories ) && '' == reset ( $post_categories ) ) {
2007-06-21 00:06:29 +02:00
return true ;
2010-02-17 21:33:29 +01:00
}
2006-02-12 08:53:23 +01:00
2012-09-24 22:35:56 +02:00
return wp_set_post_terms ( $post_ID , $post_categories , 'category' );
2008-08-19 18:38:06 +02:00
}
2004-05-24 03:34:57 +02:00
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Transition the post status of a post .
2007-12-14 01:28:34 +01:00
*
2009-05-05 07:53:55 +02:00
* Calls hooks to transition post status .
*
* The first is 'transition_post_status' with new status , old status , and post data .
*
2009-05-06 22:49:36 +02: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 18:38:06 +02:00
* post data .
2007-12-14 01:28:34 +01:00
*
2009-05-06 22:49:36 +02:00
* The final action is named 'NEWSTATUS_POSTTYPE' , 'NEWSTATUS' is from the $new_status
2008-08-19 18:38:06 +02:00
* parameter and POSTTYPE is post_type post data .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2009-05-06 22:49:36 +02:00
* @ link http :// codex . wordpress . org / Post_Status_Transitions
*
* @ uses do_action () Calls 'transition_post_status' on $new_status , $old_status and
* $post if there is a status change .
2010-11-14 16:50:02 +01:00
* @ uses do_action () Calls '{$old_status}_to_{$new_status}' on $post if there is a status change .
* @ uses do_action () Calls '{$new_status}_{$post->post_type}' on post ID and $post .
2008-08-19 18:38:06 +02:00
*
* @ param string $new_status Transition to this post status .
* @ param string $old_status Previous post status .
* @ param object $post Post data .
2007-12-14 01:28:34 +01:00
*/
2007-07-12 18:00:51 +02:00
function wp_transition_post_status ( $new_status , $old_status , $post ) {
2009-05-05 07:53:55 +02:00
do_action ( 'transition_post_status' , $new_status , $old_status , $post );
2010-11-14 16:50:02 +01:00
do_action ( " { $old_status } _to_ { $new_status } " , $post );
do_action ( " { $new_status } _ { $post -> post_type } " , $post -> ID , $post );
2007-07-12 18:00:51 +02:00
}
2006-06-08 01:17:59 +02:00
//
// Trackback and ping functions
//
2004-11-27 05:47:54 +01:00
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Add a URL to those already pung .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
* @ param string $uri Ping URI .
* @ return int How many rows were updated .
2007-12-14 01:28:34 +01:00
*/
function add_ping ( $post_id , $uri ) {
2006-06-08 01:17:59 +02:00
global $wpdb ;
2007-10-02 20:45:47 +02:00
$pung = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT pinged FROM $wpdb->posts WHERE ID = %d " , $post_id ));
2006-06-08 01:17:59 +02:00
$pung = trim ( $pung );
$pung = preg_split ( '/\s/' , $pung );
$pung [] = $uri ;
$new = implode ( " \n " , $pung );
$new = apply_filters ( 'add_ping' , $new );
2007-10-02 20:45:47 +02:00
// expected_slashed ($new)
2007-10-13 04:36:38 +02:00
$new = stripslashes ( $new );
return $wpdb -> update ( $wpdb -> posts , array ( 'pinged' => $new ), array ( 'ID' => $post_id ) );
2006-06-08 01:17:59 +02:00
}
2005-12-13 20:19:56 +01:00
2008-06-27 17:32:57 +02:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve enclosures already enclosed for a post .
2008-06-27 17:32:57 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2008-06-27 17:32:57 +02:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
* @ return array List of enclosures
2008-06-27 17:32:57 +02:00
*/
function get_enclosed ( $post_id ) {
2006-06-08 01:17:59 +02:00
$custom_fields = get_post_custom ( $post_id );
$pung = array ();
if ( ! is_array ( $custom_fields ) )
return $pung ;
2005-10-14 20:06:23 +02:00
2006-06-08 01:17:59 +02:00
foreach ( $custom_fields as $key => $val ) {
if ( 'enclosure' != $key || ! is_array ( $val ) )
continue ;
foreach ( $val as $enc ) {
2012-01-09 22:20:51 +01:00
$enclosure = explode ( " \n " , $enc );
2006-06-08 01:17:59 +02:00
$pung [] = trim ( $enclosure [ 0 ] );
2005-11-15 17:31:24 +01:00
}
}
2010-11-10 17:40:49 +01:00
$pung = apply_filters ( 'get_enclosed' , $pung , $post_id );
2006-06-08 01:17:59 +02:00
return $pung ;
2004-05-24 03:34:57 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve URLs already pinged for a post .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
* @ return array
2007-12-14 01:28:34 +01:00
*/
function get_pung ( $post_id ) {
2006-06-08 01:17:59 +02:00
global $wpdb ;
2007-10-02 20:45:47 +02:00
$pung = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT pinged FROM $wpdb->posts WHERE ID = %d " , $post_id ));
2006-06-08 01:17:59 +02:00
$pung = trim ( $pung );
$pung = preg_split ( '/\s/' , $pung );
$pung = apply_filters ( 'get_pung' , $pung );
return $pung ;
2004-05-24 03:34:57 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve URLs that need to be pinged .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID
* @ return array
2007-12-14 01:28:34 +01:00
*/
function get_to_ping ( $post_id ) {
2006-06-08 01:17:59 +02:00
global $wpdb ;
2007-10-02 20:45:47 +02:00
$to_ping = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT to_ping FROM $wpdb->posts WHERE ID = %d " , $post_id ));
2012-01-04 20:45:13 +01:00
$to_ping = sanitize_trackback_urls ( $to_ping );
2006-06-08 01:17:59 +02:00
$to_ping = preg_split ( '/\s/' , $to_ping , - 1 , PREG_SPLIT_NO_EMPTY );
$to_ping = apply_filters ( 'get_to_ping' , $to_ping );
return $to_ping ;
2004-05-24 03:34:57 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Do trackbacks for a list of URLs .
2007-12-14 01:28:34 +01:00
*
2008-06-27 17:32:57 +02:00
* @ since 1.0 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param string $tb_list Comma separated list of URLs
* @ param int $post_id Post ID
2007-12-14 01:28:34 +01:00
*/
2004-05-24 03:34:57 +02:00
function trackback_url_list ( $tb_list , $post_id ) {
2008-08-19 18:38:06 +02:00
if ( ! empty ( $tb_list ) ) {
2004-05-24 03:34:57 +02:00
// get post data
2012-08-28 21:08:28 +02:00
$postdata = get_post ( $post_id , ARRAY_A );
2004-05-24 03:34:57 +02:00
// import postdata as variables
2007-06-15 00:45:40 +02:00
extract ( $postdata , EXTR_SKIP );
2006-02-12 08:53:23 +01:00
2004-05-24 03:34:57 +02:00
// form an excerpt
2008-08-19 18:38:06 +02:00
$excerpt = strip_tags ( $post_excerpt ? $post_excerpt : $post_content );
2006-02-12 08:53:23 +01:00
2004-05-24 03:34:57 +02:00
if ( strlen ( $excerpt ) > 255 ) {
2004-08-25 16:22:39 +02:00
$excerpt = substr ( $excerpt , 0 , 252 ) . '...' ;
2004-05-24 03:34:57 +02:00
}
2006-02-12 08:53:23 +01:00
2004-05-24 03:34:57 +02:00
$trackback_urls = explode ( ',' , $tb_list );
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $trackback_urls as $tb_url ) {
2008-08-19 18:38:06 +02:00
$tb_url = trim ( $tb_url );
2013-02-14 23:51:06 +01:00
trackback ( $tb_url , $post_title , $excerpt , $post_id );
2004-05-24 03:34:57 +02:00
}
2008-08-19 18:38:06 +02:00
}
2004-05-24 03:34:57 +02:00
}
2006-06-08 01:17:59 +02:00
//
// Page functions
//
2005-01-10 21:21:06 +01:00
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Get a list of page IDs .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ return array List of page IDs .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function get_all_page_ids () {
2004-10-14 09:26:41 +02:00
global $wpdb ;
2012-03-19 20:09:03 +01:00
$page_ids = wp_cache_get ( 'all_page_ids' , 'posts' );
if ( ! is_array ( $page_ids ) ) {
2006-06-08 01:17:59 +02:00
$page_ids = $wpdb -> get_col ( " SELECT ID FROM $wpdb->posts WHERE post_type = 'page' " );
2007-10-15 22:11:30 +02:00
wp_cache_add ( 'all_page_ids' , $page_ids , 'posts' );
2006-06-08 01:17:59 +02:00
}
return $page_ids ;
2004-10-14 09:26:41 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieves page data given a page ID or page object .
2007-12-14 01:28:34 +01:00
*
2012-08-23 23:15:40 +02:00
* Use get_post () instead of get_page () .
2012-08-23 22:34:41 +02:00
*
2007-12-14 01:28:34 +01:00
* @ since 1.5 . 1
2012-08-23 22:34:41 +02:00
* @ deprecated 3.5 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
* @ param string $filter How the return value should be filtered .
2012-08-23 22:34:41 +02:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-14 01:28:34 +01:00
*/
2012-08-21 17:42:28 +02:00
function get_page ( $page , $output = OBJECT , $filter = 'raw' ) {
return get_post ( $page , $output , $filter );
2005-02-12 09:58:10 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieves a page given its path .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param string $page_path Page path
2010-03-31 10:20:28 +02:00
* @ param string $output Optional . Output type . OBJECT , ARRAY_N , or ARRAY_A . Default OBJECT .
* @ param string $post_type Optional . Post type . Default page .
2012-08-23 22:34:41 +02:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-14 01:28:34 +01:00
*/
2010-03-20 03:23:52 +01:00
function get_page_by_path ( $page_path , $output = OBJECT , $post_type = 'page' ) {
2004-10-14 09:26:41 +02:00
global $wpdb ;
2011-08-12 03:55:08 +02:00
2006-06-08 01:17:59 +02:00
$page_path = rawurlencode ( urldecode ( $page_path ));
$page_path = str_replace ( '%2F' , '/' , $page_path );
$page_path = str_replace ( '%20' , ' ' , $page_path );
2011-08-12 03:55:08 +02:00
$parts = explode ( '/' , trim ( $page_path , '/' ) );
$parts = array_map ( 'esc_sql' , $parts );
2011-11-24 01:20:21 +01:00
$parts = array_map ( 'sanitize_title_for_query' , $parts );
2006-06-08 01:17:59 +02:00
2011-08-12 03:55:08 +02:00
$in_string = " ' " . implode ( " ',' " , $parts ) . " ' " ;
2011-09-08 19:17:17 +02:00
$post_type_sql = $post_type ;
$wpdb -> escape_by_ref ( $post_type_sql );
2012-09-14 19:19:25 +02:00
$pages = $wpdb -> get_results ( " SELECT ID, post_name, post_parent, post_type FROM $wpdb->posts WHERE post_name IN ( $in_string ) AND (post_type = ' $post_type_sql ' OR post_type = 'attachment') " , OBJECT_K );
2006-06-08 01:17:59 +02:00
2011-08-12 03:55:08 +02:00
$revparts = array_reverse ( $parts );
2006-06-08 01:17:59 +02:00
2011-08-12 03:55:08 +02:00
$foundid = 0 ;
2011-08-31 08:46:16 +02:00
foreach ( ( array ) $pages as $page ) {
2011-08-12 03:55:08 +02:00
if ( $page -> post_name == $revparts [ 0 ] ) {
$count = 0 ;
2011-10-28 21:32:19 +02: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-12 03:55:08 +02:00
break ;
2011-10-28 21:32:19 +02:00
$p = $parent ;
}
if ( $p -> post_parent == 0 && $count + 1 == count ( $revparts ) && $p -> post_name == $revparts [ $count ] ) {
2011-08-12 03:55:08 +02:00
$foundid = $page -> ID ;
2012-09-14 19:19:25 +02:00
if ( $page -> post_type == $post_type )
break ;
2011-08-12 03:55:08 +02:00
}
2006-06-08 01:17:59 +02:00
}
}
2011-08-12 03:55:08 +02:00
if ( $foundid )
2012-08-23 22:01:10 +02:00
return get_post ( $foundid , $output );
2011-08-12 03:55:08 +02:00
return null ;
2004-10-14 09:26:41 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve a page given its title .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param string $page_title Page title
2010-03-31 10:20:28 +02:00
* @ param string $output Optional . Output type . OBJECT , ARRAY_N , or ARRAY_A . Default OBJECT .
* @ param string $post_type Optional . Post type . Default page .
2012-08-23 22:34:41 +02:00
* @ return WP_Post | null WP_Post on success or null on failure
2007-12-14 01:28:34 +01:00
*/
2010-03-31 10:20:28 +02:00
function get_page_by_title ( $page_title , $output = OBJECT , $post_type = 'page' ) {
2006-10-26 21:55:10 +02:00
global $wpdb ;
2010-03-31 10:20:28 +02:00
$page = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE post_title = %s AND post_type= %s " , $page_title , $post_type ) );
2006-10-26 21:55:10 +02:00
if ( $page )
2012-08-23 22:01:10 +02:00
return get_post ( $page , $output );
2006-10-26 21:55:10 +02:00
2008-08-19 18:38:06 +02:00
return null ;
2006-10-26 21:55:10 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve child pages from list of pages matching page ID .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
* @ since 1.5 . 1
*
2008-08-19 18:38:06 +02:00
* @ param int $page_id Page ID .
* @ param array $pages List of pages ' objects .
* @ return array
2007-12-14 01:28:34 +01:00
*/
2012-09-10 19:00:11 +02:00
function get_page_children ( $page_id , $pages ) {
2006-06-08 01:17:59 +02:00
$page_list = array ();
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $pages as $page ) {
2006-06-08 01:17:59 +02: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 09:26:41 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Order the pages with children under parents in a flat list .
2007-12-14 01:28:34 +01:00
*
2009-09-27 00:45:52 +02:00
* It uses auxiliary structure to hold parent - children relationships and
* runs in O ( N ) complexity
2009-10-15 22:26:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
*
2010-09-07 13:21:11 +02:00
* @ param array $pages Posts array .
* @ param int $page_id Parent page ID .
2009-05-06 22:49:36 +02:00
* @ return array A list arranged by hierarchy . Children immediately follow their parents .
2007-12-14 01:28:34 +01:00
*/
2012-09-10 19:00:11 +02:00
function get_page_hierarchy ( & $pages , $page_id = 0 ) {
2009-12-23 17:03:04 +01:00
if ( empty ( $pages ) ) {
2009-12-29 22:11:18 +01:00
$result = array ();
2009-12-23 17:03:04 +01:00
return $result ;
}
2009-10-15 22:26:21 +02:00
2009-09-27 00:45:52 +02:00
$children = array ();
foreach ( ( array ) $pages as $p ) {
$parent_id = intval ( $p -> post_parent );
$children [ $parent_id ][] = $p ;
2010-09-07 13:21:11 +02:00
}
2009-10-15 22:26:21 +02:00
2010-09-07 13:21:11 +02:00
$result = array ();
_page_traverse_name ( $page_id , $children , $result );
2009-10-15 22:26:21 +02:00
2005-12-24 17:26:55 +01:00
return $result ;
}
2009-09-27 00:45:52 +02:00
/**
* function to traverse and return all the nested children post names of a root page .
2011-09-05 21:08:15 +02:00
* $children contains parent - children relations
2009-10-15 22:26:21 +02:00
*
2010-11-16 14:16:13 +01:00
* @ since 2.9 . 0
2009-09-27 00:45:52 +02:00
*/
2009-10-15 22:26:21 +02:00
function _page_traverse_name ( $page_id , & $children , & $result ){
2009-09-27 00:45:52 +02: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-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Builds URI for a page .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* Sub pages will be in the " directory " under the parent page post name .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
*
2010-05-03 22:10:26 +02:00
* @ param mixed $page Page object or page ID .
2008-08-19 18:38:06 +02:00
* @ return string Page URI .
2007-12-14 01:28:34 +01:00
*/
2010-05-03 22:10:26 +02:00
function get_page_uri ( $page ) {
2012-12-27 16:26:05 +01:00
$page = get_post ( $page );
2008-06-16 20:40:47 +02:00
$uri = $page -> post_name ;
2006-06-08 04:22:16 +02:00
2012-08-20 21:47:52 +02:00
foreach ( $page -> ancestors as $parent ) {
2012-08-23 22:01:10 +02:00
$uri = get_post ( $parent ) -> post_name . " / " . $uri ;
2006-06-08 04:22:16 +02:00
}
return $uri ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve a list of pages .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* The defaults that can be overridden are the following : 'child_of' ,
* 'sort_order' , 'sort_column' , 'post_title' , 'hierarchical' , 'exclude' ,
2009-05-10 11:00:18 +02:00
* 'include' , 'meta_key' , 'meta_value' , 'authors' , 'number' , and 'offset' .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
*
2008-08-19 18:38:06 +02:00
* @ param mixed $args Optional . Array or string of options that overrides defaults .
2007-12-14 01:28:34 +01:00
* @ return array List of pages matching defaults or $args
*/
2012-09-10 19:00:11 +02:00
function get_pages ( $args = '' ) {
2006-06-08 01:17:59 +02:00
global $wpdb ;
2007-06-14 04:25:30 +02:00
2012-08-20 18:38:43 +02:00
$pages = false ;
2007-05-11 05:10:05 +02:00
$defaults = array (
2007-09-04 01:32:58 +02:00
'child_of' => 0 , 'sort_order' => 'ASC' ,
'sort_column' => 'post_title' , 'hierarchical' => 1 ,
2010-04-18 06:54:19 +02:00
'exclude' => array (), 'include' => array (),
2007-09-04 01:32:58 +02:00
'meta_key' => '' , 'meta_value' => '' ,
2009-05-10 10:55:49 +02:00
'authors' => '' , 'parent' => - 1 , 'exclude_tree' => '' ,
2010-03-13 21:01:02 +01:00
'number' => '' , 'offset' => 0 ,
'post_type' => 'page' , 'post_status' => 'publish' ,
2007-05-11 05:10:05 +02:00
);
2007-06-14 04:25:30 +02:00
2007-05-11 05:10:05 +02:00
$r = wp_parse_args ( $args , $defaults );
2007-06-15 00:45:40 +02:00
extract ( $r , EXTR_SKIP );
2009-05-10 10:55:49 +02:00
$number = ( int ) $number ;
$offset = ( int ) $offset ;
2010-03-17 17:27:25 +01:00
2010-03-13 21:01:02 +01: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 18:38:43 +02:00
return $pages ;
2010-03-17 17:27:25 +01:00
2010-03-13 21:01:02 +01:00
// Make sure we have a valid post status
2011-05-12 05:53:46 +02:00
if ( ! is_array ( $post_status ) )
$post_status = explode ( ',' , $post_status );
if ( array_diff ( $post_status , get_post_stati () ) )
2012-08-20 18:38:43 +02:00
return $pages ;
2006-06-08 01:17:59 +02:00
2013-01-15 18:32:35 +01:00
// $args can be whatever, only use the args defined in defaults to compute the key
2008-12-05 20:19:24 +01:00
$key = md5 ( serialize ( compact ( array_keys ( $defaults )) ) );
2013-01-15 18:32:35 +01:00
$last_changed = wp_cache_get ( 'last_changed' , 'posts' );
2013-01-22 16:46:16 +01:00
if ( ! $last_changed ) {
2013-02-11 19:08:14 +01:00
$last_changed = microtime ();
2013-01-22 16:52:13 +01:00
wp_cache_set ( 'last_changed' , $last_changed , 'posts' );
2013-01-22 16:46:16 +01:00
}
2013-01-15 18:32:35 +01: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 );
$pages = apply_filters ( 'get_pages' , $pages , $r );
return $pages ;
2008-10-18 00:55:30 +02:00
}
2006-11-23 18:21:08 +01:00
2008-12-18 23:26:57 +01:00
if ( ! is_array ( $cache ) )
$cache = array ();
2006-06-08 01:17:59 +02:00
$inclusions = '' ;
if ( ! empty ( $include ) ) {
2008-10-14 02:15:59 +02:00
$child_of = 0 ; //ignore child_of, parent, exclude, meta_key, and meta_value params if using include
$parent = - 1 ;
2006-11-24 23:55:28 +01:00
$exclude = '' ;
2006-06-08 01:17:59 +02:00
$meta_key = '' ;
$meta_value = '' ;
2007-12-24 22:24:03 +01:00
$hierarchical = false ;
2010-04-18 06:54:19 +02:00
$incpages = wp_parse_id_list ( $include );
if ( ! empty ( $incpages ) ) {
2006-06-08 01:17:59 +02:00
foreach ( $incpages as $incpage ) {
if ( empty ( $inclusions ))
2007-10-02 20:45:47 +02:00
$inclusions = $wpdb -> prepare ( ' AND ( ID = %d ' , $incpage );
2006-06-08 01:17:59 +02:00
else
2007-10-02 20:45:47 +02:00
$inclusions .= $wpdb -> prepare ( ' OR ID = %d ' , $incpage );
2006-06-08 01:17:59 +02:00
}
}
}
2006-11-24 23:55:28 +01:00
if ( ! empty ( $inclusions ))
$inclusions .= ')' ;
2006-06-08 01:17:59 +02:00
$exclusions = '' ;
if ( ! empty ( $exclude ) ) {
2010-04-18 06:54:19 +02:00
$expages = wp_parse_id_list ( $exclude );
if ( ! empty ( $expages ) ) {
2006-06-08 01:17:59 +02:00
foreach ( $expages as $expage ) {
if ( empty ( $exclusions ))
2007-10-02 20:45:47 +02:00
$exclusions = $wpdb -> prepare ( ' AND ( ID <> %d ' , $expage );
2006-06-08 01:17:59 +02:00
else
2007-10-02 20:45:47 +02:00
$exclusions .= $wpdb -> prepare ( ' AND ID <> %d ' , $expage );
2006-06-08 01:17:59 +02:00
}
}
}
2007-09-04 01:32:58 +02:00
if ( ! empty ( $exclusions ))
2006-06-08 01:17:59 +02:00
$exclusions .= ')' ;
2006-09-10 19:47:49 +02:00
$author_query = '' ;
if ( ! empty ( $authors )) {
$post_authors = preg_split ( '/[\s,]+/' , $authors );
2007-02-27 16:24:54 +01:00
2010-04-18 06:54:19 +02:00
if ( ! empty ( $post_authors ) ) {
2006-09-10 19:47:49 +02: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 18:57:31 +02:00
$post_author = get_user_by ( 'login' , $post_author );
2006-09-10 19:47:49 +02:00
if ( empty ( $post_author ) )
continue ;
if ( empty ( $post_author -> ID ) )
continue ;
$post_author = $post_author -> ID ;
}
if ( '' == $author_query )
2007-10-02 20:45:47 +02:00
$author_query = $wpdb -> prepare ( ' post_author = %d ' , $post_author );
2006-09-10 19:47:49 +02:00
else
2007-10-02 20:45:47 +02:00
$author_query .= $wpdb -> prepare ( ' OR post_author = %d ' , $post_author );
2006-09-10 19:47:49 +02:00
}
if ( '' != $author_query )
$author_query = " AND ( $author_query ) " ;
}
}
2008-04-19 00:29:43 +02:00
$join = '' ;
$where = " $exclusions $inclusions " ;
2012-11-08 04:30:56 +01:00
if ( ! empty ( $meta_key ) || ! empty ( $meta_value ) ) {
2008-04-19 00:29:43 +02:00
$join = " LEFT JOIN $wpdb->postmeta ON ( $wpdb->posts .ID = $wpdb->postmeta .post_id ) " ;
2008-08-09 07:36:14 +02:00
2008-04-19 00:29:43 +02:00
if ( ! empty ( $meta_key ) )
$where .= $wpdb -> prepare ( " AND $wpdb->postmeta .meta_key = %s " , $meta_key );
2012-11-08 04:30:56 +01:00
if ( ! empty ( $meta_value ) )
2008-04-19 00:29:43 +02:00
$where .= $wpdb -> prepare ( " AND $wpdb->postmeta .meta_value = %s " , $meta_value );
}
2008-12-09 19:03:31 +01:00
if ( $parent >= 0 )
$where .= $wpdb -> prepare ( ' AND post_parent = %d ' , $parent );
2010-03-17 17:27:25 +01:00
2011-05-12 05:53:46 +02: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 19:03:31 +01:00
2011-06-27 22:47:04 +02:00
$orderby_array = array ();
2011-09-30 20:12:14 +02:00
$allowed_keys = array ( 'author' , 'post_author' , 'date' , 'post_date' , 'title' , 'post_title' , 'name' , 'post_name' , 'modified' ,
2011-06-27 22:47:04 +02: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 21:01:02 +01:00
$query = " SELECT * FROM $wpdb->posts $join WHERE ( $where_post_type ) $where " ;
2006-09-10 19:47:49 +02:00
$query .= $author_query ;
2006-06-08 01:17:59 +02:00
$query .= " ORDER BY " . $sort_column . " " . $sort_order ;
2009-05-10 10:55:49 +02:00
if ( ! empty ( $number ) )
$query .= ' LIMIT ' . $offset . ',' . $number ;
2006-06-08 01:17:59 +02:00
$pages = $wpdb -> get_results ( $query );
2008-11-15 00:01:16 +01:00
if ( empty ( $pages ) ) {
2008-11-15 19:10:35 +01:00
$pages = apply_filters ( 'get_pages' , array (), $r );
2008-11-15 00:01:16 +01:00
return $pages ;
}
2006-06-08 01:17:59 +02:00
2009-10-19 23:28:44 +02: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-08 01:17:59 +02:00
// Update cache.
2012-04-10 18:09:44 +02:00
update_post_cache ( $pages );
2006-06-08 01:17:59 +02:00
if ( $child_of || $hierarchical )
2012-10-04 20:21:47 +02:00
$pages = get_page_children ( $child_of , $pages );
2006-06-08 01:17:59 +02:00
2008-12-08 20:29:42 +01:00
if ( ! empty ( $exclude_tree ) ) {
$exclude = ( int ) $exclude_tree ;
$children = get_page_children ( $exclude , $pages );
$excludes = array ();
foreach ( $children as $child )
$excludes [] = $child -> ID ;
$excludes [] = $exclude ;
2009-11-26 06:22:09 +01:00
$num_pages = count ( $pages );
2009-10-19 23:28:44 +02:00
for ( $i = 0 ; $i < $num_pages ; $i ++ ) {
2008-12-08 20:29:42 +01:00
if ( in_array ( $pages [ $i ] -> ID , $excludes ) )
unset ( $pages [ $i ]);
}
}
2013-01-15 18:32:35 +01:00
$page_structure = array ();
foreach ( $pages as $page )
$page_structure [] = $page -> ID ;
wp_cache_set ( $cache_key , $page_structure , 'posts' );
2006-11-23 18:21:08 +01:00
2012-08-20 21:47:52 +02:00
// Convert to WP_Post instances
$pages = array_map ( 'get_post' , $pages );
2007-08-08 06:24:44 +02:00
$pages = apply_filters ( 'get_pages' , $pages , $r );
2006-06-08 01:17:59 +02:00
return $pages ;
}
//
// Attachment functions
//
2005-10-18 01:45:50 +02:00
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Check if the attachment URI is local one and is really an attachment .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
*
* @ param string $url URL to check
2008-08-19 18:38:06 +02:00
* @ return bool True on success , false on failure .
2007-12-14 01:28:34 +01:00
*/
2006-06-22 21:44:36 +02:00
function is_local_attachment ( $url ) {
2010-05-04 02:28:29 +02:00
if ( strpos ( $url , home_url ()) === false )
2006-06-22 21:44:36 +02:00
return false ;
2010-05-04 02:28:29 +02:00
if ( strpos ( $url , home_url ( '/?attachment_id=' )) !== false )
2006-06-22 21:44:36 +02:00
return true ;
if ( $id = url_to_postid ( $url ) ) {
2012-08-23 22:01:10 +02:00
$post = get_post ( $id );
2006-06-22 21:44:36 +02:00
if ( 'attachment' == $post -> post_type )
return true ;
}
return false ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02: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 22:49:36 +02: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 18:38:06 +02:00
* 'post_content_filtered' - Attachment post content filtered .
2009-05-06 22:49:36 +02:00
* 'post_excerpt' - Attachment excerpt .
2008-08-19 18:38:06 +02:00
*
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
* @ uses $user_ID
2009-05-06 22:49:36 +02:00
* @ uses do_action () Calls 'edit_attachment' on $post_ID if this is an update .
* @ uses do_action () Calls 'add_attachment' on $post_ID if this is not an update .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param string | array $object Arguments to override defaults .
* @ param string $file Optional filename .
2010-09-07 13:21:11 +02:00
* @ param int $parent Parent post ID .
2008-08-19 18:38:06 +02:00
* @ return int Attachment ID .
2007-12-14 01:28:34 +01:00
*/
2007-09-22 18:30:40 +02:00
function wp_insert_attachment ( $object , $file = false , $parent = 0 ) {
2006-06-08 01:17:59 +02:00
global $wpdb , $user_ID ;
2005-10-18 01:45:50 +02:00
2011-05-23 01:25:28 +02:00
$defaults = array ( 'post_status' => 'inherit' , 'post_type' => 'post' , 'post_author' => $user_ID ,
2007-09-12 00:27:36 +02:00
'ping_status' => get_option ( 'default_ping_status' ), 'post_parent' => 0 ,
2008-02-26 19:51:45 +01:00
'menu_order' => 0 , 'to_ping' => '' , 'pinged' => '' , 'post_password' => '' ,
2011-05-23 01:25:28 +02:00
'guid' => '' , 'post_content_filtered' => '' , 'post_excerpt' => '' , 'import_id' => 0 , 'context' => '' );
2005-11-19 21:08:21 +01:00
2007-09-12 00:27:36 +02:00
$object = wp_parse_args ( $object , $defaults );
2007-09-22 18:30:40 +02:00
if ( ! empty ( $parent ) )
$object [ 'post_parent' ] = $parent ;
2011-06-28 23:46:18 +02:00
unset ( $object [ 'filter' ] );
2007-09-12 00:27:36 +02:00
$object = sanitize_post ( $object , 'db' );
2006-02-09 11:03:48 +01:00
2007-09-12 00:27:36 +02:00
// export array as variables
extract ( $object , EXTR_SKIP );
2006-02-09 11:03:48 +01:00
2006-06-08 01:17:59 +02:00
if ( empty ( $post_author ) )
$post_author = $user_ID ;
2006-02-09 11:03:48 +01:00
2006-06-08 01:17:59 +02:00
$post_type = 'attachment' ;
2011-05-23 01:25:28 +02:00
if ( ! in_array ( $post_status , array ( 'inherit' , 'private' ) ) )
$post_status = 'inherit' ;
2010-02-23 00:12:48 +01:00
2012-09-22 00:52:54 +02:00
if ( ! empty ( $post_category ) )
$post_category = array_filter ( $post_category ); // Filter out empty terms
2010-02-22 18:19:54 +01:00
// Make sure we set a valid category.
2012-09-22 00:52:54 +02:00
if ( empty ( $post_category ) || 0 == count ( $post_category ) || ! is_array ( $post_category ) ) {
$post_category = array ();
2010-03-17 17:27:25 +01:00
}
2005-11-19 21:08:21 +01:00
2006-06-08 01:17:59 +02:00
// Are we updating or creating?
if ( ! empty ( $ID ) ) {
$update = true ;
2007-03-23 01:59:21 +01:00
$post_ID = ( int ) $ID ;
2008-11-15 00:01:16 +01:00
} else {
$update = false ;
$post_ID = 0 ;
2006-06-08 01:17:59 +02:00
}
2005-11-19 21:08:21 +01:00
2006-06-08 01:17:59 +02: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 21:08:21 +01:00
2009-05-27 18:21:53 +02:00
$post_name = wp_unique_post_slug ( $post_name , $post_ID , $post_status , $post_type , $post_parent );
2006-12-01 00:09:27 +01:00
2007-09-12 00:27:36 +02:00
if ( empty ( $post_date ) )
2006-06-08 01:17:59 +02:00
$post_date = current_time ( 'mysql' );
2007-09-12 00:27:36 +02:00
if ( empty ( $post_date_gmt ) )
2006-06-08 01:17:59 +02:00
$post_date_gmt = current_time ( 'mysql' , 1 );
2005-12-01 23:51:40 +01:00
2008-01-23 21:25:08 +01:00
if ( empty ( $post_modified ) )
2008-08-19 18:38:06 +02:00
$post_modified = $post_date ;
2008-01-23 21:25:08 +01:00
if ( empty ( $post_modified_gmt ) )
2008-08-19 18:38:06 +02:00
$post_modified_gmt = $post_date_gmt ;
2008-01-23 21:25:08 +01:00
2006-06-08 01:17:59 +02:00
if ( empty ( $comment_status ) ) {
if ( $update )
$comment_status = 'closed' ;
2006-01-02 05:33:27 +01:00
else
2006-08-30 23:46:31 +02:00
$comment_status = get_option ( 'default_comment_status' );
2006-01-02 05:33:27 +01:00
}
2006-06-08 01:17:59 +02:00
if ( empty ( $ping_status ) )
2006-08-30 23:46:31 +02:00
$ping_status = get_option ( 'default_ping_status' );
2006-01-02 05:33:27 +01:00
2006-06-08 01:17:59 +02:00
if ( isset ( $to_ping ) )
$to_ping = preg_replace ( '|\s+|' , " \n " , $to_ping );
else
$to_ping = '' ;
2006-01-02 05:33:27 +01:00
2006-06-08 01:17:59 +02:00
if ( isset ( $post_parent ) )
$post_parent = ( int ) $post_parent ;
else
$post_parent = 0 ;
2006-01-02 05:33:27 +01:00
2006-06-08 01:17:59 +02:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
2006-01-02 05:33:27 +01:00
2006-06-08 01:17:59 +02:00
if ( ! isset ( $post_password ) )
$post_password = '' ;
2005-12-05 04:17:03 +01:00
2006-06-08 01:17:59 +02:00
if ( ! isset ( $pinged ) )
$pinged = '' ;
2005-12-05 04:17:03 +01:00
2007-10-13 02:48:52 +02: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' ) );
2007-10-11 00:01:40 +02:00
2007-10-13 04:36:38 +02:00
if ( $update ) {
$wpdb -> update ( $wpdb -> posts , $data , array ( 'ID' => $post_ID ) );
2006-06-08 01:17:59 +02:00
} else {
2008-10-26 18:05:56 +01:00
// If there is a suggested ID, use it if not already present
2008-12-09 19:03:31 +01: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 18:05:56 +01:00
2007-10-13 04:36:38 +02:00
$wpdb -> insert ( $wpdb -> posts , $data );
2007-10-11 00:01:40 +02:00
$post_ID = ( int ) $wpdb -> insert_id ;
2005-12-05 04:17:03 +01:00
}
2006-06-08 01:17:59 +02:00
if ( empty ( $post_name ) ) {
$post_name = sanitize_title ( $post_title , $post_ID );
2007-11-01 17:20:16 +01:00
$wpdb -> update ( $wpdb -> posts , compact ( " post_name " ), array ( 'ID' => $post_ID ) );
2005-12-05 04:17:03 +01:00
}
2012-09-22 00:52:54 +02: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 23:51:40 +01:00
2006-06-08 01:17:59 +02:00
if ( $file )
2006-12-05 23:37:19 +01:00
update_attached_file ( $post_ID , $file );
2008-08-09 07:36:14 +02:00
2012-04-24 00:04:35 +02:00
clean_post_cache ( $post_ID );
2005-12-01 23:51:40 +01:00
2011-05-23 01:25:28 +02:00
if ( ! empty ( $context ) )
2013-02-14 23:51:06 +01:00
wp_add_post_meta ( $post_ID , '_wp_attachment_context' , $context , true );
2011-05-23 01:25:28 +02:00
2006-06-08 01:17:59 +02:00
if ( $update ) {
do_action ( 'edit_attachment' , $post_ID );
} else {
do_action ( 'add_attachment' , $post_ID );
2005-12-29 02:46:32 +01:00
}
2006-02-12 08:53:23 +01:00
2006-06-08 01:17:59 +02:00
return $post_ID ;
}
2007-12-14 01:28:34 +01:00
/**
2010-04-04 14:20:19 +02: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-14 01:28:34 +01:00
*
2010-04-04 14:20:19 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-08-19 18:38:06 +02:00
* @ uses do_action () Calls 'delete_attachment' hook on Attachment ID .
2007-12-14 01:28:34 +01:00
*
2010-09-07 13:21:11 +02:00
* @ param int $post_id Attachment ID .
2010-04-04 14:20:19 +02:00
* @ param bool $force_delete Whether to bypass trash and force deletion . Defaults to false .
2008-08-19 18:38:06 +02:00
* @ return mixed False on failure . Post data on success .
2007-12-14 01:28:34 +01:00
*/
2009-11-09 21:12:07 +01:00
function wp_delete_attachment ( $post_id , $force_delete = false ) {
2006-06-08 01:17:59 +02:00
global $wpdb ;
2009-09-11 00:07:33 +02:00
if ( ! $post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d " , $post_id ) ) )
2006-06-08 01:17:59 +02:00
return $post ;
2006-01-02 05:59:39 +01:00
2006-06-08 01:17:59 +02:00
if ( 'attachment' != $post -> post_type )
return false ;
2009-07-30 16:55:07 +02:00
2009-12-16 18:14:21 +01:00
if ( ! $force_delete && EMPTY_TRASH_DAYS && MEDIA_TRASH && 'trash' != $post -> post_status )
2009-11-09 21:12:07 +01:00
return wp_trash_post ( $post_id );
2009-07-30 15:39:34 +02:00
2009-09-11 00:07:33 +02:00
delete_post_meta ( $post_id , '_wp_trash_meta_status' );
delete_post_meta ( $post_id , '_wp_trash_meta_time' );
2006-02-12 08:53:23 +01:00
2009-09-24 03:54:07 +02:00
$meta = wp_get_attachment_metadata ( $post_id );
$backup_sizes = get_post_meta ( $post -> ID , '_wp_attachment_backup_sizes' , true );
2009-09-11 00:07:33 +02:00
$file = get_attached_file ( $post_id );
2005-12-01 23:51:40 +01:00
2012-05-11 20:47:32 +02: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 19:57:32 +01:00
if ( is_multisite () )
delete_transient ( 'dirsize_cache' );
2009-09-11 00:07:33 +02:00
do_action ( 'delete_attachment' , $post_id );
2009-01-21 22:19:22 +01:00
2009-09-11 00:07:33 +02:00
wp_delete_object_term_relationships ( $post_id , array ( 'category' , 'post_tag' ));
2009-12-01 20:41:41 +01:00
wp_delete_object_term_relationships ( $post_id , get_object_taxonomies ( $post -> post_type ));
2007-05-29 06:26:36 +02:00
2012-04-11 22:02:39 +02:00
delete_metadata ( 'post' , null , '_thumbnail_id' , $post_id , true ); // delete all for any posts.
2009-10-18 15:58:44 +02:00
2009-11-04 18:39:53 +01:00
$comment_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d " , $post_id ));
2012-04-11 22:02:39 +02:00
foreach ( $comment_ids as $comment_id )
wp_delete_comment ( $comment_id , true );
2005-12-01 23:51:40 +01:00
2009-11-04 18:39:53 +01:00
$post_meta_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d " , $post_id ));
2012-04-11 22:02:39 +02:00
foreach ( $post_meta_ids as $mid )
delete_metadata_by_mid ( 'post' , $mid );
2009-03-31 21:16:53 +02:00
2009-09-24 19:10:28 +02:00
do_action ( 'delete_post' , $post_id );
2012-03-24 16:24:31 +01:00
$wpdb -> delete ( $wpdb -> posts , array ( 'ID' => $post_id ) );
2009-09-24 19:10:28 +02:00
do_action ( 'deleted_post' , $post_id );
2006-03-30 09:36:54 +02:00
2009-09-11 00:07:33 +02:00
$uploadpath = wp_upload_dir ();
2008-11-23 00:01:28 +01:00
2006-06-08 01:17:59 +02:00
if ( ! empty ( $meta [ 'thumb' ]) ) {
// Don't delete the thumb if another attachment uses it
2009-09-11 00:07:33 +02: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-08 01:17:59 +02:00
$thumbfile = str_replace ( basename ( $file ), $meta [ 'thumb' ], $file );
$thumbfile = apply_filters ( 'wp_delete_file' , $thumbfile );
2009-09-11 00:07:33 +02:00
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $thumbfile ) );
2006-03-30 09:36:54 +02:00
}
}
2009-09-11 00:07:33 +02:00
// remove intermediate and backup images if there are any
2012-05-11 20:47:32 +02:00
foreach ( $intermediate_sizes as $intermediate ) {
$intermediate_file = apply_filters ( 'wp_delete_file' , $intermediate [ 'path' ] );
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $intermediate_file ) );
2009-09-11 00:07:33 +02:00
}
2009-09-24 03:54:07 +02:00
if ( is_array ( $backup_sizes ) ) {
foreach ( $backup_sizes as $size ) {
$del_file = path_join ( dirname ( $meta [ 'file' ]), $size [ 'file' ] );
$del_file = apply_filters ( 'wp_delete_file' , $del_file );
2010-06-30 02:05:18 +02:00
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $del_file ) );
2008-03-13 00:15:31 +01:00
}
}
2006-06-08 01:17:59 +02:00
$file = apply_filters ( 'wp_delete_file' , $file );
2006-03-30 09:50:33 +02:00
2006-06-08 01:17:59 +02:00
if ( ! empty ( $file ) )
@ unlink ( $file );
2012-04-24 00:04:35 +02:00
clean_post_cache ( $post );
2007-10-14 06:55:33 +02:00
2006-06-08 01:17:59 +02:00
return $post ;
2006-03-30 09:50:33 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve attachment meta field for attachment ID .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*/
2010-05-16 23:00:00 +02:00
function wp_get_attachment_metadata ( $post_id = 0 , $unfiltered = false ) {
2006-12-05 23:37:19 +01:00
$post_id = ( int ) $post_id ;
2012-08-23 22:01:10 +02:00
if ( ! $post = get_post ( $post_id ) )
2007-01-05 21:54:55 +01:00
return false ;
2006-12-05 23:37:19 +01:00
2007-01-05 21:54:55 +01:00
$data = get_post_meta ( $post -> ID , '_wp_attachment_metadata' , true );
2009-09-11 00:07:33 +02:00
2006-12-05 23:37:19 +01:00
if ( $unfiltered )
return $data ;
2009-09-11 00:07:33 +02:00
2007-01-05 21:54:55 +01:00
return apply_filters ( 'wp_get_attachment_metadata' , $data , $post -> ID );
2006-12-05 23:37:19 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Update metadata for an attachment .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Attachment ID .
* @ param array $data Attachment data .
* @ return int
2007-12-14 01:28:34 +01:00
*/
2006-12-05 23:37:19 +01:00
function wp_update_attachment_metadata ( $post_id , $data ) {
2007-01-02 20:28:30 +01:00
$post_id = ( int ) $post_id ;
2012-08-23 22:01:10 +02:00
if ( ! $post = get_post ( $post_id ) )
2006-12-05 23:37:19 +01:00
return false ;
2012-09-24 15:07:34 +02: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 23:37:19 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the URL for an attachment .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Attachment ID .
* @ return string
2007-12-14 01:28:34 +01:00
*/
2007-01-02 20:28:30 +01:00
function wp_get_attachment_url ( $post_id = 0 ) {
$post_id = ( int ) $post_id ;
2012-08-23 22:01:10 +02:00
if ( ! $post = get_post ( $post_id ) )
2007-01-02 20:28:30 +01:00
return false ;
2011-11-09 23:13:35 +01:00
if ( 'attachment' != $post -> post_type )
2011-11-09 20:20:33 +01:00
return false ;
2008-09-03 00:55:39 +02: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-30 02:05:18 +02: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-03 00:55:39 +02:00
}
}
2011-09-05 21:08:15 +02: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-03 00:55:39 +02:00
$url = get_the_guid ( $post -> ID );
2007-01-02 20:28:30 +01:00
2010-12-07 19:16:21 +01:00
$url = apply_filters ( 'wp_get_attachment_url' , $url , $post -> ID );
2007-01-02 20:28:30 +01:00
2011-11-09 20:20:33 +01:00
if ( empty ( $url ) )
2010-12-07 19:16:21 +01:00
return false ;
2010-12-13 22:21:50 +01:00
2010-12-07 19:16:21 +01:00
return $url ;
2007-01-02 20:28:30 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve thumbnail for an attachment .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Attachment ID .
* @ return mixed False on failure . Thumbnail file path on success .
2007-12-14 01:28:34 +01:00
*/
2007-01-05 21:54:55 +01:00
function wp_get_attachment_thumb_file ( $post_id = 0 ) {
2007-01-02 20:28:30 +01:00
$post_id = ( int ) $post_id ;
2012-08-23 22:01:10 +02:00
if ( ! $post = get_post ( $post_id ) )
2007-01-05 21:54:55 +01:00
return false ;
2008-07-06 18:40:15 +02:00
if ( ! is_array ( $imagedata = wp_get_attachment_metadata ( $post -> ID ) ) )
2007-01-02 20:28:30 +01:00
return false ;
2007-01-05 21:54:55 +01:00
$file = get_attached_file ( $post -> ID );
2007-01-02 20:28:30 +01:00
if ( ! empty ( $imagedata [ 'thumb' ]) && ( $thumbfile = str_replace ( basename ( $file ), $imagedata [ 'thumb' ], $file )) && file_exists ( $thumbfile ) )
2007-01-05 21:54:55 +01:00
return apply_filters ( 'wp_get_attachment_thumb_file' , $thumbfile , $post -> ID );
2007-01-02 20:28:30 +01:00
return false ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve URL for an attachment thumbnail .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Attachment ID
* @ return string | bool False on failure . Thumbnail URL on success .
2007-12-14 01:28:34 +01:00
*/
2007-01-02 20:28:30 +01:00
function wp_get_attachment_thumb_url ( $post_id = 0 ) {
$post_id = ( int ) $post_id ;
2012-08-23 22:01:10 +02:00
if ( ! $post = get_post ( $post_id ) )
2007-01-05 21:54:55 +01:00
return false ;
if ( ! $url = wp_get_attachment_url ( $post -> ID ) )
2007-01-02 20:28:30 +01:00
return false ;
2008-08-09 07:36:14 +02:00
2008-03-03 05:17:37 +01:00
$sized = image_downsize ( $post_id , 'thumbnail' );
if ( $sized )
return $sized [ 0 ];
2007-01-02 20:28:30 +01:00
2007-01-05 21:54:55 +01:00
if ( ! $thumb = wp_get_attachment_thumb_file ( $post -> ID ) )
2007-01-02 20:28:30 +01:00
return false ;
$url = str_replace ( basename ( $url ), basename ( $thumb ), $url );
2007-01-05 21:54:55 +01:00
return apply_filters ( 'wp_get_attachment_thumb_url' , $url , $post -> ID );
2007-01-02 20:28:30 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Check if the attachment is an image .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Attachment ID
* @ return bool
2007-12-14 01:28:34 +01:00
*/
2007-01-02 20:28:30 +01:00
function wp_attachment_is_image ( $post_id = 0 ) {
$post_id = ( int ) $post_id ;
2012-08-23 22:01:10 +02:00
if ( ! $post = get_post ( $post_id ) )
2007-01-02 20:28:30 +01:00
return false ;
if ( ! $file = get_attached_file ( $post -> ID ) )
return false ;
2007-01-02 20:51:36 +01:00
$ext = preg_match ( '/\.([^.]+)$/' , $file , $matches ) ? strtolower ( $matches [ 1 ]) : false ;
2007-01-02 20:28:30 +01:00
2012-07-05 22:51:55 +02:00
$image_exts = array ( 'jpg' , 'jpeg' , 'jpe' , 'gif' , 'png' );
2007-01-02 20:51:36 +01:00
if ( 'image/' == substr ( $post -> post_mime_type , 0 , 6 ) || $ext && 'import' == $post -> post_mime_type && in_array ( $ext , $image_exts ) )
2007-01-02 20:28:30 +01:00
return true ;
return false ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the icon for a MIME type .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2012-02-14 19:12:01 +01:00
* @ param string | int $mime MIME type or attachment ID .
2008-08-19 18:38:06 +02:00
* @ return string | bool
2007-12-14 01:28:34 +01:00
*/
2007-01-02 20:28:30 +01:00
function wp_mime_type_icon ( $mime = 0 ) {
2008-02-26 09:54:11 +01:00
if ( ! is_numeric ( $mime ) )
$icon = wp_cache_get ( " mime_type_icon_ $mime " );
2012-09-07 23:04:58 +02:00
$post_id = 0 ;
2008-02-22 06:53:47 +01:00
if ( empty ( $icon ) ) {
2008-02-26 09:54:11 +01:00
$post_mimes = array ();
2008-02-22 06:53:47 +01:00
if ( is_numeric ( $mime ) ) {
$mime = ( int ) $mime ;
2012-08-23 22:01:10 +02:00
if ( $post = get_post ( $mime ) ) {
2008-02-26 09:54:11 +01:00
$post_id = ( int ) $post -> ID ;
$ext = preg_replace ( '/^.+?\.([^.]+)$/' , '$1' , $post -> guid );
2008-02-29 07:54:15 +01:00
if ( ! empty ( $ext ) ) {
2008-02-26 09:54:11 +01:00
$post_mimes [] = $ext ;
2008-02-29 07:54:15 +01:00
if ( $ext_type = wp_ext2type ( $ext ) )
$post_mimes [] = $ext_type ;
}
2008-02-26 09:54:11 +01:00
$mime = $post -> post_mime_type ;
} else {
$mime = 0 ;
}
} else {
$post_mimes [] = $mime ;
2008-02-22 06:53:47 +01:00
}
2008-02-26 09:54:11 +01:00
$icon_files = wp_cache_get ( 'icon_files' );
if ( ! is_array ( $icon_files ) ) {
2008-02-29 07:54:15 +01:00
$icon_dir = apply_filters ( 'icon_dir' , ABSPATH . WPINC . '/images/crystal' );
2008-06-06 09:39:11 +02:00
$icon_dir_uri = apply_filters ( 'icon_dir_uri' , includes_url ( 'images/crystal' ) );
2008-02-26 09:54:11 +01:00
$dirs = apply_filters ( 'icon_dirs' , array ( $icon_dir => $icon_dir_uri ) );
$icon_files = array ();
2008-02-29 07:54:15 +01:00
while ( $dirs ) {
2011-10-31 20:38:46 +01:00
$keys = array_keys ( $dirs );
$dir = array_shift ( $keys );
2008-02-29 07:54:15 +01:00
$uri = array_shift ( $dirs );
2008-02-26 09:54:11 +01:00
if ( $dh = opendir ( $dir ) ) {
while ( false !== $file = readdir ( $dh ) ) {
$file = basename ( $file );
2008-02-29 07:54:15 +01:00
if ( substr ( $file , 0 , 1 ) == '.' )
continue ;
2008-02-26 09:54:11 +01:00
if ( ! in_array ( strtolower ( substr ( $file , - 4 )), array ( '.png' , '.gif' , '.jpg' ) ) ) {
2008-02-29 07:54:15 +01:00
if ( is_dir ( " $dir / $file " ) )
2008-02-26 09:54:11 +01:00
$dirs [ " $dir / $file " ] = " $uri / $file " ;
continue ;
}
$icon_files [ " $dir / $file " ] = " $uri / $file " ;
2008-02-22 06:53:47 +01:00
}
2008-02-26 09:54:11 +01:00
closedir ( $dh );
2008-02-22 06:53:47 +01:00
}
2007-01-02 20:28:30 +01:00
}
2012-11-19 09:39:52 +01:00
wp_cache_add ( 'icon_files' , $icon_files , 'default' , 600 );
2008-02-26 09:54:11 +01: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 20:57:00 +01:00
$matches [ 'default' ] = array ( 'default' );
2008-02-26 09:54:11 +01:00
foreach ( $matches as $match => $wilds ) {
if ( isset ( $types [ $wilds [ 0 ]])) {
$icon = $types [ $wilds [ 0 ]];
if ( ! is_numeric ( $mime ) )
2012-09-07 23:10:43 +02:00
wp_cache_add ( " mime_type_icon_ $mime " , $icon );
2008-02-26 09:54:11 +01:00
break ;
}
2007-01-02 20:28:30 +01:00
}
}
2008-02-22 06:53:47 +01:00
return apply_filters ( 'wp_mime_type_icon' , $icon , $mime , $post_id ); // Last arg is 0 if function pass mime type.
2007-01-02 20:28:30 +01:00
}
2007-12-14 01:28:34 +01:00
/**
2010-10-18 13:24:29 +02:00
* Checked for changed slugs for published post objects and save the old slug .
2007-12-14 01:28:34 +01:00
*
2010-10-19 09:48:22 +02:00
* The function is used when a post object of any type is updated ,
2010-10-18 13:24:29 +02:00
* by comparing the current and previous post objects .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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 13:24:29 +02:00
* The most logically usage of this function is redirecting changed post objects , so
2008-08-19 18:38:06 +02:00
* that those that linked to an changed post will be redirected to the new post .
*
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
2010-10-18 13:24:29 +02:00
* @ param object $post The Post Object
* @ param object $post_before The Previous Post Object
2007-12-14 01:28:34 +01:00
* @ return int Same as $post_id
*/
2010-05-23 09:49:21 +02: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 18:17:39 +01:00
2010-12-08 22:10:38 +01:00
// we're only concerned with published, non-hierarchical objects
2010-12-08 22:17:01 +01:00
if ( $post -> post_status != 'publish' || is_post_type_hierarchical ( $post -> post_type ) )
2010-05-23 09:49:21 +02:00
return ;
2006-12-10 18:17:39 +01: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 22:22:16 +01:00
if ( ! empty ( $post_before -> post_name ) && ! in_array ( $post_before -> post_name , $old_slugs ) )
2013-02-14 23:51:06 +01:00
wp_add_post_meta ( $post_id , '_wp_old_slug' , $post_before -> post_name );
2006-12-10 18:17:39 +01: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-06 05:25:41 +02:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the private post SQL based on capability .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* This function provides a standardized way to appropriately select on the
2011-04-28 13:27:39 +02: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 18:38:06 +02:00
* published posts , and all private posts to which the user has access .
2007-09-04 01:32:58 +02:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.2 . 0
2007-12-14 01:28:34 +01:00
*
* @ uses $user_ID
*
2007-04-06 05:25:41 +02: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 13:27:39 +02:00
function get_private_posts_cap_sql ( $post_type ) {
return get_posts_by_author_sql ( $post_type , false );
2010-03-03 20:08:30 +01:00
}
/**
* Retrieve the post SQL based on capability , author , and type .
*
2011-04-28 13:27:39 +02:00
* @ see get_private_posts_cap_sql () for full description .
2010-03-03 20:08:30 +01:00
*
* @ since 3.0 . 0
2011-04-28 13:27:39 +02:00
* @ param string $post_type Post type .
2011-12-14 00:45:31 +01: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-06 00:11:25 +01:00
* @ param bool $public_only Optional . Only return public posts . Skips cap checks for $current_user . Default is false .
2010-03-03 20:08:30 +01:00
* @ return string SQL WHERE code that can be added to a query .
*/
2012-11-06 00:11:25 +01:00
function get_posts_by_author_sql ( $post_type , $full = true , $post_author = null , $public_only = false ) {
2010-03-03 20:08:30 +01:00
global $user_ID , $wpdb ;
2007-04-06 05:25:41 +02:00
// Private posts
2011-04-28 13:27:39 +02:00
$post_type_obj = get_post_type_object ( $post_type );
if ( ! $post_type_obj )
2011-11-02 18:06:34 +01:00
return $full ? 'WHERE 1 = 0' : ' 1 = 0 ' ;
2007-04-06 05:25:41 +02:00
2011-04-28 13:27:39 +02:00
// This hook is deprecated. Why you'd want to use it, I dunno.
if ( ! $cap = apply_filters ( 'pub_priv_sql_capability' , '' ) )
$cap = $post_type_obj -> cap -> read_private_posts ;
2007-04-06 05:25:41 +02:00
2011-04-28 13:27:39 +02:00
if ( $full ) {
if ( null === $post_author ) {
$sql = $wpdb -> prepare ( 'WHERE post_type = %s AND ' , $post_type );
2010-03-03 20:08:30 +01:00
} else {
2011-04-28 13:27:39 +02:00
$sql = $wpdb -> prepare ( 'WHERE post_author = %d AND post_type = %s AND ' , $post_author , $post_type );
2010-03-03 20:08:30 +01:00
}
} else {
$sql = '' ;
}
$sql .= " (post_status = 'publish' " ;
2007-04-06 05:25:41 +02:00
2012-11-06 00:11:25 +01: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 20:08:30 +01:00
$sql .= " OR post_status = 'private' " ;
2012-11-06 00:11:25 +01:00
} elseif ( is_user_logged_in () ) {
// Users can view their own private posts.
$id = ( int ) $user_ID ;
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 20:08:30 +01:00
} // else none
2012-11-06 00:11:25 +01:00
}
2007-04-06 05:25:41 +02:00
$sql .= ')' ;
return $sql ;
}
2007-12-14 01:28:34 +01:00
/**
2010-03-10 22:32:03 +01:00
* Retrieve the date that the last post was published .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
* @ since 0.71
*
* @ uses apply_filters () Calls 'get_lastpostdate' filter
*
* @ 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-27 01:32:06 +02:00
function get_lastpostdate ( $timezone = 'server' ) {
2010-10-18 23:06:49 +02:00
return apply_filters ( 'get_lastpostdate' , _get_last_post_time ( $timezone , 'date' ), $timezone );
2007-05-27 01:32:06 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve last post modified date depending on timezone .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 1.2 . 0
2007-12-14 01:28:34 +01:00
* @ uses apply_filters () Calls 'get_lastpostmodified' filter
*
* @ 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-27 01:32:06 +02:00
function get_lastpostmodified ( $timezone = 'server' ) {
2010-10-18 23:06:49 +02:00
$lastpostmodified = _get_last_post_time ( $timezone , 'modified' );
2010-03-17 17:27:25 +01:00
2010-03-10 22:32:03 +01:00
$lastpostdate = get_lastpostdate ( $timezone );
if ( $lastpostdate > $lastpostmodified )
$lastpostmodified = $lastpostdate ;
2007-10-31 17:59:05 +01:00
return apply_filters ( 'get_lastpostmodified' , $lastpostmodified , $timezone );
2007-05-27 01:32:06 +02:00
}
2010-10-19 09:35:12 +02: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 23:06:49 +02:00
function _get_last_post_time ( $timezone , $field ) {
2010-10-28 17:46:11 +02:00
global $wpdb ;
2010-10-18 23:06:49 +02:00
if ( ! in_array ( $field , array ( 'date' , 'modified' ) ) )
return false ;
2010-11-22 22:45:45 +01:00
$timezone = strtolower ( $timezone );
2010-10-18 23:06:49 +02:00
2010-11-22 22:45:45 +01:00
$key = " lastpost { $field } : $timezone " ;
2010-10-18 23:06:49 +02:00
$date = wp_cache_get ( $key , 'timeinfo' );
if ( ! $date ) {
$add_seconds_server = date ( 'Z' );
2011-06-10 19:02:03 +02:00
$post_types = get_post_types ( array ( 'public' => true ) );
2010-10-18 23:06:49 +02:00
array_walk ( $post_types , array ( & $wpdb , 'escape_by_ref' ) );
$post_types = " ' " . implode ( " ', ' " , $post_types ) . " ' " ;
2010-11-22 22:45:45 +01:00
switch ( $timezone ) {
2010-10-18 23:06:49 +02: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-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Updates posts in cache .
2007-12-14 01:28:34 +01:00
*
* @ package WordPress
* @ subpackage Cache
* @ since 1.5 . 1
*
* @ param array $posts Array of post objects
*/
2012-04-10 18:09:44 +02:00
function update_post_cache ( & $posts ) {
if ( ! $posts )
2007-05-27 01:32:06 +02:00
return ;
2007-10-12 23:12:34 +02:00
foreach ( $posts as $post )
2012-04-10 18:09:44 +02:00
wp_cache_add ( $post -> ID , $post , 'posts' );
2007-05-27 01:32:06 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Will clean the post in the cache .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
2009-05-06 22:49:36 +02:00
* This function not run if $_wp_suspend_cache_invalidation is not empty . See
* wp_suspend_cache_invalidation () .
*
2007-12-14 01:28:34 +01:00
* @ package WordPress
* @ subpackage Cache
2008-08-19 18:38:06 +02:00
* @ since 2.0 . 0
2007-12-14 01:28:34 +01:00
*
2009-05-06 22:49:36 +02:00
* @ uses do_action () Calls 'clean_post_cache' on $id before adding children ( if any ) .
2007-12-14 01:28:34 +01:00
*
2012-04-24 00:04:35 +02:00
* @ param object | int $post The post object or ID to remove from the cache
2007-12-14 01:28:34 +01:00
*/
2012-04-24 00:04:35 +02:00
function clean_post_cache ( $post ) {
2008-10-09 02:50:52 +02:00
global $_wp_suspend_cache_invalidation , $wpdb ;
2012-04-10 18:09:44 +02:00
if ( ! empty ( $_wp_suspend_cache_invalidation ) )
2008-10-09 02:50:52 +02:00
return ;
2012-04-24 00:04:35 +02:00
$post = get_post ( $post );
if ( empty ( $post ) )
2010-08-18 08:50:53 +02:00
return ;
2012-04-24 00:04:35 +02:00
wp_cache_delete ( $post -> ID , 'posts' );
wp_cache_delete ( $post -> ID , 'post_meta' );
2007-05-27 01:32:06 +02:00
2012-04-24 00:04:35 +02:00
clean_object_term_cache ( $post -> ID , $post -> post_type );
2007-10-14 06:55:33 +02:00
2007-10-30 07:03:11 +01:00
wp_cache_delete ( 'wp_get_archives' , 'general' );
2012-04-24 00:04:35 +02:00
do_action ( 'clean_post_cache' , $post -> ID , $post );
2012-04-10 18:09:44 +02:00
2012-07-20 06:35:51 +02:00
if ( is_post_type_hierarchical ( $post -> post_type ) )
wp_cache_delete ( 'get_pages' , 'posts' );
2012-04-24 00:04:35 +02:00
if ( 'page' == $post -> post_type ) {
2012-04-10 18:09:44 +02:00
wp_cache_delete ( 'all_page_ids' , 'posts' );
2012-04-24 00:04:35 +02:00
do_action ( 'clean_page_cache' , $post -> ID );
2012-04-10 18:09:44 +02:00
}
2013-01-15 18:32:35 +01:00
2013-02-11 19:08:14 +01:00
wp_cache_set ( 'last_changed' , microtime (), 'posts' );
2007-05-27 01:32:06 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Call major cache updating functions for list of Post objects .
2007-12-14 01:28:34 +01:00
*
* @ package WordPress
* @ subpackage Cache
2008-08-19 18:38:06 +02:00
* @ since 1.5 . 0
2007-12-14 01:28:34 +01:00
*
* @ uses $wpdb
* @ uses update_post_cache ()
* @ uses update_object_term_cache ()
* @ uses update_postmeta_cache ()
*
* @ param array $posts Array of Post objects
2010-05-10 02:58:39 +02: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-14 01:28:34 +01:00
*/
2010-05-10 02:58:39 +02:00
function update_post_caches ( & $posts , $post_type = 'post' , $update_term_cache = true , $update_meta_cache = true ) {
2007-05-27 01:32:06 +02:00
// No point in doing all this work if we didn't match any posts.
if ( ! $posts )
return ;
2007-10-12 23:12:34 +02:00
update_post_cache ( $posts );
2007-05-27 01:32:06 +02:00
2007-10-12 23:12:34 +02:00
$post_ids = array ();
2010-04-29 22:43:59 +02:00
foreach ( $posts as $post )
$post_ids [] = $post -> ID ;
2007-05-27 01:32:06 +02:00
2012-09-14 18:26:05 +02:00
if ( ! $post_type )
$post_type = 'any' ;
2007-05-27 01:32:06 +02:00
2010-10-04 10:56:04 +02: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-27 01:32:06 +02:00
2010-05-10 02:58:39 +02:00
if ( $update_meta_cache )
update_postmeta_cache ( $post_ids );
2007-10-12 23:12:34 +02:00
}
2007-05-27 01:32:06 +02:00
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Updates metadata cache for list of post IDs .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*
* @ package WordPress
* @ subpackage Cache
2008-08-19 18:38:06 +02:00
* @ since 2.1 . 0
2007-12-14 01:28:34 +01:00
*
* @ uses $wpdb
*
2008-08-19 18:38:06 +02: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-14 01:28:34 +01:00
*/
2007-10-12 23:12:34 +02:00
function update_postmeta_cache ( $post_ids ) {
2009-09-17 22:17:33 +02:00
return update_meta_cache ( 'post' , $post_ids );
2007-05-27 01:32:06 +02:00
}
2010-02-18 08:43:35 +01:00
/**
* Will clean the attachment in the cache .
*
2011-09-05 21:08:15 +02:00
* Cleaning means delete from the cache . Optionally will clean the term
2010-02-18 08:43:35 +01: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 () .
*
* @ package WordPress
* @ subpackage Cache
2010-03-26 20:13:36 +01:00
* @ since 3.0 . 0
2010-02-18 08:43:35 +01:00
*
* @ uses do_action () Calls 'clean_attachment_cache' on $id .
*
* @ 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-20 01:50:29 +01:00
global $_wp_suspend_cache_invalidation ;
2010-02-18 08:43:35 +01: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' );
do_action ( 'clean_attachment_cache' , $id );
}
2007-07-12 18:00:51 +02:00
//
// Hooks
//
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Hook for managing future post transitions to published .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
* @ access private
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2009-05-06 22:49:36 +02:00
* @ uses do_action () Calls 'private_to_published' on post ID if this is a 'private_to_published' call .
* @ uses wp_clear_scheduled_hook () with 'publish_future_post' and post ID .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param string $new_status New post status
* @ param string $old_status Previous post status
2007-12-14 01:28:34 +01:00
* @ param object $post Object type containing the post information
*/
2007-07-12 18:00:51 +02:00
function _transition_post_status ( $new_status , $old_status , $post ) {
global $wpdb ;
if ( $old_status != 'publish' && $new_status == 'publish' ) {
2008-01-10 22:27:08 +01:00
// Reset GUID if transitioning to publish and it is empty
if ( '' == get_the_guid ( $post -> ID ) )
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , array ( 'guid' => get_permalink ( $post -> ID ) ), array ( 'ID' => $post -> ID ) );
2008-01-10 22:27:08 +01:00
do_action ( 'private_to_published' , $post -> ID ); // Deprecated, use private_to_publish
2007-07-12 18:00:51 +02:00
}
2010-03-10 22:32:03 +01:00
// If published posts changed clear the lastpostmodified cache
if ( 'publish' == $new_status || 'publish' == $old_status ) {
2010-11-22 22:45:45 +01:00
foreach ( array ( 'server' , 'gmt' , 'blog' ) as $timezone ) {
wp_cache_delete ( " lastpostmodified: $timezone " , 'timeinfo' );
wp_cache_delete ( " lastpostdate: $timezone " , 'timeinfo' );
}
2010-03-10 22:32:03 +01:00
}
2007-07-12 18:00:51 +02:00
// Always clears the hook in case the post status bounced from future to draft.
2009-12-24 12:24:32 +01:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $post -> ID ) );
2007-07-12 18:00:51 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Hook used to schedule publication for a post marked for the future .
2007-12-14 01:28:34 +01:00
*
* The $post properties used and must exist are 'ID' and 'post_date_gmt' .
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2009-05-06 22:49:36 +02:00
* @ access private
2007-12-14 01:28:34 +01:00
*
2010-01-09 10:55:41 +01: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-14 01:28:34 +01:00
* @ param object $post Object type containing the post information
*/
2009-12-30 17:23:39 +01:00
function _future_post_hook ( $deprecated = '' , $post ) {
2009-12-24 12:24:32 +01:00
wp_clear_scheduled_hook ( 'publish_future_post' , array ( $post -> ID ) );
2010-05-07 22:57:23 +02:00
wp_schedule_single_event ( strtotime ( get_gmt_from_date ( $post -> post_date ) . ' GMT' ) , 'publish_future_post' , array ( $post -> ID ) );
2007-07-12 18:00:51 +02:00
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Hook to schedule pings and enclosures when a post is published .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ since 2.3 . 0
2009-05-06 22:49:36 +02:00
* @ access private
2013-02-05 16:45:37 +01:00
* @ uses XMLRPC_REQUEST and WP_IMPORTING constants .
* @ uses do_action () Calls 'xmlrpc_publish_post' on post ID if XMLRPC_REQUEST is defined .
2007-12-14 01:28:34 +01:00
*
* @ param int $post_id The ID in the database table of the post being published
*/
2007-07-12 18:00:51 +02:00
function _publish_post_hook ( $post_id ) {
if ( defined ( 'XMLRPC_REQUEST' ) )
do_action ( 'xmlrpc_publish_post' , $post_id );
if ( defined ( 'WP_IMPORTING' ) )
return ;
2012-04-11 22:02:39 +02:00
if ( get_option ( 'default_pingback_flag' ) )
2013-02-14 23:51:06 +01:00
wp_add_post_meta ( $post_id , '_pingme' , '1' );
wp_add_post_meta ( $post_id , '_encloseme' , '1' );
2009-09-24 19:10:28 +02:00
2007-07-12 18:00:51 +02:00
wp_schedule_single_event ( time (), 'do_pings' );
}
2008-04-19 01:38:21 +02:00
/**
2008-08-19 18:38:06 +02:00
* Determines which fields of posts are to be saved in revisions .
2008-04-19 01:38:21 +02:00
*
2008-08-19 18:38:06 +02:00
* Does two things . If passed a post * array * , it will return a post array ready
2011-09-05 21:08:15 +02:00
* to be inserted into the posts table as a post revision . Otherwise , returns
2008-08-19 18:38:06 +02:00
* an array whose keys are the post fields to be saved for post revisions .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
* @ access private
2009-05-06 22:49:36 +02:00
* @ uses apply_filters () Calls '_wp_post_revision_fields' on 'title' , 'content' and 'excerpt' fields .
2008-04-19 01:38:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param array $post Optional a post array to be processed for insertion as a post revision .
2008-05-08 19:25:07 +02:00
* @ param bool $autosave optional Is the revision an autosave ?
2008-08-19 18:38:06 +02:00
* @ return array Post array ready to be inserted as a post revision or array of fields that can be versioned .
2008-04-19 01:38:21 +02:00
*/
2008-05-30 00:21:36 +02:00
function _wp_post_revision_fields ( $post = null , $autosave = false ) {
2008-04-19 01:38:21 +02:00
static $fields = false ;
if ( ! $fields ) {
// Allow these to be versioned
$fields = array (
'post_title' => __ ( 'Title' ),
'post_content' => __ ( 'Content' ),
'post_excerpt' => __ ( 'Excerpt' ),
);
2008-05-08 19:25:07 +02:00
// Runs only once
2008-05-30 00:21:36 +02:00
$fields = apply_filters ( '_wp_post_revision_fields' , $fields );
2008-05-08 19:25:07 +02:00
2008-04-19 01:38:21 +02:00
// WP uses these internally either in versioning or elsewhere - they cannot be versioned
2008-07-29 01:58:24 +02:00
foreach ( array ( 'ID' , 'post_name' , 'post_parent' , 'post_date' , 'post_date_gmt' , 'post_status' , 'post_type' , 'comment_count' , 'post_author' ) as $protect )
2008-04-19 01:38:21 +02:00
unset ( $fields [ $protect ] );
}
if ( ! is_array ( $post ) )
return $fields ;
$return = array ();
foreach ( array_intersect ( array_keys ( $post ), array_keys ( $fields ) ) as $field )
$return [ $field ] = $post [ $field ];
$return [ 'post_parent' ] = $post [ 'ID' ];
$return [ 'post_status' ] = 'inherit' ;
$return [ 'post_type' ] = 'revision' ;
2008-05-08 19:25:07 +02:00
$return [ 'post_name' ] = $autosave ? " $post[ID] -autosave " : " $post[ID] -revision " ;
2008-11-15 00:01:16 +01:00
$return [ 'post_date' ] = isset ( $post [ 'post_modified' ]) ? $post [ 'post_modified' ] : '' ;
$return [ 'post_date_gmt' ] = isset ( $post [ 'post_modified_gmt' ]) ? $post [ 'post_modified_gmt' ] : '' ;
2008-04-19 01:38:21 +02:00
return $return ;
}
/**
2008-08-19 18:38:06 +02:00
* Saves an already existing post as a post revision .
*
* Typically used immediately prior to post updates .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-04-19 01:38:21 +02:00
*
2008-05-30 00:21:36 +02:00
* @ uses _wp_put_post_revision ()
2008-04-19 01:38:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id The ID of the post to save as a revision .
* @ return mixed Null or 0 if error , new revision ID , if success .
2008-04-19 01:38:21 +02:00
*/
2013-02-14 12:36:32 +01:00
function wp_save_post_revision ( $post_id , $new_data = null ) {
2008-05-30 00:21:36 +02:00
// We do autosaves manually with wp_create_post_autosave()
2009-11-23 19:47:22 +01:00
if ( defined ( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE )
2008-04-19 01:38:21 +02:00
return ;
2008-05-23 17:27:56 +02:00
// WP_POST_REVISIONS = 0, false
2010-02-19 02:03:58 +01:00
if ( ! WP_POST_REVISIONS )
2008-05-09 17:59:17 +02:00
return ;
2008-04-19 01:38:21 +02:00
if ( ! $post = get_post ( $post_id , ARRAY_A ) )
return ;
2012-12-03 07:28:28 +01:00
if ( 'auto-draft' == $post [ 'post_status' ] )
return ;
2010-01-18 12:44:51 +01:00
if ( ! post_type_supports ( $post [ 'post_type' ], 'revisions' ) )
2008-04-25 06:41:41 +02:00
return ;
2008-04-19 01:38:21 +02:00
2013-02-14 17:45:43 +01:00
// if new data is supplied, check that it is different from last saved revision, unless a plugin tells us to always save regardless
if ( apply_filters ( 'wp_save_post_revision_check_for_changes' , true , $post , $new_data ) && is_array ( $new_data ) ) {
2013-02-14 12:36:32 +01:00
$post_has_changed = false ;
2013-02-14 17:45:43 +01:00
foreach ( array_keys ( _wp_post_revision_fields () ) as $field ) {
if ( normalize_whitespace ( $new_data [ $field ] ) != normalize_whitespace ( $post [ $field ] ) ) {
2013-02-14 12:36:32 +01:00
$post_has_changed = true ;
break ;
}
}
//don't save revision if post unchanged
if ( ! $post_has_changed )
return ;
}
2008-05-30 00:21:36 +02:00
$return = _wp_put_post_revision ( $post );
2008-05-23 17:27:56 +02:00
// WP_POST_REVISIONS = true (default), -1
if ( ! is_numeric ( WP_POST_REVISIONS ) || WP_POST_REVISIONS < 0 )
return $return ;
// all revisions and (possibly) one autosave
$revisions = wp_get_post_revisions ( $post_id , array ( 'order' => 'ASC' ) );
2010-01-07 21:13:54 +01:00
// WP_POST_REVISIONS = (int) (# of autosaves to save)
2008-05-23 17:27:56 +02:00
$delete = count ( $revisions ) - WP_POST_REVISIONS ;
if ( $delete < 1 )
return $return ;
$revisions = array_slice ( $revisions , 0 , $delete );
for ( $i = 0 ; isset ( $revisions [ $i ]); $i ++ ) {
if ( false !== strpos ( $revisions [ $i ] -> post_name , 'autosave' ) )
continue ;
2008-05-30 00:21:36 +02:00
wp_delete_post_revision ( $revisions [ $i ] -> ID );
2008-05-23 17:27:56 +02:00
}
return $return ;
2008-04-19 01:38:21 +02:00
}
2008-05-08 19:25:07 +02:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the autosaved data of the specified post .
2008-05-08 19:25:07 +02:00
*
2008-08-19 18:38:06 +02:00
* Returns a post object containing the information that was autosaved for the
* specified post .
2008-05-08 19:25:07 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-05-08 19:25:07 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id The post ID .
* @ return object | bool The autosaved data or false on failure or when no autosave exists .
2008-05-08 19:25:07 +02:00
*/
2008-05-30 00:21:36 +02:00
function wp_get_post_autosave ( $post_id ) {
2008-11-15 19:10:35 +01:00
2008-05-08 19:25:07 +02:00
if ( ! $post = get_post ( $post_id ) )
return false ;
$q = array (
'name' => " { $post -> ID } -autosave " ,
'post_parent' => $post -> ID ,
'post_type' => 'revision' ,
'post_status' => 'inherit'
);
// Use WP_Query so that the result gets cached
$autosave_query = new WP_Query ;
2008-05-30 00:21:36 +02:00
add_action ( 'parse_query' , '_wp_get_post_autosave_hack' );
2008-05-08 19:25:07 +02:00
$autosave = $autosave_query -> query ( $q );
2008-05-30 00:21:36 +02:00
remove_action ( 'parse_query' , '_wp_get_post_autosave_hack' );
2008-05-08 19:25:07 +02:00
if ( $autosave && is_array ( $autosave ) && is_object ( $autosave [ 0 ]) )
return $autosave [ 0 ];
return false ;
}
2008-08-19 18:38:06 +02:00
/**
* Internally used to hack WP_Query into submission .
*
* @ package WordPress
* @ subpackage Post_Revisions
* @ since 2.6 . 0
*
* @ param object $query WP_Query object
*/
2008-05-30 00:21:36 +02:00
function _wp_get_post_autosave_hack ( $query ) {
2008-05-08 19:25:07 +02:00
$query -> is_single = false ;
}
2008-05-30 00:21:36 +02:00
/**
2008-08-19 18:38:06 +02:00
* Determines if the specified post is a revision .
2008-05-30 00:21:36 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-05-30 00:21:36 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int | object $post Post ID or post object .
* @ return bool | int False if not a revision , ID of revision ' s parent otherwise .
2008-05-30 00:21:36 +02:00
*/
function wp_is_post_revision ( $post ) {
if ( ! $post = wp_get_post_revision ( $post ) )
return false ;
return ( int ) $post -> post_parent ;
}
/**
2008-08-19 18:38:06 +02:00
* Determines if the specified post is an autosave .
2008-05-30 00:21:36 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-05-30 00:21:36 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int | object $post Post ID or post object .
* @ return bool | int False if not a revision , ID of autosave ' s parent otherwise
2008-05-30 00:21:36 +02:00
*/
function wp_is_post_autosave ( $post ) {
if ( ! $post = wp_get_post_revision ( $post ) )
return false ;
if ( " { $post -> post_parent } -autosave " !== $post -> post_name )
return false ;
return ( int ) $post -> post_parent ;
}
2008-04-19 01:38:21 +02:00
/**
2008-08-19 18:38:06 +02:00
* Inserts post data into the posts table as a post revision .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-04-19 01:38:21 +02:00
*
* @ uses wp_insert_post ()
*
2008-08-19 18:38:06 +02:00
* @ param int | object | array $post Post ID , post object OR post array .
* @ param bool $autosave Optional . Is the revision an autosave ?
* @ return mixed Null or 0 if error , new revision ID if success .
2008-04-19 01:38:21 +02:00
*/
2008-05-30 00:21:36 +02:00
function _wp_put_post_revision ( $post = null , $autosave = false ) {
2008-04-19 01:38:21 +02:00
if ( is_object ( $post ) )
$post = get_object_vars ( $post );
elseif ( ! is_array ( $post ) )
$post = get_post ( $post , ARRAY_A );
if ( ! $post || empty ( $post [ 'ID' ]) )
return ;
2008-08-20 00:35:28 +02:00
if ( isset ( $post [ 'post_type' ]) && 'revision' == $post [ 'post_type' ] )
2008-04-19 01:38:21 +02:00
return new WP_Error ( 'post_type' , __ ( 'Cannot create a revision of a revision' ) );
2008-05-30 00:21:36 +02:00
$post = _wp_post_revision_fields ( $post , $autosave );
2009-03-18 03:43:45 +01:00
2008-05-08 19:25:07 +02:00
$revision_id = wp_insert_post ( $post );
if ( is_wp_error ( $revision_id ) )
return $revision_id ;
2008-04-19 01:38:21 +02:00
2008-05-08 19:25:07 +02:00
if ( $revision_id )
2008-05-30 00:21:36 +02:00
do_action ( '_wp_put_post_revision' , $revision_id );
2008-04-19 01:38:21 +02:00
return $revision_id ;
}
/**
2008-08-19 18:38:06 +02:00
* Gets a post revision .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-04-19 01:38:21 +02:00
*
* @ uses get_post ()
*
2008-08-19 18:38:06 +02:00
* @ param int | object $post Post ID or post object
* @ param string $output Optional . OBJECT , ARRAY_A , or ARRAY_N .
2011-12-14 00:45:31 +01:00
* @ param string $filter Optional sanitation filter . @ see sanitize_post ()
2008-08-19 18:38:06 +02:00
* @ return mixed Null if error or post object if success
2008-04-19 01:38:21 +02:00
*/
2012-09-10 19:00:11 +02:00
function wp_get_post_revision ( & $post , $output = OBJECT , $filter = 'raw' ) {
2008-04-19 01:38:21 +02:00
$null = null ;
if ( ! $revision = get_post ( $post , OBJECT , $filter ) )
return $revision ;
if ( 'revision' !== $revision -> post_type )
return $null ;
if ( $output == OBJECT ) {
return $revision ;
} elseif ( $output == ARRAY_A ) {
$_revision = get_object_vars ( $revision );
return $_revision ;
} elseif ( $output == ARRAY_N ) {
$_revision = array_values ( get_object_vars ( $revision ));
return $_revision ;
}
return $revision ;
}
/**
2008-08-19 18:38:06 +02:00
* Restores a post to the specified revision .
2008-04-19 01:38:21 +02:00
*
2009-05-06 22:49:36 +02:00
* Can restore a past revision using all fields of the post revision , or only selected fields .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-04-19 01:38:21 +02:00
*
2008-05-30 00:21:36 +02:00
* @ uses wp_get_post_revision ()
2008-04-19 01:38:21 +02:00
* @ uses wp_update_post ()
2009-05-06 22:49:36 +02:00
* @ uses do_action () Calls 'wp_restore_post_revision' on post ID and revision ID if wp_update_post ()
* is successful .
2008-04-19 01:38:21 +02:00
*
2008-08-19 18:38:06 +02:00
* @ param int | object $revision_id Revision ID or revision object .
2009-05-06 22:49:36 +02:00
* @ param array $fields Optional . What fields to restore from . Defaults to all .
2008-08-19 18:38:06 +02:00
* @ return mixed Null if error , false if no fields to restore , ( int ) post ID if success .
2008-04-19 01:38:21 +02:00
*/
2008-05-30 00:21:36 +02:00
function wp_restore_post_revision ( $revision_id , $fields = null ) {
if ( ! $revision = wp_get_post_revision ( $revision_id , ARRAY_A ) )
2008-04-19 01:38:21 +02:00
return $revision ;
if ( ! is_array ( $fields ) )
2008-05-30 00:21:36 +02:00
$fields = array_keys ( _wp_post_revision_fields () );
2008-04-19 01:38:21 +02:00
$update = array ();
foreach ( array_intersect ( array_keys ( $revision ), $fields ) as $field )
$update [ $field ] = $revision [ $field ];
if ( ! $update )
return false ;
$update [ 'ID' ] = $revision [ 'post_parent' ];
2009-03-18 03:43:45 +01:00
2008-05-08 19:25:07 +02:00
$post_id = wp_update_post ( $update );
if ( is_wp_error ( $post_id ) )
return $post_id ;
if ( $post_id )
2008-05-30 00:21:36 +02:00
do_action ( 'wp_restore_post_revision' , $post_id , $revision [ 'ID' ] );
2008-04-19 01:38:21 +02:00
return $post_id ;
}
/**
2008-08-19 18:38:06 +02:00
* Deletes a revision .
2008-04-19 01:38:21 +02:00
*
2008-08-19 18:38:06 +02:00
* Deletes the row from the posts table corresponding to the specified revision .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-04-19 01:38:21 +02:00
*
2008-05-30 00:21:36 +02:00
* @ uses wp_get_post_revision ()
2008-04-19 01:38:21 +02:00
* @ uses wp_delete_post ()
*
2008-08-19 18:38:06 +02:00
* @ param int | object $revision_id Revision ID or revision object .
2010-09-07 13:21:11 +02:00
* @ return mixed Null or WP_Error if error , deleted post if success .
2008-04-19 01:38:21 +02:00
*/
2008-05-30 00:21:36 +02:00
function wp_delete_post_revision ( $revision_id ) {
if ( ! $revision = wp_get_post_revision ( $revision_id ) )
2008-04-19 01:38:21 +02:00
return $revision ;
2008-05-08 19:25:07 +02:00
$delete = wp_delete_post ( $revision -> ID );
if ( is_wp_error ( $delete ) )
return $delete ;
if ( $delete )
2008-05-30 00:21:36 +02:00
do_action ( 'wp_delete_post_revision' , $revision -> ID , $revision );
2008-04-19 01:38:21 +02:00
return $delete ;
}
/**
2008-08-19 18:38:06 +02:00
* Returns all revisions of specified post .
2008-04-19 01:38:21 +02:00
*
* @ package WordPress
2008-08-19 18:38:06 +02:00
* @ subpackage Post_Revisions
* @ since 2.6 . 0
2008-04-19 01:38:21 +02:00
*
* @ uses get_children ()
*
2008-08-19 18:38:06 +02:00
* @ param int | object $post_id Post ID or post object
2008-04-19 01:38:21 +02:00
* @ return array empty if no revisions
*/
2008-05-23 17:27:56 +02:00
function wp_get_post_revisions ( $post_id = 0 , $args = null ) {
2010-02-19 02:03:58 +01:00
if ( ! WP_POST_REVISIONS )
2008-05-09 17:59:17 +02:00
return array ();
2008-04-19 01:38:21 +02:00
if ( ( ! $post = get_post ( $post_id ) ) || empty ( $post -> ID ) )
return array ();
2008-05-23 17:27:56 +02:00
$defaults = array ( 'order' => 'DESC' , 'orderby' => 'date' );
$args = wp_parse_args ( $args , $defaults );
$args = array_merge ( $args , array ( 'post_parent' => $post -> ID , 'post_type' => 'revision' , 'post_status' => 'inherit' ) );
if ( ! $revisions = get_children ( $args ) )
2008-04-19 01:38:21 +02:00
return array ();
return $revisions ;
}
2008-10-31 23:47:07 +01:00
2008-11-04 14:00:12 +01:00
function _set_preview ( $post ) {
2008-10-31 23:47:07 +01:00
2008-11-04 14:00:12 +01:00
if ( ! is_object ( $post ) )
return $post ;
2008-10-31 23:47:07 +01:00
2008-11-04 14:00:12 +01:00
$preview = wp_get_post_autosave ( $post -> ID );
2008-10-31 23:47:07 +01:00
2008-11-04 14:00:12 +01:00
if ( ! is_object ( $preview ) )
return $post ;
$preview = sanitize_post ( $preview );
$post -> post_content = $preview -> post_content ;
$post -> post_title = $preview -> post_title ;
$post -> post_excerpt = $preview -> post_excerpt ;
2008-10-31 23:47:07 +01:00
2008-11-04 14:00:12 +01:00
return $post ;
}
function _show_post_preview () {
if ( isset ( $_GET [ 'preview_id' ]) && isset ( $_GET [ 'preview_nonce' ]) ) {
$id = ( int ) $_GET [ 'preview_id' ];
if ( false == wp_verify_nonce ( $_GET [ 'preview_nonce' ], 'post_preview_' . $id ) )
wp_die ( __ ( 'You do not have permission to preview drafts.' ) );
2008-10-31 23:47:07 +01:00
2008-11-04 14:00:12 +01:00
add_filter ( 'the_preview' , '_set_preview' );
2008-10-31 23:47:07 +01:00
}
2010-03-26 20:13:36 +01:00
}
2010-10-03 04:58:59 +02:00
2010-10-14 17:09:04 +02:00
/**
* Returns the post 's parent' s post_ID
*
2010-10-19 09:38:42 +02:00
* @ since 3.1 . 0
2010-10-14 17:09:04 +02: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 09:38:42 +02:00
* @ since 3.1 . 0
2010-10-14 17:09:04 +02:00
* @ uses wp_find_hierarchy_loop ()
*
* @ param int $post_parent ID of the parent for the post we ' re checking .
2012-01-24 22:52:49 +01:00
* @ param int $post_ID ID of the post we ' re checking .
2010-10-14 17:09:04 +02: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-14 00:45:31 +01:00
// There's a loop, but it doesn't contain $post_ID. Break the loop.
2010-10-14 17:09:04 +02:00
foreach ( array_keys ( $loop ) as $loop_member )
wp_update_post ( array ( 'ID' => $loop_member , 'post_parent' => 0 ) );
return $post_parent ;
}
2010-10-03 04:58:59 +02:00
2010-11-04 19:33:50 +01:00
/**
* Returns an array of post format slugs to their translated and pretty display versions
2010-11-16 14:16:13 +01:00
*
* @ since 3.1 . 0
*
2010-11-17 19:47:34 +01:00
* @ return array The array of translations
2010-11-04 19:33:50 +01:00
*/
function get_post_format_strings () {
$strings = array (
2010-12-02 04:19:14 +01:00
'standard' => _x ( 'Standard' , 'Post format' ), // Special case. any value that evals to false will be considered standard
'aside' => _x ( 'Aside' , 'Post format' ),
'chat' => _x ( 'Chat' , 'Post format' ),
'gallery' => _x ( 'Gallery' , 'Post format' ),
'link' => _x ( 'Link' , 'Post format' ),
'image' => _x ( 'Image' , 'Post format' ),
'quote' => _x ( 'Quote' , 'Post format' ),
'status' => _x ( 'Status' , 'Post format' ),
'video' => _x ( 'Video' , 'Post format' ),
'audio' => _x ( 'Audio' , 'Post format' ),
2010-11-04 19:33:50 +01:00
);
2010-11-05 04:04:13 +01:00
return $strings ;
2010-11-04 19:33:50 +01:00
}
2010-12-20 11:22:06 +01:00
/**
2011-02-05 19:24:01 +01:00
* Retrieves an array of post format slugs .
2010-12-20 11:22:06 +01:00
*
* @ since 3.1 . 0
*
2011-02-05 19:24:01 +01:00
* @ return array The array of post format slugs .
2010-12-20 11:22:06 +01:00
*/
2010-12-03 11:13:17 +01:00
function get_post_format_slugs () {
2011-05-31 21:52:38 +02:00
$slugs = array_keys ( get_post_format_strings () );
return array_combine ( $slugs , $slugs );
2010-12-03 11:13:17 +01:00
}
2010-11-05 04:04:13 +01:00
/**
* Returns a pretty , translated version of a post format slug
2010-11-17 19:47:34 +01:00
*
2010-11-16 14:16:13 +01:00
* @ since 3.1 . 0
*
2010-11-05 04:04:13 +01:00
* @ param string $slug A post format slug
* @ return string The translated post format name
*/
function get_post_format_string ( $slug ) {
$strings = get_post_format_strings ();
2010-11-19 05:32:33 +01:00
if ( ! $slug )
2010-12-02 05:36:00 +01:00
return $strings [ 'standard' ];
2010-11-19 05:32:33 +01:00
else
return ( isset ( $strings [ $slug ] ) ) ? $strings [ $slug ] : '' ;
2010-11-05 04:04:13 +01:00
}
2010-11-15 18:59:25 +01:00
/**
* Sets a post thumbnail .
*
* @ since 3.1 . 0
*
* @ param int | object $post Post ID or object where thumbnail should be attached .
* @ 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 19:06:57 +01:00
$thumbnail_id = absint ( $thumbnail_id );
2010-11-15 18:59:25 +01:00
if ( $post && $thumbnail_id && get_post ( $thumbnail_id ) ) {
2012-09-24 15:07:34 +02:00
if ( $thumbnail_html = wp_get_attachment_image ( $thumbnail_id , 'thumbnail' ) )
2013-02-14 23:51:06 +01:00
return wp_update_post_meta ( $post -> ID , '_thumbnail_id' , $thumbnail_id );
2012-09-24 15:07:34 +02:00
else
return delete_post_meta ( $post -> ID , '_thumbnail_id' );
2010-11-15 18:59:25 +01:00
}
return false ;
}
2011-09-24 21:31:38 +02:00
/**
* Removes a post thumbnail .
*
* @ since 3.3 . 0
*
* @ param int | object $post Post ID or object where thumbnail should be removed from .
* @ 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 ;
}
2010-12-03 11:13:17 +01:00
/**
* Returns a link to a post format index .
*
* @ since 3.1 . 0
*
2011-09-22 14:02:31 +02:00
* @ param string $format Post format
2010-12-03 11:13:17 +01:00
* @ return string Link
*/
function get_post_format_link ( $format ) {
$term = get_term_by ( 'slug' , 'post-format-' . $format , 'post_format' );
if ( ! $term || is_wp_error ( $term ) )
return false ;
return get_term_link ( $term );
}
2012-04-12 20:49:48 +02: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
}
2010-12-03 11:13:17 +01:00
/**
* Filters the request to allow for the format prefix .
*
* @ access private
* @ since 3.1 . 0
*/
function _post_format_request ( $qvs ) {
if ( ! isset ( $qvs [ 'post_format' ] ) )
return $qvs ;
2011-02-05 19:24:01 +01:00
$slugs = get_post_format_slugs ();
2010-12-03 11:13:17 +01:00
if ( isset ( $slugs [ $qvs [ 'post_format' ] ] ) )
$qvs [ 'post_format' ] = 'post-format-' . $slugs [ $qvs [ 'post_format' ] ];
2011-01-11 19:30:37 +01:00
$tax = get_taxonomy ( 'post_format' );
2011-11-06 22:15:23 +01:00
if ( ! is_admin () )
$qvs [ 'post_type' ] = $tax -> object_type ;
2010-12-03 11:13:17 +01:00
return $qvs ;
}
add_filter ( 'request' , '_post_format_request' );
/**
* Filters the post format term link to remove the format prefix .
*
* @ access private
* @ since 3.1 . 0
*/
function _post_format_link ( $link , $term , $taxonomy ) {
global $wp_rewrite ;
if ( 'post_format' != $taxonomy )
return $link ;
if ( $wp_rewrite -> get_extra_permastruct ( $taxonomy ) ) {
2011-02-05 19:24:01 +01:00
return str_replace ( " / { $term -> slug } " , '/' . str_replace ( 'post-format-' , '' , $term -> slug ), $link );
2010-12-03 11:13:17 +01:00
} else {
2010-12-09 15:23:54 +01:00
$link = remove_query_arg ( 'post_format' , $link );
return add_query_arg ( 'post_format' , str_replace ( 'post-format-' , '' , $term -> slug ), $link );
2010-12-03 11:13:17 +01:00
}
}
add_filter ( 'term_link' , '_post_format_link' , 10 , 3 );
2010-12-20 22:59:16 +01:00
/**
* Remove the post format prefix from the name property of the term object created by get_term () .
*
* @ access private
* @ since 3.1 . 0
*/
function _post_format_get_term ( $term ) {
if ( isset ( $term -> slug ) ) {
$term -> name = get_post_format_string ( str_replace ( 'post-format-' , '' , $term -> slug ) );
}
return $term ;
}
add_filter ( 'get_post_format' , '_post_format_get_term' );
/**
* Remove the post format prefix from the name property of the term objects created by get_terms () .
*
* @ access private
* @ since 3.1 . 0
*/
function _post_format_get_terms ( $terms , $taxonomies , $args ) {
if ( in_array ( 'post_format' , ( array ) $taxonomies ) ) {
if ( isset ( $args [ 'fields' ] ) && 'names' == $args [ 'fields' ] ) {
foreach ( $terms as $order => $name ) {
$terms [ $order ] = get_post_format_string ( str_replace ( 'post-format-' , '' , $name ) );
}
} else {
foreach ( ( array ) $terms as $order => $term ) {
if ( isset ( $term -> taxonomy ) && 'post_format' == $term -> taxonomy ) {
$terms [ $order ] -> name = get_post_format_string ( str_replace ( 'post-format-' , '' , $term -> slug ) );
}
}
}
}
return $terms ;
}
add_filter ( 'get_terms' , '_post_format_get_terms' , 10 , 3 );
/**
* Remove the post format prefix from the name property of the term objects created by wp_get_object_terms () .
*
* @ access private
* @ since 3.1 . 0
*/
function _post_format_wp_get_object_terms ( $terms ) {
foreach ( ( array ) $terms as $order => $term ) {
if ( isset ( $term -> taxonomy ) && 'post_format' == $term -> taxonomy ) {
$terms [ $order ] -> name = get_post_format_string ( str_replace ( 'post-format-' , '' , $term -> slug ) );
}
}
return $terms ;
}
add_filter ( 'wp_get_object_terms' , '_post_format_wp_get_object_terms' );
2011-10-10 22:52:44 +02: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 21:13:23 +02:00
*
2011-10-10 22:52:44 +02: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 16:09:35 +01: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 18:09:44 +02:00
}