2004-05-23 21:34:57 -04:00
< ? php
/**** DB Functions ****/
/*
* generic function for inserting data into the posts table .
*/
function wp_insert_post ( $postarr = array ()) {
2005-12-28 02:05:05 -05:00
global $wpdb , $wp_rewrite , $allowedtags , $user_ID ;
2005-06-18 21:33:38 -04:00
2005-11-22 20:35:08 -05:00
if ( is_object ( $postarr ) )
$postarr = get_object_vars ( $postarr );
2004-05-23 21:34:57 -04:00
// export array as variables
extract ( $postarr );
2005-06-18 21:33:38 -04:00
// Are we updating or creating?
$update = false ;
if ( ! empty ( $ID ) ) {
$update = true ;
$post = & get_post ( $ID );
$previous_status = $post -> post_status ;
}
2005-06-18 15:08:38 -04:00
// Get the basics.
2005-08-05 16:44:18 -04:00
$post_content = apply_filters ( 'content_save_pre' , $post_content );
$post_excerpt = apply_filters ( 'excerpt_save_pre' , $post_excerpt );
$post_title = apply_filters ( 'title_save_pre' , $post_title );
$post_category = apply_filters ( 'category_save_pre' , $post_category );
$post_status = apply_filters ( 'status_save_pre' , $post_status );
$post_name = apply_filters ( 'name_save_pre' , $post_name );
$comment_status = apply_filters ( 'comment_status_pre' , $comment_status );
$ping_status = apply_filters ( 'ping_status_pre' , $ping_status );
2005-06-18 15:08:38 -04:00
2004-05-23 21:34:57 -04:00
// Make sure we set a valid category
if ( 0 == count ( $post_category ) || ! is_array ( $post_category )) {
2005-06-18 15:17:55 -04:00
$post_category = array ( get_option ( 'default_category' ));
2004-05-23 21:34:57 -04:00
}
$post_cat = $post_category [ 0 ];
2005-06-18 15:08:38 -04:00
if ( empty ( $post_author ) )
$post_author = $user_ID ;
if ( empty ( $post_status ) )
$post_status = 'draft' ;
2005-06-18 21:33:38 -04:00
// Get the post ID.
2005-10-13 15:06:31 -04:00
if ( $update )
2005-06-18 21:33:38 -04:00
$post_ID = $ID ;
2005-06-18 15:08:38 -04: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 15:06:31 -04:00
$post_name = sanitize_title ( $post_title );
2005-06-18 15:08:38 -04:00
} else {
2005-10-13 15:06:31 -04:00
$post_name = sanitize_title ( $post_name );
2005-06-18 15:08:38 -04:00
}
2004-05-23 21:34:57 -04:00
2005-11-14 04:56:41 -05: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 )) {
if ( 'draft' != $post_status )
$post_date = current_time ( 'mysql' );
}
if ( empty ( $post_date_gmt )) {
if ( 'draft' != $post_status )
$post_date_gmt = get_gmt_from_date ( $post_date );
}
2005-06-18 15:08:38 -04:00
2005-08-05 16:44:18 -04:00
if ( empty ( $comment_status ) ) {
if ( $update )
$comment_status = 'closed' ;
else
$comment_status = get_settings ( 'default_comment_status' );
}
if ( empty ( $ping_status ) )
2004-09-04 02:44:58 -04:00
$ping_status = get_settings ( 'default_ping_status' );
2005-06-18 15:08:38 -04:00
if ( empty ( $post_pingback ) )
$post_pingback = get_option ( 'default_pingback_flag' );
2005-06-18 21:33:38 -04:00
if ( isset ( $to_ping ) )
$to_ping = preg_replace ( '|\s+|' , " \n " , $to_ping );
2005-06-18 15:08:38 -04:00
else
2005-06-18 21:33:38 -04:00
$to_ping = '' ;
2005-12-10 18:22:47 -05:00
if ( ! isset ( $pinged ) )
$pinged = '' ;
2005-06-18 15:08:38 -04:00
if ( isset ( $post_parent ) )
$post_parent = ( int ) $post_parent ;
else
2005-02-10 22:36:49 -05:00
$post_parent = 0 ;
2005-02-13 23:51:14 -05:00
2005-06-18 15:08:38 -04:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
if ( ! isset ( $post_password ) )
$post_password = '' ;
2005-12-07 14:02:05 -05:00
if ( ( 'publish' == $post_status ) || ( 'static' == $post_status ) ) {
$post_name_check = ( 'publish' == $post_status )
? $wpdb -> get_var ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $post_name ' AND post_status = 'publish' AND ID != ' $post_ID ' LIMIT 1 " )
: $wpdb -> get_var ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $post_name ' AND post_status = 'static' AND ID != ' $post_ID ' AND post_parent = ' $post_parent ' LIMIT 1 " );
2005-02-13 23:51:14 -05:00
if ( $post_name_check ) {
$suffix = 2 ;
while ( $post_name_check ) {
$alt_post_name = $post_name . " - $suffix " ;
2005-12-07 14:02:05 -05:00
$post_name_check = ( 'publish' == $post_status )
? $wpdb -> get_var ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $alt_post_name ' AND post_status = 'publish' AND ID != ' $post_ID ' LIMIT 1 " )
: $wpdb -> get_var ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $alt_post_name ' AND post_status = 'static' AND ID != ' $post_ID ' AND post_parent = ' $post_parent ' LIMIT 1 " );
2005-02-13 23:51:14 -05:00
$suffix ++ ;
}
$post_name = $alt_post_name ;
}
}
2005-06-18 21:33:38 -04:00
if ( $update ) {
2005-10-13 15:06:31 -04:00
$wpdb -> query (
2005-12-31 17:34:58 -05:00
" UPDATE IGNORE $wpdb->posts SET
2005-06-18 21:33:38 -04:00
post_author = '$post_author' ,
post_date = '$post_date' ,
post_date_gmt = '$post_date_gmt' ,
post_content = '$post_content' ,
2005-12-10 18:22:47 -05:00
post_content_filtered = '$post_content_filtered' ,
2005-06-18 21:33:38 -04:00
post_title = '$post_title' ,
post_excerpt = '$post_excerpt' ,
post_status = '$post_status' ,
comment_status = '$comment_status' ,
ping_status = '$ping_status' ,
post_password = '$post_password' ,
post_name = '$post_name' ,
to_ping = '$to_ping' ,
2005-12-10 18:22:47 -05:00
pinged = '$pinged' ,
2005-12-24 15:04:59 -05:00
post_modified = '".current_time(' mysql ')."' ,
post_modified_gmt = '".current_time(' mysql ',1)."' ,
2005-06-18 21:33:38 -04:00
post_parent = '$post_parent' ,
menu_order = '$menu_order'
2005-10-13 15:06:31 -04:00
WHERE ID = $post_ID " );
2005-06-18 21:33:38 -04:00
} else {
2005-10-13 15:06:31 -04:00
$wpdb -> query (
2005-12-31 17:34:58 -05:00
" INSERT IGNORE INTO $wpdb->posts
2005-12-10 18:22:47 -05:00
( post_author , post_date , post_date_gmt , post_content , post_content_filtered , post_title , post_excerpt , post_status , comment_status , ping_status , post_password , post_name , to_ping , pinged , post_modified , post_modified_gmt , post_parent , menu_order , post_mime_type )
2005-06-18 15:08:38 -04:00
VALUES
2005-12-10 18:22:47 -05:00
( '$post_author' , '$post_date' , '$post_date_gmt' , '$post_content' , '$post_content_filtered' , '$post_title' , '$post_excerpt' , '$post_status' , '$comment_status' , '$ping_status' , '$post_password' , '$post_name' , '$to_ping' , '$pinged' , '$post_date' , '$post_date_gmt' , '$post_parent' , '$menu_order' , '$post_mime_type' ) " );
2005-10-13 15:06:31 -04:00
$post_ID = $wpdb -> insert_id ;
}
if ( empty ( $post_name ) && 'draft' != $post_status ) {
$post_name = sanitize_title ( $post_title , $post_ID );
$wpdb -> query ( " UPDATE $wpdb->posts SET post_name = ' $post_name ' WHERE ID = ' $post_ID ' " );
2005-06-18 21:33:38 -04:00
}
2005-09-13 20:34:04 -04:00
wp_set_post_cats ( '' , $post_ID , $post_category );
2005-11-07 16:56:03 -05:00
if ( 'static' == $post_status ) {
2005-09-13 20:34:04 -04:00
clean_page_cache ( $post_ID );
2005-11-07 16:56:03 -05:00
wp_cache_delete ( $post_ID , 'pages' );
} else {
2005-09-13 20:34:04 -04:00
clean_post_cache ( $post_ID );
2005-11-07 16:56:03 -05:00
}
2004-09-04 22:03:51 -04:00
// Set GUID
2005-06-18 21:33:38 -04:00
if ( ! $update )
$wpdb -> query ( " UPDATE $wpdb->posts SET guid = ' " . get_permalink ( $post_ID ) . " ' WHERE ID = ' $post_ID ' " );
2005-06-18 15:08:38 -04:00
2005-06-18 21:33:38 -04:00
if ( $update ) {
2005-09-13 20:34:04 -04:00
if ( $previous_status != 'publish' && $post_status == 'publish' ) {
// Reset GUID if transitioning to publish.
$wpdb -> query ( " UPDATE $wpdb->posts SET guid = ' " . get_permalink ( $post_ID ) . " ' WHERE ID = ' $post_ID ' " );
2005-06-18 21:33:38 -04:00
do_action ( 'private_to_published' , $post_ID );
2005-09-13 20:34:04 -04:00
}
2005-06-18 21:33:38 -04:00
do_action ( 'edit_post' , $post_ID );
}
2004-05-23 21:34:57 -04:00
if ( $post_status == 'publish' ) {
do_action ( 'publish_post' , $post_ID );
2005-11-15 11:31:24 -05:00
2005-12-15 22:04:33 -05:00
if ( ! defined ( 'WP_IMPORTING' ) ) {
if ( $post_pingback )
$result = $wpdb -> query ( "
INSERT INTO $wpdb -> postmeta
( post_id , meta_key , meta_value )
VALUES ( '$post_ID' , '_pingme' , '1' )
" );
2005-10-17 19:45:50 -04:00
$result = $wpdb -> query ( "
INSERT INTO $wpdb -> postmeta
( post_id , meta_key , meta_value )
VALUES ( '$post_ID' , '_encloseme' , '1' )
" );
2005-12-15 22:04:33 -05:00
spawn_pinger ();
}
} else if ( $post_status == 'static' ) {
2006-01-29 14:58:48 -05:00
wp_cache_delete ( 'all_page_ids' , 'pages' );
2005-12-28 02:05:05 -05:00
$wp_rewrite -> flush_rules ();
2005-06-18 21:33:38 -04:00
2005-11-21 19:36:36 -05:00
if ( ! empty ( $page_template ) )
if ( ! update_post_meta ( $post_ID , '_wp_page_template' , $page_template ))
add_post_meta ( $post_ID , '_wp_page_template' , $page_template , true );
2004-05-23 21:34:57 -04:00
}
2005-12-11 19:30:14 -05:00
do_action ( 'save_post' , $post_ID );
2005-09-16 13:27:09 -04:00
do_action ( 'wp_insert_post' , $post_ID );
2005-09-15 19:34:54 -04:00
return $post_ID ;
2004-05-23 21:34:57 -04:00
}
2005-12-13 14:19:56 -05:00
function wp_insert_attachment ( $object , $file = false , $post_parent = 0 ) {
2005-09-26 19:55:36 -04:00
global $wpdb , $user_ID ;
2005-11-22 20:35:08 -05:00
if ( is_object ( $object ) )
$object = get_object_vars ( $object );
2005-12-13 14:19:56 -05:00
2005-09-26 19:55:36 -04:00
// Export array as variables
extract ( $object );
// Get the basics.
$post_content = apply_filters ( 'content_save_pre' , $post_content );
$post_excerpt = apply_filters ( 'excerpt_save_pre' , $post_excerpt );
$post_title = apply_filters ( 'title_save_pre' , $post_title );
$post_category = apply_filters ( 'category_save_pre' , $post_category );
$post_name = apply_filters ( 'name_save_pre' , $post_name );
$comment_status = apply_filters ( 'comment_status_pre' , $comment_status );
$ping_status = apply_filters ( 'ping_status_pre' , $ping_status );
2005-11-15 17:55:24 -05:00
$post_mime_type = apply_filters ( 'post_mime_type_pre' , $post_mime_type );
2005-09-26 19:55:36 -04:00
// Make sure we set a valid category
if ( 0 == count ( $post_category ) || ! is_array ( $post_category )) {
$post_category = array ( get_option ( 'default_category' ));
}
$post_cat = $post_category [ 0 ];
if ( empty ( $post_author ) )
$post_author = $user_ID ;
2005-11-15 17:55:24 -05:00
$post_status = 'attachment' ;
2005-09-26 19:55:36 -04:00
2005-11-22 20:35:08 -05:00
// Are we updating or creating?
$update = false ;
if ( ! empty ( $ID ) ) {
$update = true ;
$post_ID = $ID ;
}
2005-09-26 19:55:36 -04:00
// Create a valid post name.
2005-10-14 14:06:23 -04:00
if ( empty ( $post_name ) )
$post_name = sanitize_title ( $post_title );
else
$post_name = sanitize_title ( $post_name );
2005-09-26 19:55:36 -04:00
if ( empty ( $post_date ))
$post_date = current_time ( 'mysql' );
if ( empty ( $post_date_gmt ))
$post_date_gmt = current_time ( 'mysql' , 1 );
if ( empty ( $comment_status ) ) {
if ( $update )
$comment_status = 'closed' ;
else
$comment_status = get_settings ( 'default_comment_status' );
}
if ( empty ( $ping_status ) )
$ping_status = get_settings ( 'default_ping_status' );
if ( empty ( $post_pingback ) )
$post_pingback = get_option ( 'default_pingback_flag' );
if ( isset ( $to_ping ) )
$to_ping = preg_replace ( '|\s+|' , " \n " , $to_ping );
else
$to_ping = '' ;
2005-12-24 00:34:50 -05:00
if ( isset ( $post_parent ) )
$post_parent = ( int ) $post_parent ;
else
$post_parent = 0 ;
2005-09-26 19:55:36 -04:00
if ( isset ( $menu_order ) )
$menu_order = ( int ) $menu_order ;
else
$menu_order = 0 ;
if ( ! isset ( $post_password ) )
$post_password = '' ;
2005-12-24 00:32:49 -05:00
if ( isset ( $to_ping ) )
$to_ping = preg_replace ( '|\s+|' , " \n " , $to_ping );
else
$to_ping = '' ;
if ( ! isset ( $pinged ) )
$pinged = '' ;
2005-09-26 19:55:36 -04:00
if ( $update ) {
2005-10-14 14:06:23 -04:00
$wpdb -> query (
2005-09-26 19:55:36 -04:00
" UPDATE $wpdb->posts SET
post_author = '$post_author' ,
post_date = '$post_date' ,
post_date_gmt = '$post_date_gmt' ,
post_content = '$post_content' ,
post_title = '$post_title' ,
post_excerpt = '$post_excerpt' ,
post_status = '$post_status' ,
comment_status = '$comment_status' ,
ping_status = '$ping_status' ,
post_password = '$post_password' ,
post_name = '$post_name' ,
to_ping = '$to_ping' ,
2005-12-24 00:32:49 -05:00
pinged = '$pinged' ,
2005-12-24 15:04:59 -05:00
post_modified = '".current_time(' mysql ')."' ,
post_modified_gmt = '".current_time(' mysql ',1)."' ,
2005-09-26 19:55:36 -04:00
post_parent = '$post_parent' ,
menu_order = '$menu_order' ,
2005-11-15 17:55:24 -05:00
post_mime_type = '$post_mime_type' ,
2005-09-26 19:55:36 -04:00
guid = '$guid'
2005-10-14 14:06:23 -04:00
WHERE ID = $post_ID " );
2005-09-26 19:55:36 -04:00
} else {
2005-10-14 14:06:23 -04:00
$wpdb -> query (
2005-09-26 19:55:36 -04:00
" INSERT INTO $wpdb->posts
2005-12-24 00:32:49 -05:00
( post_author , post_date , post_date_gmt , post_content , post_title , post_excerpt , post_status , comment_status , ping_status , post_password , post_name , to_ping , pinged , post_modified , post_modified_gmt , post_parent , menu_order , post_mime_type , guid )
2005-09-26 19:55:36 -04:00
VALUES
2005-12-24 00:32:49 -05:00
( '$post_author' , '$post_date' , '$post_date_gmt' , '$post_content' , '$post_title' , '$post_excerpt' , '$post_status' , '$comment_status' , '$ping_status' , '$post_password' , '$post_name' , '$to_ping' , '$pinged' , '$post_date' , '$post_date_gmt' , '$post_parent' , '$menu_order' , '$post_mime_type' , '$guid' ) " );
2005-10-14 14:06:23 -04:00
$post_ID = $wpdb -> insert_id ;
2005-09-26 19:55:36 -04:00
}
2005-10-14 14:06:23 -04:00
if ( empty ( $post_name ) ) {
$post_name = sanitize_title ( $post_title , $post_ID );
$wpdb -> query ( " UPDATE $wpdb->posts SET post_name = ' $post_name ' WHERE ID = ' $post_ID ' " );
}
2005-09-26 19:55:36 -04:00
wp_set_post_cats ( '' , $post_ID , $post_category );
2005-12-13 14:19:56 -05:00
if ( $file )
add_post_meta ( $post_ID , '_wp_attached_file' , $file );
2005-11-15 17:55:24 -05:00
2005-09-26 19:55:36 -04:00
clean_post_cache ( $post_ID );
if ( $update ) {
2005-11-15 17:55:24 -05:00
do_action ( 'edit_attachment' , $post_ID );
2005-09-26 19:55:36 -04:00
} else {
2005-11-15 17:55:24 -05:00
do_action ( 'add_attachment' , $post_ID );
2005-09-26 19:55:36 -04:00
}
return $post_ID ;
}
2005-11-15 17:55:24 -05:00
function wp_delete_attachment ( $postid ) {
2005-10-04 13:38:04 -04:00
global $wpdb ;
$postid = ( int ) $postid ;
2006-05-04 18:25:24 -04:00
if ( ! $post = $wpdb -> get_row ( " SELECT * FROM $wpdb->posts WHERE ID = ' $postid ' " ) )
2005-10-04 13:38:04 -04:00
return $post ;
2005-11-15 17:55:24 -05:00
if ( 'attachment' != $post -> post_status )
2005-10-04 13:38:04 -04:00
return false ;
2005-12-13 14:19:56 -05:00
$meta = get_post_meta ( $postid , '_wp_attachment_metadata' , true );
2005-11-15 17:55:24 -05:00
$file = get_post_meta ( $postid , '_wp_attached_file' , true );
2005-10-04 13:38:04 -04:00
2006-05-04 18:25:24 -04:00
$wpdb -> query ( " DELETE FROM $wpdb->posts WHERE ID = ' $postid ' " );
2005-10-04 13:38:04 -04:00
2006-05-04 18:25:24 -04:00
$wpdb -> query ( " DELETE FROM $wpdb->comments WHERE comment_post_ID = ' $postid ' " );
2005-10-04 13:38:04 -04:00
2006-05-04 18:25:24 -04:00
$wpdb -> query ( " DELETE FROM $wpdb->post2cat WHERE post_id = ' $postid ' " );
2005-10-04 13:38:04 -04:00
2006-05-04 18:25:24 -04:00
$wpdb -> query ( " DELETE FROM $wpdb->postmeta WHERE post_id = ' $postid ' " );
2005-10-04 13:38:04 -04:00
2005-12-13 14:19:56 -05:00
if ( ! empty ( $meta [ 'thumb' ]) ) {
// Don't delete the thumb if another attachment uses it
2006-05-04 18:25:24 -04:00
if ( ! $foo = $wpdb -> get_row ( " SELECT meta_id FROM $wpdb->postmeta WHERE meta_key = '_wp_attachment_metadata' AND meta_value LIKE '% " . $wpdb -> escape ( $meta [ 'thumb' ]) . " %' AND post_id <> ' $postid ' " ))
2005-12-13 14:19:56 -05:00
@ unlink ( str_replace ( basename ( $file ), $meta [ 'thumb' ], $file ));
}
2005-11-15 17:55:24 -05:00
if ( ! empty ( $file ) )
@ unlink ( $file );
2005-10-04 13:38:04 -04:00
2005-11-15 17:55:24 -05:00
do_action ( 'delete_attachment' , $postid );
2005-10-04 13:38:04 -04:00
return $post ;
}
2004-05-23 21:34:57 -04:00
function wp_get_single_post ( $postid = 0 , $mode = OBJECT ) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
2005-06-18 21:33:38 -04:00
$post = get_post ( $postid , $mode );
2004-05-23 21:34:57 -04:00
// Set categories
2005-02-05 15:45:50 -05:00
if ( $mode == OBJECT ) {
2005-06-18 21:33:38 -04:00
$post -> post_category = wp_get_post_cats ( '' , $postid );
2005-02-05 15:45:50 -05:00
}
else {
2005-06-18 21:33:38 -04:00
$post [ 'post_category' ] = wp_get_post_cats ( '' , $postid );
2005-02-05 15:45:50 -05:00
}
2004-05-23 21:34:57 -04:00
2005-06-18 21:33:38 -04:00
return $post ;
2004-05-23 21:34:57 -04:00
}
function wp_get_recent_posts ( $num = 10 ) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
// Set the limit clause, if we got a limit
if ( $num ) {
$limit = " LIMIT $num " ;
}
2005-02-12 00:25:09 -05:00
$sql = " SELECT * FROM $wpdb->posts WHERE post_status IN ('publish', 'draft', 'private') ORDER BY post_date DESC $limit " ;
2004-05-23 21:34:57 -04:00
$result = $wpdb -> get_results ( $sql , ARRAY_A );
return $result ? $result : array ();
}
function wp_update_post ( $postarr = array ()) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
2005-11-22 20:35:08 -05:00
if ( is_object ( $postarr ) )
$postarr = get_object_vars ( $postarr );
2005-06-18 21:33:38 -04:00
// First, get all of the original fields
$post = wp_get_single_post ( $postarr [ 'ID' ], ARRAY_A );
2005-01-06 20:21:12 -05:00
2005-06-18 21:33:38 -04:00
// Escape data pulled from DB.
2005-07-03 14:33:03 -04:00
$post = add_magic_quotes ( $post );
2004-05-23 21:34:57 -04:00
2005-07-03 14:33:03 -04:00
// Passed post category list overwrites existing category list if not empty.
if ( isset ( $postarr [ 'post_category' ]) && is_array ( $postarr [ 'post_category' ])
&& 0 != count ( $postarr [ 'post_category' ]) )
2005-06-18 21:33:38 -04:00
$post_cats = $postarr [ 'post_category' ];
else
$post_cats = $post [ 'post_category' ];
2005-01-06 20:21:12 -05:00
2005-11-14 04:56:41 -05:00
// Drafts shouldn't be assigned a date unless explicitly done so by the user
if ( 'draft' == $post [ 'post_status' ] && empty ( $postarr [ 'edit_date' ]) && empty ( $postarr [ 'post_date' ]) &&
( '0000-00-00 00:00:00' == $post [ 'post_date' ]) )
$clear_date = true ;
else
$clear_date = false ;
// Merge old and new fields with new fields overwriting old ones.
$postarr = array_merge ( $post , $postarr );
$postarr [ 'post_category' ] = $post_cats ;
if ( $clear_date ) {
$postarr [ 'post_date' ] = '' ;
$postarr [ 'post_date_gmt' ] = '' ;
}
2005-12-13 14:19:56 -05:00
if ( $postarr [ 'post_status' ] == 'attachment' )
return wp_insert_attachment ( $postarr );
2005-06-18 21:33:38 -04:00
return wp_insert_post ( $postarr );
2004-05-23 21:34:57 -04:00
}
function wp_get_post_cats ( $blogid = '1' , $post_ID = 0 ) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
2006-05-04 18:25:24 -04:00
$post_ID = ( int ) $post_ID ;
2004-05-23 21:34:57 -04:00
$sql = " SELECT category_id
2004-05-24 04:22:18 -04:00
FROM $wpdb -> post2cat
2006-05-04 18:25:24 -04:00
WHERE post_id = '$post_ID'
2004-05-23 21:34:57 -04:00
ORDER BY category_id " ;
$result = $wpdb -> get_col ( $sql );
2005-07-02 13:28:06 -04:00
if ( ! $result )
$result = array ();
2004-05-23 21:34:57 -04:00
return array_unique ( $result );
}
function wp_set_post_cats ( $blogid = '1' , $post_ID = 0 , $post_categories = array ()) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
// If $post_categories isn't already an array, make it one:
2005-07-03 14:33:03 -04:00
if ( ! is_array ( $post_categories ) || 0 == count ( $post_categories ))
$post_categories = array ( get_option ( 'default_category' ));
2004-05-23 21:34:57 -04:00
$post_categories = array_unique ( $post_categories );
// First the old categories
$old_categories = $wpdb -> get_col ( "
SELECT category_id
2004-05-24 04:22:18 -04:00
FROM $wpdb -> post2cat
2004-05-23 21:34:57 -04:00
WHERE post_id = $post_ID " );
if ( ! $old_categories ) {
$old_categories = array ();
} else {
$old_categories = array_unique ( $old_categories );
}
// Delete any?
$delete_cats = array_diff ( $old_categories , $post_categories );
if ( $delete_cats ) {
foreach ( $delete_cats as $del ) {
$wpdb -> query ( "
2004-05-24 04:22:18 -04:00
DELETE FROM $wpdb -> post2cat
2004-05-23 21:34:57 -04:00
WHERE category_id = $del
AND post_id = $post_ID
" );
}
}
// Add any?
$add_cats = array_diff ( $post_categories , $old_categories );
if ( $add_cats ) {
foreach ( $add_cats as $new_cat ) {
$wpdb -> query ( "
2004-05-24 04:22:18 -04:00
INSERT INTO $wpdb -> post2cat ( post_id , category_id )
2004-05-23 21:34:57 -04:00
VALUES ( $post_ID , $new_cat ) " );
}
}
2005-11-15 18:47:16 -05:00
// Update category counts.
2005-12-15 15:31:29 -05:00
$all_affected_cats = array_unique ( array_merge ( $post_categories , $old_categories ));
foreach ( $all_affected_cats as $cat_id ) {
2005-11-15 18:47:16 -05:00
$count = $wpdb -> get_var ( " SELECT COUNT(*) FROM $wpdb->post2cat , $wpdb->posts WHERE $wpdb->posts .ID= $wpdb->post2cat .post_id AND post_status='publish' AND category_id = ' $cat_id ' " );
$wpdb -> query ( " UPDATE $wpdb->categories SET category_count = ' $count ' WHERE cat_ID = ' $cat_id ' " );
wp_cache_delete ( $cat_id , 'category' );
}
2004-05-23 21:34:57 -04:00
} // wp_set_post_cats()
function wp_delete_post ( $postid = 0 ) {
2005-12-28 02:05:05 -05:00
global $wpdb , $wp_rewrite ;
2005-01-01 18:13:38 -05:00
$postid = ( int ) $postid ;
2004-05-23 21:34:57 -04:00
2005-01-01 18:13:38 -05:00
if ( ! $post = $wpdb -> get_row ( " SELECT * FROM $wpdb->posts WHERE ID = $postid " ) )
return $post ;
2004-11-26 23:47:54 -05:00
2005-12-13 14:19:56 -05:00
if ( 'attachment' == $post -> post_status )
return wp_delete_attachment ( $postid );
2005-10-14 14:06:23 -04:00
do_action ( 'delete_post' , $postid );
2005-11-15 11:31:24 -05:00
if ( 'publish' == $post -> post_status ) {
$categories = wp_get_post_cats ( '' , $post -> ID );
if ( is_array ( $categories ) ) {
foreach ( $categories as $cat_id ) {
$wpdb -> query ( " UPDATE $wpdb->categories SET category_count = category_count - 1 WHERE cat_ID = ' $cat_id ' " );
wp_cache_delete ( $cat_id , 'category' );
}
}
}
2005-01-01 18:13:38 -05:00
if ( 'static' == $post -> post_status )
$wpdb -> query ( " UPDATE $wpdb->posts SET post_parent = $post->post_parent WHERE post_parent = $postid AND post_status = 'static' " );
2004-11-26 23:47:54 -05:00
2005-01-01 18:13:38 -05:00
$wpdb -> query ( " DELETE FROM $wpdb->posts WHERE ID = $postid " );
2004-11-26 23:47:54 -05:00
$wpdb -> query ( " DELETE FROM $wpdb->comments WHERE comment_post_ID = $postid " );
$wpdb -> query ( " DELETE FROM $wpdb->post2cat WHERE post_id = $postid " );
$wpdb -> query ( " DELETE FROM $wpdb->postmeta WHERE post_id = $postid " );
2005-06-18 22:51:48 -04:00
2006-01-29 14:58:48 -05:00
if ( 'static' == $post -> post_status ) {
wp_cache_delete ( 'all_page_ids' , 'pages' );
2005-12-28 02:05:05 -05:00
$wp_rewrite -> flush_rules ();
2006-01-29 14:58:48 -05:00
}
2005-12-28 02:05:05 -05:00
2005-01-01 18:13:38 -05:00
return $post ;
2004-05-23 21:34:57 -04:00
}
/**** /DB Functions ****/
/**** Misc ****/
// get permalink from post ID
2004-09-04 20:24:28 -04:00
function post_permalink ( $post_id = 0 , $mode = '' ) { // $mode legacy
return get_permalink ( $post_id );
2004-05-23 21:34:57 -04:00
}
// Get the name of a category from its ID
function get_cat_name ( $cat_id ) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
$cat_id -= 0 ; // force numeric
2004-05-24 04:22:18 -04:00
$name = $wpdb -> get_var ( " SELECT cat_name FROM $wpdb->categories WHERE cat_ID= $cat_id " );
2004-05-23 21:34:57 -04:00
return $name ;
}
// Get the ID of a category from its name
function get_cat_ID ( $cat_name = 'General' ) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
2004-05-23 21:34:57 -04:00
2004-05-24 04:22:18 -04:00
$cid = $wpdb -> get_var ( " SELECT cat_ID FROM $wpdb->categories WHERE cat_name=' $cat_name ' " );
2004-05-23 21:34:57 -04:00
return $cid ? $cid : 1 ; // default to cat 1
}
// Get author's preferred display name
2005-01-06 20:11:51 -05:00
function get_author_name ( $auth_id ) {
$authordata = get_userdata ( $auth_id );
2004-05-23 21:34:57 -04:00
2005-06-12 19:22:06 -04:00
return $authordata -> display_name ;
2004-05-23 21:34:57 -04:00
}
// get extended entry info (<!--more-->)
function get_extended ( $post ) {
2005-01-06 20:11:51 -05:00
list ( $main , $extended ) = explode ( '<!--more-->' , $post , 2 );
2004-05-23 21:34:57 -04:00
// Strip leading and trailing whitespace
$main = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $main );
$extended = preg_replace ( '/^[\s]*(.*)[\s]*$/' , '\\1' , $extended );
return array ( 'main' => $main , 'extended' => $extended );
}
// do trackbacks for a list of urls
// borrowed from edit.php
// 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
extract ( $postdata );
// form an excerpt
$excerpt = strip_tags ( $post_excerpt ? $post_excerpt : $post_content );
if ( strlen ( $excerpt ) > 255 ) {
2004-08-25 10:22:39 -04:00
$excerpt = substr ( $excerpt , 0 , 252 ) . '...' ;
2004-05-23 21:34:57 -04:00
}
$trackback_urls = explode ( ',' , $tb_list );
foreach ( $trackback_urls as $tb_url ) {
$tb_url = trim ( $tb_url );
trackback ( $tb_url , stripslashes ( $post_title ), $excerpt , $post_id );
}
}
}
2005-01-10 15:21:06 -05:00
function wp_blacklist_check ( $author , $email , $url , $comment , $user_ip , $user_agent ) {
global $wpdb ;
2005-02-05 22:40:08 -05:00
do_action ( 'wp_blacklist_check' , $author , $email , $url , $comment , $user_ip , $user_agent );
2005-01-10 15:26:10 -05:00
2005-01-11 17:42:09 -05:00
if ( preg_match_all ( '/&#(\d+);/' , $comment . $author . $url , $chars ) ) {
2005-01-10 15:21:06 -05:00
foreach ( $chars [ 1 ] as $char ) {
// If it's an encoded char in the normal ASCII set, reject
if ( $char < 128 )
return true ;
}
}
2004-10-15 12:20:25 -04:00
2005-01-10 15:21:06 -05:00
$mod_keys = trim ( get_settings ( 'blacklist_keys' ) );
if ( '' == $mod_keys )
return false ; // If moderation keys are empty
$words = explode ( " \n " , $mod_keys );
foreach ( $words as $word ) {
$word = trim ( $word );
// Skip empty lines
if ( empty ( $word ) ) { continue ; }
// Do some escaping magic so that '#' chars in the
// spam words don't break things:
$word = preg_quote ( $word , '#' );
$pattern = " # $word #i " ;
if ( preg_match ( $pattern , $author ) ) return true ;
if ( preg_match ( $pattern , $email ) ) return true ;
if ( preg_match ( $pattern , $url ) ) return true ;
if ( preg_match ( $pattern , $comment ) ) return true ;
if ( preg_match ( $pattern , $user_ip ) ) return true ;
if ( preg_match ( $pattern , $user_agent ) ) return true ;
}
2005-02-02 03:40:44 -05:00
2005-02-16 16:35:58 -05:00
if ( isset ( $_SERVER [ 'REMOTE_ADDR' ]) ) {
2005-02-16 17:01:52 -05:00
if ( wp_proxy_check ( $_SERVER [ 'REMOTE_ADDR' ]) ) return true ;
2005-02-16 16:35:58 -05:00
}
return false ;
}
function wp_proxy_check ( $ipnum ) {
if ( get_option ( 'open_proxy_check' ) && isset ( $ipnum ) ) {
$rev_ip = implode ( '.' , array_reverse ( explode ( '.' , $ipnum ) ) );
2006-07-04 17:40:41 -04:00
$lookup = $rev_ip . '.sbl-xbl.spamhaus.org.' ;
2005-02-02 03:40:44 -05:00
if ( $lookup != gethostbyname ( $lookup ) )
return true ;
}
2005-01-10 15:21:06 -05:00
return false ;
}
2004-10-14 03:26:41 -04:00
function do_trackbacks ( $post_id ) {
global $wpdb ;
$post = $wpdb -> get_row ( " SELECT * FROM $wpdb->posts WHERE ID = $post_id " );
$to_ping = get_to_ping ( $post_id );
$pinged = get_pung ( $post_id );
2005-12-31 16:24:56 -05:00
if ( empty ( $to_ping ) ) {
$wpdb -> query ( " UPDATE $wpdb->posts SET to_ping = '' WHERE ID = ' $post_id ' " );
2005-05-17 23:17:55 -04:00
return ;
2005-12-31 16:24:56 -05:00
}
2005-03-13 19:55:21 -05:00
if ( empty ( $post -> post_excerpt ))
$excerpt = apply_filters ( 'the_content' , $post -> post_content );
2004-10-14 03:26:41 -04:00
else
2005-03-13 19:55:21 -05:00
$excerpt = apply_filters ( 'the_excerpt' , $post -> post_excerpt );
$excerpt = str_replace ( ']]>' , ']]>' , $excerpt );
$excerpt = strip_tags ( $excerpt );
2005-12-27 19:55:55 -05:00
if ( function_exists ( 'mb_strcut' ) ) // For international trackbacks
$excerpt = mb_strcut ( $excerpt , 0 , 252 , get_settings ( 'blog_charset' )) . '...' ;
else
$excerpt = substr ( $excerpt , 0 , 252 ) . '...' ;
2005-03-13 19:55:21 -05:00
$post_title = apply_filters ( 'the_title' , $post -> post_title );
$post_title = strip_tags ( $post_title );
2004-10-14 03:26:41 -04:00
if ( $to_ping ) : foreach ( $to_ping as $tb_ping ) :
$tb_ping = trim ( $tb_ping );
2005-11-05 23:02:12 -05:00
if ( ! in_array ( $tb_ping , $pinged ) ) {
trackback ( $tb_ping , $post_title , $excerpt , $post_id );
$pinged [] = $tb_ping ;
2005-12-15 22:04:33 -05:00
} else {
$wpdb -> query ( " UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, ' $tb_ping ', '')) WHERE ID = ' $post_id ' " );
2005-11-05 23:02:12 -05:00
}
2004-10-14 03:26:41 -04:00
endforeach ; endif ;
}
function get_pung ( $post_id ) { // Get URIs already pung for a post
global $wpdb ;
$pung = $wpdb -> get_var ( " SELECT pinged FROM $wpdb->posts WHERE ID = $post_id " );
$pung = trim ( $pung );
$pung = preg_split ( '/\s/' , $pung );
2005-08-02 20:40:42 -04:00
$pung = apply_filters ( 'get_pung' , $pung );
2004-10-14 03:26:41 -04:00
return $pung ;
}
2005-02-12 03:58:10 -05:00
function get_enclosed ( $post_id ) { // Get enclosures already enclosed for a post
global $wpdb ;
$custom_fields = get_post_custom ( $post_id );
$pung = array ();
2005-08-02 20:40:42 -04:00
if ( ! is_array ( $custom_fields ) )
return $pung ;
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-02-12 03:58:10 -05:00
}
}
2005-08-02 20:40:42 -04:00
$pung = apply_filters ( 'get_enclosed' , $pung );
2005-02-12 03:58:10 -05:00
return $pung ;
}
2004-10-14 03:26:41 -04:00
function get_to_ping ( $post_id ) { // Get any URIs in the todo list
global $wpdb ;
$to_ping = $wpdb -> get_var ( " SELECT to_ping FROM $wpdb->posts WHERE ID = $post_id " );
$to_ping = trim ( $to_ping );
2005-05-17 23:17:55 -04:00
$to_ping = preg_split ( '/\s/' , $to_ping , - 1 , PREG_SPLIT_NO_EMPTY );
2005-08-02 20:40:42 -04:00
$to_ping = apply_filters ( 'get_to_ping' , $to_ping );
2004-10-14 03:26:41 -04:00
return $to_ping ;
}
function add_ping ( $post_id , $uri ) { // Add a URI to those already pung
global $wpdb ;
$pung = $wpdb -> get_var ( " SELECT pinged FROM $wpdb->posts WHERE ID = $post_id " );
$pung = trim ( $pung );
$pung = preg_split ( '/\s/' , $pung );
$pung [] = $uri ;
$new = implode ( " \n " , $pung );
2005-08-02 20:40:42 -04:00
$new = apply_filters ( 'add_ping' , $new );
2004-10-14 03:26:41 -04:00
return $wpdb -> query ( " UPDATE $wpdb->posts SET pinged = ' $new ' WHERE ID = $post_id " );
}
2005-12-24 11:26:55 -05: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 ;
}
2005-06-18 22:51:48 -04:00
function generate_page_rewrite_rules () {
global $wpdb ;
2005-12-24 11:26:55 -05:00
//get pages in order of hierarchy, i.e. children after parents
$posts = get_page_hierarchy ( $wpdb -> get_results ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_status = 'static' " ));
//now reverse it, because we need parents after children for rewrite rules to work properly
$posts = array_reverse ( $posts , true );
2005-06-18 22:51:48 -04:00
$page_rewrite_rules = array ();
2005-12-27 23:27:21 -05:00
$page_attachment_rewrite_rules = array ();
2005-06-18 22:51:48 -04:00
if ( $posts ) {
2005-12-24 11:26:55 -05:00
foreach ( $posts as $id => $post ) {
2005-12-27 23:27:21 -05:00
2005-06-18 22:51:48 -04:00
// URI => page name
2005-12-24 11:26:55 -05:00
$uri = get_page_uri ( $id );
2005-12-27 23:27:21 -05:00
$attachments = $wpdb -> get_results ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_status = 'attachment' AND post_parent = ' $id ' " );
if ( $attachments ) {
foreach ( $attachments as $attachment ) {
$attach_uri = get_page_uri ( $attachment -> ID );
$page_attachment_rewrite_rules [ $attach_uri ] = $attachment -> post_name ;
}
}
2005-12-24 11:26:55 -05:00
$page_rewrite_rules [ $uri ] = $post ;
2005-06-18 22:51:48 -04:00
}
2005-12-27 23:27:21 -05:00
2005-06-18 22:51:48 -04:00
update_option ( 'page_uris' , $page_rewrite_rules );
2005-12-27 23:27:21 -05:00
if ( $page_attachment_rewrite_rules )
update_option ( 'page_attachment_uris' , $page_attachment_rewrite_rules );
2005-06-18 22:51:48 -04:00
}
}
2005-11-19 15:08:21 -05:00
function get_post_status ( $ID = '' ) {
$post = get_post ( $ID );
2005-10-17 19:45:50 -04:00
if ( is_object ( $post ) ) {
2005-11-15 17:55:24 -05:00
if ( ( 'attachment' == $post -> post_status ) && $post -> post_parent && ( $post -> ID != $post -> post_parent ) )
2005-10-17 19:45:50 -04:00
return get_post_status ( $post -> post_parent );
else
return $post -> post_status ;
}
return false ;
}
2005-11-19 15:08:21 -05: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 ;
}
2005-11-23 05:00:07 -05:00
function get_attached_file ( $attachment_id ) {
return get_post_meta ( $attachment_id , '_wp_attached_file' , true );
}
2005-12-01 17:51:40 -05:00
2006-01-01 23:33:27 -05:00
function wp_mkdir_p ( $target ) {
// from php.net/mkdir user contributed notes
if ( file_exists ( $target )) {
if ( ! @ is_dir ( $target ))
return false ;
else
return true ;
}
// Attempting to create the directory may clutter up our display.
if ( @ mkdir ( $target )) {
$stat = @ stat ( dirname ( $target ));
$dir_perms = $stat [ 'mode' ] & 0007777 ; // Get the permission bits.
@ chmod ( $target , $dir_perms );
return true ;
} else {
if ( is_dir ( dirname ( $target )) )
return false ;
}
// If the above failed, attempt to create the parent node, then try again.
if ( wp_mkdir_p ( dirname ( $target )))
return wp_mkdir_p ( $target );
return false ;
}
2005-12-04 22:17:03 -05:00
// Returns an array containing the current upload directory's path and url, or an error message.
function wp_upload_dir () {
2006-01-09 17:24:57 -05:00
$siteurl = get_settings ( 'siteurl' );
//prepend ABSPATH to $dir and $siteurl to $url if they're not already there
2006-01-14 17:09:51 -05:00
$path = str_replace ( ABSPATH , '' , trim ( get_settings ( 'upload_path' )));
$dir = ABSPATH . $path ;
$url = trailingslashit ( $siteurl ) . $path ;
2005-12-04 22:17:03 -05:00
2006-01-09 17:24:57 -05:00
if ( $dir == ABSPATH ) { //the option was empty
2006-01-01 23:33:27 -05:00
$dir = ABSPATH . 'wp-content/uploads' ;
2006-01-09 17:24:57 -05:00
}
2005-12-04 22:17:03 -05:00
2006-01-01 23:33:27 -05:00
if ( defined ( 'UPLOADS' ) ) {
$dir = ABSPATH . UPLOADS ;
2006-01-14 17:09:51 -05:00
$url = trailingslashit ( $siteurl ) . UPLOADS ;
2006-01-01 23:33:27 -05:00
}
2005-12-04 22:17:03 -05:00
2006-01-14 17:09:51 -05:00
if ( get_settings ( 'uploads_use_yearmonth_folders' )) {
2006-01-01 23:33:27 -05:00
// Generate the yearly and monthly dirs
$time = current_time ( 'mysql' );
$y = substr ( $time , 0 , 4 );
$m = substr ( $time , 5 , 2 );
$dir = $dir . " / $y / $m " ;
$url = $url . " / $y / $m " ;
2005-12-04 22:17:03 -05:00
}
2006-01-01 23:33:27 -05:00
// Make sure we have an uploads dir
if ( ! wp_mkdir_p ( $dir ) ) {
$message = sprintf ( __ ( 'Unable to create directory %s. Is its parent directory writable by the server?' ), $dir );
return array ( 'error' => $message );
2005-12-04 22:17:03 -05:00
}
2006-01-01 23:33:27 -05:00
$uploads = array ( 'path' => $dir , 'url' => $url , 'error' => false );
2005-12-04 22:17:03 -05:00
return apply_filters ( 'upload_dir' , $uploads );
}
2005-12-01 17:51:40 -05:00
function wp_upload_bits ( $name , $type , $bits ) {
if ( empty ( $name ) )
2006-06-21 19:24:13 -04:00
return array ( 'error' => __ ( " Empty filename " ));
$wp_filetype = wp_check_filetype ( $name );
if ( ! $wp_filetype [ 'ext' ] )
return array ( 'error' => __ ( " Invalid file type " ));
2005-12-01 17:51:40 -05:00
$upload = wp_upload_dir ();
if ( $upload [ 'error' ] !== false )
return $upload ;
$number = '' ;
$filename = $name ;
2005-12-28 20:46:32 -05:00
$path_parts = pathinfo ( $filename );
$ext = $path_parts [ 'extension' ];
if ( empty ( $ext ) )
$ext = '' ;
else
$ext = " . $ext " ;
while ( file_exists ( $upload [ 'path' ] . " / $filename " ) ) {
if ( '' == " $number $ext " )
$filename = $filename . ++ $number . $ext ;
else
$filename = str_replace ( " $number $ext " , ++ $number . $ext , $filename );
}
2005-12-28 20:40:42 -05:00
$new_file = $upload [ 'path' ] . " / $filename " ;
2006-01-01 23:59:39 -05:00
if ( ! wp_mkdir_p ( dirname ( $new_file ) ) ) {
$message = sprintf ( __ ( 'Unable to create directory %s. Is its parent directory writable by the server?' ), dirname ( $new_file ));
return array ( 'error' => $message );
}
2005-12-01 17:51:40 -05:00
$ifp = @ fopen ( $new_file , 'wb' );
if ( ! $ifp )
return array ( 'error' => " Could not write file $new_file . " );
$success = @ fwrite ( $ifp , $bits );
fclose ( $ifp );
// Set correct file permissions
$stat = @ stat ( dirname ( $new_file ));
2006-01-01 21:50:59 -05:00
$perms = $stat [ 'mode' ] & 0007777 ;
$perms = $perms & 0000666 ;
2005-12-01 17:51:40 -05:00
@ chmod ( $new_file , $perms );
// Compute the URL
$url = $upload [ 'url' ] . " / $filename " ;
2005-12-28 21:07:10 -05:00
return array ( 'file' => $new_file , 'url' => $url , 'error' => false );
2005-12-01 17:51:40 -05:00
}
2006-06-21 19:24:13 -04:00
function wp_check_filetype ( $filename , $mimes = null ) {
// Accepted MIME types are set here as PCRE unless provided.
$mimes = is_array ( $mimes ) ? $mimes : apply_filters ( 'upload_mimes' , array (
'jpg|jpeg|jpe' => 'image/jpeg' ,
'gif' => 'image/gif' ,
'png' => 'image/png' ,
'bmp' => 'image/bmp' ,
'tif|tiff' => 'image/tiff' ,
'ico' => 'image/x-icon' ,
'asf|asx|wax|wmv|wmx' => 'video/asf' ,
'avi' => 'video/avi' ,
'mov|qt' => 'video/quicktime' ,
'mpeg|mpg|mpe' => 'video/mpeg' ,
'txt|c|cc|h' => 'text/plain' ,
'rtx' => 'text/richtext' ,
'css' => 'text/css' ,
'htm|html' => 'text/html' ,
'mp3|mp4' => 'audio/mpeg' ,
'ra|ram' => 'audio/x-realaudio' ,
'wav' => 'audio/wav' ,
'ogg' => 'audio/ogg' ,
'mid|midi' => 'audio/midi' ,
'wma' => 'audio/wma' ,
'rtf' => 'application/rtf' ,
'js' => 'application/javascript' ,
'pdf' => 'application/pdf' ,
'doc' => 'application/msword' ,
'pot|pps|ppt' => 'application/vnd.ms-powerpoint' ,
'wri' => 'application/vnd.ms-write' ,
'xla|xls|xlt|xlw' => 'application/vnd.ms-excel' ,
'mdb' => 'application/vnd.ms-access' ,
'mpp' => 'application/vnd.ms-project' ,
'swf' => 'application/x-shockwave-flash' ,
'class' => 'application/java' ,
'tar' => 'application/x-tar' ,
'zip' => 'application/zip' ,
'gz|gzip' => 'application/x-gzip' ,
'exe' => 'application/x-msdownload'
));
$type = false ;
$ext = false ;
foreach ( $mimes as $ext_preg => $mime_match ) {
$ext_preg = '!\.(' . $ext_preg . ')$!i' ;
if ( preg_match ( $ext_preg , $filename , $ext_matches ) ) {
$type = $mime_match ;
$ext = $ext_matches [ 1 ];
break ;
}
}
return compact ( 'ext' , 'type' );
}
2005-04-27 19:55:06 -04:00
?>