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-01-26 17:29:18 -05:00
global $wpdb , $post_default_category , $allowedtags ;
2004-05-23 21:34:57 -04:00
// export array as variables
extract ( $postarr );
// Do some escapes for safety
$post_title = $wpdb -> escape ( $post_title );
$post_name = sanitize_title ( $post_title );
$post_excerpt = $wpdb -> escape ( $post_excerpt );
$post_content = $wpdb -> escape ( $post_content );
$post_author = ( int ) $post_author ;
// Make sure we set a valid category
if ( 0 == count ( $post_category ) || ! is_array ( $post_category )) {
$post_category = array ( $post_default_category );
}
$post_cat = $post_category [ 0 ];
if ( empty ( $post_date ))
$post_date = current_time ( 'mysql' );
// Make sure we have a good gmt date:
if ( empty ( $post_date_gmt ))
$post_date_gmt = get_gmt_from_date ( $post_date );
2004-09-04 02:44:58 -04:00
if ( empty ( $comment_status ))
$comment_status = get_settings ( 'default_comment_status' );
if ( empty ( $ping_status ))
$ping_status = get_settings ( 'default_ping_status' );
2005-02-10 22:36:49 -05:00
if ( empty ( $post_parent ) )
$post_parent = 0 ;
2005-02-13 23:51:14 -05:00
if ( 'publish' == $post_status ) {
$post_name_check = $wpdb -> get_var ( " SELECT post_name FROM $wpdb->posts WHERE post_name = ' $post_name ' AND post_status = 'publish' AND ID != ' $post_ID ' LIMIT 1 " );
if ( $post_name_check ) {
$suffix = 2 ;
while ( $post_name_check ) {
$alt_post_name = $post_name . " - $suffix " ;
$post_name_check = $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 " );
$suffix ++ ;
}
$post_name = $alt_post_name ;
}
}
2004-05-24 04:22:18 -04:00
$sql = " INSERT INTO $wpdb->posts
2005-02-10 22:36:49 -05:00
( post_author , post_date , post_date_gmt , post_modified , post_modified_gmt , post_content , post_title , post_excerpt , post_category , post_status , post_name , comment_status , ping_status , post_parent )
VALUES ( '$post_author' , '$post_date' , '$post_date_gmt' , '$post_date' , '$post_date_gmt' , '$post_content' , '$post_title' , '$post_excerpt' , '$post_cat' , '$post_status' , '$post_name' , '$comment_status' , '$ping_status' , '$post_parent' ) " ;
2004-05-23 21:34:57 -04:00
$result = $wpdb -> query ( $sql );
$post_ID = $wpdb -> insert_id ;
2004-09-04 22:03:51 -04:00
// Set GUID
$wpdb -> query ( " UPDATE $wpdb->posts SET guid = ' " . get_permalink ( $post_ID ) . " ' WHERE ID = ' $post_ID ' " );
2004-05-23 21:34:57 -04:00
2004-09-04 22:03:51 -04:00
wp_set_post_cats ( '' , $post_ID , $post_category );
2004-05-23 21:34:57 -04:00
if ( $post_status == 'publish' ) {
do_action ( 'publish_post' , $post_ID );
}
2004-09-04 22:03:51 -04:00
pingback ( $content , $post_ID );
2004-05-23 21:34:57 -04:00
// Return insert_id if we got a good result, otherwise return zero.
return $result ? $post_ID : 0 ;
}
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
2004-05-24 04:22:18 -04:00
$sql = " SELECT * FROM $wpdb->posts WHERE ID= $postid " ;
2004-05-23 21:34:57 -04:00
$result = $wpdb -> get_row ( $sql , $mode );
// Set categories
2005-02-05 15:45:50 -05:00
if ( $mode == OBJECT ) {
$result -> post_category = wp_get_post_cats ( '' , $postid );
}
else {
$result [ 'post_category' ] = wp_get_post_cats ( '' , $postid );
}
2004-05-23 21:34:57 -04:00
return $result ;
}
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
// First get all of the original fields
2005-01-06 20:21:12 -05:00
extract ( wp_get_single_post ( $postarr [ 'ID' ], ARRAY_A ));
2004-05-23 21:34:57 -04:00
// Now overwrite any changed values being passed in
extract ( $postarr );
2005-01-06 20:21:12 -05:00
2004-05-23 21:34:57 -04:00
// Make sure we set a valid category
2005-01-06 20:21:12 -05:00
if ( 0 == count ( $post_category ) || ! is_array ( $post_category ) )
2004-05-23 21:34:57 -04:00
$post_category = array ( $post_default_category );
// Do some escapes for safety
2005-01-06 20:21:12 -05:00
$post_title = $wpdb -> escape ( $post_title );
2004-05-23 21:34:57 -04:00
$post_excerpt = $wpdb -> escape ( $post_excerpt );
$post_content = $wpdb -> escape ( $post_content );
$post_modified = current_time ( 'mysql' );
$post_modified_gmt = current_time ( 'mysql' , 1 );
2004-05-24 04:22:18 -04:00
$sql = " UPDATE $wpdb->posts
2004-05-23 21:34:57 -04:00
SET post_content = '$post_content' ,
post_title = '$post_title' ,
post_category = $post_category [ 0 ],
post_status = '$post_status' ,
post_date = '$post_date' ,
post_date_gmt = '$post_date_gmt' ,
post_modified = '$post_modified' ,
post_modified_gmt = '$post_modified_gmt' ,
post_excerpt = '$post_excerpt' ,
ping_status = '$ping_status' ,
comment_status = '$comment_status'
WHERE ID = $ID " ;
$result = $wpdb -> query ( $sql );
2005-03-04 15:43:57 -05:00
$rows_affected = $wpdb -> rows_affected ;
2004-05-23 21:34:57 -04:00
2005-03-04 21:02:15 -05:00
wp_set_post_cats ( '' , $ID , $post_category );
2005-01-06 20:21:12 -05:00
do_action ( 'edit_post' , $ID );
2005-03-04 15:43:57 -05:00
return $rows_affected ;
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
$sql = " 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
ORDER BY category_id " ;
$result = $wpdb -> get_col ( $sql );
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:
if ( ! is_array ( $post_categories )) {
if ( ! $post_categories ) {
$post_categories = 1 ;
}
$post_categories = array ( $post_categories );
}
$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 );
}
2004-10-11 12:49:52 -04:00
$oldies = printr ( $old_categories , 1 );
$newbies = printr ( $post_categories , 1 );
2004-05-23 21:34:57 -04:00
// 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 ) " );
}
}
} // wp_set_post_cats()
function wp_delete_post ( $postid = 0 ) {
2004-05-24 04:22:18 -04:00
global $wpdb ;
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-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 " );
2004-05-23 21:34:57 -04: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-01-06 20:11:51 -05:00
switch ( $authordata [ 'user_idmode' ] ) {
case 'nickname' :
$authorname = $authordata [ 'user_nickname' ];
2004-05-23 21:34:57 -04:00
break ;
2005-01-06 20:11:51 -05:00
case 'login' :
$authorname = $authordata [ 'user_login' ];
2004-05-23 21:34:57 -04:00
break ;
2005-01-06 20:11:51 -05:00
case 'firstname' :
$authorname = $authordata [ 'user_firstname' ];
2004-05-23 21:34:57 -04:00
break ;
2005-01-06 20:11:51 -05:00
case 'lastname' :
$authorname = $authordata [ 'user_lastname' ];
2004-05-23 21:34:57 -04:00
break ;
2005-01-06 20:11:51 -05:00
case 'namefl' :
$authorname = $authordata [ 'user_firstname' ] . ' ' . $authordata [ 'user_lastname' ];
break ;
case 'namelf' :
$authorname = $authordata [ 'user_lastname' ] . ' ' . $authordata [ 'user_firstname' ];
2004-05-23 21:34:57 -04:00
break ;
default :
2005-01-06 20:11:51 -05:00
$authorname = $authordata [ 'user_nickname' ];
2004-05-23 21:34:57 -04:00
break ;
}
return $authorname ;
}
// 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 );
}
}
}
2004-08-25 11:12:10 -04:00
// query user capabilities
2004-10-15 12:20:25 -04:00
// rather simplistic. shall evolve with future permission system overhaul
// $blog_id and $category_id are there for future usage
2004-08-25 11:12:10 -04:00
2004-10-15 12:20:25 -04:00
/* returns true if $user_id can create a new post */
2004-09-09 11:54:03 -04:00
function user_can_create_post ( $user_id , $blog_id = 1 , $category_id = 'None' ) {
$author_data = get_userdata ( $user_id );
return ( $author_data -> user_level > 1 );
}
2004-10-15 12:20:25 -04:00
/* returns true if $user_id can create a new post */
function user_can_create_draft ( $user_id , $blog_id = 1 , $category_id = 'None' ) {
$author_data = get_userdata ( $user_id );
return ( $author_data -> user_level >= 1 );
}
2004-09-09 11:54:03 -04:00
2004-10-15 12:20:25 -04:00
/* returns true if $user_id can edit $post_id */
2004-08-25 11:12:10 -04:00
function user_can_edit_post ( $user_id , $post_id , $blog_id = 1 ) {
$author_data = get_userdata ( $user_id );
2005-04-09 13:12:36 -04:00
$post = get_post ( $post_id );
$post_author_data = get_userdata ( $post -> post_author );
2004-08-25 11:12:10 -04:00
2005-04-09 13:12:36 -04:00
if ( (( $user_id == $post_author_data -> ID ) && ! ( $post -> post_status == 'publish' && $author_data -> user_level < 2 ))
2004-11-23 10:09:24 -05:00
|| ( $author_data -> user_level > $post_author_data -> user_level )
|| ( $author_data -> user_level >= 10 ) ) {
2004-08-25 11:12:10 -04:00
return true ;
} else {
return false ;
}
}
2004-10-15 12:20:25 -04:00
/* returns true if $user_id can delete $post_id */
2004-08-25 11:12:10 -04:00
function user_can_delete_post ( $user_id , $post_id , $blog_id = 1 ) {
// right now if one can edit, one can delete
return user_can_edit_post ( $user_id , $post_id , $blog_id );
}
2004-10-15 12:20:25 -04:00
/* returns true if $user_id can set new posts' dates on $blog_id */
function user_can_set_post_date ( $user_id , $blog_id = 1 , $category_id = 'None' ) {
$author_data = get_userdata ( $user_id );
return (( $author_data -> user_level > 4 ) && user_can_create_post ( $user_id , $blog_id , $category_id ));
}
/* returns true if $user_id can edit $post_id's date */
function user_can_edit_post_date ( $user_id , $post_id , $blog_id = 1 ) {
$author_data = get_userdata ( $user_id );
return (( $author_data -> user_level > 4 ) && user_can_edit_post ( $user_id , $post_id , $blog_id ));
}
/* returns true if $user_id can edit $post_id's comments */
function user_can_edit_post_comments ( $user_id , $post_id , $blog_id = 1 ) {
// right now if one can edit a post, one can edit comments made on it
return user_can_edit_post ( $user_id , $post_id , $blog_id );
}
/* returns true if $user_id can delete $post_id's comments */
function user_can_delete_post_comments ( $user_id , $post_id , $blog_id = 1 ) {
// right now if one can edit comments, one can delete comments
return user_can_edit_post_comments ( $user_id , $post_id , $blog_id );
}
2004-11-18 14:40:36 -05:00
function user_can_edit_user ( $user_id , $other_user ) {
$user = get_userdata ( $user_id );
$other = get_userdata ( $other_user );
if ( $user -> user_level > $other -> user_level || $user -> user_level > 8 || $user -> ID == $other -> ID )
return true ;
else
return false ;
}
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 ) ) );
2005-02-02 03:40:44 -05:00
$lookup = $rev_ip . '.opm.blitzed.org' ;
if ( $lookup != gethostbyname ( $lookup ) )
return true ;
}
2005-01-10 15:21:06 -05:00
return false ;
}
function wp_new_comment ( $commentdata , $spam = false ) {
2004-09-06 22:34:12 -04:00
global $wpdb ;
2004-12-15 21:57:05 -05:00
2005-01-05 16:11:42 -05:00
$commentdata = apply_filters ( 'preprocess_comment' , $commentdata );
2004-09-06 22:34:12 -04:00
extract ( $commentdata );
2004-09-22 15:44:35 -04:00
$comment_post_ID = ( int ) $comment_post_ID ;
2004-09-06 22:34:12 -04:00
2005-01-31 01:38:12 -05:00
$user_id = apply_filters ( 'pre_user_id' , $user_ID );
2004-12-15 21:57:05 -05:00
$author = apply_filters ( 'pre_comment_author_name' , $comment_author );
$email = apply_filters ( 'pre_comment_author_email' , $comment_author_email );
$url = apply_filters ( 'pre_comment_author_url' , $comment_author_url );
$comment = apply_filters ( 'pre_comment_content' , $comment_content );
$comment = apply_filters ( 'post_comment_text' , $comment ); // Deprecated
2005-01-26 15:35:13 -05:00
$comment = apply_filters ( 'comment_content_presave' , $comment ); // Deprecated
2004-09-06 22:34:12 -04:00
2004-12-15 21:57:05 -05:00
$user_ip = apply_filters ( 'pre_comment_user_ip' , $_SERVER [ 'REMOTE_ADDR' ]);
$user_domain = apply_filters ( 'pre_comment_user_domain' , gethostbyaddr ( $user_ip ) );
$user_agent = apply_filters ( 'pre_comment_user_agent' , $_SERVER [ 'HTTP_USER_AGENT' ]);
2004-09-06 22:34:12 -04:00
2004-12-15 21:57:05 -05:00
$now = current_time ( 'mysql' );
2004-09-06 22:34:12 -04:00
$now_gmt = current_time ( 'mysql' , 1 );
2004-09-27 07:45:15 -04:00
2005-04-19 23:37:23 -04:00
if ( $user_id ) {
$userdata = get_userdata ( $user_id );
$post_author = $wpdb -> get_var ( " SELECT post_author FROM $wpdb->posts WHERE ID = ' $comment_post_ID ' LIMIT 1 " );
}
2005-04-20 17:56:28 -04:00
// Simple duplicate check
$dupe = " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = ' $comment_post_ID ' AND ( comment_author = ' $author ' " ;
if ( $email ) $dupe .= " OR comment_author_email = ' $email ' " ;
$dupe .= " ) AND comment_content = ' $comment ' LIMIT 1 " ;
if ( $wpdb -> get_var ( $dupe ) )
die ( __ ( 'Duplicate comment detected; it looks as though you\'ve already said that!' ) );
2004-09-06 22:34:12 -04:00
// Simple flood-protection
2004-12-15 21:57:05 -05:00
if ( $lasttime = $wpdb -> get_var ( " SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_author_IP = ' $user_ip ' OR comment_author_email = ' $email ' ORDER BY comment_date DESC LIMIT 1 " ) ) {
$time_lastcomment = mysql2date ( 'U' , $lasttime );
$time_newcomment = mysql2date ( 'U' , $now_gmt );
2005-01-11 13:47:07 -05:00
if ( ( $time_newcomment - $time_lastcomment ) < 15 ) {
2005-02-05 22:40:08 -05:00
do_action ( 'comment_flood_trigger' , $time_lastcomment , $time_newcomment );
2004-09-06 22:34:12 -04:00
die ( __ ( 'Sorry, you can only post a new comment once every 15 seconds. Slow down cowboy.' ) );
2005-01-11 13:47:07 -05:00
}
2004-09-06 22:34:12 -04:00
}
2005-04-27 19:55:06 -04:00
if ( $userdata && ( $user_id == $post_author || $userdata -> user_level >= 9 ) ) {
2005-04-19 23:37:23 -04:00
$approved = 1 ;
2005-04-27 19:55:06 -04:00
} else {
if ( check_comment ( $author , $email , $url , $comment , $user_ip , $user_agent , $comment_type ) )
$approved = 1 ;
else
$approved = 0 ;
if ( wp_blacklist_check ( $author , $email , $url , $comment , $user_ip , $user_agent ) )
$approved = 'spam' ;
}
2005-04-19 23:37:23 -04:00
2005-01-10 15:26:10 -05:00
$approved = apply_filters ( 'pre_comment_approved' , $approved );
2004-09-06 22:34:12 -04:00
$result = $wpdb -> query ( " INSERT INTO $wpdb->comments
2005-01-31 01:38:12 -05:00
( comment_post_ID , comment_author , comment_author_email , comment_author_url , comment_author_IP , comment_date , comment_date_gmt , comment_content , comment_approved , comment_agent , comment_type , user_id )
2004-09-06 22:34:12 -04:00
VALUES
2005-01-31 01:38:12 -05:00
( '$comment_post_ID' , '$author' , '$email' , '$url' , '$user_ip' , '$now' , '$now_gmt' , '$comment' , '$approved' , '$user_agent' , '$comment_type' , '$user_id' )
2004-09-06 22:34:12 -04:00
" );
2004-12-15 21:57:05 -05:00
$comment_id = $wpdb -> insert_id ;
2005-02-05 22:40:08 -05:00
do_action ( 'comment_post' , $comment_id , $approved );
2004-12-15 21:57:05 -05:00
2005-01-24 03:27:53 -05:00
if ( 'spam' !== $approved ) { // If it's spam save it silently for later crunching
if ( '0' == $approved )
2005-01-10 15:21:06 -05:00
wp_notify_moderator ( $comment_id );
if ( get_settings ( 'comments_notify' ) && $approved )
2005-01-14 20:07:53 -05:00
wp_notify_postauthor ( $comment_id , $comment_type );
2005-01-10 15:21:06 -05:00
}
2004-09-06 22:34:12 -04:00
return $result ;
}
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-05-17 23:17:55 -04:00
if ( empty ( $to_ping ) )
return ;
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 );
$excerpt = substr ( $excerpt , 0 , 252 ) . '...' ;
$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 );
if ( ! in_array ( $tb_ping , $pinged ) )
trackback ( $tb_ping , $post_title , $excerpt , $post_id );
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 );
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 ();
if ( is_array ( $custom_fields ) ) {
while ( list ( $key , $val ) = each ( $custom_fields ) ) {
if ( $key == 'enclosure' ) {
if ( is_array ( $val )) {
foreach ( $val as $enc ) {
$enclosure = split ( " \n " , $enc );
$pung [] = trim ( $enclosure [ 0 ] );
}
}
}
}
}
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 );
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 );
return $wpdb -> query ( " UPDATE $wpdb->posts SET pinged = ' $new ' WHERE ID = $post_id " );
}
2005-04-27 19:55:06 -04:00
?>