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 .
*/
function create_initial_post_types () {
2010-01-18 12:44:51 +01:00
register_post_type ( 'post' , array ( 'label' => __ ( 'Posts' ),
2010-02-13 09:56:38 +01:00
'singular_label' => __ ( 'Post' ),
2010-02-06 18:27:30 +01:00
'public' => true ,
'show_ui' => false ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'_edit_link' => 'post.php?post=%d' ,
'capability_type' => 'post' ,
'hierarchical' => false ,
2010-02-02 00:12:26 +01:00
'rewrite' => false ,
'query_var' => false ,
2010-01-18 12:44:51 +01:00
'supports' => array ( 'post-thumbnails' , 'excerpts' , 'trackbacks' , 'custom-fields' , 'comments' , 'revisions' )
) );
register_post_type ( 'page' , array ( 'label' => __ ( 'Pages' ),
2010-02-13 09:56:38 +01:00
'singular_label' => __ ( 'Page' ),
2010-02-06 18:27:30 +01:00
'public' => true ,
'show_ui' => false ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'_edit_link' => 'post.php?post=%d' ,
'capability_type' => 'page' ,
'hierarchical' => true ,
2010-02-02 00:12:26 +01:00
'rewrite' => false ,
'query_var' => false ,
2010-01-18 12:44:51 +01:00
'supports' => array ( 'post-thumbnails' , 'page-attributes' , 'custom-fields' , 'comments' , 'revisions' )
) );
register_post_type ( 'attachment' , array ( 'label' => __ ( 'Media' ),
2010-02-06 18:27:30 +01:00
'public' => true ,
'show_ui' => false ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'_edit_link' => 'media.php?attachment_id=%d' ,
'capability_type' => 'post' ,
2010-02-02 00:12:26 +01:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2010-01-18 12:44:51 +01:00
) );
register_post_type ( 'revision' , array ( 'label' => __ ( 'Revisions' ),
2010-02-13 09:56:38 +01:00
'singular_label' => __ ( 'Revision' ),
2010-02-06 18:27:30 +01:00
'public' => false ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'_edit_link' => 'revision.php?revision=%d' ,
'capability_type' => 'post' ,
2010-02-02 00:12:26 +01:00
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
2010-01-18 12:44:51 +01:00
) );
2010-02-21 19:24:41 +01:00
register_post_type ( 'nav_menu_item' , array ( 'public' => false ,
'show_ui' => false ,
'_builtin' => true ,
'capability_type' => 'post' ,
'hierarchical' => false ,
'rewrite' => false ,
'query_var' => false ,
) );
2010-02-20 23:35:39 +01:00
2010-01-18 12:44:51 +01:00
register_post_status ( 'publish' , array ( 'label' => _x ( 'Published' , 'post' ),
2010-02-06 18:46:00 +01:00
'public' => true ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'label_count' => _n_noop ( 'Published <span class="count">(%s)</span>' , 'Published <span class="count">(%s)</span>' )
) );
register_post_status ( 'future' , array ( 'label' => _x ( 'Scheduled' , 'post' ),
2010-02-16 22:13:44 +01:00
'protected' => true ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'label_count' => _n_noop ( 'Scheduled <span class="count">(%s)</span>' , 'Scheduled <span class="count">(%s)</span>' )
) );
register_post_status ( 'draft' , array ( 'label' => _x ( 'Draft' , 'post' ),
2010-02-16 22:13:44 +01:00
'protected' => true ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'label_count' => _n_noop ( 'Draft <span class="count">(%s)</span>' , 'Drafts <span class="count">(%s)</span>' )
) );
2010-02-16 22:13:44 +01:00
register_post_status ( 'pending' , array ( 'label' => _x ( 'Pending' , 'post' ),
'protected' => true ,
'_builtin' => true ,
'label_count' => _n_noop ( 'Pending <span class="count">(%s)</span>' , 'Pending <span class="count">(%s)</span>' )
) );
2010-01-18 12:44:51 +01:00
register_post_status ( 'private' , array ( 'label' => _x ( 'Private' , 'post' ),
2010-02-16 22:13:44 +01:00
'private' => true ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'label_count' => _n_noop ( 'Private <span class="count">(%s)</span>' , 'Private <span class="count">(%s)</span>' )
) );
register_post_status ( 'trash' , array ( 'label' => _x ( 'Trash' , 'post' ),
2010-02-16 22:13:44 +01:00
'internal' => true ,
'show_in_admin_status_list' => true ,
2010-01-18 12:44:51 +01:00
'_builtin' => true ,
'label_count' => _n_noop ( 'Trash <span class="count">(%s)</span>' , 'Trash <span class="count">(%s)</span>' )
) );
2010-02-06 18:09:34 +01:00
register_post_status ( 'auto-draft' , array ( 'label' => _x ( 'Auto-Draft' , 'post' ),
2010-02-16 22:13:44 +01:00
'internal' => true ,
2010-02-06 18:09:34 +01:00
'_builtin' => true ,
'label_count' => _n_noop ( 'Auto-Draft <span class="count">(%s)</span>' , 'Auto-Drafts <span class="count">(%s)</span>' )
) );
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 .
* @ param bool $unfiltered Whether to apply filters or not .
2008-06-27 17:32:57 +02:00
* @ return string The file path to the attached file .
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
2008-10-18 21:48:49 +02:00
if ( 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 );
2009-11-11 12:24:01 +01:00
$file = _wp_relative_upload_path ( $file );
2006-12-05 23:37:19 +01:00
2009-11-11 12:24:01 +01:00
return update_post_meta ( $attachment_id , '_wp_attached_file' , $file );
}
/**
* Return relative path to an uploaded file .
*
* The path is relative to the current upload dir .
*
* @ since 2.9
* @ 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 ;
if ( ( $uploads = wp_upload_dir ()) && false === $uploads [ 'error' ] ) {
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 ()} f unction . 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
*/
2006-11-20 05:23:12 +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 )
$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 .
*
* The returned array has 'main' and 'extended' keys . Main has the text before
* the < code ><!-- more --></ code >. The 'extended' key has the content after the
* < code ><!-- more --></ code > comment .
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 .
* @ return array Post before ( 'main' ) and after ( 'extended' ) .
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 );
2006-08-05 06:11:51 +02:00
} else {
$main = $post ;
$extended = '' ;
}
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 );
2006-06-08 01:17:59 +02:00
return array ( 'main' => $main , 'extended' => $extended );
}
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
*
2008-08-19 18:38:06 +02:00
* @ param int | object $post Post ID or post object .
* @ 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 .
2008-08-19 18:38:06 +02:00
* @ return mixed Post data
2007-12-14 01:28:34 +01:00
*/
2007-07-11 21:57:43 +02:00
function & get_post ( & $post , $output = OBJECT , $filter = 'raw' ) {
2007-10-12 23:12:34 +02:00
global $wpdb ;
2008-01-10 21:51:07 +01:00
$null = null ;
2006-06-08 01:17:59 +02:00
if ( empty ( $post ) ) {
if ( isset ( $GLOBALS [ 'post' ]) )
$_post = & $GLOBALS [ 'post' ];
else
2008-01-10 21:51:07 +01:00
return $null ;
2008-12-17 00:50:39 +01:00
} elseif ( is_object ( $post ) && empty ( $post -> filter ) ) {
2008-04-16 19:23:17 +02:00
_get_post_ancestors ( $post );
2009-10-19 23:28:44 +02:00
$_post = sanitize_post ( $post , 'raw' );
wp_cache_add ( $post -> ID , $_post , 'posts' );
2006-06-08 01:17:59 +02:00
} else {
2008-12-17 00:50:39 +01:00
if ( is_object ( $post ) )
$post = $post -> ID ;
2007-03-10 21:34:01 +01:00
$post = ( int ) $post ;
2007-10-12 23:12:34 +02:00
if ( ! $_post = wp_cache_get ( $post , 'posts' ) ) {
2008-09-24 07:28:05 +02:00
$_post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $post ));
2008-06-23 23:50:19 +02:00
if ( ! $_post )
return $null ;
2008-04-16 19:23:17 +02:00
_get_post_ancestors ( $_post );
2009-10-19 23:28:44 +02:00
$_post = sanitize_post ( $_post , 'raw' );
2007-10-12 23:12:34 +02:00
wp_cache_add ( $_post -> ID , $_post , 'posts' );
2006-06-08 01:17:59 +02:00
}
}
2009-10-19 23:28:44 +02:00
if ( $filter != 'raw' )
$_post = sanitize_post ( $_post , $filter );
2007-07-11 21:57:43 +02:00
2006-06-08 01:17:59 +02:00
if ( $output == OBJECT ) {
return $_post ;
} elseif ( $output == ARRAY_A ) {
2008-02-22 18:43:56 +01:00
$__post = get_object_vars ( $_post );
return $__post ;
2006-06-08 01:17:59 +02:00
} elseif ( $output == ARRAY_N ) {
2008-02-22 18:43:56 +01:00
$__post = array_values ( get_object_vars ( $_post ));
return $__post ;
2006-06-08 01:17:59 +02:00
} else {
return $_post ;
}
}
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
*/
function get_post_ancestors ( $post ) {
2008-05-30 22:31:45 +02:00
$post = get_post ( $post );
2008-02-28 00:28:18 +01:00
if ( ! empty ( $post -> ancestors ) )
return $post -> ancestors ;
return array ();
}
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 .
*
* Examples of the post field will be , 'post_type' , 'post_status' , 'content' ,
* 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 .
2007-12-14 01:28:34 +01:00
* @ return WP_Error | string Value in post field or WP_Error on failure
*/
2007-07-11 21:57:43 +02:00
function get_post_field ( $field , $post , $context = 'display' ) {
$post = ( int ) $post ;
2007-07-12 18:00:51 +02:00
$post = get_post ( $post );
2007-07-11 21:57:43 +02:00
if ( is_wp_error ( $post ) )
return $post ;
if ( ! is_object ( $post ) )
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 = '' ) {
$post = & get_post ( $ID );
if ( is_object ( $post ) )
return $post -> post_mime_type ;
return false ;
}
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 );
if ( is_object ( $post ) ) {
if ( ( 'attachment' == $post -> post_type ) && $post -> post_parent && ( $post -> ID != $post -> post_parent ) )
return get_post_status ( $post -> post_parent );
else
return $post -> post_status ;
}
return false ;
}
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
*/
function get_post_statuses ( ) {
$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
*/
function get_page_statuses ( ) {
$status = array (
'draft' => __ ( 'Draft' ),
'private' => __ ( 'Private' ),
'publish' => __ ( 'Published' )
);
return $status ;
}
2010-01-13 19:49:56 +01:00
/**
* Register a post type . Do not use before init .
*
* 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 .
* public - Whether posts of this status should be shown in the admin UI . Defaults to true .
* exclude_from_search - Whether to exclude posts with this post status from search results . Defaults to true .
*
* @ package WordPress
* @ subpackage Post
* @ since 3.0
* @ 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.
2010-02-16 22:13:44 +01:00
$defaults = array ( 'label' => false , 'label_count' => false , 'exclude_from_search' => null , '_builtin' => false , '_edit_link' => 'post.php?post=%d' , 'capability_type' => 'post' , 'hierarchical' => false , 'public' => null , 'internal' => null , 'protected' => null , 'private' => null , 'show_in_admin_all' => null , 'publicly_queryable' => null , 'show_in_admin_status_list' => null , 'show_in_admin_all_list' => null , 'single_view_cap' => null );
2010-01-13 19:49:56 +01:00
$args = wp_parse_args ( $args , $defaults );
$args = ( object ) $args ;
$post_status = sanitize_user ( $post_status , true );
$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 )
$args -> show_in_admin_status_list = ! $args -> internal ;
if ( null === $args -> single_view_cap )
$args -> single_view_cap = $args -> public ? '' : 'edit' ;
2010-02-06 18:46:00 +01:00
2010-01-13 19:49:56 +01:00
if ( false === $args -> label )
$args -> label = $post_status ;
if ( false === $args -> label_count )
$args -> label_count = $args -> label ;
$wp_post_statuses [ $post_status ] = $args ;
return $args ;
}
/**
* Retrieve a post status object by name
*
* @ package WordPress
* @ subpackage Post
* @ since 3.0
* @ uses $wp_post_statuses
* @ see register_post_status
* @ see get_post_statuses
*
* @ param string $post_type The name of a registered post status
* @ 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
* @ since 3.0
* @ uses $wp_post_statuses
* @ see register_post_status
* @ see get_post_status_object
*
* @ param array | string $args An array of key => value arguments to match against the post statuses .
* Only post statuses having attributes that match all arguments are returned .
* @ param string $output The type of output to return , either post status 'names' or 'objects' . 'names' is the default .
2010-02-16 22:13:44 +01:00
* @ param string $operator Whether the elements in $args should be logicallly 'or' ed or 'and' ed together . 'or' means only one element from the array needs to match . 'and' means all elements must match . The default is 'or' .
2010-01-13 19:49:56 +01:00
* @ return array A list of post type names or objects
*/
2010-02-16 22:13:44 +01:00
function get_post_stati ( $args = array (), $output = 'names' , $operator = 'or' ) {
2010-01-13 19:49:56 +01:00
global $wp_post_statuses ;
$do_names = false ;
if ( 'names' == $output )
$do_names = true ;
2010-02-16 22:13:44 +01:00
if ( 'and' == $operator )
$arg_count = count ( $args );
else
$arg_count = 0 ;
2010-01-13 19:49:56 +01:00
$post_statuses = array ();
foreach ( ( array ) $wp_post_statuses as $post_status ) {
if ( empty ( $args ) ) {
if ( $do_names )
$post_statuses [] = $post_status -> name ;
else
$post_statuses [] = $post_status ;
2010-02-16 22:13:44 +01:00
} elseif ( $intersect = array_intersect_assoc (( array ) $post_status , $args ) ) {
if ( $arg_count && ( $arg_count != count ( $intersect ) ) )
continue ;
2010-01-13 19:49:56 +01:00
if ( $do_names )
$post_statuses [] = $post_status -> name ;
else
$post_statuses [] = $post_status ;
}
}
return $post_statuses ;
}
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
*
* @ uses $wpdb
2008-08-19 18:38:06 +02:00
* @ uses $posts The Loop post global
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param mixed $post Optional . Post object or post ID .
* @ return bool | string post type or false on failure .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function get_post_type ( $post = false ) {
2007-12-06 20:49:33 +01:00
global $posts ;
2006-06-08 01:17:59 +02:00
if ( false === $post )
$post = $posts [ 0 ];
elseif ( ( int ) $post )
$post = get_post ( $post , OBJECT );
if ( is_object ( $post ) )
return $post -> post_type ;
return false ;
}
2010-01-04 17:58:43 +01:00
/**
* Retrieve a post type object by name
*
* @ package WordPress
* @ subpackage Post
* @ since 3.0
* @ 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
* @ see get_post_types
*
* @ param array | string $args An array of key => value arguments to match against the post types .
* Only post types having attributes that match all arguments are returned .
* @ param string $output The type of output to return , either post type 'names' or 'objects' . 'names' is the default .
* @ return array A list of post type names or objects
*/
function get_post_types ( $args = array (), $output = 'names' ) {
global $wp_post_types ;
$do_names = false ;
if ( 'names' == $output )
$do_names = true ;
$post_types = array ();
foreach ( ( array ) $wp_post_types as $post_type ) {
if ( empty ( $args ) ) {
if ( $do_names )
$post_types [] = $post_type -> name ;
else
$post_types [] = $post_type ;
2009-10-17 18:20:52 +02:00
} elseif ( array_intersect_assoc (( array ) $post_type , $args ) ) {
2009-10-06 16:43:05 +02:00
if ( $do_names )
$post_types [] = $post_type -> name ;
else
$post_types [] = $post_type ;
}
}
return $post_types ;
}
/**
* Register a post type . Do not use before init .
*
* A simple function for creating or modifying a post type based on the
* parameters given . The function will accept an array ( second optional
* parameter ), along with a string for the post type name .
*
*
* Optional $args contents :
*
2010-02-13 09:56:38 +01:00
* label - A ( plural ) descriptive name for the post type marked for translation . Defaults to $post_type .
* singular_label - A ( singular ) descriptive name for the post type marked for translation . Defaults to $label .
2010-02-10 21:37:18 +01:00
* description - A short descriptive summary of what the post type is . Defaults to blank .
2010-01-29 19:26:33 +01:00
* public - Whether posts of this type should be shown in the admin UI . Defaults to false .
2010-02-02 00:12:26 +01:00
* exclude_from_search - Whether to exclude posts with this post type from search results . Defaults to true if the type is not public , false if the type is public .
* publicly_queryable - Whether post_type queries can be performed from the front page . Defaults to whatever public is set as .
2010-02-06 18:27:30 +01:00
* show_ui - Whether to generate a default UI for managing this post type . Defaults to true if the type is public , false if the type is not public .
2010-01-04 17:58:43 +01:00
* inherit_type - The post type from which to inherit the edit link and capability type . Defaults to none .
* capability_type - The post type to use for checking read , edit , and delete capabilities . Defaults to " post " .
2010-02-02 18:37:03 +01:00
* edit_cap - The capability that controls editing a particular object of this post type . Defaults to " edit_ $capability_type " ( edit_post ) .
* edit_type_cap - The capability that controls editing objects of this post type as a class . Defaults to " edit_ . $capability_type . s " ( edit_posts ) .
* edit_others_cap - The capability that controls editing objects of this post type that are owned by other users . Defaults to " edit_others_ . $capability_type . s " ( edit_others_posts ) .
* edit_others_cap - The capability that controls publishing objects of this post type . Defaults to " publish_ . $capability_type . s " ( publish_posts ) .
* read_cap - The capability that controls reading a particular object of this post type . Defaults to " read_ $capability_type " ( read_post ) .
* delete_cap - The capability that controls deleting a particular object of this post type . Defaults to " delete_ $capability_type " ( delete_post ) .
2010-01-04 17:58:43 +01:00
* hierarchical - Whether the post type is hierarchical . Defaults to false .
2010-01-18 12:44:51 +01:00
* supports - An alias for calling add_post_type_support () directly . See add_post_type_support () for Documentation . Defaults to none .
2010-02-03 19:54:42 +01:00
* register_meta_box_cb - Provide a callback function that will be called when setting up the meta boxes for the edit form . Do remove_meta_box () and add_meta_box () calls in the callback .
2010-02-03 20:50:37 +01:00
* taxonomies - An array of taxonomy identifiers that will be registered for the post type . Default is no taxonomies . Taxonomies can be registered later with register_taxonomy () or register_taxonomy_for_object_type () .
2009-10-15 22:26:21 +02:00
*
2009-10-06 16:43:05 +02:00
* @ package WordPress
* @ subpackage Post
* @ since 2.9 . 0
* @ uses $wp_post_types Inserts new post type object into the list
*
* @ param string $post_type Name of the post type .
* @ param array | string $args See above description .
*/
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-02-13 09:56:38 +01:00
$defaults = array ( 'label' => false , 'singular_label' => false , 'description' => '' , 'publicly_queryable' => null , 'exclude_from_search' => null , '_builtin' => false , '_edit_link' => 'post.php?post=%d' , 'capability_type' => 'post' , 'hierarchical' => false , 'public' => false , 'rewrite' => true , 'query_var' => true , 'supports' => array (), 'register_meta_box_cb' => null , 'taxonomies' => array (), 'show_ui' => null );
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
$post_type = sanitize_user ( $post_type , true );
2010-01-04 17:58:43 +01:00
$args -> name = $post_type ;
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-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-01-04 17:58:43 +01:00
if ( false === $args -> label )
$args -> label = $post_type ;
2010-02-13 09:56:38 +01:00
if ( false === $args -> singular_label )
$args -> singular_label = $args -> label ;
2010-02-02 18:37:03 +01:00
if ( empty ( $args -> capability_type ) )
$args -> capability_type = 'post' ;
if ( empty ( $args -> edit_cap ) )
2010-01-04 17:58:43 +01:00
$args -> edit_cap = 'edit_' . $args -> capability_type ;
2010-02-02 18:37:03 +01:00
if ( empty ( $args -> edit_type_cap ) )
$args -> edit_type_cap = 'edit_' . $args -> capability_type . 's' ;
if ( empty ( $args -> edit_others_cap ) )
$args -> edit_others_cap = 'edit_others_' . $args -> capability_type . 's' ;
if ( empty ( $args -> publish_cap ) )
$args -> publish_cap = 'publish_' . $args -> capability_type . 's' ;
if ( empty ( $args -> read_cap ) )
2010-01-04 17:58:43 +01:00
$args -> read_cap = 'read_' . $args -> capability_type ;
2010-02-16 22:13:44 +01:00
if ( empty ( $args -> read_private_cap ) )
$args -> read_private_cap = 'read_private_' . $args -> capability_type . 's' ;
2010-02-02 18:37:03 +01:00
if ( empty ( $args -> delete_cap ) )
2010-01-21 07:53:33 +01:00
$args -> delete_cap = 'delete_' . $args -> capability_type ;
2010-01-04 17:58:43 +01:00
2010-01-18 12:44:51 +01:00
if ( ! empty ( $args -> supports ) ) {
add_post_type_support ( $post_type , $args -> supports );
unset ( $args -> supports );
}
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 ;
$args -> query_var = sanitize_title_with_dashes ( $args -> query_var );
$wp -> add_query_var ( $args -> query_var );
}
if ( false !== $args -> rewrite && '' != get_option ( 'permalink_structure' ) ) {
if ( ! is_array ( $args -> rewrite ) )
$args -> rewrite = array ();
if ( ! isset ( $args -> rewrite [ 'slug' ]) )
$args -> rewrite [ 'slug' ] = $post_type ;
if ( ! isset ( $args -> rewrite [ 'with_front' ]) )
$args -> rewrite [ 'with_front' ] = true ;
$wp_rewrite -> add_rewrite_tag ( " % $post_type % " , '([^/]+)' , $args -> query_var ? " { $args -> query_var } = " : " post_type= $post_type &name= " );
2010-02-10 22:57:25 +01:00
$wp_rewrite -> add_permastruct ( $post_type , " { $args -> rewrite [ 'slug' ] } /% $post_type % " , $args -> rewrite [ 'with_front' ]);
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-01-04 17:58:43 +01:00
$wp_post_types [ $post_type ] = $args ;
2010-02-03 20:50:37 +01:00
foreach ( $args -> taxonomies as $taxonomy ) {
register_taxonomy_for_object_type ( $taxonomy , $post_type );
}
2010-01-04 17:58:43 +01:00
return $args ;
2009-10-06 16:43:05 +02:00
}
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-01-10 02:23:14 +01:00
* @ since 3.0
* @ 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 );
}
}
/**
* Checks a post type ' s support for a given feature
*
* @ since 3.0
* @ 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' );
2009-03-06 05:27:51 +01:00
$return = $wpdb -> update ( $wpdb -> posts , array ( 'post_type' => $post_type ), array ( 'ID' => $post_id ) );
2008-01-02 21:06:00 +01:00
if ( 'page' == $post_type )
clean_page_cache ( $post_id );
else
clean_post_cache ( $post_id );
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 .
* 'post_status' - Default is 'published' . 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' ,
'order' => 'DESC' , 'include' => '' ,
'exclude' => '' , 'meta_key' => '' ,
'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' ;
2008-05-03 22:08:32 +02:00
if ( ! empty ( $r [ 'numberposts' ]) )
$r [ 'posts_per_page' ] = $r [ 'numberposts' ];
if ( ! empty ( $r [ 'category' ]) )
$r [ 'cat' ] = $r [ 'category' ];
if ( ! empty ( $r [ 'include' ]) ) {
$incposts = preg_split ( '/[\s,]+/' , $r [ 'include' ]);
$r [ 'posts_per_page' ] = count ( $incposts ); // only the number of posts included
$r [ 'post__in' ] = $incposts ;
} elseif ( ! empty ( $r [ 'exclude' ]) )
$r [ 'post__not_in' ] = preg_split ( '/[\s,]+/' , $r [ 'exclude' ]);
2008-08-05 07:48:21 +02:00
$r [ 'caller_get_posts' ] = true ;
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
*
2008-08-19 18:38:06 +02:00
* Post meta data is called " Custom Fields " on the Administration Panels .
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 .
* @ param string $key Metadata name .
* @ param mixed $value Metadata value .
* @ 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
*/
2007-10-13 04:36:38 +02:00
function 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
if ( $the_post = wp_is_post_revision ( $post_id ) )
$post_id = $the_post ;
2009-09-17 22:17:33 +02: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 .
* @ param string $key The meta key to retrieve .
* @ 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
*/
2006-06-08 01:17:59 +02: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
*
* @ since 1.5
* @ 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 .
* @ param string $key Metadata key .
* @ param mixed $value Metadata value .
* @ 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
*/
2007-10-13 04:36:38 +02:00
function 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
if ( $the_post = wp_is_post_revision ( $post_id ) )
$post_id = $the_post ;
2009-09-17 22:17:33 +02: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 ) {
2009-03-04 23:59:16 +01:00
if ( ! $post_meta_key )
return false ;
2009-03-18 03:43:45 +01:00
2007-10-12 23:12:34 +02:00
global $wpdb ;
2009-05-12 19:10:05 +02:00
$post_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT DISTINCT post_id FROM $wpdb->postmeta WHERE meta_key = %s " , $post_meta_key ));
if ( $post_ids ) {
2009-09-24 19:10:28 +02:00
$postmetaids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE meta_key = %s " , $post_meta_key ) );
2009-11-08 12:05:49 +01:00
$in = implode ( ',' , array_fill ( 1 , count ( $postmetaids ), '%d' ));
2009-09-24 19:10:28 +02:00
do_action ( 'delete_postmeta' , $postmetaids );
2009-11-08 12:05:49 +01:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE meta_id IN( $in ) " , $postmetaids ));
2009-09-24 19:10:28 +02:00
do_action ( 'deleted_postmeta' , $postmetaids );
2009-05-12 19:10:05 +02:00
foreach ( $post_ids as $post_id )
wp_cache_delete ( $post_id , 'post_meta' );
2007-08-29 21:12:20 +02:00
return true ;
}
return false ;
}
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
*
2008-08-19 18:38:06 +02:00
* The post meta fields are retrieved from the cache , so the function is
* optimized to be called more than once . It also applies to the functions , that
* use this function .
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
*
2008-08-19 18:38:06 +02:00
* @ uses $id Current Loop Post ID
2007-12-14 01:28:34 +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
*/
2006-10-24 12:52:59 +02:00
function get_post_custom ( $post_id = 0 ) {
2007-12-06 20:49:33 +01:00
global $id ;
2006-06-08 01:17:59 +02:00
2006-10-24 12:52:59 +02:00
if ( ! $post_id )
2007-03-23 01:59:21 +01:00
$post_id = ( int ) $id ;
2006-06-08 01:17:59 +02:00
2006-10-11 11:18:54 +02:00
$post_id = ( int ) $post_id ;
2007-10-12 23:12:34 +02:00
if ( ! wp_cache_get ( $post_id , 'post_meta' ) )
2006-10-24 12:52:59 +02:00
update_postmeta_cache ( $post_id );
2006-06-08 01:17:59 +02:00
2007-10-12 23:12:34 +02:00
return wp_cache_get ( $post_id , 'post_meta' );
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
}
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 .
* @ return bool Whether post is sticky ( true ) or not sticky ( false ) .
2008-08-05 07:48:21 +02:00
*/
2008-08-13 20:21:52 +02:00
function is_sticky ( $post_id = null ) {
global $id ;
$post_id = absint ( $post_id );
if ( ! $post_id )
$post_id = absint ( $id );
2008-08-05 07:48:21 +02:00
$stickies = get_option ( 'sticky_posts' );
if ( ! is_array ( $stickies ) )
return false ;
if ( in_array ( $post_id , $stickies ) )
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
*
* @ param object | 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 .
2008-06-27 17:32:57 +02:00
* @ return object | array The now sanitized Post Object or Array ( will be the same type as $post )
*/
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
2009-05-06 22:49:36 +02:00
* @ uses apply_filters () Calls 'edit_$field' and '${field_no_prefix}_edit_pre' passing $value and
* $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_' .
* @ uses apply_filters () Calls '${field}_pre' passing $value if $context == 'db' and field name prefix != 'post_' .
*
* @ 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 ) {
$int_fields = array ( 'ID' , 'post_parent' , 'menu_order' );
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 ) {
$value = apply_filters ( " edit_ $field " , $value , $post_id );
// Old school
$value = apply_filters ( " ${ field_no_prefix } _edit_pre " , $value , $post_id );
} else {
$value = apply_filters ( " edit_post_ $field " , $value , $post_id );
}
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 ) {
$value = apply_filters ( " pre_ $field " , $value );
$value = apply_filters ( " ${ field_no_prefix } _save_pre " , $value );
} else {
$value = apply_filters ( " pre_post_ $field " , $value );
$value = apply_filters ( " ${ field } _pre " , $value );
}
} 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
$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 );
if ( ! current_user_can ( " read_private_ { $post_type_object -> capability_type } s " ) ) {
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-04-09 22:09:45 +02: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
$stats = array ( );
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 ;
}
/**
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
*
2008-08-19 18:38:06 +02:00
* @ param string | array $mime_types List of mime types or comma separated string of mime types .
* @ return string The SQL AND clause for mime searching .
2008-02-19 07:13:20 +01:00
*/
function wp_post_mime_type_where ( $post_mime_types ) {
$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 , '%' ) )
$wheres [] = " post_mime_type LIKE ' $mime_pattern ' " ;
else
$wheres [] = " post_mime_type = ' $mime_pattern ' " ;
}
if ( ! empty ( $wheres ) )
$where = ' AND (' . join ( ' OR ' , $wheres ) . ') ' ;
return $where ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Removes a post , attachment , or page .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* When the post and page goes , everything that is tied to it is deleted also .
* This includes comments , post meta fields , and terms associated with the post .
2007-12-14 01:28:34 +01:00
*
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' .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $postid Post ID .
2009-11-09 21:12:07 +01:00
* @ param bool $force_delete Whether to bypass trash and force deletion
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 ) {
2006-06-08 01:17:59 +02:00
global $wpdb , $wp_rewrite ;
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 ;
2009-11-09 21:12:07 +01:00
if ( ! $force_delete && ( $post -> post_type == 'post' || $post -> post_type == 'page' ) && get_post_status ( $postid ) != 'trash' && EMPTY_TRASH_DAYS > 0 )
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
do_action ( '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 );
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' );
}
2007-12-14 21:56:55 +01:00
// 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='page' " , $postid );
2007-12-27 09:09:31 +01:00
$children = $wpdb -> get_results ( $children_query );
2007-12-14 21:56:55 +01:00
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , $parent_data , $parent_where + array ( 'post_type' => 'page' ) );
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
2008-05-09 17:59:17 +02:00
// Do raw query. wp_get_post_revisions() is filtered
$revision_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE post_parent = %d AND post_type = 'revision' " , $postid ) );
2008-05-30 00:21:36 +02: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 ));
if ( ! empty ( $comment_ids ) ) {
do_action ( 'delete_comment' , $comment_ids );
$in_comment_ids = " ' " . implode ( " ', ' " , $comment_ids ) . " ' " ;
$wpdb -> query ( " DELETE FROM $wpdb->comments WHERE comment_ID IN( $in_comment_ids ) " );
do_action ( 'deleted_comment' , $comment_ids );
}
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 ));
if ( ! empty ( $post_meta_ids ) ) {
do_action ( 'delete_postmeta' , $post_meta_ids );
$in_post_meta_ids = " ' " . implode ( " ', ' " , $post_meta_ids ) . " ' " ;
$wpdb -> query ( " DELETE FROM $wpdb->postmeta WHERE meta_id IN( $in_post_meta_ids ) " );
do_action ( 'deleted_postmeta' , $post_meta_ids );
}
2006-06-08 01:17:59 +02:00
2009-11-19 18:55:23 +01:00
do_action ( 'delete_post' , $postid );
2009-03-31 21:16:53 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->posts WHERE ID = %d " , $postid ));
2009-11-19 18:55:23 +01:00
do_action ( 'deleted_post' , $postid );
2009-03-31 21:16:53 +02:00
2006-11-24 21:44:03 +01:00
if ( 'page' == $post -> post_type ) {
2006-12-08 08:35:45 +01:00
clean_page_cache ( $postid );
2007-12-14 21:56:55 +01:00
2007-12-27 09:09:31 +01:00
foreach ( ( array ) $children as $child )
2007-12-14 21:56:55 +01:00
clean_page_cache ( $child -> ID );
2009-06-16 04:44:28 +02:00
$wp_rewrite -> flush_rules ( false );
2007-10-14 06:55:33 +02:00
} else {
clean_post_cache ( $postid );
2006-06-08 01:17:59 +02: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
2009-04-01 18:10:14 +02:00
do_action ( 'deleted_post' , $postid );
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
*
* @ since 2.9 . 0
* @ uses do_action () on 'trash_post' before trashing
* @ uses do_action () on 'trashed_post' after trashing
*
* @ param int $postid Post ID .
* @ return mixed False on failure
*/
2009-08-26 00:05:15 +02:00
function wp_trash_post ( $post_id = 0 ) {
2009-07-30 15:39:34 +02:00
if ( EMPTY_TRASH_DAYS == 0 )
2009-08-26 00:05:15 +02:00
return wp_delete_post ( $post_id );
2009-07-30 15:39:34 +02:00
2009-08-26 00:05:15 +02:00
if ( ! $post = wp_get_single_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 ( 'trash_post' , $post_id );
2009-07-30 15:39:34 +02:00
2009-08-26 00:05:15 +02:00
add_post_meta ( $post_id , '_wp_trash_meta_status' , $post [ 'post_status' ]);
add_post_meta ( $post_id , '_wp_trash_meta_time' , time ());
2009-07-30 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
*
* @ param int $postid Post ID .
* @ return mixed False on failure
*/
2009-08-26 00:05:15 +02:00
function wp_untrash_post ( $post_id = 0 ) {
if ( ! $post = wp_get_single_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 ;
add_post_meta ( $post_id , '_wp_trash_meta_comments_status' , $statuses );
// 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
2008-08-19 18:38:06 +02:00
* @ uses $wpdb
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ param int $num Optional , default is 10. Number of posts to get .
* @ return array List of posts .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function wp_get_recent_posts ( $num = 10 ) {
global $wpdb ;
// Set the limit clause, if we got a limit
2007-03-23 00:03:07 +01:00
$num = ( int ) $num ;
2009-11-20 04:01:22 +01:00
if ( $num ) {
2006-06-08 01:17:59 +02:00
$limit = " LIMIT $num " ;
}
2009-11-20 04:01:22 +01:00
$sql = " SELECT * FROM $wpdb->posts WHERE post_type = 'post' AND post_status IN ( 'draft', 'publish', 'future', 'pending', 'private' ) ORDER BY post_date DESC $limit " ;
$result = $wpdb -> get_results ( $sql , ARRAY_A );
2006-06-08 01:17:59 +02:00
2008-08-19 18:38:06 +02:00
return $result ? $result : array ();
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 a single post , based on post ID .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* Has categories in 'post_category' property or key . Has tags in 'tags_input'
* property or key .
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 int $postid Post ID .
* @ param string $mode How to return result , either OBJECT , ARRAY_N , or ARRAY_A .
2007-12-14 01:28:34 +01:00
* @ return object | array Post object or array holding post contents and information
*/
2006-06-08 01:17:59 +02:00
function wp_get_single_post ( $postid = 0 , $mode = OBJECT ) {
2007-03-22 21:52:29 +01:00
$postid = ( int ) $postid ;
2006-06-08 01:17:59 +02:00
$post = get_post ( $postid , $mode );
2007-09-16 04:36:23 +02:00
// Set categories and tags
2006-06-08 01:17:59 +02:00
if ( $mode == OBJECT ) {
$post -> post_category = wp_get_post_categories ( $postid );
2007-09-16 04:36:23 +02:00
$post -> tags_input = wp_get_post_tags ( $postid , array ( 'fields' => 'names' ));
2006-11-19 08:56:05 +01:00
}
2006-06-08 01:17:59 +02:00
else {
$post [ 'post_category' ] = wp_get_post_categories ( $postid );
2007-09-16 04:36:23 +02:00
$post [ 'tags_input' ] = wp_get_post_tags ( $postid , array ( 'fields' => 'names' ));
2006-06-08 01:17:59 +02:00
}
return $post ;
}
2004-05-24 03:34:57 +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
*
2008-08-19 18:38:06 +02:00
* You can set the post date manually , but setting the values for 'post_date'
* 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
2009-05-06 22:49:36 +02:00
* @ link http :// core . trac . wordpress . org / ticket / 9084 Bug report on 'wp_insert_post_data' filter .
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
* @ uses $wp_rewrite
* @ 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 .
* @ 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 .
* @ uses wp_transition_post_status ()
*
* @ param array $postarr Optional . Overrides defaults .
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
*/
2008-05-06 01:19:27 +02:00
function wp_insert_post ( $postarr = array (), $wp_error = false ) {
2007-12-06 20:49:33 +01:00
global $wpdb , $wp_rewrite , $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 );
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
}
2009-11-24 17:52:32 +01:00
if ( ( '' == $post_content ) && ( '' == $post_title ) && ( '' == $post_excerpt ) && ( 'attachment' != $post_type ) ) {
2008-05-06 01:19:27 +02:00
if ( $wp_error )
return new WP_Error ( 'empty_content' , __ ( 'Content, title, and excerpt are empty.' ));
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' ;
// 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.
if ( 'post' == $post_type )
$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
2010-02-17 21:33:29 +01:00
// Set the default tag list
2008-11-10 19:54:18 +01:00
if ( ! isset ( $tags_input ) )
$tags_input = array ();
2005-06-18 21:08:38 +02:00
if ( empty ( $post_author ) )
$post_author = $user_ID ;
if ( empty ( $post_status ) )
$post_status = 'draft' ;
2006-02-09 11:03:48 +01:00
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 );
}
2008-02-05 07:47:27 +01:00
2008-10-02 06:10:54 +02:00
// Don't allow contributors to set to set the post slug for pending review posts
if ( 'pending' == $post_status && ! current_user_can ( 'publish_posts' ) )
$post_name = '' ;
// 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.
2009-04-23 22:21:18 +02:00
if ( ! isset ( $post_name ) || 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 {
2005-10-13 21:06:31 +02:00
$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
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' ;
}
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
2006-08-30 23:46:31 +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 ) )
$to_ping = preg_replace ( '|\s+|' , " \n " , $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
2008-12-08 20:29:42 +01:00
if ( ! empty ( $post_ID ) ) {
if ( $post_parent == $post_ID ) {
// Post can't be its own parent
$post_parent = 0 ;
} elseif ( ! empty ( $post_parent ) ) {
$parent_post = get_post ( $post_parent );
// Check for circular dependency
if ( $parent_post -> post_parent == $post_ID )
$post_parent = 0 ;
}
}
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
2007-10-13 02:48:52 +02:00
// expected_slashed (everything!)
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 02:48:52 +02:00
$data = stripslashes_deep ( $data );
2007-10-13 04:36:38 +02:00
$where = array ( 'ID' => $post_ID );
2007-10-13 02:48:52 +02:00
2009-03-06 01:50:19 +01:00
if ( $update ) {
2008-02-20 17:46:44 +01:00
do_action ( 'pre_post_update' , $post_ID );
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 ) )
$data [ 'post_mime_type' ] = stripslashes ( $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
2007-03-26 09:28:29 +02:00
wp_set_post_categories ( $post_ID , $post_category );
2008-12-18 20:12:26 +01:00
// old-style tags_input
if ( ! empty ( $tags_input ) )
wp_set_post_tags ( $post_ID , $tags_input );
// new-style support for all tag-like taxonomies
if ( ! empty ( $tax_input ) ) {
2010-02-19 11:26:44 +01:00
foreach ( $tax_input as $taxonomy => $tags ) {
$taxonomy_obj = get_taxonomy ( $taxonomy );
2010-02-22 09:36:32 +01:00
if ( current_user_can ( $taxonomy_obj -> assign_cap ) )
2010-02-19 11:26:44 +01: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 );
2009-05-19 17:54:19 +02:00
if ( 'page' == $data [ 'post_type' ] )
2005-09-14 02:34:04 +02:00
clean_page_cache ( $post_ID );
2008-05-06 01:19:27 +02:00
else
2005-09-14 02:34:04 +02:00
clean_post_cache ( $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
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 ;
2008-05-06 01:19:27 +02:00
$page_templates = get_page_templates ();
2008-05-13 23:03:10 +02:00
if ( 'default' != $page_template && ! in_array ( $page_template , $page_templates ) ) {
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 ;
}
2008-05-22 18:33:06 +02:00
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
2007-07-12 18:00:51 +02:00
if ( $update )
do_action ( 'edit_post' , $post_ID , $post );
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 .
2008-08-19 18:38:06 +02:00
* @ return int 0 on failure , Post ID on success .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function wp_update_post ( $postarr = array ()) {
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
$postarr = add_magic_quotes ( $postarr );
}
2005-12-13 20:19:56 +01:00
2006-06-08 01:17:59 +02:00
// First, get all of the original fields
$post = wp_get_single_post ( $postarr [ 'ID' ], ARRAY_A );
2005-01-07 02:21:12 +01:00
2005-06-19 03:33:38 +02:00
// Escape data pulled from DB.
2005-07-03 20:33:03 +02:00
$post = add_magic_quotes ( $post );
2004-05-24 03:34:57 +02: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-02-06 11:07:57 +01:00
if ( 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' ] = '' ;
}
2006-02-09 11:03:48 +01:00
if ( $postarr [ 'post_type' ] == 'attachment' )
2005-12-13 20:19:56 +01:00
return wp_insert_attachment ( $postarr );
2005-06-19 03:33:38 +02:00
return wp_insert_post ( $postarr );
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
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2008-08-19 18:38:06 +02:00
* @ 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
*
2008-08-19 18:38:06 +02:00
* @ param int $post_id Post ID .
* @ return null
2007-12-14 01:28:34 +01:00
*/
2006-02-12 08:41:56 +01:00
function wp_publish_post ( $post_id ) {
2007-07-12 18:00:51 +02:00
global $wpdb ;
2006-02-12 08:41:56 +01:00
$post = get_post ( $post_id );
if ( empty ( $post ) )
return ;
2006-08-07 05:50:55 +02:00
if ( 'publish' == $post -> post_status )
2006-02-12 08:41:56 +01:00
return ;
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , array ( 'post_status' => 'publish' ), array ( 'ID' => $post_id ) );
2007-07-12 18:00:51 +02:00
$old_status = $post -> post_status ;
$post -> post_status = 'publish' ;
wp_transition_post_status ( 'publish' , $old_status , $post );
2007-12-20 01:48:49 +01:00
// Update counts for the post's terms.
2008-08-06 22:31:54 +02:00
foreach ( ( array ) get_object_taxonomies ( 'post' ) as $taxonomy ) {
2009-12-23 16:31:02 +01:00
$tt_ids = wp_get_object_terms ( $post_id , $taxonomy , array ( 'fields' => 'tt_ids' ));
2008-10-26 00:56:02 +02:00
wp_update_term_count ( $tt_ids , $taxonomy );
2007-12-20 01:48:49 +01:00
}
2007-07-12 18:00:51 +02:00
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-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
$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-02-13 03:42:17 +01:00
$hierarchical_post_types = apply_filters ( 'hierarchical_post_types' , array ( 'page' ) );
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-02-13 03:42:17 +01:00
if ( $post_name_check || in_array ( $slug , $feeds ) ) {
2009-05-27 18:21:53 +02:00
$suffix = 2 ;
do {
2010-02-13 03:42:17 +01:00
$alt_post_name = substr ( $slug , 0 , 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 ) ) {
// 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-02-13 03:42:17 +01:00
if ( $post_name_check || in_array ( $slug , $feeds ) ) {
2009-05-27 18:21:53 +02:00
$suffix = 2 ;
do {
2010-02-13 03:42:17 +01:00
$alt_post_name = substr ( $slug , 0 , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
$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-02-13 03:42:17 +01:00
if ( $post_name_check || in_array ( $slug , $feeds ) ) {
2009-04-23 22:21:18 +02:00
$suffix = 2 ;
do {
2010-02-13 03:42:17 +01:00
$alt_post_name = substr ( $slug , 0 , 200 - ( strlen ( $suffix ) + 1 ) ) . " - $suffix " ;
$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
2009-04-23 22:21:18 +02:00
return $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-08-19 18:38:06 +02:00
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 .
* @ 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_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 .
* @ param bool $append If true , don ' t delete existing tags , just add on . If false , replace the tags with the new tags .
* @ return bool | null Will return false if $post_id is not an integer or is 0. Will return null otherwise
*/
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
$tags = is_array ( $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.
$taxonomy_obj = get_taxonomy ( $taxonomy );
if ( $taxonomy_obj -> hierarchical ) {
$tags = array_map ( 'intval' , $tags );
$tags = array_unique ( $tags );
}
2008-12-18 20:12:26 +01:00
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 );
2004-05-24 03:34:57 +02:00
// If $post_categories isn't already an array, make it one:
2010-02-17 21:33:29 +01:00
if ( ! is_array ( $post_categories ) || 0 == count ( $post_categories ) || empty ( $post_categories ) ) {
if ( 'post' == $post_type )
$post_categories = array ( get_option ( 'default_category' ) );
else
$post_categories = array ();
} else if ( 1 == count ( $post_categories ) && '' == $post_categories [ 0 ] ) {
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
2010-02-17 21:33:29 +01:00
if ( ! empty ( $post_categories ) ) {
$post_categories = array_map ( 'intval' , $post_categories );
$post_categories = array_unique ( $post_categories );
}
2004-05-24 03:34:57 +02:00
2007-05-23 20:07:53 +02:00
return wp_set_object_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 .
* @ 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 );
do_action ( " ${ old_status } _to_ $new_status " , $post );
2007-07-12 18:00:51 +02:00
do_action ( " ${ new_status } _ $post->post_type " , $post -> ID , $post );
}
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 ) {
$enclosure = split ( " \n " , $enc );
$pung [] = trim ( $enclosure [ 0 ] );
2005-11-15 17:31:24 +01:00
}
}
2006-06-08 01:17:59 +02:00
$pung = apply_filters ( 'get_enclosed' , $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 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 ));
2006-06-08 01:17:59 +02:00
$to_ping = trim ( $to_ping );
$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
$postdata = wp_get_single_post ( $post_id , ARRAY_A );
// 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 );
trackback ( $tb_url , stripslashes ( $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 ;
2007-10-15 22:11:30 +02:00
if ( ! $page_ids = wp_cache_get ( 'all_page_ids' , 'posts' ) ) {
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
*
* @ since 1.5 . 1
*
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 .
2008-08-19 18:38:06 +02:00
* @ return mixed Page data .
2007-12-14 01:28:34 +01:00
*/
2007-10-03 18:27:07 +02:00
function & get_page ( & $page , $output = OBJECT , $filter = 'raw' ) {
2006-06-08 01:17:59 +02:00
if ( empty ( $page ) ) {
2009-12-07 19:01:02 +01:00
if ( isset ( $GLOBALS [ 'post' ] ) && isset ( $GLOBALS [ 'post' ] -> ID ) ) {
return get_post ( $GLOBALS [ 'post' ], $output , $filter );
2008-08-14 22:36:09 +02:00
} else {
$page = null ;
return $page ;
}
2005-02-12 09:58:10 +01:00
}
2006-06-08 01:17:59 +02:00
2008-11-17 16:47:41 +01:00
$the_page = get_post ( $page , $output , $filter );
return $the_page ;
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
* @ param string $output Optional . Output type . OBJECT , ARRAY_N , or ARRAY_A .
* @ return mixed Null when complete .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 01:17:59 +02:00
function get_page_by_path ( $page_path , $output = OBJECT ) {
2004-10-14 09:26:41 +02:00
global $wpdb ;
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 );
$page_paths = '/' . trim ( $page_path , '/' );
$leaf_path = sanitize_title ( basename ( $page_paths ));
$page_paths = explode ( '/' , $page_paths );
2008-08-14 19:00:37 +02:00
$full_path = '' ;
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $page_paths as $pathdir )
2006-06-08 01:17:59 +02:00
$full_path .= ( $pathdir != '' ? '/' : '' ) . sanitize_title ( $pathdir );
2007-12-12 12:45:55 +01:00
$pages = $wpdb -> get_results ( $wpdb -> prepare ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_name = %s AND (post_type = 'page' OR post_type = 'attachment') " , $leaf_path ));
2006-06-08 01:17:59 +02:00
2006-11-19 08:56:05 +01:00
if ( empty ( $pages ) )
2008-08-19 18:38:06 +02:00
return null ;
2006-06-08 01:17:59 +02:00
foreach ( $pages as $page ) {
$path = '/' . $leaf_path ;
$curpage = $page ;
while ( $curpage -> post_parent != 0 ) {
2007-10-02 20:45:47 +02:00
$curpage = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE ID = %d and post_type='page' " , $curpage -> post_parent ));
2006-06-08 01:17:59 +02:00
$path = '/' . $curpage -> post_name . $path ;
}
if ( $path == $full_path )
return get_page ( $page -> ID , $output );
}
2008-08-19 18:38:06 +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
* @ param string $output Optional . Output type . OBJECT , ARRAY_N , or ARRAY_A .
* @ return mixed
2007-12-14 01:28:34 +01:00
*/
2006-10-26 21:55:10 +02:00
function get_page_by_title ( $page_title , $output = OBJECT ) {
global $wpdb ;
2007-10-02 20:45:47 +02:00
$page = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE post_title = %s AND post_type='page' " , $page_title ));
2006-10-26 21:55:10 +02:00
if ( $page )
return get_page ( $page , $output );
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
*/
2006-06-08 01:17:59 +02:00
function & get_page_children ( $page_id , $pages ) {
$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
*
2008-08-19 18:38:06 +02:00
* @ param array $posts Posts array .
* @ param int $parent 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
*/
2009-09-27 00:45:52 +02:00
function & get_page_hierarchy ( & $pages , $page_id = 0 ) {
2009-10-15 22:26:21 +02:00
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 ) {
2009-10-15 22:26:21 +02:00
2009-09-27 00:45:52 +02:00
$parent_id = intval ( $p -> post_parent );
$children [ $parent_id ][] = $p ;
}
2009-10-15 22:26:21 +02:00
2009-09-27 00:45:52 +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 .
* $children contains parent - chilren relations
2009-10-15 22:26:21 +02:00
*
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 ] ) ){
2009-10-15 22:26:21 +02:00
2009-09-27 00:45:52 +02:00
foreach ( ( array ) $children [ $page_id ] as $child ) {
2009-10-15 22:26:21 +02:00
2009-09-27 00:45:52 +02:00
$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
*
2008-08-19 18:38:06 +02:00
* @ param int $page_id Page ID .
* @ return string Page URI .
2007-12-14 01:28:34 +01:00
*/
2006-06-08 04:22:16 +02:00
function get_page_uri ( $page_id ) {
$page = get_page ( $page_id );
2008-06-16 20:40:47 +02:00
$uri = $page -> post_name ;
2006-06-08 04:22:16 +02:00
// A page cannot be it's own parent.
if ( $page -> post_parent == $page -> ID )
return $uri ;
while ( $page -> post_parent != 0 ) {
$page = get_page ( $page -> post_parent );
2008-06-16 20:40:47 +02:00
$uri = $page -> 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
*/
2006-06-08 01:17:59 +02:00
function & get_pages ( $args = '' ) {
global $wpdb ;
2007-06-14 04:25:30 +02:00
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 ,
'exclude' => '' , 'include' => '' ,
'meta_key' => '' , 'meta_value' => '' ,
2009-05-10 10:55:49 +02:00
'authors' => '' , 'parent' => - 1 , 'exclude_tree' => '' ,
2009-05-10 11:00:18 +02:00
'number' => '' , 'offset' => 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 );
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 ;
2006-06-08 01:17:59 +02:00
2008-12-18 23:26:57 +01:00
$cache = array ();
2008-12-05 20:19:24 +01:00
$key = md5 ( serialize ( compact ( array_keys ( $defaults )) ) );
2008-10-18 00:55:30 +02:00
if ( $cache = wp_cache_get ( 'get_pages' , 'posts' ) ) {
2008-12-18 23:26:57 +01:00
if ( is_array ( $cache ) && isset ( $cache [ $key ] ) ) {
2008-10-18 00:55:30 +02:00
$pages = apply_filters ( 'get_pages' , $cache [ $key ], $r );
return $pages ;
}
}
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 ;
2006-06-08 01:17:59 +02:00
$incpages = preg_split ( '/[\s,]+/' , $include );
if ( count ( $incpages ) ) {
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 ) ) {
$expages = preg_split ( '/[\s,]+/' , $exclude );
if ( count ( $expages ) ) {
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
2006-09-10 19:47:49 +02:00
if ( count ( $post_authors ) ) {
foreach ( $post_authors as $post_author ) {
//Do we have an author id or an author login?
if ( 0 == intval ( $post_author ) ) {
$post_author = get_userdatabylogin ( $post_author );
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 " ;
if ( ! empty ( $meta_key ) || ! empty ( $meta_value ) ) {
$join = " LEFT JOIN $wpdb->postmeta ON ( $wpdb->posts .ID = $wpdb->postmeta .post_id ) " ;
2008-08-09 07:36:14 +02:00
2008-08-19 18:38:06 +02:00
// meta_key and meta_value might be slashed
2008-04-19 00:29:43 +02:00
$meta_key = stripslashes ( $meta_key );
$meta_value = stripslashes ( $meta_value );
if ( ! empty ( $meta_key ) )
$where .= $wpdb -> prepare ( " AND $wpdb->postmeta .meta_key = %s " , $meta_key );
if ( ! empty ( $meta_value ) )
$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 );
2008-04-19 00:29:43 +02:00
$query = " SELECT * FROM $wpdb->posts $join WHERE (post_type = 'page' AND post_status = 'publish') $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.
update_page_cache ( $pages );
if ( $child_of || $hierarchical )
$pages = & get_page_children ( $child_of , $pages );
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 ]);
}
}
2006-11-23 18:21:08 +01:00
$cache [ $key ] = $pages ;
2007-10-15 22:11:30 +02:00
wp_cache_set ( 'get_pages' , $cache , 'posts' );
2006-11-23 18:21:08 +01:00
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 ) {
2007-03-07 06:29:15 +01:00
if ( strpos ( $url , get_bloginfo ( 'url' )) === false )
2006-06-22 21:44:36 +02:00
return false ;
2007-03-07 06:29:15 +01:00
if ( strpos ( $url , get_bloginfo ( 'url' ) . '/?attachment_id=' ) !== false )
2006-06-22 21:44:36 +02:00
return true ;
if ( $id = url_to_postid ( $url ) ) {
$post = & get_post ( $id );
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 .
* @ param int $post_parent Parent post ID .
* @ 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
2007-09-12 00:27:36 +02:00
$defaults = array ( 'post_status' => 'draft' , 'post_type' => 'post' , 'post_author' => $user_ID ,
'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' => '' ,
2008-10-26 18:05:56 +01:00
'guid' => '' , 'post_content_filtered' => '' , 'post_excerpt' => '' , 'import_id' => 0 );
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 ;
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' ;
$post_status = 'inherit' ;
2010-02-22 18:19:54 +01:00
// Make sure we set a valid category.
if ( ! isset ( $post_category ) || 0 == count ( $post_category ) || ! is_array ( $post_category ) ) {
// 'post' requires at least one category.
if ( 'post' == $post_type )
$post_category = array ( get_option ( 'default_category' ) );
else
$post_category = array ();
}
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-26 10:58:10 +02:00
// expected_slashed ($post_name)
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-11 00:01:40 +02:00
// expected_slashed (everything!)
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' ) );
$data = stripslashes_deep ( $data );
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
}
2006-06-08 01:17:59 +02:00
wp_set_post_categories ( $post_ID , $post_category );
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
2006-06-08 01:17:59 +02:00
clean_post_cache ( $post_ID );
2005-12-01 23:51:40 +01:00
2009-11-30 22:41:52 +01:00
if ( isset ( $post_parent ) && $post_parent < 0 )
add_post_meta ( $post_ID , '_wp_attachment_temp_parent' , $post_parent , true );
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
/**
2008-08-19 18:38:06 +02:00
* Delete an attachment .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* Will remove the file also , when the attachment is removed . Removes all post
* meta fields , taxonomy , comments , etc associated with the attachment ( except
* the main post ) .
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
*
2008-08-19 18:38:06 +02:00
* @ param int $postid Attachment ID .
2009-11-09 21:12:07 +01:00
* @ param bool $force_delete Whether to bypass trash and force deletion
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
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
2009-10-18 15:58:44 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE meta_key = '_thumbnail_id' AND meta_value = %d " , $post_id ));
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 ));
if ( ! empty ( $comment_ids ) ) {
do_action ( 'delete_comment' , $comment_ids );
$in_comment_ids = " ' " . implode ( " ', ' " , $comment_ids ) . " ' " ;
$wpdb -> query ( " DELETE FROM $wpdb->comments WHERE comment_ID IN( $in_comment_ids ) " );
do_action ( 'deleted_comment' , $comment_ids );
}
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 ));
if ( ! empty ( $post_meta_ids ) ) {
do_action ( 'delete_postmeta' , $post_meta_ids );
$in_post_meta_ids = " ' " . implode ( " ', ' " , $post_meta_ids ) . " ' " ;
$wpdb -> query ( " DELETE FROM $wpdb->postmeta WHERE meta_id IN( $in_post_meta_ids ) " );
do_action ( 'deleted_postmeta' , $post_meta_ids );
}
2009-03-31 21:16:53 +02:00
2009-09-24 19:10:28 +02:00
do_action ( 'delete_post' , $post_id );
2009-09-11 00:07:33 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->posts WHERE ID = %d " , $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
2010-01-08 09:51:12 +01:00
foreach ( get_intermediate_image_sizes () as $size ) {
2009-09-11 00:07:33 +02:00
if ( $intermediate = image_get_intermediate_size ( $post_id , $size ) ) {
2008-03-13 00:15:31 +01:00
$intermediate_file = apply_filters ( 'wp_delete_file' , $intermediate [ 'path' ]);
2009-09-11 00:07:33 +02:00
@ unlink ( path_join ( $uploadpath [ 'basedir' ], $intermediate_file ) );
}
}
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 );
@ 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 );
2009-09-11 00:07:33 +02:00
clean_post_cache ( $post_id );
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
*/
2009-09-24 03:54:07 +02:00
function wp_get_attachment_metadata ( $post_id , $unfiltered = false ) {
2006-12-05 23:37:19 +01:00
$post_id = ( int ) $post_id ;
2007-01-05 21:54:55 +01:00
if ( ! $post =& get_post ( $post_id ) )
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 ;
2007-01-05 21:54:55 +01:00
if ( ! $post =& get_post ( $post_id ) )
2006-12-05 23:37:19 +01:00
return false ;
2007-01-05 21:54:55 +01:00
$data = apply_filters ( 'wp_update_attachment_metadata' , $data , $post -> ID );
2006-12-05 23:37:19 +01:00
2008-05-22 18:33:06 +02:00
return update_post_meta ( $post -> ID , '_wp_attachment_metadata' , $data );
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 ;
if ( ! $post =& get_post ( $post_id ) )
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-01-18 23:21:36 +01: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
}
}
if ( empty ( $url ) ) //If any of the above options failed, Fallback on the GUID as used pre-2.7, not recomended to rely upon this.
$url = get_the_guid ( $post -> ID );
2007-01-02 20:28:30 +01:00
2008-09-03 00:55:39 +02:00
if ( 'attachment' != $post -> post_type || empty ( $url ) )
2007-01-02 20:28:30 +01:00
return false ;
2007-01-05 21:54:55 +01:00
return apply_filters ( 'wp_get_attachment_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
* 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 ;
2007-01-05 21:54:55 +01:00
if ( ! $post =& get_post ( $post_id ) )
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 ;
2007-01-05 21:54:55 +01:00
if ( ! $post =& get_post ( $post_id ) )
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 ;
if ( ! $post =& get_post ( $post_id ) )
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
2007-01-02 20:51:36 +01:00
$image_exts = array ( 'jpg' , 'jpeg' , 'gif' , 'png' );
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
*
* @ param string $mime MIME type
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 " );
2008-02-22 06:53:47 +01:00
if ( empty ( $icon ) ) {
2008-02-26 09:54:11 +01:00
$post_id = 0 ;
$post_mimes = array ();
2008-02-22 06:53:47 +01:00
if ( is_numeric ( $mime ) ) {
$mime = ( int ) $mime ;
2008-02-26 09:54:11 +01:00
if ( $post =& get_post ( $mime ) ) {
$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 ) {
2008-04-17 01:09:51 +02:00
$dir = array_shift ( $keys = array_keys ( $dirs ));
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
}
2008-02-26 09:54:11 +01:00
wp_cache_set ( 'icon_files' , $icon_files , 600 );
}
// 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 ) )
wp_cache_set ( " mime_type_icon_ $mime " , $icon );
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
/**
2008-08-19 18:38:06 +02:00
* Checked for changed slugs for published posts and save old slug .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* The function is used along with form POST data . It checks for the wp - old - slug
* POST field . Will only be concerned with published posts and the slug actually
* changing .
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 .
*
* The most logically usage of this function is redirecting changed posts , so
* 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 .
2007-12-14 01:28:34 +01:00
* @ return int Same as $post_id
*/
2006-12-10 18:17:39 +01:00
function wp_check_for_changed_slugs ( $post_id ) {
2008-02-22 18:43:56 +01:00
if ( ! isset ( $_POST [ 'wp-old-slug' ]) || ! strlen ( $_POST [ 'wp-old-slug' ]) )
2006-12-10 18:17:39 +01:00
return $post_id ;
$post = & get_post ( $post_id );
// we're only concerned with published posts
if ( $post -> post_status != 'publish' || $post -> post_type != 'post' )
return $post_id ;
// only bother if the slug has changed
if ( $post -> post_name == $_POST [ 'wp-old-slug' ] )
return $post_id ;
$old_slugs = ( array ) get_post_meta ( $post_id , '_wp_old_slug' );
// if we haven't added this old slug before, add it now
if ( ! count ( $old_slugs ) || ! in_array ( $_POST [ 'wp-old-slug' ], $old_slugs ) )
add_post_meta ( $post_id , '_wp_old_slug' , $_POST [ 'wp-old-slug' ]);
// 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 );
return $post_id ;
}
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
* post_status of posts / pages . The function will return a piece of SQL code that
* can be added to a WHERE clause ; this SQL is constructed to allow all
* 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
* It also allows plugins that define their own post type to control the cap by
* using the hook 'pub_priv_sql_capability' . The plugin is expected to return
* the capability the user must have to read the private post type .
*
* @ since 2.2 . 0
2007-12-14 01:28:34 +01:00
*
* @ uses $user_ID
2008-08-19 18:38:06 +02:00
* @ uses apply_filters () Call 'pub_priv_sql_capability' filter for plugins with different post types .
2007-12-14 01:28:34 +01:00
*
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 .
*/
function get_private_posts_cap_sql ( $post_type ) {
global $user_ID ;
$cap = '' ;
// Private posts
if ( $post_type == 'post' ) {
$cap = 'read_private_posts' ;
// Private pages
} elseif ( $post_type == 'page' ) {
$cap = 'read_private_pages' ;
// Dunno what it is, maybe plugins have their own post type?
} else {
$cap = apply_filters ( 'pub_priv_sql_capability' , $cap );
if ( empty ( $cap )) {
// We don't know what it is, filters don't change anything,
// so set the SQL up to return nothing.
return '1 = 0' ;
}
}
$sql = '(post_status = \'publish\'' ;
if ( current_user_can ( $cap )) {
// Does the user have the capability to view private posts? Guess so.
$sql .= ' OR post_status = \'private\'' ;
} elseif ( is_user_logged_in ()) {
// Users can view their own private posts.
2007-04-07 21:31:54 +02:00
$sql .= ' OR post_status = \'private\' AND post_author = \'' . $user_ID . '\'' ;
2007-04-06 05:25:41 +02:00
}
$sql .= ')' ;
return $sql ;
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Retrieve the date the 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 $wpdb
* @ uses $blog_id
* @ uses apply_filters () Calls 'get_lastpostdate' filter
*
* @ global mixed $cache_lastpostdate Stores the last post date
* @ global mixed $pagenow The current page being viewed
*
* @ 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' ) {
2007-12-06 20:49:33 +01:00
global $cache_lastpostdate , $wpdb , $blog_id ;
2007-05-27 01:32:06 +02:00
$add_seconds_server = date ( 'Z' );
if ( ! isset ( $cache_lastpostdate [ $blog_id ][ $timezone ]) ) {
switch ( strtolower ( $timezone )) {
case 'gmt' :
2009-04-28 07:42:30 +02:00
$lastpostdate = $wpdb -> get_var ( " SELECT post_date_gmt FROM $wpdb->posts WHERE post_status = 'publish' AND post_type = 'post' ORDER BY post_date_gmt DESC LIMIT 1 " );
2007-05-27 01:32:06 +02:00
break ;
case 'blog' :
2009-04-28 07:42:30 +02:00
$lastpostdate = $wpdb -> get_var ( " SELECT post_date FROM $wpdb->posts WHERE post_status = 'publish' AND post_type = 'post' ORDER BY post_date_gmt DESC LIMIT 1 " );
2007-05-27 01:32:06 +02:00
break ;
case 'server' :
2009-04-28 07:42:30 +02:00
$lastpostdate = $wpdb -> get_var ( " SELECT DATE_ADD(post_date_gmt, INTERVAL ' $add_seconds_server ' SECOND) FROM $wpdb->posts WHERE post_status = 'publish' AND post_type = 'post' ORDER BY post_date_gmt DESC LIMIT 1 " );
2007-05-27 01:32:06 +02:00
break ;
}
$cache_lastpostdate [ $blog_id ][ $timezone ] = $lastpostdate ;
} else {
$lastpostdate = $cache_lastpostdate [ $blog_id ][ $timezone ];
}
2007-10-31 17:59:05 +01:00
return apply_filters ( 'get_lastpostdate' , $lastpostdate , $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 $wpdb
* @ uses $blog_id
* @ uses apply_filters () Calls 'get_lastpostmodified' filter
*
* @ global mixed $cache_lastpostmodified Stores the date the last post was modified
*
* @ 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' ) {
2007-12-06 20:49:33 +01:00
global $cache_lastpostmodified , $wpdb , $blog_id ;
2007-05-27 01:32:06 +02:00
$add_seconds_server = date ( 'Z' );
if ( ! isset ( $cache_lastpostmodified [ $blog_id ][ $timezone ]) ) {
switch ( strtolower ( $timezone )) {
case 'gmt' :
2009-04-28 07:42:30 +02:00
$lastpostmodified = $wpdb -> get_var ( " SELECT post_modified_gmt FROM $wpdb->posts WHERE post_status = 'publish' AND post_type = 'post' ORDER BY post_modified_gmt DESC LIMIT 1 " );
2007-05-27 01:32:06 +02:00
break ;
case 'blog' :
2009-04-28 07:42:30 +02:00
$lastpostmodified = $wpdb -> get_var ( " SELECT post_modified FROM $wpdb->posts WHERE post_status = 'publish' AND post_type = 'post' ORDER BY post_modified_gmt DESC LIMIT 1 " );
2007-05-27 01:32:06 +02:00
break ;
case 'server' :
2009-04-28 07:42:30 +02:00
$lastpostmodified = $wpdb -> get_var ( " SELECT DATE_ADD(post_modified_gmt, INTERVAL ' $add_seconds_server ' SECOND) FROM $wpdb->posts WHERE post_status = 'publish' AND post_type = 'post' ORDER BY post_modified_gmt DESC LIMIT 1 " );
2007-05-27 01:32:06 +02:00
break ;
}
$lastpostdate = get_lastpostdate ( $timezone );
if ( $lastpostdate > $lastpostmodified ) {
$lastpostmodified = $lastpostdate ;
}
$cache_lastpostmodified [ $blog_id ][ $timezone ] = $lastpostmodified ;
} else {
$lastpostmodified = $cache_lastpostmodified [ $blog_id ][ $timezone ];
}
2007-10-31 17:59:05 +01:00
return apply_filters ( 'get_lastpostmodified' , $lastpostmodified , $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
* Updates posts in cache .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* @ usedby update_page_cache () Aliased by this function .
2007-12-14 01:28:34 +01:00
*
* @ package WordPress
* @ subpackage Cache
* @ since 1.5 . 1
*
* @ param array $posts Array of post objects
*/
2007-05-27 01:32:06 +02:00
function update_post_cache ( & $posts ) {
if ( ! $posts )
return ;
2007-10-12 23:12:34 +02:00
foreach ( $posts as $post )
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
* clean_post_cache () will call itself recursively for each child post .
*
* 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
*
* @ param int $id The Post ID in the cache to clean
*/
2007-05-27 01:32:06 +02:00
function clean_post_cache ( $id ) {
2008-10-09 02:50:52 +02:00
global $_wp_suspend_cache_invalidation , $wpdb ;
if ( ! empty ( $_wp_suspend_cache_invalidation ) )
return ;
2008-04-18 22:23:50 +02:00
$id = ( int ) $id ;
2007-10-12 23:12:34 +02:00
wp_cache_delete ( $id , 'posts' );
wp_cache_delete ( $id , 'post_meta' );
2007-05-27 01:32:06 +02:00
2007-05-31 23:38:33 +02:00
clean_object_term_cache ( $id , 'post' );
2007-10-14 06:55:33 +02:00
2007-10-30 07:03:11 +01:00
wp_cache_delete ( 'wp_get_archives' , 'general' );
2007-10-14 06:55:33 +02:00
do_action ( 'clean_post_cache' , $id );
2008-04-18 22:23:50 +02:00
if ( $children = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT ID FROM $wpdb->posts WHERE post_parent = %d " , $id ) ) ) {
foreach ( $children as $cid )
clean_post_cache ( $cid );
}
2010-01-19 20:45:44 +01:00
if ( is_multisite () )
wp_cache_delete ( $wpdb -> blogid . '-' . $id , 'global-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
* Alias of update_post_cache () .
2007-12-14 01:28:34 +01:00
*
* @ see update_post_cache () Posts and pages are the same , alias is intentional
*
* @ package WordPress
* @ subpackage Cache
* @ since 1.5 . 1
*
* @ param array $pages list of page objects
*/
2007-05-27 01:32:06 +02:00
function update_page_cache ( & $pages ) {
2007-10-12 23:12:34 +02:00
update_post_cache ( $pages );
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 page in the cache .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* Clean ( read : delete ) page from cache that matches $id . Will also clean cache
* associated with 'all_page_ids' and 'get_pages' .
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
*
* @ uses do_action () Will call the 'clean_page_cache' hook action .
*
* @ param int $id Page ID to clean
*/
2007-05-27 01:32:06 +02:00
function clean_page_cache ( $id ) {
2007-10-12 23:12:34 +02:00
clean_post_cache ( $id );
2007-05-27 01:32:06 +02:00
2007-10-15 22:11:30 +02:00
wp_cache_delete ( 'all_page_ids' , 'posts' );
wp_cache_delete ( 'get_pages' , 'posts' );
2007-10-14 06:55:33 +02:00
do_action ( 'clean_page_cache' , $id );
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
*/
2007-05-27 01:32:06 +02:00
function update_post_caches ( & $posts ) {
// 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 ();
2007-05-27 01:32:06 +02:00
2007-10-12 23:12:34 +02:00
for ( $i = 0 ; $i < count ( $posts ); $i ++ )
$post_ids [] = $posts [ $i ] -> ID ;
2007-05-27 01:32:06 +02:00
2007-10-12 23:12:34 +02:00
update_object_term_cache ( $post_ids , 'post' );
2007-05-27 01:32:06 +02:00
2007-10-12 23:12:34 +02:00
update_postmeta_cache ( $post_ids );
}
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 .
*
* Cleaning means delete from the cache . Optionaly will clean the term
* 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
* @ since 3.0
*
* @ 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
}
// 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 ) );
2009-12-30 17:23:39 +01:00
wp_schedule_single_event ( strtotime ( $post -> post_date_gmt . ' 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
2007-12-14 01:28:34 +01:00
* @ uses $wpdb
2009-05-06 22:49:36 +02:00
* @ uses XMLRPC_REQUEST and APP_REQUEST constants .
* @ uses do_action () Calls 'xmlprc_publish_post' on post ID if XMLRPC_REQUEST is defined .
* @ uses do_action () Calls 'app_publish_post' on post ID if APP_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 ) {
global $wpdb ;
if ( defined ( 'XMLRPC_REQUEST' ) )
do_action ( 'xmlrpc_publish_post' , $post_id );
if ( defined ( 'APP_REQUEST' ) )
do_action ( 'app_publish_post' , $post_id );
if ( defined ( 'WP_IMPORTING' ) )
return ;
2007-10-13 04:36:38 +02:00
$data = array ( 'post_id' => $post_id , 'meta_value' => '1' );
2009-09-24 19:10:28 +02:00
if ( get_option ( 'default_pingback_flag' ) ) {
2007-10-13 04:36:38 +02:00
$wpdb -> insert ( $wpdb -> postmeta , $data + array ( 'meta_key' => '_pingme' ) );
2009-09-24 19:10:28 +02:00
do_action ( 'added_postmeta' , $wpdb -> insert_id , $post_id , '_pingme' , 1 );
}
2007-10-13 04:36:38 +02:00
$wpdb -> insert ( $wpdb -> postmeta , $data + array ( 'meta_key' => '_encloseme' ) );
2009-09-24 19:10:28 +02:00
do_action ( 'added_postmeta' , $wpdb -> insert_id , $post_id , '_encloseme' , 1 );
2007-07-12 18:00:51 +02:00
wp_schedule_single_event ( time (), 'do_pings' );
}
2007-12-14 01:28:34 +01:00
/**
2008-08-19 18:38:06 +02:00
* Hook used to prevent page / post cache and rewrite rules from staying dirty .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* Does two things . If the post is a page and has a template then it will
* update / add that template to the meta . For both pages and posts , it will clean
* the post cache to make sure that the cache updates to the changes done
* recently . For pages , the rewrite rules of WordPress are flushed to allow for
* any changes .
2007-12-14 01:28:34 +01:00
*
2008-08-19 18:38:06 +02:00
* The $post parameter , only uses 'post_type' property and 'page_template'
* property .
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
2007-12-14 01:28:34 +01:00
* @ uses $wp_rewrite Flushes Rewrite Rules .
*
* @ param int $post_id The ID in the database table for the $post
* @ param object $post Object type containing the post information
*/
2007-07-12 18:00:51 +02:00
function _save_post_hook ( $post_id , $post ) {
if ( $post -> post_type == 'page' ) {
clean_page_cache ( $post_id );
2008-10-09 00:16:35 +02:00
// Avoid flushing rules for every post during import.
if ( ! defined ( 'WP_IMPORTING' ) ) {
global $wp_rewrite ;
2009-06-16 04:44:28 +02:00
$wp_rewrite -> flush_rules ( false );
2008-10-09 00:16:35 +02:00
}
2007-07-12 18:00:51 +02:00
} else {
clean_post_cache ( $post_id );
}
}
2008-08-19 18:38:06 +02:00
/**
* Retrieve post ancestors and append to post ancestors property .
*
* Will only retrieve ancestors once , if property is already set , then nothing
* will be done . If there is not a parent post , or post ID and post parent ID
* are the same then nothing will be done .
*
* The parameter is passed by reference , so nothing needs to be returned . The
* property will be updated and can be referenced after the function is
* complete . The post parent will be an ancestor and the parent of the post
* parent will be an ancestor . There will only be two ancestors at the most .
*
* @ since unknown
2009-05-06 22:49:36 +02:00
* @ access private
2008-08-19 18:38:06 +02:00
* @ uses $wpdb
*
* @ param object $_post Post data .
* @ return null When nothing needs to be done .
*/
2008-02-28 00:28:18 +01:00
function _get_post_ancestors ( & $_post ) {
2008-04-16 19:23:17 +02:00
global $wpdb ;
2008-02-28 00:28:18 +01:00
2008-04-16 19:23:17 +02:00
if ( isset ( $_post -> ancestors ) )
return ;
2008-03-02 21:17:30 +01:00
2008-04-16 19:23:17 +02:00
$_post -> ancestors = array ();
2008-02-28 00:28:18 +01:00
2008-04-16 19:23:17 +02:00
if ( empty ( $_post -> post_parent ) || $_post -> ID == $_post -> post_parent )
return ;
2008-02-28 00:28:18 +01:00
2008-04-16 19:23:17 +02:00
$id = $_post -> ancestors [] = $_post -> post_parent ;
while ( $ancestor = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT `post_parent` FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $id ) ) ) {
if ( $id == $ancestor )
break ;
$id = $_post -> ancestors [] = $ancestor ;
}
2008-02-28 00:28:18 +01:00
}
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
* to be insterted into the posts table as a post revision . Otherwise , returns
* 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
*/
2008-05-30 00:21:36 +02:00
function wp_save_post_revision ( $post_id ) {
// 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 ;
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
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-02-22 01:35:42 +01:00
$post = add_magic_quotes ( $post ); //since data is from db
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 .
* @ param string $filter Optional sanitation filter . @ see sanitize_post ()
* @ return mixed Null if error or post object if success
2008-04-19 01:38:21 +02:00
*/
2008-05-30 00:21:36 +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
2009-02-22 01:35:42 +01:00
$update = add_magic_quotes ( $update ); //since data is from db
2008-04-19 01:38:21 +02: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 .
* @ param array $fields Optional . What fields to restore from . Defaults to all .
* @ 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_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-02-20 22:57:43 +01:00
}