2004-12-16 03:57:05 +01:00
< ? php
2008-01-04 21:03:42 +01:00
/**
* Manages WordPress comments
*
* @ package WordPress
2008-08-05 00:29:37 +02:00
* @ subpackage Comment
2008-01-04 21:03:42 +01:00
*/
/**
2008-06-15 11:34:00 +02:00
* Checks whether a comment passes internal checks to be allowed to add .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* If comment moderation is set in the administration , then all comments ,
2008-09-22 05:39:41 +02:00
* regardless of their type and whitelist will be set to false . If the number of
* links exceeds the amount in the administration , then the check fails . If any
* of the parameter contents match the blacklist of words , then the check fails .
2008-06-15 11:34:00 +02:00
*
2008-09-22 22:21:10 +02:00
* If the number of links exceeds the amount in the administration , then the
* check fails . If any of the parameter contents match the blacklist of words ,
* then the check fails .
*
2008-06-15 11:34:00 +02:00
* If the comment is a trackback and part of the blogroll , then the trackback is
* automatically whitelisted . If the comment author was approved before , then
* the comment is automatically whitelisted .
*
* If none of the checks fail , then the failback is to set the check to pass
* ( return true ) .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ since 1.2 . 0
2008-01-04 21:03:42 +01:00
* @ uses $wpdb
*
2008-06-15 11:34:00 +02:00
* @ param string $author Comment Author ' s name
* @ param string $email Comment Author ' s email
* @ param string $url Comment Author ' s URL
* @ param string $comment Comment contents
* @ param string $user_ip Comment Author ' s IP address
* @ param string $user_agent Comment Author ' s User Agent
* @ param string $comment_type Comment type , either user submitted comment ,
* trackback , or pingback
* @ return bool Whether the checks passed ( true ) and the comments should be
* displayed or set to moderated
2008-01-04 21:03:42 +01:00
*/
2006-04-19 04:32:12 +02:00
function check_comment ( $author , $email , $url , $comment , $user_ip , $user_agent , $comment_type ) {
global $wpdb ;
2006-02-12 08:53:23 +01:00
2006-12-07 04:57:23 +01:00
if ( 1 == get_option ( 'comment_moderation' ) )
return false ; // If moderation is set to manual
2005-09-20 05:17:43 +02:00
2009-01-28 22:12:57 +01:00
if ( get_option ( 'comment_max_links' ) && preg_match_all ( " /<[Aa][^>]*[Hh][Rr][Ee][Ff]=[' \" ]([^ \" '>]+)[^>]*>/ " , apply_filters ( 'comment_text' , $comment ), $out ) >= get_option ( 'comment_max_links' ) )
2006-04-19 04:32:12 +02:00
return false ; // Check # of external links
2005-09-20 05:17:43 +02:00
2006-12-07 04:57:23 +01:00
$mod_keys = trim ( get_option ( 'moderation_keys' ));
2006-04-19 04:32:12 +02:00
if ( ! empty ( $mod_keys ) ) {
$words = explode ( " \n " , $mod_keys );
2005-09-20 05:17:43 +02:00
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $words as $word ) {
2006-04-19 04:32:12 +02:00
$word = trim ( $word );
2005-09-20 05:17:43 +02:00
2006-04-19 04:32:12 +02:00
// Skip empty lines
2006-12-07 04:57:23 +01:00
if ( empty ( $word ) )
continue ;
2005-09-20 05:17:43 +02:00
2006-11-19 08:56:05 +01:00
// Do some escaping magic so that '#' chars in the
2006-04-19 04:32:12 +02:00
// spam words don't break things:
$word = preg_quote ( $word , '#' );
2005-11-11 00:31:58 +01:00
2006-11-19 08:56:05 +01:00
$pattern = " # $word #i " ;
2006-04-19 04:32:12 +02:00
if ( preg_match ( $pattern , $author ) ) return false ;
if ( preg_match ( $pattern , $email ) ) return false ;
if ( preg_match ( $pattern , $url ) ) return false ;
if ( preg_match ( $pattern , $comment ) ) return false ;
if ( preg_match ( $pattern , $user_ip ) ) return false ;
if ( preg_match ( $pattern , $user_agent ) ) return false ;
}
}
2005-11-11 00:31:58 +01:00
2006-04-19 04:32:12 +02:00
// Comment whitelisting:
2006-08-30 23:46:31 +02:00
if ( 1 == get_option ( 'comment_whitelist' )) {
2006-04-19 04:32:12 +02:00
if ( 'trackback' == $comment_type || 'pingback' == $comment_type ) { // check if domain is in blogroll
$uri = parse_url ( $url );
$domain = $uri [ 'host' ];
$uri = parse_url ( get_option ( 'home' ) );
$home_domain = $uri [ 'host' ];
2007-09-27 09:34:15 +02:00
if ( $wpdb -> get_var ( $wpdb -> prepare ( " SELECT link_id FROM $wpdb->links WHERE link_url LIKE (%s) LIMIT 1 " , '%' . $domain . '%' )) || $domain == $home_domain )
2006-04-19 04:32:12 +02:00
return true ;
else
return false ;
2006-12-07 04:57:23 +01:00
} elseif ( $author != '' && $email != '' ) {
2007-09-27 09:34:15 +02:00
// expected_slashed ($author, $email)
2006-04-19 04:32:12 +02:00
$ok_to_comment = $wpdb -> get_var ( " SELECT comment_approved FROM $wpdb->comments WHERE comment_author = ' $author ' AND comment_author_email = ' $email ' and comment_approved = '1' LIMIT 1 " );
if ( ( 1 == $ok_to_comment ) &&
( empty ( $mod_keys ) || false === strpos ( $email , $mod_keys ) ) )
return true ;
else
return false ;
} else {
return false ;
}
2005-09-20 05:17:43 +02:00
}
2006-04-19 04:32:12 +02:00
return true ;
2005-09-20 05:17:43 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Retrieve the approved comments for post $post_id .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ since 2.0 . 0
2008-01-04 21:03:42 +01:00
* @ uses $wpdb
*
* @ param int $post_id The ID of the post
* @ return array $comments The approved comments
*/
2006-04-19 04:32:12 +02:00
function get_approved_comments ( $post_id ) {
2005-09-20 05:17:43 +02:00
global $wpdb ;
2007-09-27 09:34:15 +02:00
return $wpdb -> get_results ( $wpdb -> prepare ( " SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1' ORDER BY comment_date " , $post_id ));
2006-04-19 04:32:12 +02:00
}
2005-09-20 05:17:43 +02:00
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Retrieves comment data given a comment ID or comment object .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* If an object is passed then the comment data will be cached and then returned
2008-09-22 05:39:41 +02:00
* after being passed through a filter . If the comment is empty , then the global
* comment variable will be used , if it is set .
2008-06-15 11:34:00 +02:00
*
2008-09-22 22:21:10 +02:00
* If the comment is empty , then the global comment variable will be used , if it
* is set .
*
2008-09-22 05:39:41 +02:00
* @ since 2.0 . 0
2008-01-04 21:03:42 +01:00
* @ uses $wpdb
*
2008-06-15 11:34:00 +02:00
* @ param object | string | int $comment Comment to retrieve .
2008-09-22 05:39:41 +02:00
* @ param string $output Optional . OBJECT or ARRAY_A or ARRAY_N constants .
2008-01-04 21:03:42 +01:00
* @ return object | array | null Depends on $output value .
*/
2006-04-19 04:32:12 +02:00
function & get_comment ( & $comment , $output = OBJECT ) {
2007-06-08 02:20:22 +02:00
global $wpdb ;
2005-09-20 05:17:43 +02:00
2007-04-27 05:51:36 +02:00
if ( empty ( $comment ) ) {
if ( isset ( $GLOBALS [ 'comment' ]) )
$_comment = & $GLOBALS [ 'comment' ];
else
$_comment = null ;
} elseif ( is_object ( $comment ) ) {
2007-06-08 02:20:22 +02:00
wp_cache_add ( $comment -> comment_ID , $comment , 'comment' );
$_comment = $comment ;
2006-04-19 04:32:12 +02:00
} else {
2007-04-27 06:34:44 +02:00
if ( isset ( $GLOBALS [ 'comment' ]) && ( $GLOBALS [ 'comment' ] -> comment_ID == $comment ) ) {
2007-04-27 05:51:36 +02:00
$_comment = & $GLOBALS [ 'comment' ];
2007-06-08 02:20:22 +02:00
} elseif ( ! $_comment = wp_cache_get ( $comment , 'comment' ) ) {
2007-09-27 09:34:15 +02:00
$_comment = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1 " , $comment ));
2007-06-08 02:20:22 +02:00
wp_cache_add ( $_comment -> comment_ID , $_comment , 'comment' );
2006-04-19 04:32:12 +02:00
}
}
2005-11-16 07:29:36 +01:00
2007-06-08 02:20:22 +02:00
$_comment = apply_filters ( 'get_comment' , $_comment );
2006-04-19 04:32:12 +02:00
if ( $output == OBJECT ) {
return $_comment ;
} elseif ( $output == ARRAY_A ) {
2008-11-03 07:44:48 +01:00
$__comment = get_object_vars ( $_comment );
return $__comment ;
2006-04-19 04:32:12 +02:00
} elseif ( $output == ARRAY_N ) {
2008-11-03 07:44:48 +01:00
$__comment = array_values ( get_object_vars ( $_comment ));
return $__comment ;
2006-04-19 04:32:12 +02:00
} else {
return $_comment ;
2005-11-22 04:45:40 +01:00
}
2005-09-20 05:17:43 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Retrieve a list of comments .
2008-01-04 21:03:42 +01:00
*
2009-05-04 11:22:44 +02:00
* The comment list can be for the blog as a whole or for an individual post .
2009-05-25 01:47:49 +02:00
*
2008-09-22 05:39:41 +02:00
* The list of comment arguments are 'status' , 'orderby' , 'comment_date_gmt' ,
* 'order' , 'number' , 'offset' , and 'post_id' .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ since 2.7 . 0
2008-08-05 00:29:37 +02:00
* @ uses $wpdb
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ param mixed $args Optional . Array or string of options to override defaults .
* @ return array List of comments .
2008-01-04 21:03:42 +01:00
*/
2008-08-05 00:29:37 +02:00
function get_comments ( $args = '' ) {
global $wpdb ;
$defaults = array ( 'status' => '' , 'orderby' => 'comment_date_gmt' , 'order' => 'DESC' , 'number' => '' , 'offset' => '' , 'post_id' => 0 );
2008-11-04 17:44:55 +01:00
$args = wp_parse_args ( $args , $defaults );
extract ( $args , EXTR_SKIP );
// $args can be whatever, only use the args defined in defaults to compute the key
$key = md5 ( serialize ( compact ( array_keys ( $defaults )) ) );
$last_changed = wp_cache_get ( 'last_changed' , 'comment' );
if ( ! $last_changed ) {
$last_changed = time ();
wp_cache_set ( 'last_changed' , $last_changed , 'comment' );
}
$cache_key = " get_comments: $key : $last_changed " ;
if ( $cache = wp_cache_get ( $cache_key , 'comment' ) ) {
return $cache ;
}
2008-08-05 00:29:37 +02:00
$post_id = absint ( $post_id );
if ( 'hold' == $status )
$approved = " comment_approved = '0' " ;
elseif ( 'approve' == $status )
$approved = " comment_approved = '1' " ;
elseif ( 'spam' == $status )
$approved = " comment_approved = 'spam' " ;
2009-07-30 15:39:34 +02:00
elseif ( 'trash' == $status )
$approved = " comment_approved = 'trash' " ;
2008-08-05 00:29:37 +02:00
else
$approved = " ( comment_approved = '0' OR comment_approved = '1' ) " ;
2008-10-28 08:29:04 +01:00
$order = ( 'ASC' == $order ) ? 'ASC' : 'DESC' ;
2008-08-05 00:29:37 +02:00
$orderby = 'comment_date_gmt' ; // Hard code for now
$number = absint ( $number );
$offset = absint ( $offset );
if ( ! empty ( $number ) ) {
if ( $offset )
$number = 'LIMIT ' . $offset . ',' . $number ;
else
$number = 'LIMIT ' . $number ;
2006-04-19 04:32:12 +02:00
} else {
2008-08-05 00:29:37 +02:00
$number = '' ;
2006-04-19 04:32:12 +02:00
}
2008-08-05 00:29:37 +02:00
if ( ! empty ( $post_id ) )
2008-11-10 23:16:50 +01:00
$post_where = $wpdb -> prepare ( 'comment_post_ID = %d AND' , $post_id );
2008-08-05 00:29:37 +02:00
else
$post_where = '' ;
2008-11-04 17:44:55 +01:00
$comments = $wpdb -> get_results ( " SELECT * FROM $wpdb->comments WHERE $post_where $approved ORDER BY $orderby $order $number " );
wp_cache_add ( $cache_key , $comments , 'comment' );
return $comments ;
2008-08-05 00:29:37 +02:00
}
/**
* Retrieve all of the WordPress supported comment statuses .
*
2008-09-22 05:39:41 +02:00
* Comments have a limited set of valid status values , this provides the comment
* status values and descriptions .
2008-08-05 00:29:37 +02:00
*
* @ package WordPress
* @ subpackage Post
2008-09-22 05:39:41 +02:00
* @ since 2.7 . 0
2008-08-05 00:29:37 +02:00
*
* @ return array List of comment statuses .
*/
function get_comment_statuses ( ) {
$status = array (
'hold' => __ ( 'Unapproved' ),
2009-03-11 00:02:29 +01:00
/* translators: comment status */
'approve' => _x ( 'Approved' , 'adjective' ),
/* translators: comment status */
'spam' => _x ( 'Spam' , 'adjective' ),
2008-08-05 00:29:37 +02:00
);
return $status ;
2006-04-19 04:32:12 +02:00
}
2008-08-05 00:29:37 +02:00
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* The date the last comment was modified .
2008-01-04 21:03:42 +01:00
*
* @ since 1.5 . 0
* @ uses $wpdb
* @ global array $cache_lastcommentmodified
*
2008-06-15 11:34:00 +02:00
* @ param string $timezone Which timezone to use in reference to 'gmt' , 'blog' ,
2008-09-22 05:39:41 +02:00
* or 'server' locations .
* @ return string Last comment modified date .
2008-01-04 21:03:42 +01:00
*/
2006-04-19 04:32:12 +02:00
function get_lastcommentmodified ( $timezone = 'server' ) {
2007-12-06 20:49:33 +01:00
global $cache_lastcommentmodified , $wpdb ;
2008-01-14 06:59:39 +01:00
if ( isset ( $cache_lastcommentmodified [ $timezone ]) )
return $cache_lastcommentmodified [ $timezone ];
2006-04-19 04:32:12 +02:00
$add_seconds_server = date ( 'Z' );
2008-01-14 06:59:39 +01:00
switch ( strtolower ( $timezone )) {
case 'gmt' :
2008-02-06 00:29:59 +01:00
$lastcommentmodified = $wpdb -> get_var ( " SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1 " );
2008-01-14 06:59:39 +01:00
break ;
case 'blog' :
2008-02-06 00:29:59 +01:00
$lastcommentmodified = $wpdb -> get_var ( " SELECT comment_date FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1 " );
2008-01-14 06:59:39 +01:00
break ;
case 'server' :
$lastcommentmodified = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT DATE_ADD(comment_date_gmt, INTERVAL %s SECOND) FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1 " , $add_seconds_server ));
break ;
2006-04-19 04:32:12 +02:00
}
2008-01-14 06:59:39 +01:00
$cache_lastcommentmodified [ $timezone ] = $lastcommentmodified ;
2006-04-19 04:32:12 +02:00
return $lastcommentmodified ;
2005-09-20 05:17:43 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* The amount of comments in a post or total comments .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* A lot like { @ link wp_count_comments ()}, in that they both return comment
* stats ( albeit with different types ) . The { @ link wp_count_comments ()} actual
* caches , but this function does not .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 0
* @ uses $wpdb
*
2008-09-22 05:39:41 +02:00
* @ param int $post_id Optional . Comment amount in post if > 0 , else total comments blog wide .
* @ return array The amount of spam , approved , awaiting moderation , and total comments .
2008-01-04 21:03:42 +01:00
*/
2008-01-01 19:40:39 +01:00
function get_comment_count ( $post_id = 0 ) {
2008-01-04 21:03:42 +01:00
global $wpdb ;
$post_id = ( int ) $post_id ;
$where = '' ;
if ( $post_id > 0 ) {
2008-04-14 18:13:25 +02:00
$where = $wpdb -> prepare ( " WHERE comment_post_ID = %d " , $post_id );
2008-01-04 21:03:42 +01:00
}
2008-02-05 07:47:27 +01:00
$totals = ( array ) $wpdb -> get_results ( "
SELECT comment_approved , COUNT ( * ) AS total
FROM { $wpdb -> comments }
{ $where }
GROUP BY comment_approved
2008-01-04 21:03:42 +01:00
" , ARRAY_A);
2008-02-05 07:47:27 +01:00
$comment_count = array (
" approved " => 0 ,
2008-01-04 21:03:42 +01:00
" awaiting_moderation " => 0 ,
" spam " => 0 ,
" total_comments " => 0
2008-02-05 07:47:27 +01:00
);
2008-01-04 21:03:42 +01:00
2008-02-05 07:47:27 +01:00
foreach ( $totals as $row ) {
switch ( $row [ 'comment_approved' ] ) {
case 'spam' :
$comment_count [ 'spam' ] = $row [ 'total' ];
2008-01-04 21:03:42 +01:00
$comment_count [ " total_comments " ] += $row [ 'total' ];
2008-02-05 07:47:27 +01:00
break ;
case 1 :
$comment_count [ 'approved' ] = $row [ 'total' ];
2008-01-04 21:03:42 +01:00
$comment_count [ 'total_comments' ] += $row [ 'total' ];
2008-02-05 07:47:27 +01:00
break ;
2008-01-04 21:03:42 +01:00
case 0 :
$comment_count [ 'awaiting_moderation' ] = $row [ 'total' ];
$comment_count [ 'total_comments' ] += $row [ 'total' ];
break ;
default :
break ;
}
}
2008-01-01 19:40:39 +01:00
2008-01-04 21:03:42 +01:00
return $comment_count ;
}
2008-01-01 19:40:39 +01:00
2009-09-17 22:17:33 +02:00
//
// Comment meta functions
//
/**
* Add meta data field to a comment .
*
* Post meta data is called " Custom Fields " on the Administration Panels .
*
* @ since 2.9
* @ uses add_metadata
* @ link http :// codex . wordpress . org / Function_Reference / add_comment_meta
*
* @ param int $comment_id Post ID .
* @ param string $key Metadata name .
* @ param mixed $value Metadata value .
* @ param bool $unique Optional , default is false . Whether the same key should not be added .
* @ return bool False for failure . True for success .
*/
function add_comment_meta ( $comment_id , $meta_key , $meta_value , $unique = false ) {
return add_metadata ( 'comment' , $comment_id , $meta_key , $meta_value , $unique );
}
/**
* Remove metadata matching criteria from a comment .
*
* You can match based on the key , or key and value . Removing based on key and
* value , will keep from removing duplicate metadata with the same key . It also
* allows removing all metadata matching key , if needed .
*
* @ since 2.9
* @ uses delete_metadata
* @ link http :// codex . wordpress . org / Function_Reference / delete_comment_meta
*
* @ param int $comment_id comment ID
* @ param string $meta_key Metadata name .
* @ param mixed $meta_value Optional . Metadata value .
* @ return bool False for failure . True for success .
*/
function delete_comment_meta ( $comment_id , $meta_key , $meta_value = '' ) {
return delete_metadata ( 'comment' , $comment_id , $meta_key , $meta_value );
}
/**
* Retrieve comment meta field for a comment .
*
* @ since 2.9
* @ uses get_metadata
* @ link http :// codex . wordpress . org / Function_Reference / get_comment_meta
*
* @ param int $comment_id Post ID .
* @ param string $key The meta key to retrieve .
* @ param bool $single Whether to return a single value .
* @ return mixed Will be an array if $single is false . Will be value of meta data field if $single
* is true .
*/
function get_comment_meta ( $comment_id , $key , $single = false ) {
return get_metadata ( 'comment' , $comment_id , $key , $single );
}
/**
* Update comment meta field based on comment ID .
*
* Use the $prev_value parameter to differentiate between meta fields with the
* same key and comment ID .
*
* If the meta field for the comment does not exist , it will be added .
*
* @ since 2.9
* @ uses update_metadata
* @ link http :// codex . wordpress . org / Function_Reference / update_comment_meta
*
* @ param int $comment_id Post ID .
* @ param string $key Metadata key .
* @ param mixed $value Metadata value .
* @ param mixed $prev_value Optional . Previous value to check before removing .
* @ return bool False on failure , true if success .
*/
function update_comment_meta ( $comment_id , $meta_key , $meta_value , $prev_value = '' ) {
return update_metadata ( 'comment' , $comment_id , $meta_key , $meta_value , $prev_value );
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Sanitizes the cookies sent to the user already .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* Will only do anything if the cookies have already been created for the user .
* Mostly used after cookies had been sent to use elsewhere .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 4
*/
2006-06-22 22:52:12 +02:00
function sanitize_comment_cookies () {
if ( isset ( $_COOKIE [ 'comment_author_' . COOKIEHASH ]) ) {
$comment_author = apply_filters ( 'pre_comment_author_name' , $_COOKIE [ 'comment_author_' . COOKIEHASH ]);
$comment_author = stripslashes ( $comment_author );
2009-05-05 21:43:53 +02:00
$comment_author = esc_attr ( $comment_author );
2006-06-22 22:52:12 +02:00
$_COOKIE [ 'comment_author_' . COOKIEHASH ] = $comment_author ;
}
if ( isset ( $_COOKIE [ 'comment_author_email_' . COOKIEHASH ]) ) {
$comment_author_email = apply_filters ( 'pre_comment_author_email' , $_COOKIE [ 'comment_author_email_' . COOKIEHASH ]);
$comment_author_email = stripslashes ( $comment_author_email );
2009-05-05 21:43:53 +02:00
$comment_author_email = esc_attr ( $comment_author_email );
2006-06-22 22:52:12 +02:00
$_COOKIE [ 'comment_author_email_' . COOKIEHASH ] = $comment_author_email ;
}
if ( isset ( $_COOKIE [ 'comment_author_url_' . COOKIEHASH ]) ) {
$comment_author_url = apply_filters ( 'pre_comment_author_url' , $_COOKIE [ 'comment_author_url_' . COOKIEHASH ]);
$comment_author_url = stripslashes ( $comment_author_url );
$_COOKIE [ 'comment_author_url_' . COOKIEHASH ] = $comment_author_url ;
}
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Validates whether this comment is allowed to be made or not .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 0
* @ uses $wpdb
* @ uses apply_filters () Calls 'pre_comment_approved' hook on the type of comment
* @ uses do_action () Calls 'check_comment_flood' hook on $comment_author_IP , $comment_author_email , and $comment_date_gmt
*
* @ param array $commentdata Contains information on the comment
* @ return mixed Signifies the approval status ( 0 | 1 | 'spam' )
*/
2005-09-20 05:17:43 +02:00
function wp_allow_comment ( $commentdata ) {
global $wpdb ;
2007-06-15 00:45:40 +02:00
extract ( $commentdata , EXTR_SKIP );
2005-09-20 05:17:43 +02:00
// Simple duplicate check
2007-09-27 09:34:15 +02:00
// expected_slashed ($comment_post_ID, $comment_author, $comment_author_email, $comment_content)
2005-09-20 05:17:43 +02:00
$dupe = " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = ' $comment_post_ID ' AND ( comment_author = ' $comment_author ' " ;
if ( $comment_author_email )
$dupe .= " OR comment_author_email = ' $comment_author_email ' " ;
$dupe .= " ) AND comment_content = ' $comment_content ' LIMIT 1 " ;
2008-08-24 08:56:22 +02:00
if ( $wpdb -> get_var ( $dupe ) ) {
if ( defined ( 'DOING_AJAX' ) )
2009-05-05 06:28:05 +02:00
die ( __ ( 'Duplicate comment detected; it looks as though you’ve already said that!' ) );
2008-08-24 08:56:22 +02:00
2009-05-05 06:28:05 +02:00
wp_die ( __ ( 'Duplicate comment detected; it looks as though you’ve already said that!' ) );
2008-08-24 08:56:22 +02:00
}
2005-09-20 05:17:43 +02:00
2007-08-27 08:34:18 +02:00
do_action ( 'check_comment_flood' , $comment_author_IP , $comment_author_email , $comment_date_gmt );
2005-09-20 05:17:43 +02:00
if ( $user_id ) {
$userdata = get_userdata ( $user_id );
$user = new WP_User ( $user_id );
2007-09-27 09:34:15 +02:00
$post_author = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT post_author FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $comment_post_ID ));
2005-09-20 05:17:43 +02:00
}
2008-12-04 21:26:05 +01:00
if ( isset ( $userdata ) && ( $user_id == $post_author || $user -> has_cap ( 'moderate_comments' ) ) ) {
2006-12-07 04:57:23 +01:00
// The author and the admins get respect.
2005-09-20 05:17:43 +02:00
$approved = 1 ;
2006-12-07 04:57:23 +01:00
} else {
// Everyone else's comments will be checked.
2005-09-20 05:17:43 +02:00
if ( check_comment ( $comment_author , $comment_author_email , $comment_author_url , $comment_content , $comment_author_IP , $comment_agent , $comment_type ) )
$approved = 1 ;
else
$approved = 0 ;
if ( wp_blacklist_check ( $comment_author , $comment_author_email , $comment_author_url , $comment_content , $comment_author_IP , $comment_agent ) )
$approved = 'spam' ;
}
$approved = apply_filters ( 'pre_comment_approved' , $approved );
return $approved ;
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Check whether comment flooding is occurring .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* Won ' t run , if current user can manage options , so to not block
* administrators .
2008-01-04 21:03:42 +01:00
*
* @ since 2.3 . 0
* @ uses $wpdb
2008-09-22 05:39:41 +02:00
* @ uses apply_filters () Calls 'comment_flood_filter' filter with first
* parameter false , last comment timestamp , new comment timestamp .
* @ uses do_action () Calls 'comment_flood_trigger' action with parameters with
* last comment timestamp and new comment timestamp .
*
* @ param string $ip Comment IP .
* @ param string $email Comment author email address .
* @ param string $date MySQL time string .
2008-01-04 21:03:42 +01:00
*/
2007-08-27 08:34:18 +02:00
function check_comment_flood_db ( $ip , $email , $date ) {
global $wpdb ;
2008-03-20 21:32:18 +01:00
if ( current_user_can ( 'manage_options' ) )
return ; // don't throttle admins
2008-04-14 18:13:25 +02:00
if ( $lasttime = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_author_IP = %s OR comment_author_email = %s ORDER BY comment_date DESC LIMIT 1 " , $ip , $email ) ) ) {
2009-05-14 04:00:32 +02:00
$time_lastcomment = mysql2date ( 'U' , $lasttime , false );
$time_newcomment = mysql2date ( 'U' , $date , false );
2007-08-27 08:34:18 +02:00
$flood_die = apply_filters ( 'comment_flood_filter' , false , $time_lastcomment , $time_newcomment );
if ( $flood_die ) {
do_action ( 'comment_flood_trigger' , $time_lastcomment , $time_newcomment );
2008-08-24 08:56:22 +02:00
if ( defined ( 'DOING_AJAX' ) )
die ( __ ( 'You are posting comments too quickly. Slow down.' ) );
2008-10-24 23:00:40 +02:00
wp_die ( __ ( 'You are posting comments too quickly. Slow down.' ), '' , array ( 'response' => 403 ) );
2007-08-27 08:34:18 +02:00
}
}
}
2006-12-07 04:57:23 +01:00
2008-09-16 02:23:38 +02:00
/**
* Separates an array of comments into an array keyed by comment_type .
*
2008-09-22 05:39:41 +02:00
* @ since 2.7 . 0
2008-09-16 02:23:38 +02:00
*
* @ param array $comments Array of comments
* @ return array Array of comments keyed by comment_type .
*/
function & separate_comments ( & $comments ) {
$comments_by_type = array ( 'comment' => array (), 'trackback' => array (), 'pingback' => array (), 'pings' => array ());
$count = count ( $comments );
for ( $i = 0 ; $i < $count ; $i ++ ) {
$type = $comments [ $i ] -> comment_type ;
2008-09-30 21:49:26 +02:00
if ( empty ( $type ) )
$type = 'comment' ;
2008-09-16 02:23:38 +02:00
$comments_by_type [ $type ][] = & $comments [ $i ];
if ( 'trackback' == $type || 'pingback' == $type )
$comments_by_type [ 'pings' ][] = & $comments [ $i ];
}
return $comments_by_type ;
}
2008-10-23 18:08:47 +02:00
/**
* Calculate the total number of comment pages .
*
* @ since 2.7 . 0
2008-10-28 08:29:04 +01:00
* @ uses get_query_var () Used to fill in the default for $per_page parameter .
* @ uses get_option () Used to fill in defaults for parameters .
* @ uses Walker_Comment
2008-10-23 18:08:47 +02:00
*
* @ param array $comments Optional array of comment objects . Defaults to $wp_query -> comments
* @ param int $per_page Optional comments per page .
* @ param boolean $threaded Optional control over flat or threaded comments .
* @ return int Number of comment pages .
*/
function get_comment_pages_count ( $comments = null , $per_page = null , $threaded = null ) {
global $wp_query ;
2008-12-07 05:49:22 +01:00
if ( null === $comments && null === $per_page && null === $threaded && ! empty ( $wp_query -> max_num_comment_pages ) )
return $wp_query -> max_num_comment_pages ;
2008-10-23 18:08:47 +02:00
if ( ! $comments || ! is_array ( $comments ) )
$comments = $wp_query -> comments ;
if ( empty ( $comments ) )
return 0 ;
if ( ! isset ( $per_page ) )
$per_page = ( int ) get_query_var ( 'comments_per_page' );
if ( 0 === $per_page )
$per_page = ( int ) get_option ( 'comments_per_page' );
if ( 0 === $per_page )
return 1 ;
if ( ! isset ( $threaded ) )
$threaded = get_option ( 'thread_comments' );
if ( $threaded ) {
$walker = new Walker_Comment ;
$count = ceil ( $walker -> get_number_of_root_elements ( $comments ) / $per_page );
} else {
$count = ceil ( count ( $comments ) / $per_page );
}
return $count ;
}
2008-10-27 17:31:26 +01:00
/**
* Calculate what page number a comment will appear on for comment paging .
*
* @ since 2.7 . 0
2008-10-28 08:29:04 +01:00
* @ uses get_comment () Gets the full comment of the $comment_ID parameter .
* @ uses get_option () Get various settings to control function and defaults .
* @ uses get_page_of_comment () Used to loop up to top level comment .
2008-10-27 17:31:26 +01:00
*
* @ param int $comment_ID Comment ID .
2008-11-20 07:41:55 +01:00
* @ param array $args Optional args .
2008-10-27 17:31:26 +01:00
* @ return int | null Comment page number or null on error .
*/
2008-11-20 07:41:55 +01:00
function get_page_of_comment ( $comment_ID , $args = array () ) {
2008-11-05 08:09:20 +01:00
global $wpdb ;
2008-10-28 08:29:04 +01:00
if ( ! $comment = get_comment ( $comment_ID ) )
2008-10-27 17:31:26 +01:00
return ;
2008-11-20 07:41:55 +01:00
$defaults = array ( 'type' => 'all' , 'page' => '' , 'per_page' => '' , 'max_depth' => '' );
$args = wp_parse_args ( $args , $defaults );
2008-10-27 17:31:26 +01:00
2008-11-20 07:41:55 +01:00
if ( '' === $args [ 'per_page' ] && get_option ( 'page_comments' ) )
$args [ 'per_page' ] = get_query_var ( 'comments_per_page' );
if ( empty ( $args [ 'per_page' ]) ) {
$args [ 'per_page' ] = 0 ;
$args [ 'page' ] = 0 ;
}
if ( $args [ 'per_page' ] < 1 )
return 1 ;
2008-10-27 17:31:26 +01:00
2008-11-20 07:41:55 +01:00
if ( '' === $args [ 'max_depth' ] ) {
if ( get_option ( 'thread_comments' ) )
$args [ 'max_depth' ] = get_option ( 'thread_comments_depth' );
else
$args [ 'max_depth' ] = - 1 ;
}
2008-10-27 17:31:26 +01:00
2008-10-28 08:17:29 +01:00
// Find this comment's top level parent if threading is enabled
2008-11-20 07:41:55 +01:00
if ( $args [ 'max_depth' ] > 1 && 0 != $comment -> comment_parent )
return get_page_of_comment ( $comment -> comment_parent , $args );
$allowedtypes = array (
'comment' => '' ,
'pingback' => 'pingback' ,
'trackback' => 'trackback' ,
);
$comtypewhere = ( 'all' != $args [ 'type' ] && isset ( $allowedtypes [ $args [ 'type' ]]) ) ? " AND comment_type = ' " . $allowedtypes [ $args [ 'type' ]] . " ' " : '' ;
2008-10-28 08:29:04 +01:00
2008-11-05 08:09:20 +01:00
// Count comments older than this one
2009-01-28 19:43:08 +01:00
$oldercoms = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(comment_ID) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_parent = 0 AND comment_approved = '1' AND comment_date_gmt < '%s' " . $comtypewhere , $comment -> comment_post_ID , $comment -> comment_date_gmt ) );
2008-10-27 17:31:26 +01:00
2008-11-05 08:09:20 +01:00
// No older comments? Then it's page #1.
if ( 0 == $oldercoms )
return 1 ;
2008-10-27 17:31:26 +01:00
2008-11-05 08:09:20 +01:00
// Divide comments older than this one by comments per page to get this comment's page number
2008-11-20 07:41:55 +01:00
return ceil ( ( $oldercoms + 1 ) / $args [ 'per_page' ] );
2008-10-27 17:31:26 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Does comment contain blacklisted characters or words .
2008-01-04 21:03:42 +01:00
*
* @ since 1.5 . 0
2008-09-22 05:39:41 +02:00
* @ uses do_action () Calls 'wp_blacklist_check' hook for all parameters .
2008-01-04 21:03:42 +01:00
*
* @ param string $author The author of the comment
* @ param string $email The email of the comment
* @ param string $url The url used in the comment
* @ param string $comment The comment content
* @ param string $user_ip The comment author IP address
* @ param string $user_agent The author ' s browser user agent
* @ return bool True if comment contains blacklisted content , false if comment does not
*/
2006-06-08 01:17:59 +02:00
function wp_blacklist_check ( $author , $email , $url , $comment , $user_ip , $user_agent ) {
do_action ( 'wp_blacklist_check' , $author , $email , $url , $comment , $user_ip , $user_agent );
2006-08-30 23:46:31 +02:00
$mod_keys = trim ( get_option ( 'blacklist_keys' ) );
2006-12-07 04:57:23 +01:00
if ( '' == $mod_keys )
2006-06-08 01:17:59 +02:00
return false ; // If moderation keys are empty
$words = explode ( " \n " , $mod_keys );
2006-12-07 04:57:23 +01:00
foreach ( ( array ) $words as $word ) {
2006-06-08 01:17:59 +02:00
$word = trim ( $word );
// Skip empty lines
if ( empty ( $word ) ) { continue ; }
2006-11-19 08:56:05 +01:00
// Do some escaping magic so that '#' chars in the
2006-06-08 01:17:59 +02:00
// spam words don't break things:
$word = preg_quote ( $word , '#' );
2006-11-19 08:56:05 +01:00
$pattern = " # $word #i " ;
2006-12-07 04:57:23 +01:00
if (
preg_match ( $pattern , $author )
|| preg_match ( $pattern , $email )
|| preg_match ( $pattern , $url )
|| preg_match ( $pattern , $comment )
|| preg_match ( $pattern , $user_ip )
|| preg_match ( $pattern , $user_agent )
)
return true ;
2006-06-08 01:17:59 +02:00
}
return false ;
}
2008-06-15 11:34:00 +02:00
/**
2008-09-22 05:39:41 +02:00
* Retrieve total comments for blog or single post .
2008-06-15 11:34:00 +02:00
*
2008-09-22 05:39:41 +02:00
* The properties of the returned object contain the 'moderated' , 'approved' ,
* and spam comments for either the entire blog or single post . Those properties
* contain the amount of comments that match the status . The 'total_comments'
* property contains the integer of total comments .
2008-06-15 11:34:00 +02:00
*
2008-09-22 05:39:41 +02:00
* The comment stats are cached and then retrieved , if they already exist in the
* cache .
*
* @ since 2.5 . 0
*
* @ param int $post_id Optional . Post ID .
* @ return object Comment stats .
2008-06-15 11:34:00 +02:00
*/
2008-05-01 18:52:48 +02:00
function wp_count_comments ( $post_id = 0 ) {
2008-02-23 09:33:44 +01:00
global $wpdb ;
2008-05-01 18:52:48 +02:00
$post_id = ( int ) $post_id ;
2008-12-06 00:40:09 +01:00
$stats = apply_filters ( 'wp_count_comments' , array (), $post_id );
if ( ! empty ( $stats ) )
return $stats ;
2008-05-02 21:42:44 +02:00
$count = wp_cache_get ( " comments- { $post_id } " , 'counts' );
2008-04-17 01:45:39 +02:00
if ( false !== $count )
return $count ;
2009-07-30 15:39:34 +02:00
$where = 'WHERE ' ;
2008-05-01 18:52:48 +02:00
if ( $post_id > 0 )
2009-07-30 15:39:34 +02:00
$where .= $wpdb -> prepare ( " c.comment_post_ID = %d AND " , $post_id );
$where .= " p.post_status <> 'trash' " ;
2008-05-01 18:52:48 +02:00
2009-07-30 15:39:34 +02:00
$count = $wpdb -> get_results ( " SELECT comment_approved, COUNT( * ) AS num_comments FROM { $wpdb -> comments } c LEFT JOIN { $wpdb -> posts } p ON c.comment_post_ID = p.ID { $where } GROUP BY comment_approved " , ARRAY_A );
2008-02-23 09:33:44 +01:00
2008-05-01 18:52:48 +02:00
$total = 0 ;
2009-07-30 15:39:34 +02:00
$approved = array ( '0' => 'moderated' , '1' => 'approved' , 'spam' => 'spam' , 'trash' => 'trash' );
2008-12-09 09:07:52 +01:00
$known_types = array_keys ( $approved );
2008-02-23 09:33:44 +01:00
foreach ( ( array ) $count as $row_num => $row ) {
2008-05-01 18:52:48 +02:00
$total += $row [ 'num_comments' ];
2008-12-09 09:07:52 +01:00
if ( in_array ( $row [ 'comment_approved' ], $known_types ) )
$stats [ $approved [ $row [ 'comment_approved' ]]] = $row [ 'num_comments' ];
2008-02-23 09:33:44 +01:00
}
2008-05-01 18:52:48 +02:00
$stats [ 'total_comments' ] = $total ;
2008-02-23 09:33:44 +01:00
foreach ( $approved as $key ) {
if ( empty ( $stats [ $key ]) )
$stats [ $key ] = 0 ;
}
2008-04-17 01:45:39 +02:00
$stats = ( object ) $stats ;
2008-05-02 21:42:44 +02:00
wp_cache_set ( " comments- { $post_id } " , $stats , 'counts' );
2008-04-17 01:45:39 +02:00
return $stats ;
2008-02-23 09:33:44 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Removes comment ID and maybe updates post comment count .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* The post comment count will be updated if the comment was approved and has a
* post ID available .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 0
* @ uses $wpdb
* @ uses do_action () Calls 'delete_comment' hook on comment ID
* @ uses do_action () Calls 'wp_set_comment_status' hook on comment ID with 'delete' set for the second parameter
2008-10-16 06:18:45 +02:00
* @ uses wp_transition_comment_status () Passes new and old comment status along with $comment object
2008-01-04 21:03:42 +01:00
*
* @ param int $comment_id Comment ID
2008-09-22 22:21:10 +02:00
* @ return bool False if delete comment query failure , true on success .
2008-01-04 21:03:42 +01:00
*/
2005-11-16 07:29:36 +01:00
function wp_delete_comment ( $comment_id ) {
global $wpdb ;
2009-07-30 15:39:34 +02:00
if ( ! $comment = get_comment ( $comment_id ))
return false ;
if ( wp_get_comment_status ( $comment_id ) != 'trash' && wp_get_comment_status ( $comment_id ) != 'spam' && EMPTY_TRASH_DAYS > 0 )
return wp_trash_comment ( $comment_id );
2009-09-14 16:03:32 +02:00
2005-11-16 07:29:36 +01:00
do_action ( 'delete_comment' , $comment_id );
2009-09-14 16:03:32 +02:00
2009-09-17 22:51:12 +02:00
delete_comment_meta ( $comment_id , '_wp_trash_meta_status' );
delete_comment_meta ( $comment_id , '_wp_trash_meta_time' );
2005-11-16 07:29:36 +01:00
2008-04-14 18:13:25 +02:00
if ( ! $wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1 " , $comment_id ) ) )
2005-11-16 07:29:36 +01:00
return false ;
2009-03-10 20:02:27 +01:00
// Move children up a level.
$children = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT comment_ID FROM $wpdb->comments WHERE comment_parent = %d " , $comment_id ) );
if ( ! empty ( $children ) ) {
$wpdb -> update ( $wpdb -> comments , array ( 'comment_parent' => $comment -> comment_parent ), array ( 'comment_parent' => $comment_id ));
clean_comment_cache ( $children );
}
2005-11-16 07:29:36 +01:00
$post_id = $comment -> comment_post_ID ;
2005-12-05 06:31:27 +01:00
if ( $post_id && $comment -> comment_approved == 1 )
2006-06-19 19:17:52 +02:00
wp_update_comment_count ( $post_id );
2005-11-16 07:29:36 +01:00
2007-06-08 02:20:22 +02:00
clean_comment_cache ( $comment_id );
2005-11-16 07:29:36 +01:00
do_action ( 'wp_set_comment_status' , $comment_id , 'delete' );
2008-10-16 06:18:45 +02:00
wp_transition_comment_status ( 'delete' , $comment -> comment_approved , $comment );
2005-11-16 07:29:36 +01:00
return true ;
2005-09-20 05:17:43 +02:00
}
2009-07-30 15:39:34 +02:00
/**
* Moves a comment to the Trash
*
* @ since 2.9 . 0
* @ uses do_action () on 'trash_comment' before trashing
* @ uses do_action () on 'trashed_comment' after trashing
*
* @ param int $comment_id Comment ID .
* @ return mixed False on failure
*/
2009-10-05 03:49:19 +02:00
function wp_trash_comment ( $comment_id ) {
if ( EMPTY_TRASH_DAYS == 0 )
2009-07-30 15:39:34 +02:00
return wp_delete_comment ( $comment_id );
2009-10-05 03:49:19 +02:00
if ( ! $comment = get_comment ( $comment_id ) )
2009-07-30 15:39:34 +02:00
return false ;
do_action ( 'trash_comment' , $comment_id );
2009-10-05 03:49:19 +02:00
add_comment_meta ( $comment_id , '_wp_trash_meta_status' , $comment -> comment_approved );
add_comment_meta ( $comment_id , '_wp_trash_meta_time' , time () );
2009-09-24 19:19:13 +02:00
2009-07-30 15:39:34 +02:00
wp_set_comment_status ( $comment_id , 'trash' );
do_action ( 'trashed_comment' , $comment_id );
return true ;
}
/**
* Removes a comment from the Trash
*
* @ since 2.9 . 0
* @ uses do_action () on 'untrash_comment' before undeletion
* @ uses do_action () on 'untrashed_comment' after undeletion
*
* @ param int $comment_id Comment ID .
* @ return mixed False on failure
*/
2009-10-05 03:49:19 +02:00
function wp_untrash_comment ( $comment_id ) {
if ( ! ( int ) $comment_id )
return false ;
2009-07-30 15:39:34 +02:00
do_action ( 'untrash_comment' , $comment_id );
2009-10-05 03:49:19 +02:00
$comment = array ( 'comment_ID' => $comment_id );
2009-09-24 19:19:13 +02:00
2009-10-05 03:49:19 +02:00
$status = get_comment_meta ( $comment_id , '_wp_trash_meta_status' , true );
if ( false === $status || '' === $status )
$status = '0' ;
$comment [ 'comment_approved' ] = $status ;
2009-07-30 15:39:34 +02:00
2009-10-01 21:59:35 +02:00
delete_comment_meta ( $comment_id , '_wp_trash_meta_time' );
delete_comment_meta ( $comment_id , '_wp_trash_meta_status' );
2009-10-05 03:49:19 +02:00
2009-07-30 15:39:34 +02:00
wp_update_comment ( $comment );
2009-10-05 03:49:19 +02:00
2009-07-30 15:39:34 +02:00
do_action ( 'untrashed_comment' , $comment_id );
return true ;
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* The status of a comment by ID .
2008-01-04 21:03:42 +01:00
*
* @ since 1.0 . 0
*
* @ param int $comment_id Comment ID
2009-07-30 15:39:34 +02:00
* @ return string | bool Status might be 'trash' , 'approved' , 'unapproved' , 'spam' . False on failure .
2008-01-04 21:03:42 +01:00
*/
2006-04-19 04:32:12 +02:00
function wp_get_comment_status ( $comment_id ) {
2007-06-08 02:20:22 +02:00
$comment = get_comment ( $comment_id );
if ( ! $comment )
return false ;
$approved = $comment -> comment_approved ;
2006-12-07 04:57:23 +01:00
2007-06-08 02:20:22 +02:00
if ( $approved == NULL )
2009-07-30 15:39:34 +02:00
return false ;
2007-06-08 02:20:22 +02:00
elseif ( $approved == '1' )
2006-04-19 04:32:12 +02:00
return 'approved' ;
2007-06-08 02:20:22 +02:00
elseif ( $approved == '0' )
2006-04-19 04:32:12 +02:00
return 'unapproved' ;
2007-06-08 02:20:22 +02:00
elseif ( $approved == 'spam' )
2006-04-19 04:32:12 +02:00
return 'spam' ;
2009-07-30 15:39:34 +02:00
elseif ( $approved == 'trash' )
return 'trash' ;
2006-12-07 04:57:23 +01:00
else
2006-04-19 04:32:12 +02:00
return false ;
2004-12-16 03:57:05 +01:00
}
2008-10-16 06:18:45 +02:00
/**
* Call hooks for when a comment status transition occurs .
*
* Calls hooks for comment status transitions . If the new comment status is not the same
* as the previous comment status , then two hooks will be ran , the first is
* 'transition_comment_status' with new status , old status , and comment data . The
* next action called is 'comment_OLDSTATUS_to_NEWSTATUS' the NEWSTATUS is the
* $new_status parameter and the OLDSTATUS is $old_status parameter ; it has the
* comment data .
*
* The final action will run whether or not the comment statuses are the same . The
* action is named 'comment_NEWSTATUS_COMMENTTYPE' , NEWSTATUS is from the $new_status
* parameter and COMMENTTYPE is comment_type comment data .
*
* @ since 2.7 . 0
*
* @ param string $new_status New comment status .
* @ param string $old_status Previous comment status .
* @ param object $comment Comment data .
*/
function wp_transition_comment_status ( $new_status , $old_status , $comment ) {
// Translate raw statuses to human readable formats for the hooks
// This is not a complete list of comment status, it's only the ones that need to be renamed
$comment_statuses = array (
0 => 'unapproved' ,
'hold' => 'unapproved' , // wp_set_comment_status() uses "hold"
1 => 'approved' ,
'approve' => 'approved' , // wp_set_comment_status() uses "approve"
);
if ( isset ( $comment_statuses [ $new_status ]) ) $new_status = $comment_statuses [ $new_status ];
if ( isset ( $comment_statuses [ $old_status ]) ) $old_status = $comment_statuses [ $old_status ];
// Call the hooks
if ( $new_status != $old_status ) {
do_action ( 'transition_comment_status' , $new_status , $old_status , $comment );
do_action ( " comment_ ${ old_status } _to_ $new_status " , $comment );
}
2008-11-03 07:44:48 +01:00
do_action ( " comment_ ${ new_status } _ $comment->comment_type " , $comment -> comment_ID , $comment );
2008-10-16 06:18:45 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Get current commenter ' s name , email , and URL .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* Expects cookies content to already be sanitized . User of this function might
* wish to recheck the returned array for validity .
2008-01-04 21:03:42 +01:00
*
* @ see sanitize_comment_cookies () Use to sanitize cookies
*
* @ since 2.0 . 4
*
2008-09-22 05:39:41 +02:00
* @ return array Comment author , email , url respectively .
2008-01-04 21:03:42 +01:00
*/
2006-06-22 22:52:12 +02:00
function wp_get_current_commenter () {
// Cookies should already be sanitized.
$comment_author = '' ;
if ( isset ( $_COOKIE [ 'comment_author_' . COOKIEHASH ]) )
$comment_author = $_COOKIE [ 'comment_author_' . COOKIEHASH ];
$comment_author_email = '' ;
if ( isset ( $_COOKIE [ 'comment_author_email_' . COOKIEHASH ]) )
$comment_author_email = $_COOKIE [ 'comment_author_email_' . COOKIEHASH ];
$comment_author_url = '' ;
if ( isset ( $_COOKIE [ 'comment_author_url_' . COOKIEHASH ]) )
$comment_author_url = $_COOKIE [ 'comment_author_url_' . COOKIEHASH ];
return compact ( 'comment_author' , 'comment_author_email' , 'comment_author_url' );
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Inserts a comment to the database .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* The available comment data key names are 'comment_author_IP' , 'comment_date' ,
* 'comment_date_gmt' , 'comment_parent' , 'comment_approved' , and 'user_id' .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 0
* @ uses $wpdb
*
2008-09-22 05:39:41 +02:00
* @ param array $commentdata Contains information on the comment .
* @ return int The new comment ' s ID .
2008-01-04 21:03:42 +01:00
*/
2006-04-19 04:32:12 +02:00
function wp_insert_comment ( $commentdata ) {
global $wpdb ;
2008-04-15 20:05:08 +02:00
extract ( stripslashes_deep ( $commentdata ), EXTR_SKIP );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
if ( ! isset ( $comment_author_IP ) )
2008-01-26 11:18:33 +01:00
$comment_author_IP = '' ;
2006-04-19 04:32:12 +02:00
if ( ! isset ( $comment_date ) )
$comment_date = current_time ( 'mysql' );
if ( ! isset ( $comment_date_gmt ) )
2007-01-09 09:22:28 +01:00
$comment_date_gmt = get_gmt_from_date ( $comment_date );
2006-04-19 04:32:12 +02:00
if ( ! isset ( $comment_parent ) )
$comment_parent = 0 ;
if ( ! isset ( $comment_approved ) )
$comment_approved = 1 ;
2009-02-10 20:16:00 +01:00
if ( ! isset ( $comment_karma ) )
$comment_karma = 0 ;
2006-04-19 04:32:12 +02:00
if ( ! isset ( $user_id ) )
$user_id = 0 ;
2008-11-06 03:05:59 +01:00
if ( ! isset ( $comment_type ) )
$comment_type = '' ;
2004-12-16 03:57:05 +01:00
2009-03-06 06:06:15 +01:00
$data = compact ( 'comment_post_ID' , 'comment_author' , 'comment_author_email' , 'comment_author_url' , 'comment_author_IP' , 'comment_date' , 'comment_date_gmt' , 'comment_content' , 'comment_karma' , 'comment_approved' , 'comment_agent' , 'comment_type' , 'comment_parent' , 'user_id' );
$wpdb -> insert ( $wpdb -> comments , $data );
2004-12-16 03:57:05 +01:00
2007-03-23 01:59:21 +01:00
$id = ( int ) $wpdb -> insert_id ;
2004-12-16 03:57:05 +01:00
2009-03-06 06:06:15 +01:00
if ( $comment_approved == 1 )
2006-06-19 19:17:52 +02:00
wp_update_comment_count ( $comment_post_ID );
2009-01-29 23:22:20 +01:00
$comment = get_comment ( $id );
do_action ( 'wp_insert_comment' , $id , $comment );
2006-04-19 04:32:12 +02:00
return $id ;
2004-12-16 03:57:05 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Filters and sanitizes comment data .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* Sets the comment data 'filtered' field to true when finished . This can be
* checked as to whether the comment should be filtered and to keep from
* filtering the same comment more than once .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 0
* @ uses apply_filters () Calls 'pre_user_id' hook on comment author ' s user ID
* @ uses apply_filters () Calls 'pre_comment_user_agent' hook on comment author ' s user agent
* @ uses apply_filters () Calls 'pre_comment_author_name' hook on comment author ' s name
* @ uses apply_filters () Calls 'pre_comment_content' hook on the comment ' s content
* @ uses apply_filters () Calls 'pre_comment_user_ip' hook on comment author ' s IP
* @ uses apply_filters () Calls 'pre_comment_author_url' hook on comment author ' s URL
* @ uses apply_filters () Calls 'pre_comment_author_email' hook on comment author ' s email address
*
2008-09-22 22:21:10 +02:00
* @ param array $commentdata Contains information on the comment .
* @ return array Parsed comment information .
2008-01-04 21:03:42 +01:00
*/
2006-04-19 04:32:12 +02:00
function wp_filter_comment ( $commentdata ) {
$commentdata [ 'user_id' ] = apply_filters ( 'pre_user_id' , $commentdata [ 'user_ID' ]);
$commentdata [ 'comment_agent' ] = apply_filters ( 'pre_comment_user_agent' , $commentdata [ 'comment_agent' ]);
$commentdata [ 'comment_author' ] = apply_filters ( 'pre_comment_author_name' , $commentdata [ 'comment_author' ]);
$commentdata [ 'comment_content' ] = apply_filters ( 'pre_comment_content' , $commentdata [ 'comment_content' ]);
$commentdata [ 'comment_author_IP' ] = apply_filters ( 'pre_comment_user_ip' , $commentdata [ 'comment_author_IP' ]);
$commentdata [ 'comment_author_url' ] = apply_filters ( 'pre_comment_author_url' , $commentdata [ 'comment_author_url' ]);
$commentdata [ 'comment_author_email' ] = apply_filters ( 'pre_comment_author_email' , $commentdata [ 'comment_author_email' ]);
$commentdata [ 'filtered' ] = true ;
return $commentdata ;
2004-12-16 03:57:05 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Whether comment should be blocked because of comment flood .
2008-01-04 21:03:42 +01:00
*
* @ since 2.1 . 0
*
2008-09-22 05:39:41 +02:00
* @ param bool $block Whether plugin has already blocked comment .
* @ param int $time_lastcomment Timestamp for last comment .
* @ param int $time_newcomment Timestamp for new comment .
* @ return bool Whether comment should be blocked .
2008-01-04 21:03:42 +01:00
*/
2006-10-02 20:19:44 +02:00
function wp_throttle_comment_flood ( $block , $time_lastcomment , $time_newcomment ) {
if ( $block ) // a plugin has already blocked... we'll let that decision stand
return $block ;
if ( ( $time_newcomment - $time_lastcomment ) < 15 )
return true ;
return false ;
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Adds a new comment to the database .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* Filters new comment to ensure that the fields are sanitized and valid before
* inserting comment into database . Calls 'comment_post' action with comment ID
* and whether comment is approved by WordPress . Also has 'preprocess_comment'
* filter for processing the comment data before the function handles it .
2008-01-04 21:03:42 +01:00
*
* @ since 1.5 . 0
* @ uses apply_filters () Calls 'preprocess_comment' hook on $commentdata parameter array before processing
* @ uses do_action () Calls 'comment_post' hook on $comment_ID returned from adding the comment and if the comment was approved .
2008-09-22 05:39:41 +02:00
* @ uses wp_filter_comment () Used to filter comment before adding comment .
2008-01-04 21:03:42 +01:00
* @ uses wp_allow_comment () checks to see if comment is approved .
2008-09-22 05:39:41 +02:00
* @ uses wp_insert_comment () Does the actual comment insertion to the database .
2008-01-04 21:03:42 +01:00
*
2008-09-22 22:21:10 +02:00
* @ param array $commentdata Contains information on the comment .
2008-01-04 21:03:42 +01:00
* @ return int The ID of the comment after adding .
*/
2006-04-19 04:32:12 +02:00
function wp_new_comment ( $commentdata ) {
$commentdata = apply_filters ( 'preprocess_comment' , $commentdata );
2005-01-24 11:13:28 +01:00
2006-04-19 04:32:12 +02:00
$commentdata [ 'comment_post_ID' ] = ( int ) $commentdata [ 'comment_post_ID' ];
$commentdata [ 'user_ID' ] = ( int ) $commentdata [ 'user_ID' ];
2005-01-24 11:13:28 +01:00
2008-08-24 08:56:22 +02:00
$commentdata [ 'comment_parent' ] = absint ( $commentdata [ 'comment_parent' ]);
$parent_status = ( 0 < $commentdata [ 'comment_parent' ] ) ? wp_get_comment_status ( $commentdata [ 'comment_parent' ]) : '' ;
$commentdata [ 'comment_parent' ] = ( 'approved' == $parent_status || 'unapproved' == $parent_status ) ? $commentdata [ 'comment_parent' ] : 0 ;
2008-01-26 11:18:33 +01:00
$commentdata [ 'comment_author_IP' ] = preg_replace ( '/[^0-9a-fA-F:., ]/' , '' , $_SERVER [ 'REMOTE_ADDR' ] );
2009-07-14 10:20:24 +02:00
$commentdata [ 'comment_agent' ] = substr ( $_SERVER [ 'HTTP_USER_AGENT' ], 0 , 254 );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
$commentdata [ 'comment_date' ] = current_time ( 'mysql' );
$commentdata [ 'comment_date_gmt' ] = current_time ( 'mysql' , 1 );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
$commentdata = wp_filter_comment ( $commentdata );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
$commentdata [ 'comment_approved' ] = wp_allow_comment ( $commentdata );
2004-12-16 03:57:05 +01:00
2007-03-23 03:05:29 +01:00
$comment_ID = wp_insert_comment ( $commentdata );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
do_action ( 'comment_post' , $comment_ID , $commentdata [ 'comment_approved' ]);
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
if ( 'spam' !== $commentdata [ 'comment_approved' ] ) { // If it's spam save it silently for later crunching
if ( '0' == $commentdata [ 'comment_approved' ] )
wp_notify_moderator ( $comment_ID );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
$post = & get_post ( $commentdata [ 'comment_post_ID' ]); // Don't notify if it's your own comment
2004-12-16 03:57:05 +01:00
2006-08-30 23:46:31 +02:00
if ( get_option ( 'comments_notify' ) && $commentdata [ 'comment_approved' ] && $post -> post_author != $commentdata [ 'user_ID' ] )
2006-04-19 04:32:12 +02:00
wp_notify_postauthor ( $comment_ID , $commentdata [ 'comment_type' ]);
}
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
return $comment_ID ;
2004-12-16 03:57:05 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Sets the status of a comment .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* The 'wp_set_comment_status' action is called after the comment is handled and
* will only be called , if the comment status is either 'hold' , 'approve' , or
* 'spam' . If the comment status is not in the list , then false is returned and
* if the status is 'delete' , then the comment is deleted without calling the
* action .
2008-01-04 21:03:42 +01:00
*
* @ since 1.0 . 0
2008-10-16 06:18:45 +02:00
* @ uses wp_transition_comment_status () Passes new and old comment status along with $comment object
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ param int $comment_id Comment ID .
* @ param string $comment_status New comment status , either 'hold' , 'approve' , 'spam' , or 'delete' .
2009-03-02 22:48:37 +01:00
* @ param bool $wp_error Whether to return a WP_Error object if there is a failure . Default is false .
2008-01-04 21:03:42 +01:00
* @ return bool False on failure or deletion and true on success .
*/
2009-03-02 22:48:37 +01:00
function wp_set_comment_status ( $comment_id , $comment_status , $wp_error = false ) {
2006-12-07 04:57:23 +01:00
global $wpdb ;
2009-09-14 16:03:32 +02:00
2009-03-06 05:27:51 +01:00
$status = '0' ;
2006-12-07 04:57:23 +01:00
switch ( $comment_status ) {
2006-04-19 04:32:12 +02:00
case 'hold' :
2009-03-06 05:27:51 +01:00
$status = '0' ;
2006-12-07 04:57:23 +01:00
break ;
2006-04-19 04:32:12 +02:00
case 'approve' :
2009-03-06 05:27:51 +01:00
$status = '1' ;
2008-05-28 17:37:59 +02:00
if ( get_option ( 'comments_notify' ) ) {
$comment = get_comment ( $comment_id );
wp_notify_postauthor ( $comment_id , $comment -> comment_type );
}
2006-12-07 04:57:23 +01:00
break ;
2006-11-19 08:56:05 +01:00
case 'spam' :
2009-03-06 05:27:51 +01:00
$status = 'spam' ;
2006-12-07 04:57:23 +01:00
break ;
2009-07-30 15:39:34 +02:00
case 'trash' :
$status = 'trash' ;
2006-12-07 04:57:23 +01:00
break ;
2006-04-19 04:32:12 +02:00
default :
return false ;
2006-12-07 04:57:23 +01:00
}
2006-11-19 08:56:05 +01:00
2009-08-21 03:27:01 +02:00
$comment_old = get_comment ( $comment_id );
2009-03-06 05:27:51 +01:00
if ( ! $wpdb -> update ( $wpdb -> comments , array ( 'comment_approved' => $status ), array ( 'comment_ID' => $comment_id ) ) ) {
2009-03-02 22:48:37 +01:00
if ( $wp_error )
return new WP_Error ( 'db_update_error' , __ ( 'Could not update comment status' ), $wpdb -> last_error );
else
return false ;
}
2006-12-08 08:35:45 +01:00
2007-06-08 02:20:22 +02:00
clean_comment_cache ( $comment_id );
2006-12-08 08:35:45 +01:00
$comment = get_comment ( $comment_id );
2008-10-16 06:18:45 +02:00
do_action ( 'wp_set_comment_status' , $comment_id , $comment_status );
2009-08-21 03:27:01 +02:00
wp_transition_comment_status ( $comment_status , $comment_old -> comment_approved , $comment );
2008-10-16 06:18:45 +02:00
2006-12-08 08:35:45 +01:00
wp_update_comment_count ( $comment -> comment_post_ID );
2007-06-08 02:20:22 +02:00
2006-12-08 08:35:45 +01:00
return true ;
2004-12-16 03:57:05 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Updates an existing comment in the database .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* Filters the comment and makes sure certain fields are valid before updating .
2008-01-04 21:03:42 +01:00
*
* @ since 2.0 . 0
* @ uses $wpdb
2008-10-16 06:18:45 +02:00
* @ uses wp_transition_comment_status () Passes new and old comment status along with $comment object
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ param array $commentarr Contains information on the comment .
2008-01-04 21:03:42 +01:00
* @ return int Comment was updated if value is 1 , or was not updated if value is 0.
*/
2006-04-19 04:32:12 +02:00
function wp_update_comment ( $commentarr ) {
global $wpdb ;
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
// First, get all of the original fields
$comment = get_comment ( $commentarr [ 'comment_ID' ], ARRAY_A );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
// Escape data pulled from DB.
2009-09-27 07:33:56 +02:00
$comment = esc_sql ( $comment );
2004-12-16 03:57:05 +01:00
2009-04-29 19:22:08 +02:00
$old_status = $comment [ 'comment_approved' ];
2006-04-19 04:32:12 +02:00
// Merge old and new fields with new fields overwriting old ones.
$commentarr = array_merge ( $comment , $commentarr );
2004-12-16 04:08:07 +01:00
2006-04-19 04:32:12 +02:00
$commentarr = wp_filter_comment ( $commentarr );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
// Now extract the merged array.
2008-04-15 20:05:08 +02:00
extract ( stripslashes_deep ( $commentarr ), EXTR_SKIP );
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
$comment_content = apply_filters ( 'comment_save_pre' , $comment_content );
2004-12-16 03:57:05 +01:00
2007-01-09 09:22:28 +01:00
$comment_date_gmt = get_gmt_from_date ( $comment_date );
2008-08-12 18:23:47 +02:00
if ( ! isset ( $comment_approved ) )
2008-08-05 00:29:37 +02:00
$comment_approved = 1 ;
else if ( 'hold' == $comment_approved )
$comment_approved = 0 ;
else if ( 'approve' == $comment_approved )
$comment_approved = 1 ;
2009-03-06 06:06:15 +01:00
$data = compact ( 'comment_content' , 'comment_author' , 'comment_author_email' , 'comment_approved' , 'comment_karma' , 'comment_author_url' , 'comment_date' , 'comment_date_gmt' );
$wpdb -> update ( $wpdb -> comments , $data , compact ( 'comment_ID' ));
2004-12-16 03:57:05 +01:00
2006-04-19 04:32:12 +02:00
$rval = $wpdb -> rows_affected ;
2007-06-08 02:20:22 +02:00
clean_comment_cache ( $comment_ID );
2006-06-19 19:17:52 +02:00
wp_update_comment_count ( $comment_post_ID );
2006-04-19 04:32:12 +02:00
do_action ( 'edit_comment' , $comment_ID );
2008-11-03 07:44:48 +01:00
$comment = get_comment ( $comment_ID );
2009-04-29 19:22:08 +02:00
wp_transition_comment_status ( $comment -> comment_approved , $old_status , $comment );
2006-04-19 04:32:12 +02:00
return $rval ;
2004-12-16 03:57:05 +01:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Whether to defer comment counting .
2008-01-04 21:03:42 +01:00
*
* When setting $defer to true , all post comment counts will not be updated
* until $defer is set to false . When $defer is set to false , then all
* previously deferred updated post comment counts will then be automatically
* updated without having to call wp_update_comment_count () after .
*
2008-09-22 05:39:41 +02:00
* @ since 2.5 . 0
2008-01-04 21:03:42 +01:00
* @ staticvar bool $_defer
*
* @ param bool $defer
* @ return unknown
*/
function wp_defer_comment_counting ( $defer = null ) {
2008-01-01 18:03:52 +01:00
static $_defer = false ;
2008-02-05 07:47:27 +01:00
2008-01-01 18:03:52 +01:00
if ( is_bool ( $defer ) ) {
$_defer = $defer ;
// flush any deferred counts
if ( ! $defer )
2008-01-04 21:03:42 +01:00
wp_update_comment_count ( null , true );
2008-01-01 18:03:52 +01:00
}
2008-02-05 07:47:27 +01:00
2008-01-01 18:03:52 +01:00
return $_defer ;
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Updates the comment count for post ( s ) .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* When $do_deferred is false ( is by default ) and the comments have been set to
* be deferred , the post_id will be added to a queue , which will be updated at a
* later date and only updated once per post ID .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* If the comments have not be set up to be deferred , then the post will be
* updated . When $do_deferred is set to true , then all previous deferred post
* IDs will be updated along with the current $post_id .
2008-01-04 21:03:42 +01:00
*
* @ since 2.1 . 0
* @ see wp_update_comment_count_now () For what could cause a false return value
*
* @ param int $post_id Post ID
* @ param bool $do_deferred Whether to process previously deferred post comment counts
* @ return bool True on success , false on failure
*/
2008-01-01 18:03:52 +01:00
function wp_update_comment_count ( $post_id , $do_deferred = false ) {
static $_deferred = array ();
2008-02-05 07:47:27 +01:00
2008-01-01 18:03:52 +01:00
if ( $do_deferred ) {
$_deferred = array_unique ( $_deferred );
foreach ( $_deferred as $i => $_post_id ) {
wp_update_comment_count_now ( $_post_id );
2008-01-04 21:03:42 +01:00
unset ( $_deferred [ $i ] ); /** @todo Move this outside of the foreach and reset $_deferred to an array instead */
2008-01-01 18:03:52 +01:00
}
}
2008-02-05 07:47:27 +01:00
2008-01-01 18:03:52 +01:00
if ( wp_defer_comment_counting () ) {
$_deferred [] = $post_id ;
return true ;
}
elseif ( $post_id ) {
return wp_update_comment_count_now ( $post_id );
}
2008-02-05 07:47:27 +01:00
2008-01-01 18:03:52 +01:00
}
2006-12-07 04:57:23 +01:00
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Updates the comment count for the post .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* @ since 2.5 . 0
2008-01-04 21:03:42 +01:00
* @ uses $wpdb
* @ uses do_action () Calls 'wp_update_comment_count' hook on $post_id , $new , and $old
* @ uses do_action () Calls 'edit_posts' hook on $post_id and $post
*
* @ param int $post_id Post ID
2008-02-05 07:47:27 +01:00
* @ return bool False on '0' $post_id or if post with ID does not exist . True on success .
2008-01-04 21:03:42 +01:00
*/
2008-01-01 18:03:52 +01:00
function wp_update_comment_count_now ( $post_id ) {
2007-11-29 06:03:25 +01:00
global $wpdb ;
2006-06-19 19:17:52 +02:00
$post_id = ( int ) $post_id ;
if ( ! $post_id )
return false ;
2007-08-14 05:08:44 +02:00
if ( ! $post = get_post ( $post_id ) )
return false ;
$old = ( int ) $post -> comment_count ;
2008-04-14 18:13:25 +02:00
$new = ( int ) $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1' " , $post_id ) );
2009-03-06 06:06:15 +01:00
$wpdb -> update ( $wpdb -> posts , array ( 'comment_count' => $new ), array ( 'ID' => $post_id ) );
2006-12-08 08:35:45 +01:00
if ( 'page' == $post -> post_type )
clean_page_cache ( $post_id );
else
clean_post_cache ( $post_id );
2007-08-14 05:08:44 +02:00
do_action ( 'wp_update_comment_count' , $post_id , $new , $old );
do_action ( 'edit_post' , $post_id , $post );
2006-12-08 08:35:45 +01:00
2006-06-19 19:17:52 +02:00
return true ;
}
2006-06-22 21:44:36 +02:00
//
// Ping and trackback functions.
//
2004-12-16 03:57:05 +01:00
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Finds a pingback server URI based on the given URL .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* Checks the HTML for the rel = " pingback " link and x - pingback headers . It does
* a check for the x - pingback headers first and returns that , if available . The
* check for the rel = " pingback " has more overhead than just the header .
2008-01-04 21:03:42 +01:00
*
* @ since 1.5 . 0
*
2008-09-22 05:39:41 +02:00
* @ param string $url URL to ping .
2008-09-27 23:40:09 +02:00
* @ param int $deprecated Not Used .
2008-01-04 21:03:42 +01:00
* @ return bool | string False on failure , string containing URI on success .
*/
2008-09-27 23:40:09 +02:00
function discover_pingback_server_uri ( $url , $deprecated = 2048 ) {
2004-12-16 03:57:05 +01:00
$pingback_str_dquote = 'rel="pingback"' ;
$pingback_str_squote = 'rel=\'pingback\'' ;
2008-09-27 23:40:09 +02:00
/** @todo Should use Filter Extension or custom preg_match instead. */
$parsed_url = parse_url ( $url );
2004-12-16 03:57:05 +01:00
2008-09-27 23:40:09 +02:00
if ( ! isset ( $parsed_url [ 'host' ] ) ) // Not an URL. This should never happen.
2004-12-16 03:57:05 +01:00
return false ;
2009-02-15 21:56:54 +01:00
//Do not search for a pingback server on our own uploads
$uploads_dir = wp_upload_dir ();
if ( 0 === strpos ( $url , $uploads_dir [ 'baseurl' ]) )
return false ;
$response = wp_remote_head ( $url , array ( 'timeout' => 2 , 'httpversion' => '1.0' ) );
2004-12-16 03:57:05 +01:00
2008-09-27 23:40:09 +02:00
if ( is_wp_error ( $response ) )
2004-12-16 03:57:05 +01:00
return false ;
2008-09-27 23:40:09 +02:00
if ( isset ( $response [ 'headers' ][ 'x-pingback' ] ) )
return $response [ 'headers' ][ 'x-pingback' ];
2004-12-16 03:57:05 +01:00
2008-09-27 23:40:09 +02:00
// Not an (x)html, sgml, or xml page, no use going further.
if ( isset ( $response [ 'headers' ][ 'content-type' ] ) && preg_match ( '#(image|audio|video|model)/#is' , $response [ 'headers' ][ 'content-type' ]) )
2004-12-16 03:57:05 +01:00
return false ;
2009-02-15 21:56:54 +01:00
// Now do a GET since we're going to look in the html headers (and we're sure its not a binary file)
$response = wp_remote_get ( $url , array ( 'timeout' => 2 , 'httpversion' => '1.0' ) );
if ( is_wp_error ( $response ) )
return false ;
2008-09-27 23:40:09 +02:00
$contents = $response [ 'body' ];
$pingback_link_offset_dquote = strpos ( $contents , $pingback_str_dquote );
$pingback_link_offset_squote = strpos ( $contents , $pingback_str_squote );
if ( $pingback_link_offset_dquote || $pingback_link_offset_squote ) {
$quote = ( $pingback_link_offset_dquote ) ? '"' : '\'' ;
$pingback_link_offset = ( $quote == '"' ) ? $pingback_link_offset_dquote : $pingback_link_offset_squote ;
$pingback_href_pos = @ strpos ( $contents , 'href=' , $pingback_link_offset );
$pingback_href_start = $pingback_href_pos + 6 ;
$pingback_href_end = @ strpos ( $contents , $quote , $pingback_href_start );
$pingback_server_url_len = $pingback_href_end - $pingback_href_start ;
$pingback_server_url = substr ( $contents , $pingback_href_start , $pingback_server_url_len );
// We may find rel="pingback" but an incomplete pingback URL
if ( $pingback_server_url_len > 0 ) { // We got it!
return $pingback_server_url ;
2004-12-16 03:57:05 +01:00
}
}
return false ;
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Perform all pingbacks , enclosures , trackbacks , and send to pingback services .
2008-01-04 21:03:42 +01:00
*
* @ since 2.1 . 0
* @ uses $wpdb
*/
2006-06-22 21:44:36 +02:00
function do_all_pings () {
global $wpdb ;
// Do pingbacks
while ( $ping = $wpdb -> get_row ( " SELECT * FROM { $wpdb -> posts } , { $wpdb -> postmeta } WHERE { $wpdb -> posts } .ID = { $wpdb -> postmeta } .post_id AND { $wpdb -> postmeta } .meta_key = '_pingme' LIMIT 1 " )) {
2009-09-24 19:10:28 +02:00
$mid = $wpdb -> get_var ( " SELECT meta_id FROM { $wpdb -> postmeta } WHERE post_id = { $ping -> ID } AND meta_key = '_pingme' LIMIT 1 " );
do_action ( 'delete_postmeta' , $mid );
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM { $wpdb -> postmeta } WHERE meta_id = %d " , $mid ) );
do_action ( 'deleted_postmeta' , $mid );
2006-06-22 21:44:36 +02:00
pingback ( $ping -> post_content , $ping -> ID );
2006-02-12 08:53:23 +01:00
}
2006-11-19 08:56:05 +01:00
2006-06-22 21:44:36 +02:00
// Do Enclosures
while ( $enclosure = $wpdb -> get_row ( " SELECT * FROM { $wpdb -> posts } , { $wpdb -> postmeta } WHERE { $wpdb -> posts } .ID = { $wpdb -> postmeta } .post_id AND { $wpdb -> postmeta } .meta_key = '_encloseme' LIMIT 1 " )) {
2009-09-24 19:10:28 +02:00
$mid = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT meta_id FROM { $wpdb -> postmeta } WHERE post_id = %d AND meta_key = '_encloseme' " , $enclosure -> ID ) );
do_action ( 'delete_postmeta' , $mid );
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM { $wpdb -> postmeta } WHERE meta_id = %d " , $mid ) );
do_action ( 'deleted_postmeta' , $mid );
2006-06-22 21:44:36 +02:00
do_enclose ( $enclosure -> post_content , $enclosure -> ID );
}
// Do Trackbacks
2008-01-22 06:50:22 +01:00
$trackbacks = $wpdb -> get_col ( " SELECT ID FROM $wpdb->posts WHERE to_ping <> '' AND post_status = 'publish' " );
if ( is_array ( $trackbacks ) )
2006-12-07 04:57:23 +01:00
foreach ( $trackbacks as $trackback )
2008-01-22 06:50:22 +01:00
do_trackbacks ( $trackback );
2009-07-22 01:09:47 +02:00
//Do Update Services/Generic Pings
generic_ping ();
2006-06-22 21:44:36 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Perform trackbacks .
2008-01-04 21:03:42 +01:00
*
* @ since 1.5 . 0
* @ uses $wpdb
*
2008-09-22 05:39:41 +02:00
* @ param int $post_id Post ID to do trackbacks on .
2008-01-04 21:03:42 +01:00
*/
2006-06-22 21:44:36 +02:00
function do_trackbacks ( $post_id ) {
global $wpdb ;
2008-04-14 18:13:25 +02:00
$post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d " , $post_id ) );
2006-06-22 21:44:36 +02:00
$to_ping = get_to_ping ( $post_id );
$pinged = get_pung ( $post_id );
if ( empty ( $to_ping ) ) {
2009-03-18 03:43:45 +01:00
$wpdb -> update ( $wpdb -> posts , array ( 'to_ping' => '' ), array ( 'ID' => $post_id ) );
2006-06-22 21:44:36 +02:00
return ;
}
2006-12-07 04:57:23 +01:00
if ( empty ( $post -> post_excerpt ) )
2006-06-22 21:44:36 +02:00
$excerpt = apply_filters ( 'the_content' , $post -> post_content );
else
$excerpt = apply_filters ( 'the_excerpt' , $post -> post_excerpt );
$excerpt = str_replace ( ']]>' , ']]>' , $excerpt );
2008-03-03 22:05:23 +01:00
$excerpt = wp_html_excerpt ( $excerpt , 252 ) . '...' ;
2006-06-22 21:44:36 +02:00
$post_title = apply_filters ( 'the_title' , $post -> post_title );
$post_title = strip_tags ( $post_title );
2006-12-07 04:57:23 +01:00
if ( $to_ping ) {
foreach ( ( array ) $to_ping as $tb_ping ) {
$tb_ping = trim ( $tb_ping );
if ( ! in_array ( $tb_ping , $pinged ) ) {
trackback ( $tb_ping , $post_title , $excerpt , $post_id );
$pinged [] = $tb_ping ;
} else {
2008-04-14 18:13:25 +02:00
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, ' $tb_ping ', '')) WHERE ID = %d " , $post_id ) );
2006-12-07 04:57:23 +01:00
}
2006-06-22 21:44:36 +02:00
}
2006-12-07 04:57:23 +01:00
}
2006-06-22 21:44:36 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Sends pings to all of the ping site services .
2008-01-04 21:03:42 +01:00
*
* @ since 1.2 . 0
*
* @ param int $post_id Post ID . Not actually used .
* @ return int Same as Post ID from parameter
*/
2006-06-22 21:44:36 +02:00
function generic_ping ( $post_id = 0 ) {
2006-08-30 23:46:31 +02:00
$services = get_option ( 'ping_sites' );
2008-02-14 22:50:43 +01:00
$services = explode ( " \n " , $services );
foreach ( ( array ) $services as $service ) {
$service = trim ( $service );
if ( '' != $service )
2006-06-22 21:44:36 +02:00
weblog_ping ( $service );
}
return $post_id ;
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Pings back the links found in a post .
2008-01-04 21:03:42 +01:00
*
* @ since 0.71
* @ uses $wp_version
* @ uses IXR_Client
*
2008-09-22 05:39:41 +02:00
* @ param string $content Post content to check for links .
* @ param int $post_ID Post ID .
2008-01-04 21:03:42 +01:00
*/
2006-06-22 21:44:36 +02:00
function pingback ( $content , $post_ID ) {
2007-12-06 20:49:33 +01:00
global $wp_version ;
2006-12-07 04:57:23 +01:00
include_once ( ABSPATH . WPINC . '/class-IXR.php' );
2006-06-22 21:44:36 +02:00
// original code by Mort (http://mort.mine.nu:8080)
$post_links = array ();
$pung = get_pung ( $post_ID );
// Variables
$ltrs = '\w' ;
$gunk = '/#~:.?+=&%@!\-' ;
$punc = '.:?\-' ;
$any = $ltrs . $gunk . $punc ;
// Step 1
// Parsing the post, external links (if any) are stored in the $post_links array
// This regexp comes straight from phpfreaks.com
// http://www.phpfreaks.com/quickcode/Extract_All_URLs_on_a_Page/15.php
preg_match_all ( " { \ b http : [ $any ] +? (?= [ $punc ] * [^ $any ] | $ )}x " , $content , $post_links_temp );
// Step 2.
// Walking thru the links array
// first we get rid of links pointing to sites, not to specific files
// Example:
// http://dummy-weblog.org
// http://dummy-weblog.org/
// http://dummy-weblog.org/post.php
// We don't wanna ping first and second types, even if they have a valid <link/>
2008-08-06 22:31:54 +02:00
foreach ( ( array ) $post_links_temp [ 0 ] as $link_test ) :
2006-06-22 21:44:36 +02:00
if ( ! in_array ( $link_test , $pung ) && ( url_to_postid ( $link_test ) != $post_ID ) // If we haven't pung it already and it isn't a link to itself
&& ! is_local_attachment ( $link_test ) ) : // Also, let's never ping local attachments.
2008-11-10 19:54:18 +01:00
if ( $test = @ parse_url ( $link_test ) ) {
if ( isset ( $test [ 'query' ]) )
$post_links [] = $link_test ;
elseif ( ( $test [ 'path' ] != '/' ) && ( $test [ 'path' ] != '' ) )
$post_links [] = $link_test ;
}
2006-06-22 21:44:36 +02:00
endif ;
endforeach ;
2006-12-07 04:57:23 +01:00
do_action_ref_array ( 'pre_ping' , array ( & $post_links , & $pung ));
2006-06-22 21:44:36 +02:00
2006-12-07 04:57:23 +01:00
foreach ( ( array ) $post_links as $pagelinkedto ) {
2006-06-22 21:44:36 +02:00
$pingback_server_url = discover_pingback_server_uri ( $pagelinkedto , 2048 );
2006-12-07 04:57:23 +01:00
if ( $pingback_server_url ) {
2006-11-19 08:56:05 +01:00
@ set_time_limit ( 60 );
2006-06-22 21:44:36 +02:00
// Now, the RPC call
$pagelinkedfrom = get_permalink ( $post_ID );
// using a timeout of 3 seconds should be enough to cover slow servers
$client = new IXR_Client ( $pingback_server_url );
$client -> timeout = 3 ;
$client -> useragent .= ' -- WordPress/' . $wp_version ;
// when set to true, this outputs debug messages by itself
$client -> debug = false ;
2007-06-28 01:28:36 +02:00
if ( $client -> query ( 'pingback.ping' , $pagelinkedfrom , $pagelinkedto ) || ( isset ( $client -> error -> code ) && 48 == $client -> error -> code ) ) // Already registered
2006-06-22 21:44:36 +02:00
add_ping ( $post_ID , $pagelinkedto );
}
}
}
2008-01-04 21:03:42 +01:00
/**
2008-09-22 05:39:41 +02:00
* Check whether blog is public before returning sites .
2008-01-04 21:03:42 +01:00
*
* @ since 2.1 . 0
*
2008-09-22 05:39:41 +02:00
* @ param mixed $sites Will return if blog is public , will not return if not public .
* @ return mixed Empty string if blog is not public , returns $sites , if site is public .
2008-01-04 21:03:42 +01:00
*/
2006-12-07 04:57:23 +01:00
function privacy_ping_filter ( $sites ) {
2006-06-22 21:44:36 +02:00
if ( '0' != get_option ( 'blog_public' ) )
return $sites ;
else
return '' ;
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Send a Trackback .
2008-01-04 21:03:42 +01:00
*
2008-06-15 11:34:00 +02:00
* Updates database when sending trackback to prevent duplicates .
2008-01-04 21:03:42 +01:00
*
* @ since 0.71
* @ uses $wpdb
*
2008-06-15 11:34:00 +02:00
* @ param string $trackback_url URL to send trackbacks .
2008-09-22 05:39:41 +02:00
* @ param string $title Title of post .
* @ param string $excerpt Excerpt of post .
* @ param int $ID Post ID .
* @ return mixed Database query from update .
2008-01-04 21:03:42 +01:00
*/
2006-06-22 21:44:36 +02:00
function trackback ( $trackback_url , $title , $excerpt , $ID ) {
2008-09-27 23:40:09 +02:00
global $wpdb ;
2006-06-22 21:44:36 +02:00
if ( empty ( $trackback_url ) )
return ;
2008-09-27 23:40:09 +02:00
$options = array ();
$options [ 'timeout' ] = 4 ;
$options [ 'body' ] = array (
2008-10-23 00:48:14 +02:00
'title' => $title ,
'url' => get_permalink ( $ID ),
'blog_name' => get_option ( 'blogname' ),
'excerpt' => $excerpt
2008-09-27 23:40:09 +02:00
);
2008-10-02 02:32:21 +02:00
$response = wp_remote_post ( $trackback_url , $options );
2008-12-09 19:03:31 +01:00
2008-10-02 02:32:21 +02:00
if ( is_wp_error ( $response ) )
return ;
2008-09-27 23:40:09 +02:00
$tb_url = addslashes ( $trackback_url );
2008-04-14 18:13:25 +02:00
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET pinged = CONCAT(pinged, ' \n ', ' $tb_url ') WHERE ID = %d " , $ID ) );
return $wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, ' $tb_url ', '')) WHERE ID = %d " , $ID ) );
2006-06-22 21:44:36 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Send a pingback .
2008-01-04 21:03:42 +01:00
*
* @ since 1.2 . 0
* @ uses $wp_version
* @ uses IXR_Client
*
2008-06-15 11:34:00 +02:00
* @ param string $server Host of blog to connect to .
* @ param string $path Path to send the ping .
2008-01-04 21:03:42 +01:00
*/
2006-06-22 21:44:36 +02:00
function weblog_ping ( $server = '' , $path = '' ) {
global $wp_version ;
2006-12-07 04:57:23 +01:00
include_once ( ABSPATH . WPINC . '/class-IXR.php' );
2006-06-22 21:44:36 +02:00
// using a timeout of 3 seconds should be enough to cover slow servers
$client = new IXR_Client ( $server , (( ! strlen ( trim ( $path )) || ( '/' == $path )) ? false : $path ));
$client -> timeout = 3 ;
$client -> useragent .= ' -- WordPress/' . $wp_version ;
// when set to true, this outputs debug messages by itself
$client -> debug = false ;
$home = trailingslashit ( get_option ( 'home' ) );
2006-08-30 23:46:31 +02:00
if ( ! $client -> query ( 'weblogUpdates.extendedPing' , get_option ( 'blogname' ), $home , get_bloginfo ( 'rss2_url' ) ) ) // then try a normal ping
$client -> query ( 'weblogUpdates.ping' , get_option ( 'blogname' ), $home );
2005-11-18 10:25:47 +01:00
}
2004-12-16 03:57:05 +01:00
2007-06-08 02:20:22 +02:00
//
// Cache
//
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Removes comment ID from the comment cache .
2008-01-04 21:03:42 +01:00
*
* @ since 2.3 . 0
* @ package WordPress
* @ subpackage Cache
*
2009-03-10 20:02:27 +01:00
* @ param int | array $id Comment ID or array of comment IDs to remove from cache
2008-01-04 21:03:42 +01:00
*/
2009-03-10 20:02:27 +01:00
function clean_comment_cache ( $ids ) {
foreach ( ( array ) $ids as $id )
wp_cache_delete ( $id , 'comment' );
2007-06-08 02:20:22 +02:00
}
2008-01-04 21:03:42 +01:00
/**
2008-06-15 11:34:00 +02:00
* Updates the comment cache of given comments .
2008-01-04 21:03:42 +01:00
*
2008-09-22 05:39:41 +02:00
* Will add the comments in $comments to the cache . If comment ID already exists
* in the comment cache then it will not be updated . The comment is added to the
* cache using the comment group with the key using the ID of the comments .
2008-01-04 21:03:42 +01:00
*
* @ since 2.3 . 0
2008-09-22 05:39:41 +02:00
* @ package WordPress
* @ subpackage Cache
2008-01-04 21:03:42 +01:00
*
* @ param array $comments Array of comment row objects
*/
2007-06-08 02:20:22 +02:00
function update_comment_cache ( $comments ) {
2008-01-04 21:03:42 +01:00
foreach ( ( array ) $comments as $comment )
2007-06-08 02:20:22 +02:00
wp_cache_add ( $comment -> comment_ID , $comment , 'comment' );
}
2008-09-15 18:26:37 +02:00
//
// Internal
//
/**
2008-09-28 05:31:26 +02:00
* Close comments on old posts on the fly , without any extra DB queries . Hooked to the_posts .
2008-09-15 18:26:37 +02:00
*
2008-09-22 05:39:41 +02:00
* @ access private
* @ since 2.7 . 0
*
* @ param object $posts Post data object .
* @ return object
2008-09-15 18:26:37 +02:00
*/
function _close_comments_for_old_posts ( $posts ) {
2008-12-30 21:09:40 +01:00
if ( empty ( $posts ) || ! is_singular () || ! get_option ( 'close_comments_for_old_posts' ) )
2008-09-15 18:26:37 +02:00
return $posts ;
$days_old = ( int ) get_option ( 'close_comments_days_old' );
if ( ! $days_old )
return $posts ;
if ( time () - strtotime ( $posts [ 0 ] -> post_date_gmt ) > ( $days_old * 24 * 60 * 60 ) ) {
$posts [ 0 ] -> comment_status = 'closed' ;
$posts [ 0 ] -> ping_status = 'closed' ;
}
return $posts ;
}
2008-09-28 05:31:26 +02:00
/**
2008-11-14 23:33:13 +01:00
* Close comments on an old post . Hooked to comments_open and pings_open .
2008-09-28 05:31:26 +02:00
*
* @ access private
* @ since 2.7 . 0
*
* @ param bool $open Comments open or closed
* @ param int $post_id Post ID
* @ return bool $open
*/
function _close_comments_for_old_post ( $open , $post_id ) {
if ( ! $open )
return $open ;
if ( ! get_option ( 'close_comments_for_old_posts' ) )
return $open ;
$days_old = ( int ) get_option ( 'close_comments_days_old' );
if ( ! $days_old )
return $open ;
$post = get_post ( $post_id );
if ( time () - strtotime ( $post -> post_date_gmt ) > ( $days_old * 24 * 60 * 60 ) )
return false ;
return $open ;
}
2007-08-14 05:08:44 +02:00
?>