2004-05-24 03:34:57 +02:00
< ? php
2006-06-08 01:17:59 +02:00
//
// Post functions
//
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 );
if ( $unfiltered )
return $file ;
return apply_filters ( 'get_attached_file' , $file , $attachment_id );
}
function update_attached_file ( $attachment_id , $file ) {
if ( ! get_post ( $attachment_id ) )
return false ;
$old_file = get_attached_file ( $attachment_id , true );
$file = apply_filters ( 'update_attached_file' , $file , $attachment_id );
if ( $old_file )
return update_post_meta ( $attachment_id , '_wp_attached_file' , $file , $old_file );
else
return add_post_meta ( $attachment_id , '_wp_attached_file' , $file );
2006-06-08 01:17:59 +02:00
}
2006-11-20 05:23:12 +01:00
function & get_children ( $args = '' , $output = OBJECT ) {
2007-05-11 05:10:05 +02:00
if ( empty ( $args ) ) {
if ( isset ( $GLOBALS [ 'post' ] ) ) {
$args = 'post_parent=' . ( int ) $GLOBALS [ 'post' ] -> post_parent ;
} else {
2006-06-08 01:17:59 +02:00
return false ;
2007-05-11 05:10:05 +02:00
}
} elseif ( is_object ( $args ) ) {
$args = 'post_parent=' . ( int ) $args -> post_parent ;
} elseif ( is_numeric ( $args ) ) {
$args = 'post_parent=' . ( int ) $args ;
}
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
'numberposts' => - 1 , 'post_type' => '' ,
2007-05-11 05:10:05 +02:00
'post_status' => '' , 'post_parent' => 0
);
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 );
2006-06-08 01:17:59 +02:00
2007-10-12 23:12:34 +02:00
if ( ! $children )
2006-06-08 01:17:59 +02:00
return false ;
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 ) {
foreach ( $kids as $kid )
$weeuns [ $kid -> ID ] = get_object_vars ( $kids [ $kid -> ID ]);
return $weeuns ;
} elseif ( $output == ARRAY_N ) {
foreach ( $kids as $kid )
$babes [ $kid -> ID ] = array_values ( get_object_vars ( $kids [ $kid -> ID ]));
return $babes ;
} else {
return $kids ;
}
}
// get extended entry info (<!--more-->)
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 );
}
// Retrieves post data given a post ID or post object.
// Handles post caching.
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 ;
2006-06-08 01:17:59 +02:00
if ( empty ( $post ) ) {
if ( isset ( $GLOBALS [ 'post' ]) )
$_post = & $GLOBALS [ 'post' ];
else
2007-10-12 23:12:34 +02:00
return null ;
2006-06-08 01:17:59 +02:00
} elseif ( is_object ( $post ) ) {
2007-10-12 23:12:34 +02:00
wp_cache_add ( $post -> ID , $post , 'posts' );
$_post = & $post ;
2006-06-08 01:17:59 +02:00
} else {
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' ) ) {
2007-10-02 20:45:47 +02:00
$_post = & $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $post ));
2007-10-12 23:12:34 +02:00
wp_cache_add ( $_post -> ID , $_post , 'posts' );
2006-06-08 01:17:59 +02:00
}
}
2007-07-11 21:57:43 +02:00
$_post = sanitize_post ( $_post , $filter );
2006-06-08 01:17:59 +02:00
if ( $output == OBJECT ) {
return $_post ;
} elseif ( $output == ARRAY_A ) {
return get_object_vars ( $_post );
} elseif ( $output == ARRAY_N ) {
return array_values ( get_object_vars ( $_post ));
} else {
return $_post ;
}
}
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 );
}
2006-06-08 01:17:59 +02:00
// Takes a post ID, returns its mime type.
function get_post_mime_type ( $ID = '' ) {
$post = & get_post ( $ID );
if ( is_object ( $post ) )
return $post -> post_mime_type ;
return false ;
}
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 ;
}
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 ;
}
2006-06-08 04:22:16 +02:00
function get_posts ( $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
'numberposts' => 5 , 'offset' => 0 ,
'category' => 0 , 'orderby' => 'post_date' ,
'order' => 'DESC' , 'include' => '' ,
'exclude' => '' , 'meta_key' => '' ,
'meta_value' => '' , 'post_type' => 'post' ,
2007-05-11 05:10:05 +02:00
'post_status' => 'publish' , 'post_parent' => 0
);
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 );
2007-06-14 04:25:30 +02:00
2006-11-20 05:23:12 +01:00
$numberposts = ( int ) $numberposts ;
$offset = ( int ) $offset ;
$category = ( int ) $category ;
$post_parent = ( int ) $post_parent ;
2006-06-08 04:22:16 +02:00
$inclusions = '' ;
if ( ! empty ( $include ) ) {
2006-11-20 05:23:12 +01:00
$offset = 0 ; //ignore offset, category, exclude, meta_key, and meta_value, post_parent if using include
$category = 0 ;
2006-11-19 08:56:05 +01:00
$exclude = '' ;
2006-06-08 04:22:16 +02:00
$meta_key = '' ;
$meta_value = '' ;
2006-11-20 05:23:12 +01:00
$post_parent = 0 ;
2006-06-08 04:22:16 +02:00
$incposts = preg_split ( '/[\s,]+/' , $include );
$numberposts = count ( $incposts ); // only the number of posts included
if ( count ( $incposts ) ) {
foreach ( $incposts as $incpost ) {
if ( empty ( $inclusions ))
2007-10-02 20:45:47 +02:00
$inclusions = $wpdb -> prepare ( ' AND ( ID = %d ' , $incpost );
2006-06-08 04:22:16 +02:00
else
2007-10-02 20:45:47 +02:00
$inclusions .= $wpdb -> prepare ( ' OR ID = %d ' , $incpost );
2006-06-08 04:22:16 +02:00
}
}
}
2006-11-19 08:56:05 +01:00
if ( ! empty ( $inclusions ))
$inclusions .= ')' ;
2006-06-08 04:22:16 +02:00
$exclusions = '' ;
if ( ! empty ( $exclude ) ) {
$exposts = preg_split ( '/[\s,]+/' , $exclude );
if ( count ( $exposts ) ) {
foreach ( $exposts as $expost ) {
if ( empty ( $exclusions ))
2007-10-02 20:45:47 +02:00
$exclusions = $wpdb -> prepare ( ' AND ( ID <> %d ' , $expost );
2006-06-08 04:22:16 +02:00
else
2007-10-02 20:45:47 +02:00
$exclusions .= $wpdb -> prepare ( ' AND ID <> %d ' , $expost );
2006-06-08 04:22:16 +02:00
}
}
}
2006-11-19 08:56:05 +01:00
if ( ! empty ( $exclusions ))
2006-06-08 04:22:16 +02:00
$exclusions .= ')' ;
2006-11-20 05:23:12 +01:00
$query = " SELECT DISTINCT * FROM $wpdb->posts " ;
2007-09-04 01:32:58 +02:00
$query .= empty ( $category ) ? '' : " , $wpdb->term_relationships , $wpdb->term_taxonomy " ;
2006-11-20 05:23:12 +01:00
$query .= empty ( $meta_key ) ? '' : " , $wpdb->postmeta " ;
$query .= " WHERE 1=1 " ;
2007-10-02 20:45:47 +02:00
$query .= empty ( $post_type ) ? '' : $wpdb -> prepare ( " AND post_type = %s " , $post_type );
$query .= empty ( $post_status ) ? '' : $wpdb -> prepare ( " AND post_status = %s " , $post_status );
2006-11-20 05:23:12 +01:00
$query .= " $exclusions $inclusions " ;
2007-10-02 20:45:47 +02:00
$query .= empty ( $category ) ? '' : $wpdb -> prepare ( " AND ( $wpdb->posts .ID = $wpdb->term_relationships .object_id AND $wpdb->term_relationships .term_taxonomy_id = $wpdb->term_taxonomy .term_taxonomy_id AND $wpdb->term_taxonomy .term_id = %d) " , $category );
$query .= empty ( $post_parent ) ? '' : $wpdb -> prepare ( " AND $wpdb->posts .post_parent = %d " , $post_parent );
// expected_slashed ($meta_key, $meta_value) -- Also, this looks really funky, doesn't seem like it works
2006-11-20 05:23:12 +01:00
$query .= empty ( $meta_key ) | empty ( $meta_value ) ? '' : " AND ( $wpdb->posts .ID = $wpdb->postmeta .post_id AND $wpdb->postmeta .meta_key = ' $meta_key ' AND $wpdb->postmeta .meta_value = ' $meta_value ' ) " ;
$query .= " GROUP BY $wpdb->posts .ID ORDER BY " . $orderby . ' ' . $order ;
if ( 0 < $numberposts )
2007-10-02 20:45:47 +02:00
$query .= $wpdb -> prepare ( " LIMIT %d,%d " , $offset , $numberposts );
2006-06-08 04:22:16 +02:00
$posts = $wpdb -> get_results ( $query );
update_post_caches ( $posts );
return $posts ;
}
2006-06-08 01:17:59 +02:00
//
// Post meta functions
//
2007-10-13 04:36:38 +02:00
function add_post_meta ( $post_id , $meta_key , $meta_value , $unique = false ) {
2007-10-12 23:12:34 +02:00
global $wpdb ;
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
// expected_slashed ($meta_key)
$meta_key = stripslashes ( $meta_key );
if ( $unique && $wpdb -> get_var ( $wpdb -> prepare ( " SELECT meta_key FROM $wpdb->postmeta WHERE meta_key = %s AND post_id = %d " , $meta_key , $post_id ) ) )
return false ;
2006-06-08 01:17:59 +02:00
2007-10-12 23:12:34 +02:00
$cache = wp_cache_get ( $post_id , 'post_meta' );
if ( ! is_array ( $cache ) )
$cache = array ();
2007-10-13 04:36:38 +02:00
// expected_slashed ($meta_key)
$cache [ $wpdb -> escape ( $meta_key )][] = $meta_value ;
2007-10-12 23:12:34 +02:00
wp_cache_set ( $post_id , $cache , 'post_meta' );
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
$meta_value = maybe_serialize ( $meta_value );
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
$wpdb -> insert ( $wpdb -> postmeta , compact ( 'post_id' , 'meta_key' , 'meta_value' ) );
2006-06-08 01:17:59 +02:00
return true ;
}
function delete_post_meta ( $post_id , $key , $value = '' ) {
2007-10-12 23:12:34 +02:00
global $wpdb ;
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
$post_id = absint ( $post_id );
// expected_slashed ($key, $value)
$key = stripslashes ( $key );
$value = stripslashes ( $value );
if ( empty ( $value ) )
$meta_id = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s " , $post_id , $key ) );
else
$meta_id = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s AND meta_value = %s " , $post_id , $key , $value ) );
2006-06-08 01:17:59 +02:00
if ( ! $meta_id )
return false ;
2007-10-13 04:36:38 +02:00
if ( empty ( $value ) )
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s " , $post_id , $key ) );
else
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s AND meta_value = %s " , $post_id , $key , $value ) );
2006-06-08 01:17:59 +02:00
2007-10-12 23:12:34 +02:00
wp_cache_delete ( $post_id , 'post_meta' );
2006-06-08 01:17:59 +02:00
return true ;
}
function get_post_meta ( $post_id , $key , $single = false ) {
2006-10-11 11:18:54 +02:00
$post_id = ( int ) $post_id ;
2007-10-12 23:12:34 +02:00
$meta_cache = wp_cache_get ( $post_id , 'post_meta' );
if ( isset ( $meta_cache [ $key ]) ) {
2006-11-23 21:39:39 +01:00
if ( $single ) {
2007-10-12 23:12:34 +02:00
return maybe_unserialize ( $meta_cache [ $key ][ 0 ] );
2006-11-23 21:39:39 +01:00
} else {
2007-10-12 23:12:34 +02:00
return maybe_unserialize ( $meta_cache [ $key ] );
2006-11-23 21:39:39 +01:00
}
}
2007-10-12 23:12:34 +02:00
if ( ! $meta_cache ) {
2006-10-24 12:52:59 +02:00
update_postmeta_cache ( $post_id );
2007-10-12 23:12:34 +02:00
$meta_cache = wp_cache_get ( $post_id , 'post_meta' );
}
2006-06-08 01:17:59 +02:00
if ( $single ) {
2007-10-12 23:12:34 +02:00
if ( isset ( $meta_cache [ $key ][ 0 ]) )
return maybe_unserialize ( $meta_cache [ $key ][ 0 ]);
2006-10-24 12:52:59 +02:00
else
2006-06-08 01:17:59 +02:00
return '' ;
2007-10-12 23:12:34 +02:00
} else {
return maybe_unserialize ( $meta_cache [ $key ]);
2006-06-08 01:17:59 +02:00
}
}
2007-10-13 04:36:38 +02:00
function update_post_meta ( $post_id , $meta_key , $meta_value , $prev_value = '' ) {
2007-10-12 23:12:34 +02:00
global $wpdb ;
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
$meta_value = maybe_serialize ( $meta_value );
2006-10-13 02:23:25 +02:00
$prev_value = maybe_serialize ( $prev_value );
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
// expected_slashed ($meta_key)
$meta_key = stripslashes ( $meta_key );
if ( ! $wpdb -> get_var ( $wpdb -> prepare ( " SELECT meta_key FROM $wpdb->postmeta WHERE meta_key = %s AND post_id = %d " , $meta_key , $post_id ) ) )
2006-06-08 01:17:59 +02:00
return false ;
2007-10-13 04:36:38 +02:00
$data = compact ( 'meta_value' );
$where = compact ( 'meta_key' , 'post_id' );
2006-06-08 01:17:59 +02:00
2007-10-13 04:36:38 +02:00
if ( ! empty ( $prev_value ) )
$where [ 'meta_value' ] = $prev_value ;
2007-10-12 23:12:34 +02:00
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> postmeta , $data , $where );
wp_cache_delete ( $post_id , 'post_meta' );
2006-06-08 01:17:59 +02:00
return true ;
}
2007-08-29 21:12:20 +02:00
function delete_post_meta_by_key ( $post_meta_key ) {
2007-10-12 23:12:34 +02:00
global $wpdb ;
2007-10-02 20:45:47 +02:00
if ( $wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE meta_key = %s " , $post_meta_key )) ) {
2007-10-12 23:12:34 +02:00
// TODO Get post_ids and delete cache
// wp_cache_delete($post_id, 'post_meta');
2007-08-29 21:12:20 +02:00
return true ;
}
return false ;
}
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
}
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 ;
}
function get_post_custom_values ( $key = '' , $post_id = 0 ) {
$custom = get_post_custom ( $post_id );
return $custom [ $key ];
}
2007-07-11 21:57:43 +02:00
function sanitize_post ( $post , $context = 'display' ) {
2007-11-07 07:20:08 +01:00
if ( 'raw' == $context )
return $post ;
2007-07-11 21:57:43 +02:00
// TODO: Use array keys instead of hard coded list
2007-07-25 00:29:41 +02:00
$fields = 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_date' , 'post_date_gmt' , 'post_parent' , 'menu_order' , 'post_mime_type' , 'post_category' );
2007-07-11 21:57:43 +02:00
$do_object = false ;
if ( is_object ( $post ) )
$do_object = true ;
foreach ( $fields as $field ) {
if ( $do_object )
$post -> $field = sanitize_post_field ( $field , $post -> $field , $post -> ID , $context );
else
2007-09-04 01:32:58 +02:00
$post [ $field ] = sanitize_post_field ( $field , $post [ $field ], $post [ 'ID' ], $context );
2007-07-11 21:57:43 +02:00
}
return $post ;
}
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 ;
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 {
$value = attribute_escape ( $value );
}
} 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 )
$value = attribute_escape ( $value );
else if ( 'js' == $context )
$value = js_escape ( $value );
return $value ;
}
2006-06-08 01:17:59 +02:00
function wp_delete_post ( $postid = 0 ) {
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 ;
if ( 'attachment' == $post -> post_type )
return wp_delete_attachment ( $postid );
do_action ( 'delete_post' , $postid );
2007-05-27 07:15:18 +02:00
// TODO delete for pluggable post taxonomies too
wp_delete_object_term_relationships ( $postid , array ( 'category' , 'post_tag' ));
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 ) {
// if the page is defined in option page_on_front or post_for_posts,
// 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' );
}
// Point children of this page to its parent
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , $parent_data , $parent_where + array ( 'post_type' => 'page' ) );
2007-11-16 18:39:15 +01:00
}
2006-06-08 01:17:59 +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
2007-10-02 20:45:47 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->posts WHERE ID = %d " , $postid ));
2006-06-08 01:17:59 +02:00
2007-10-02 20:45:47 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->comments WHERE comment_post_ID = %d " , $postid ));
2006-06-08 01:17:59 +02:00
2007-10-02 20:45:47 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE post_id = %d " , $postid ));
2006-06-08 01:17:59 +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 );
2006-06-08 01:17:59 +02:00
$wp_rewrite -> flush_rules ();
2007-10-14 06:55:33 +02:00
} else {
clean_post_cache ( $postid );
2006-06-08 01:17:59 +02:00
}
2007-03-31 23:41:08 +02:00
do_action ( 'deleted_post' , $postid );
2007-06-14 04:25:30 +02:00
2006-06-08 01:17:59 +02:00
return $post ;
}
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-05-27 07:15:18 +02:00
function wp_get_post_tags ( $post_id = 0 , $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
2007-06-19 02:33:44 +02:00
$tags = wp_get_object_terms ( $post_id , 'post_tag' , $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
}
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 ;
2006-06-08 01:17:59 +02:00
if ( $num ) {
$limit = " LIMIT $num " ;
}
$sql = " SELECT * FROM $wpdb->posts WHERE post_type = 'post' ORDER BY post_date DESC $limit " ;
$result = $wpdb -> get_results ( $sql , ARRAY_A );
return $result ? $result : array ();
}
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
function wp_insert_post ( $postarr = array ()) {
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 ,
'menu_order' => 0 , 'to_ping' => '' , 'pinged' => '' , 'post_password' => '' );
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
}
2006-09-02 22:19:07 +02:00
if ( ( '' == $post_content ) && ( '' == $post_title ) && ( '' == $post_excerpt ) )
2006-08-25 02:27:15 +02:00
return 0 ;
2004-05-24 03:34:57 +02:00
// Make sure we set a valid category
if ( 0 == count ( $post_category ) || ! is_array ( $post_category )) {
2005-06-18 21:17:55 +02:00
$post_category = array ( get_option ( 'default_category' ));
2004-05-24 03:34:57 +02:00
}
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
if ( empty ( $post_type ) )
$post_type = 'post' ;
2005-06-19 03:33:38 +02:00
// Get the post ID.
2005-10-13 21:06:31 +02:00
if ( $update )
2007-03-23 01:59:21 +01:00
$post_ID = ( int ) $ID ;
2005-06-18 21:08:38 +02:00
// Create a valid post name. Drafts are allowed to have an empty
// post name.
if ( empty ( $post_name ) ) {
if ( 'draft' != $post_status )
2005-10-13 21:06:31 +02:00
$post_name = sanitize_title ( $post_title );
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
2005-11-14 10:56:41 +01:00
// If the post date is empty (due to having been new or a draft) and status is not 'draft', set date to now
if ( empty ( $post_date )) {
2007-06-14 18:24:28 +02:00
if ( ! in_array ( $post_status , array ( 'draft' , 'pending' )) )
2005-11-14 10:56:41 +01:00
$post_date = current_time ( 'mysql' );
}
if ( empty ( $post_date_gmt )) {
2007-06-14 18:24:28 +02:00
if ( ! in_array ( $post_status , array ( 'draft' , 'pending' )) )
2005-11-14 10:56:41 +01:00
$post_date_gmt = get_gmt_from_date ( $post_date );
}
2007-02-27 16:24:54 +01:00
2007-10-13 02:48:52 +02:00
if ( $update ) {
$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' );
if ( mysql2date ( 'U' , $post_date_gmt ) > mysql2date ( 'U' , $now ) )
$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
2005-06-18 21:08:38 +02:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
if ( ! isset ( $post_password ) )
$post_password = '' ;
2006-02-09 11:03:48 +01:00
if ( 'draft' != $post_status ) {
2007-10-13 02:48:52 +02:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND post_type = %s AND ID != %d AND post_parent = %d LIMIT 1 " , $post_name , $post_type , $post_ID , $post_parent ));
2005-12-07 20:02:05 +01:00
2006-09-21 02:01:20 +02:00
if ( $post_name_check || in_array ( $post_name , $wp_rewrite -> feeds ) ) {
2005-02-14 05:51:14 +01:00
$suffix = 2 ;
2006-09-21 02:01:20 +02:00
do {
2007-06-12 22:49:40 +02:00
$alt_post_name = substr ( $post_name , 0 , 200 - ( strlen ( $suffix ) + 1 )) . " - $suffix " ;
2007-10-02 20:45:47 +02:00
// expected_slashed ($alt_post_name, $post_name, $post_type)
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $alt_post_name ' AND post_type = ' $post_type ' AND ID != %d AND post_parent = %d LIMIT 1 " , $post_ID , $post_parent ));
2005-02-14 05:51:14 +01:00
$suffix ++ ;
2006-09-21 02:01:20 +02:00
} while ( $post_name_check );
2005-02-14 05:51:14 +01:00
$post_name = $alt_post_name ;
}
}
2007-10-13 02:48:52 +02:00
// expected_slashed (everything!)
$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' ) );
$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
2005-06-19 03:33:38 +02:00
if ( $update ) {
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , $data , $where );
2005-06-19 03:33:38 +02:00
} else {
2007-10-13 02:48:52 +02:00
$data [ 'post_mime_type' ] = stripslashes ( $post_mime_type ); // This isn't in the update
2007-10-13 02:54:26 +02:00
$wpdb -> insert ( $wpdb -> posts , $data );
2007-10-13 02:48:52 +02:00
$post_ID = ( int ) $wpdb -> insert_id ;
2007-11-02 01:47:04 +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
}
if ( empty ( $post_name ) && 'draft' != $post_status ) {
$post_name = sanitize_title ( $post_title , $post_ID );
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , compact ( '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 );
wp_set_post_tags ( $post_ID , $tags_input );
2005-09-14 02:34:04 +02:00
2006-02-09 11:03:48 +01:00
if ( 'page' == $post_type ) {
2005-09-14 02:34:04 +02:00
clean_page_cache ( $post_ID );
2005-11-07 22:56:03 +01:00
} else {
2005-09-14 02:34:04 +02:00
clean_post_cache ( $post_ID );
2005-11-07 22:56:03 +01:00
}
2004-09-05 04:03:51 +02:00
// Set GUID
2005-06-19 03:33:38 +02:00
if ( ! $update )
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 );
if ( ! empty ( $page_template ) )
$post -> page_template = $page_template ;
2006-11-19 08:56:05 +01:00
2007-07-12 18:00:51 +02:00
wp_transition_post_status ( $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
}
2006-06-08 01:17:59 +02:00
function wp_update_post ( $postarr = array ()) {
if ( is_object ( $postarr ) )
$postarr = get_object_vars ( $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
2007-06-14 18:24:28 +02:00
if ( in_array ( $post [ 'post_status' ], array ( 'draft' , 'pending' )) && empty ( $postarr [ 'edit_date' ]) && empty ( $postarr [ 'post_date' ]) &&
2006-11-19 08:56:05 +01:00
( '0000-00-00 00:00:00' == $post [ 'post_date' ]) )
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 ) {
$postarr [ 'post_date' ] = '' ;
$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
}
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 );
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
}
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 );
}
function wp_set_post_tags ( $post_id = 0 , $tags = '' , $append = false ) {
/* $append - true = don't delete existing tags, just add on, false = replace the tags with the new tags */
2007-06-14 04:25:30 +02:00
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 ();
2007-04-07 21:00:19 +02:00
$tags = ( is_array ( $tags )) ? $tags : explode ( ',' , $tags );
2007-05-22 22:39:26 +02:00
wp_set_object_terms ( $post_id , $tags , 'post_tag' , $append );
2007-03-26 09:28:29 +02: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 ;
2004-05-24 03:34:57 +02:00
// If $post_categories isn't already an array, make it one:
2006-08-27 21:26:03 +02:00
if ( ! is_array ( $post_categories ) || 0 == count ( $post_categories ) || empty ( $post_categories ))
2005-07-03 20:33:03 +02:00
$post_categories = array ( get_option ( 'default_category' ));
2007-06-21 00:06:29 +02:00
else if ( 1 == count ( $post_categories ) && '' == $post_categories [ 0 ] )
return true ;
2006-02-12 08:53:23 +01:00
2007-05-23 20:07:53 +02:00
$post_categories = array_map ( 'intval' , $post_categories );
2004-05-24 03:34:57 +02:00
$post_categories = array_unique ( $post_categories );
2007-05-23 20:07:53 +02:00
return wp_set_object_terms ( $post_ID , $post_categories , 'category' );
2006-06-06 07:04:41 +02:00
} // wp_set_post_categories()
2004-05-24 03:34:57 +02:00
2007-07-12 18:00:51 +02:00
function wp_transition_post_status ( $new_status , $old_status , $post ) {
if ( $new_status != $old_status ) {
do_action ( 'transition_post_status' , $new_status , $old_status , $post );
do_action ( " ${ old_status } _to_ $new_status " , $post );
}
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
2006-08-30 18:40:17 +02:00
function add_ping ( $post_id , $uri ) { // Add a URL to those already pung
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
2006-06-08 01:17:59 +02:00
function get_enclosed ( $post_id ) { // Get enclosures already enclosed for a post
$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
}
2006-08-30 18:40:17 +02:00
function get_pung ( $post_id ) { // Get URLs already pung for a post
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
}
2006-08-30 18:40:17 +02:00
function get_to_ping ( $post_id ) { // Get any URLs in the todo list
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
}
// do trackbacks for a list of urls
// accepts a comma-separated list of trackback urls and a post id
function trackback_url_list ( $tb_list , $post_id ) {
if ( ! empty ( $tb_list )) {
// 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
$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 );
foreach ( $trackback_urls as $tb_url ) {
2006-11-19 08:56:05 +01:00
$tb_url = trim ( $tb_url );
trackback ( $tb_url , stripslashes ( $post_title ), $excerpt , $post_id );
}
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
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
}
2006-06-08 01:17:59 +02:00
// Retrieves page data given a page ID or page object.
// Handles page caching.
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 ) ) {
2007-10-12 23:12:34 +02:00
if ( isset ( $GLOBALS [ 'page' ] ) && isset ( $GLOBALS [ 'page' ] -> ID ) )
return get_post ( $GLOBALS [ 'page' ], $output , $filter );
else
return null ;
2005-02-12 09:58:10 +01:00
}
2006-06-08 01:17:59 +02:00
2007-10-12 23:12:34 +02:00
return get_post ( $page , $output , $filter );
2005-02-12 09:58:10 +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 );
foreach ( $page_paths as $pathdir )
$full_path .= ( $pathdir != '' ? '/' : '' ) . sanitize_title ( $pathdir );
2007-10-02 20:45:47 +02:00
$pages = $wpdb -> get_results ( $wpdb -> prepare ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_name = %s AND post_type='page' " , $leaf_path ));
2006-06-08 01:17:59 +02:00
2006-11-19 08:56:05 +01:00
if ( empty ( $pages ) )
2006-06-08 01:17:59 +02:00
return NULL ;
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 );
}
return NULL ;
2004-10-14 09:26:41 +02: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 );
return NULL ;
}
2006-06-08 01:17:59 +02:00
function & get_page_children ( $page_id , $pages ) {
$page_list = array ();
foreach ( $pages as $page ) {
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
}
2005-12-24 17:26:55 +01:00
//fetches the pages returned as a FLAT list, but arranged in order of their hierarchy, i.e., child parents
//immediately follow their parents
function get_page_hierarchy ( $posts , $parent = 0 ) {
$result = array ( );
if ( $posts ) { foreach ( $posts as $post ) {
if ( $post -> post_parent == $parent ) {
$result [ $post -> ID ] = $post -> post_name ;
$children = get_page_hierarchy ( $posts , $post -> ID );
$result += $children ; //append $children to $result
}
} }
return $result ;
}
2006-06-08 04:22:16 +02:00
function get_page_uri ( $page_id ) {
$page = get_page ( $page_id );
$uri = urldecode ( $page -> post_name );
// 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 );
$uri = urldecode ( $page -> post_name ) . " / " . $uri ;
}
return $uri ;
}
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' => '' ,
2007-05-11 05:10:05 +02:00
'authors' => ''
);
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 );
2006-06-08 01:17:59 +02:00
2006-11-23 18:21:08 +01:00
$key = md5 ( serialize ( $r ) );
2007-10-15 22:11:30 +02:00
if ( $cache = wp_cache_get ( 'get_pages' , 'posts' ) )
2006-11-23 18:21:08 +01:00
if ( isset ( $cache [ $key ] ) )
return apply_filters ( 'get_pages' , $cache [ $key ], $r );
2006-06-08 01:17:59 +02:00
$inclusions = '' ;
if ( ! empty ( $include ) ) {
2007-09-04 01:32:58 +02:00
$child_of = 0 ; //ignore child_of, exclude, meta_key, and meta_value params if using include
2006-11-24 23:55:28 +01:00
$exclude = '' ;
2006-06-08 01:17:59 +02:00
$meta_key = '' ;
$meta_value = '' ;
$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 ) " ;
}
}
2006-06-08 01:17:59 +02:00
$query = " SELECT * FROM $wpdb->posts " ;
2007-09-04 01:32:58 +02:00
$query .= ( empty ( $meta_key ) ? " " : " , $wpdb->postmeta " ) ;
2006-06-08 01:17:59 +02:00
$query .= " WHERE (post_type = 'page' AND post_status = 'publish') $exclusions $inclusions " ;
2007-10-02 20:45:47 +02:00
// expected_slashed ($meta_key, $meta_value) -- also, it looks funky
2006-06-08 01:17:59 +02:00
$query .= ( empty ( $meta_key ) | empty ( $meta_value ) ? " " : " AND ( $wpdb->posts .ID = $wpdb->postmeta .post_id AND $wpdb->postmeta .meta_key = ' $meta_key ' AND $wpdb->postmeta .meta_value = ' $meta_value ' ) " ) ;
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 ;
$pages = $wpdb -> get_results ( $query );
if ( empty ( $pages ) )
2007-10-09 00:25:33 +02:00
return apply_filters ( 'get_pages' , array (), $r );
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 );
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
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-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 ,
'menu_order' => 0 , 'to_ping' => '' , 'pinged' => '' , 'post_password' => '' );
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
// Make sure we set a valid category
if ( 0 == count ( $post_category ) || ! is_array ( $post_category )) {
$post_category = array ( get_option ( 'default_category' ));
}
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' ;
2005-11-19 21:08:21 +01:00
2006-06-08 01:17:59 +02:00
// Are we updating or creating?
$update = false ;
if ( ! empty ( $ID ) ) {
$update = true ;
2007-03-23 01:59:21 +01:00
$post_ID = ( int ) $ID ;
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
2007-10-02 20:45:47 +02:00
// expected_slashed ($post_name)
2007-12-06 20:49:33 +01:00
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $post_name ' AND post_status = 'inherit' AND ID != %d LIMIT 1 " , $post_ID ));
2006-12-01 00:09:27 +01:00
if ( $post_name_check ) {
$suffix = 2 ;
while ( $post_name_check ) {
$alt_post_name = $post_name . " - $suffix " ;
2007-10-02 20:45:47 +02:00
// expected_slashed ($alt_post_name, $post_name)
$post_name_check = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $alt_post_name ' AND post_status = 'inherit' AND ID != %d AND post_parent = %d LIMIT 1 " , $post_ID , $post_parent ));
2006-12-01 00:09:27 +01:00
$suffix ++ ;
}
$post_name = $alt_post_name ;
}
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
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 {
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 );
2006-02-12 08:53:23 +01:00
2006-06-08 01:17:59 +02:00
clean_post_cache ( $post_ID );
2005-12-01 23:51:40 +01:00
2006-06-08 01:17:59 +02:00
if ( $update ) {
do_action ( 'edit_attachment' , $post_ID );
} else {
do_action ( 'add_attachment' , $post_ID );
2005-12-29 02:46:32 +01:00
}
2006-02-12 08:53:23 +01:00
2006-06-08 01:17:59 +02:00
return $post_ID ;
}
function wp_delete_attachment ( $postid ) {
global $wpdb ;
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 ;
2006-01-02 05:59:39 +01:00
2006-06-08 01:17:59 +02:00
if ( 'attachment' != $post -> post_type )
return false ;
2006-02-12 08:53:23 +01:00
2006-12-05 23:37:19 +01:00
$meta = wp_get_attachment_metadata ( $postid );
$file = get_attached_file ( $postid );
2005-12-01 23:51:40 +01:00
2007-05-29 06:26:36 +02:00
// TODO delete for pluggable post taxonomies too
wp_delete_object_term_relationships ( $postid , array ( 'category' , 'post_tag' ));
2007-10-02 20:45:47 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->posts WHERE ID = %d " , $postid ));
2005-12-01 23:51:40 +01:00
2007-10-02 20:45:47 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->comments WHERE comment_post_ID = %d " , $postid ));
2005-12-01 23:51:40 +01:00
2007-10-02 20:45:47 +02:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->postmeta WHERE post_id = %d " , $postid ));
2006-03-30 09:36:54 +02:00
2006-06-08 01:17:59 +02:00
if ( ! empty ( $meta [ 'thumb' ]) ) {
// Don't delete the thumb if another attachment uses it
2007-10-02 20:45:47 +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' ] . '%' , $postid )) ) {
2006-06-08 01:17:59 +02:00
$thumbfile = str_replace ( basename ( $file ), $meta [ 'thumb' ], $file );
$thumbfile = apply_filters ( 'wp_delete_file' , $thumbfile );
@ unlink ( $thumbfile );
2006-03-30 09:36:54 +02: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 );
2007-10-14 06:55:33 +02:00
clean_post_cache ( $postid );
2006-06-08 01:17:59 +02:00
do_action ( 'delete_attachment' , $postid );
return $post ;
2006-03-30 09:50:33 +02:00
}
2006-12-05 23:37:19 +01:00
function wp_get_attachment_metadata ( $post_id , $unfiltered = false ) {
$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 );
2006-12-05 23:37:19 +01:00
if ( $unfiltered )
return $data ;
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
}
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
$old_data = wp_get_attachment_metadata ( $post -> ID , true );
2006-12-05 23:37:19 +01:00
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
if ( $old_data )
2007-01-05 21:54:55 +01:00
return update_post_meta ( $post -> ID , '_wp_attachment_metadata' , $data , $old_data );
2006-12-05 23:37:19 +01:00
else
2007-01-05 21:54:55 +01:00
return add_post_meta ( $post -> ID , '_wp_attachment_metadata' , $data );
2006-12-05 23:37:19 +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 ;
2007-01-05 21:54:55 +01:00
$url = get_the_guid ( $post -> ID );
2007-01-02 20:28:30 +01:00
if ( 'attachment' != $post -> post_type || ! $url )
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-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 ;
if ( ! $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 ;
}
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 ;
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
}
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 ;
}
function wp_mime_type_icon ( $mime = 0 ) {
$post_id = 0 ;
if ( is_numeric ( $mime ) ) {
$mime = ( int ) $mime ;
if ( ! $post =& get_post ( $mime ) )
return false ;
2007-03-23 01:59:21 +01:00
$post_id = ( int ) $post -> ID ;
2007-01-02 20:28:30 +01:00
$mime = $post -> post_mime_type ;
}
if ( empty ( $mime ) )
return false ;
$icon_dir = apply_filters ( 'icon_dir' , get_template_directory () . '/images' );
$icon_dir_uri = apply_filters ( 'icon_dir_uri' , get_template_directory_uri () . '/images' );
$types = array (
substr ( $mime , 0 , strpos ( $mime , '/' )),
substr ( $mime , strpos ( $mime , '/' ) + 1 ),
str_replace ( '/' , '_' , $mime )
);
$exts = array ( 'jpg' , 'gif' , 'png' );
$src = false ;
foreach ( $types as $type ) {
foreach ( $exts as $ext ) {
$src_file = " $icon_dir / $type . $ext " ;
if ( file_exists ( $src_file ) ) {
$src = " $icon_dir_uri / $type . $ext " ;
break 2 ;
}
}
}
return apply_filters ( 'wp_mime_type_icon' , $src , $mime , $post_id ); // Last arg is 0 if function pass mime type.
}
2006-12-10 18:17:39 +01:00
function wp_check_for_changed_slugs ( $post_id ) {
if ( ! strlen ( $_POST [ 'wp-old-slug' ]) )
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
/**
* 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
*
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-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' :
$lastpostdate = $wpdb -> get_var ( " SELECT post_date_gmt FROM $wpdb->posts WHERE post_status = 'publish' ORDER BY post_date_gmt DESC LIMIT 1 " );
break ;
case 'blog' :
$lastpostdate = $wpdb -> get_var ( " SELECT post_date FROM $wpdb->posts WHERE post_status = 'publish' ORDER BY post_date_gmt DESC LIMIT 1 " );
break ;
case 'server' :
$lastpostdate = $wpdb -> get_var ( " SELECT DATE_ADD(post_date_gmt, INTERVAL ' $add_seconds_server ' SECOND) FROM $wpdb->posts WHERE post_status = 'publish' ORDER BY post_date_gmt DESC LIMIT 1 " );
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
}
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' :
$lastpostmodified = $wpdb -> get_var ( " SELECT post_modified_gmt FROM $wpdb->posts WHERE post_status = 'publish' ORDER BY post_modified_gmt DESC LIMIT 1 " );
break ;
case 'blog' :
$lastpostmodified = $wpdb -> get_var ( " SELECT post_modified FROM $wpdb->posts WHERE post_status = 'publish' ORDER BY post_modified_gmt DESC LIMIT 1 " );
break ;
case 'server' :
$lastpostmodified = $wpdb -> get_var ( " SELECT DATE_ADD(post_modified_gmt, INTERVAL ' $add_seconds_server ' SECOND) FROM $wpdb->posts WHERE post_status = 'publish' ORDER BY post_modified_gmt DESC LIMIT 1 " );
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
}
//
// Cache
//
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
}
function clean_post_cache ( $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 );
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
}
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
}
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-10-12 23:12:34 +02:00
function update_postmeta_cache ( $post_ids ) {
global $wpdb ;
2007-05-27 01:32:06 +02:00
2007-10-12 23:12:34 +02:00
if ( empty ( $post_ids ) )
2007-05-27 01:32:06 +02:00
return false ;
2007-10-14 03:08:07 +02:00
if ( ! is_array ( $post_ids ) ) {
$post_ids = preg_replace ( '|[^0-9,]|' , '' , $post_ids );
$post_ids = explode ( ',' , $post_ids );
}
$post_ids = array_map ( 'intval' , $post_ids );
2007-10-12 23:12:34 +02:00
$ids = array ();
2007-10-13 07:33:39 +02:00
foreach ( ( array ) $post_ids as $id ) {
2007-10-12 23:12:34 +02:00
if ( false === wp_cache_get ( $id , 'post_meta' ) )
$ids [] = $id ;
2007-05-27 01:32:06 +02:00
}
2007-10-12 23:12:34 +02:00
if ( empty ( $ids ) )
return false ;
2007-05-27 01:32:06 +02:00
2007-10-12 23:12:34 +02:00
// Get post-meta info
$id_list = join ( ',' , $ids );
$cache = array ();
if ( $meta_list = $wpdb -> get_results ( " SELECT post_id, meta_key, meta_value FROM $wpdb->postmeta WHERE post_id IN ( $id_list ) ORDER BY post_id, meta_key " , ARRAY_A ) ) {
2007-10-13 07:33:39 +02:00
foreach ( ( array ) $meta_list as $metarow ) {
2007-05-27 01:32:06 +02:00
$mpid = ( int ) $metarow [ 'post_id' ];
$mkey = $metarow [ 'meta_key' ];
$mval = $metarow [ 'meta_value' ];
// Force subkeys to be array type:
2007-10-12 23:12:34 +02:00
if ( ! isset ( $cache [ $mpid ]) || ! is_array ( $cache [ $mpid ]) )
$cache [ $mpid ] = array ();
if ( ! isset ( $cache [ $mpid ][ $mkey ]) || ! is_array ( $cache [ $mpid ][ $mkey ]) )
$cache [ $mpid ][ $mkey ] = array ();
2007-05-27 01:32:06 +02:00
// Add a value to the current pid/key:
2007-10-12 23:12:34 +02:00
$cache [ $mpid ][ $mkey ][] = $mval ;
2007-05-27 01:32:06 +02:00
}
}
2007-10-12 23:12:34 +02:00
2007-10-13 07:33:39 +02:00
foreach ( ( array ) $ids as $id ) {
2007-10-12 23:12:34 +02:00
if ( ! isset ( $cache [ $id ]) )
$cache [ $id ] = array ();
}
foreach ( array_keys ( $cache ) as $post )
wp_cache_set ( $post , $cache [ $post ], 'post_meta' );
return $cache ;
2007-05-27 01:32:06 +02:00
}
2007-07-12 18:00:51 +02:00
//
// Hooks
//
function _transition_post_status ( $new_status , $old_status , $post ) {
global $wpdb ;
if ( $old_status != 'publish' && $new_status == 'publish' ) {
// Reset GUID if transitioning to publish.
2007-10-13 04:36:38 +02:00
$wpdb -> update ( $wpdb -> posts , array ( 'guid' => get_permalink ( $post -> ID ) ), array ( 'ID' => $post -> ID ) );
2007-07-12 18:00:51 +02:00
do_action ( 'private_to_published' , $post -> ID ); // Deprecated, use private_to_publish
}
// Always clears the hook in case the post status bounced from future to draft.
wp_clear_scheduled_hook ( 'publish_future_post' , $post -> ID );
}
function _future_post_hook ( $post_id , $post ) {
// Schedule publication.
2007-08-08 06:08:06 +02:00
wp_clear_scheduled_hook ( 'publish_future_post' , $post -> ID );
2007-07-12 18:00:51 +02:00
wp_schedule_single_event ( strtotime ( $post -> post_date_gmt . ' GMT' ), 'publish_future_post' , array ( $post -> ID ));
}
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' );
2007-07-17 01:11:51 +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' ) );
$wpdb -> insert ( $wpdb -> postmeta , $data + array ( 'meta_key' => '_encloseme' ) );
2007-07-12 18:00:51 +02:00
wp_schedule_single_event ( time (), 'do_pings' );
}
function _save_post_hook ( $post_id , $post ) {
if ( $post -> post_type == 'page' ) {
if ( ! empty ( $post -> page_template ) )
if ( ! update_post_meta ( $post_id , '_wp_page_template' , $post -> page_template ))
add_post_meta ( $post_id , '_wp_page_template' , $post -> page_template , true );
clean_page_cache ( $post_id );
global $wp_rewrite ;
$wp_rewrite -> flush_rules ();
} else {
clean_post_cache ( $post_id );
}
}
2007-04-07 21:31:54 +02:00
?>