Make WordPress Core

Changeset 3851


Ignore:
Timestamp:
06/07/2006 11:17:59 PM (20 years ago)
Author:
ryan
Message:

Reworg post/page/attachment functions. #2525

Location:
trunk
Files:
6 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/wp-includes/comment.php

    r3740 r3851  
    196196}
    197197
     198function wp_blacklist_check($author, $email, $url, $comment, $user_ip, $user_agent) {
     199        global $wpdb;
     200
     201        do_action('wp_blacklist_check', $author, $email, $url, $comment, $user_ip, $user_agent);
     202
     203        if ( preg_match_all('/&#(\d+);/', $comment . $author . $url, $chars) ) {
     204                foreach ($chars[1] as $char) {
     205                        // If it's an encoded char in the normal ASCII set, reject
     206                        if ( 38 == $char )
     207                                continue; // Unless it's &
     208                        if ($char < 128)
     209                                return true;
     210                }
     211        }
     212
     213        $mod_keys = trim( get_settings('blacklist_keys') );
     214        if ('' == $mod_keys )
     215                return false; // If moderation keys are empty
     216        $words = explode("\n", $mod_keys );
     217
     218        foreach ($words as $word) {
     219                $word = trim($word);
     220
     221                // Skip empty lines
     222                if ( empty($word) ) { continue; }
     223
     224                // Do some escaping magic so that '#' chars in the
     225                // spam words don't break things:
     226                $word = preg_quote($word, '#');
     227
     228                $pattern = "#$word#i";
     229                if ( preg_match($pattern, $author    ) ) return true;
     230                if ( preg_match($pattern, $email     ) ) return true;
     231                if ( preg_match($pattern, $url       ) ) return true;
     232                if ( preg_match($pattern, $comment   ) ) return true;
     233                if ( preg_match($pattern, $user_ip   ) ) return true;
     234                if ( preg_match($pattern, $user_agent) ) return true;
     235        }
     236
     237        if ( isset($_SERVER['REMOTE_ADDR']) ) {
     238                if ( wp_proxy_check($_SERVER['REMOTE_ADDR']) ) return true;
     239        }
     240
     241        return false;
     242}
     243
    198244function wp_delete_comment($comment_id) {
    199245        global $wpdb;
  • trunk/wp-includes/functions.php

    r3843 r3851  
    339339        wp_cache_delete($name, 'options');
    340340        return true;
    341 }
    342 
    343 function add_post_meta($post_id, $key, $value, $unique = false) {
    344         global $wpdb, $post_meta_cache;
    345 
    346         if ( $unique ) {
    347                 if ( $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
    348 = '$key' AND post_id = '$post_id'") ) {
    349                         return false;
    350                 }
    351         }
    352 
    353         $original = $value;
    354         if ( is_array($value) || is_object($value) )
    355                 $value = $wpdb->escape(serialize($value));
    356 
    357         $wpdb->query("INSERT INTO $wpdb->postmeta (post_id,meta_key,meta_value) VALUES ('$post_id','$key','$value')");
    358 
    359         $post_meta_cache['$post_id'][$key][] = $original;
    360 
    361         return true;
    362 }
    363 
    364 function delete_post_meta($post_id, $key, $value = '') {
    365         global $wpdb, $post_meta_cache;
    366 
    367         if ( empty($value) ) {
    368                 $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
    369 post_id = '$post_id' AND meta_key = '$key'");
    370         } else {
    371                 $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
    372 post_id = '$post_id' AND meta_key = '$key' AND meta_value = '$value'");
    373         }
    374 
    375         if ( !$meta_id )
    376                 return false;
    377 
    378         if ( empty($value) ) {
    379                 $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
    380 AND meta_key = '$key'");
    381                 unset($post_meta_cache['$post_id'][$key]);
    382         } else {
    383                 $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
    384 AND meta_key = '$key' AND meta_value = '$value'");
    385                 $cache_key = $post_meta_cache['$post_id'][$key];
    386                 if ($cache_key) foreach ( $cache_key as $index => $data )
    387                         if ( $data == $value )
    388                                 unset($post_meta_cache['$post_id'][$key][$index]);
    389         }
    390 
    391         unset($post_meta_cache['$post_id'][$key]);
    392 
    393         return true;
    394 }
    395 
    396 function get_post_meta($post_id, $key, $single = false) {
    397         global $wpdb, $post_meta_cache;
    398 
    399         if ( isset($post_meta_cache[$post_id][$key]) ) {
    400                 if ( $single ) {
    401                         return maybe_unserialize( $post_meta_cache[$post_id][$key][0] );
    402                 } else {
    403                         return maybe_unserialize( $post_meta_cache[$post_id][$key] );
    404                 }
    405         }
    406 
    407         $metalist = $wpdb->get_results("SELECT meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' AND meta_key = '$key'", ARRAY_N);
    408 
    409         $values = array();
    410         if ( $metalist ) {
    411                 foreach ($metalist as $metarow) {
    412                         $values[] = $metarow[0];
    413                 }
    414         }
    415 
    416         if ( $single ) {
    417                 if ( count($values) ) {
    418                         $return = maybe_unserialize( $values[0] );
    419                 } else {
    420                         return '';
    421                 }
    422         } else {
    423                 $return = $values;
    424         }
    425 
    426         return maybe_unserialize($return);
    427 }
    428 
    429 function update_post_meta($post_id, $key, $value, $prev_value = '') {
    430         global $wpdb, $post_meta_cache;
    431 
    432         $original_value = $value;
    433         if ( is_array($value) || is_object($value) )
    434                 $value = $wpdb->escape(serialize($value));
    435 
    436         $original_prev = $prev_value;
    437         if ( is_array($prev_value) || is_object($prev_value) )
    438                 $prev_value = $wpdb->escape(serialize($prev_value));
    439 
    440         if (! $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
    441 = '$key' AND post_id = '$post_id'") ) {
    442                 return false;
    443         }
    444 
    445         if ( empty($prev_value) ) {
    446                 $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
    447 meta_key = '$key' AND post_id = '$post_id'");
    448                 $cache_key = $post_meta_cache['$post_id'][$key];
    449                 if ( !empty($cache_key) )
    450                         foreach ($cache_key as $index => $data)
    451                                 $post_meta_cache['$post_id'][$key][$index] = $original_value;
    452         } else {
    453                 $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
    454 meta_key = '$key' AND post_id = '$post_id' AND meta_value = '$prev_value'");
    455                 $cache_key = $post_meta_cache['$post_id'][$key];
    456                 if ( !empty($cache_key) )
    457                         foreach ($cache_key as $index => $data)
    458                                 if ( $data == $original_prev )
    459                                         $post_meta_cache['$post_id'][$key][$index] = $original_value;
    460         }
    461 
    462         return true;
    463 }
    464 
    465 // Retrieves post data given a post ID or post object.
    466 // Handles post caching.
    467 function &get_post(&$post, $output = OBJECT) {
    468         global $post_cache, $wpdb;
    469 
    470         if ( empty($post) ) {
    471                 if ( isset($GLOBALS['post']) )
    472                         $_post = & $GLOBALS['post'];
    473                 else
    474                         $_post = null;
    475         } elseif ( is_object($post) ) {
    476                 if ( 'page' == $post->post_type )
    477                         return get_page($post, $output);
    478                 if ( !isset($post_cache[$post->ID]) )
    479                         $post_cache[$post->ID] = &$post;
    480                 $_post = & $post_cache[$post->ID];
    481         } else {
    482                 if ( $_post = wp_cache_get($post, 'pages') )
    483                         return get_page($_post, $output);
    484                 elseif ( isset($post_cache[$post]) )
    485                         $_post = & $post_cache[$post];
    486                 else {
    487                         $query = "SELECT * FROM $wpdb->posts WHERE ID = '$post' LIMIT 1";
    488                         $_post = & $wpdb->get_row($query);
    489                         if ( 'page' == $_post->post_type )
    490                                 return get_page($_post, $output);
    491                         $post_cache[$post] = & $_post;
    492                 }
    493         }
    494 
    495         if ( defined(WP_IMPORTING) )
    496                 unset($post_cache);
    497 
    498         if ( $output == OBJECT ) {
    499                 return $_post;
    500         } elseif ( $output == ARRAY_A ) {
    501                 return get_object_vars($_post);
    502         } elseif ( $output == ARRAY_N ) {
    503                 return array_values(get_object_vars($_post));
    504         } else {
    505                 return $_post;
    506         }
    507 }
    508 
    509 function &get_children($post = 0, $output = OBJECT) {
    510         global $post_cache, $wpdb;
    511 
    512         if ( empty($post) ) {
    513                 if ( isset($GLOBALS['post']) )
    514                         $post_parent = & $GLOBALS['post']->post_parent;
    515                 else
    516                         return false;
    517         } elseif ( is_object($post) ) {
    518                 $post_parent = $post->post_parent;
    519         } else {
    520                 $post_parent = $post;
    521         }
    522 
    523         $post_parent = (int) $post_parent;
    524 
    525         $query = "SELECT * FROM $wpdb->posts WHERE post_parent = $post_parent";
    526 
    527         $children = $wpdb->get_results($query);
    528 
    529         if ( $children ) {
    530                 foreach ( $children as $key => $child ) {
    531                         $post_cache[$child->ID] =& $children[$key];
    532                         $kids[$child->ID] =& $children[$key];
    533                 }
    534         } else {
    535                 return false;
    536         }
    537 
    538         if ( $output == OBJECT ) {
    539                 return $kids;
    540         } elseif ( $output == ARRAY_A ) {
    541                 foreach ( $kids as $kid )
    542                         $weeuns[$kid->ID] = get_object_vars($kids[$kid->ID]);
    543                 return $weeuns;
    544         } elseif ( $output == ARRAY_N ) {
    545                 foreach ( $kids as $kid )
    546                         $babes[$kid->ID] = array_values(get_object_vars($kids[$kid->ID]));
    547                 return $babes;
    548         } else {
    549                 return $kids;
    550         }
    551 }
    552 
    553 function get_page_by_path($page_path, $output = OBJECT) {
    554         global $wpdb;
    555         $page_path = rawurlencode(urldecode($page_path));
    556         $page_path = str_replace('%2F', '/', $page_path);
    557         $page_path = str_replace('%20', ' ', $page_path);
    558         $page_paths = '/' . trim($page_path, '/');
    559         $leaf_path  = sanitize_title(basename($page_paths));
    560         $page_paths = explode('/', $page_paths);
    561         foreach($page_paths as $pathdir)
    562                 $full_path .= ($pathdir!=''?'/':'') . sanitize_title($pathdir);
    563 
    564         $pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_name = '$leaf_path' AND post_type='page'");
    565 
    566         if ( empty($pages) )
    567                 return NULL;
    568 
    569         foreach ($pages as $page) {
    570                 $path = '/' . $leaf_path;
    571                 $curpage = $page;
    572                 while ($curpage->post_parent != 0) {
    573                         $curpage = $wpdb->get_row("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE ID = '$curpage->post_parent' and post_type='page'");
    574                         $path = '/' . $curpage->post_name . $path;
    575                 }
    576 
    577                 if ( $path == $full_path )
    578                         return get_page($page->ID, $output);
    579         }
    580 
    581         return NULL;
    582 }
    583 
    584 // Retrieves page data given a page ID or page object.
    585 // Handles page caching.
    586 function &get_page(&$page, $output = OBJECT) {
    587         global $wpdb;
    588 
    589         if ( empty($page) ) {
    590                 if ( isset($GLOBALS['page']) ) {
    591                         $_page = & $GLOBALS['page'];
    592                         wp_cache_add($_page->ID, $_page, 'pages');
    593                 } else {
    594                         $_page = null;
    595                 }
    596         } elseif ( is_object($page) ) {
    597                 if ( 'post' == $page->post_type )
    598                         return get_post($page, $output);
    599                 wp_cache_add($page->ID, $page, 'pages');
    600                 $_page = $page;
    601         } else {
    602                 if ( isset($GLOBALS['page']) && ($page == $GLOBALS['page']->ID) ) {
    603                         $_page = & $GLOBALS['page'];
    604                         wp_cache_add($_page->ID, $_page, 'pages');
    605                 } elseif ( $_page = $GLOBALS['post_cache'][$page] ) {
    606                         return get_post($page, $output);
    607                 } elseif ( $_page = wp_cache_get($page, 'pages') ) {
    608                         // Got it.
    609                 } else {
    610                         $query = "SELECT * FROM $wpdb->posts WHERE ID= '$page' LIMIT 1";
    611                         $_page = & $wpdb->get_row($query);
    612                         if ( 'post' == $_page->post_type )
    613                                 return get_post($_page, $output);
    614                         wp_cache_add($_page->ID, $_page, 'pages');
    615                 }
    616         }
    617 
    618         if ( $output == OBJECT ) {
    619                 return $_page;
    620         } elseif ( $output == ARRAY_A ) {
    621                 return get_object_vars($_page);
    622         } elseif ( $output == ARRAY_N ) {
    623                 return array_values(get_object_vars($_page));
    624         } else {
    625                 return $_page;
    626         }
    627 }
    628 
    629 function get_all_page_ids() {
    630         global $wpdb;
    631 
    632         if ( ! $page_ids = wp_cache_get('all_page_ids', 'pages') ) {
    633                 $page_ids = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE post_type = 'page'");
    634                 wp_cache_add('all_page_ids', $page_ids, 'pages');
    635         }
    636 
    637         return $page_ids;
    638341}
    639342
    … …  
    1275978}
    1276979
    1277 function wp_head() {
    1278         do_action('wp_head');
    1279 }
    1280 
    1281 function wp_footer() {
    1282         do_action('wp_footer');
    1283 }
    1284 
    1285980/*
    1286981add_query_arg: Returns a modified querystring by adding
    … …  
    16011296}
    16021297
     1298function wp_mkdir_p($target) {
     1299        // from php.net/mkdir user contributed notes
     1300        if (file_exists($target)) {
     1301                if (! @ is_dir($target))
     1302                        return false;
     1303                else
     1304                        return true;
     1305        }
     1306
     1307        // Attempting to create the directory may clutter up our display.
     1308        if (@ mkdir($target)) {
     1309                $stat = @ stat(dirname($target));
     1310                $dir_perms = $stat['mode'] & 0007777;  // Get the permission bits.
     1311                @ chmod($target, $dir_perms);
     1312                return true;
     1313        } else {
     1314                if ( is_dir(dirname($target)) )
     1315                        return false;
     1316        }
     1317
     1318        // If the above failed, attempt to create the parent node, then try again.
     1319        if (wp_mkdir_p(dirname($target)))
     1320                return wp_mkdir_p($target);
     1321
     1322        return false;
     1323}
     1324
     1325// Returns an array containing the current upload directory's path and url, or an error message.
     1326function wp_upload_dir() {
     1327        $siteurl = get_settings('siteurl');
     1328        //prepend ABSPATH to $dir and $siteurl to $url if they're not already there
     1329        $path = str_replace(ABSPATH, '', trim(get_settings('upload_path')));
     1330        $dir = ABSPATH . $path;
     1331        $url = trailingslashit($siteurl) . $path;
     1332
     1333        if ( $dir == ABSPATH ) { //the option was empty
     1334                $dir = ABSPATH . 'wp-content/uploads';
     1335        }
     1336
     1337        if ( defined('UPLOADS') ) {
     1338                $dir = ABSPATH . UPLOADS;
     1339                $url = trailingslashit($siteurl) . UPLOADS;
     1340        }
     1341
     1342        if ( get_settings('uploads_use_yearmonth_folders')) {
     1343                // Generate the yearly and monthly dirs
     1344                $time = current_time( 'mysql' );
     1345                $y = substr( $time, 0, 4 );
     1346                $m = substr( $time, 5, 2 );
     1347                $dir = $dir . "/$y/$m";
     1348                $url = $url . "/$y/$m";
     1349        }
     1350
     1351        // Make sure we have an uploads dir
     1352        if ( ! wp_mkdir_p( $dir ) ) {
     1353                $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), $dir);
     1354                return array('error' => $message);
     1355        }
     1356
     1357    $uploads = array('path' => $dir, 'url' => $url, 'error' => false);
     1358        return apply_filters('upload_dir', $uploads);
     1359}
     1360
     1361function wp_upload_bits($name, $type, $bits) {
     1362        if ( empty($name) )
     1363                return array('error' => "Empty filename");
     1364
     1365        $upload = wp_upload_dir();
     1366
     1367        if ( $upload['error'] !== false )
     1368                return $upload;
     1369
     1370        $number = '';
     1371        $filename = $name;
     1372        $path_parts = pathinfo($filename);
     1373        $ext = $path_parts['extension'];
     1374        if ( empty($ext) )
     1375                $ext = '';
     1376        else
     1377                $ext = ".$ext";
     1378        while ( file_exists($upload['path'] . "/$filename") ) {
     1379                if ( '' == "$number$ext" )
     1380                        $filename = $filename . ++$number . $ext;
     1381                else
     1382                        $filename = str_replace("$number$ext", ++$number . $ext, $filename);
     1383        }
     1384
     1385        $new_file = $upload['path'] . "/$filename";
     1386        if ( ! wp_mkdir_p( dirname($new_file) ) ) {
     1387                $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), dirname($new_file));
     1388                return array('error' => $message);
     1389        }
     1390
     1391        $ifp = @ fopen($new_file, 'wb');
     1392        if ( ! $ifp )
     1393                return array('error' => "Could not write file $new_file.");
     1394
     1395        $success = @ fwrite($ifp, $bits);
     1396        fclose($ifp);
     1397        // Set correct file permissions
     1398        $stat = @ stat(dirname($new_file));
     1399        $perms = $stat['mode'] & 0007777;
     1400        $perms = $perms & 0000666;
     1401        @ chmod($new_file, $perms);
     1402
     1403        // Compute the URL
     1404        $url = $upload['url'] . "/$filename";
     1405
     1406        return array('file' => $new_file, 'url' => $url, 'error' => false);
     1407}
     1408
     1409function do_trackbacks($post_id) {
     1410        global $wpdb;
     1411
     1412        $post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $post_id");
     1413        $to_ping = get_to_ping($post_id);
     1414        $pinged  = get_pung($post_id);
     1415        if ( empty($to_ping) ) {
     1416                $wpdb->query("UPDATE $wpdb->posts SET to_ping = '' WHERE ID = '$post_id'");
     1417                return;
     1418        }
     1419
     1420        if (empty($post->post_excerpt))
     1421                $excerpt = apply_filters('the_content', $post->post_content);
     1422        else
     1423                $excerpt = apply_filters('the_excerpt', $post->post_excerpt);
     1424        $excerpt = str_replace(']]>', ']]&gt;', $excerpt);
     1425        $excerpt = strip_tags($excerpt);
     1426        if ( function_exists('mb_strcut') ) // For international trackbacks
     1427        $excerpt = mb_strcut($excerpt, 0, 252, get_settings('blog_charset')) . '...';
     1428        else
     1429                $excerpt = substr($excerpt, 0, 252) . '...';
     1430
     1431        $post_title = apply_filters('the_title', $post->post_title);
     1432        $post_title = strip_tags($post_title);
     1433
     1434        if ($to_ping) : foreach ($to_ping as $tb_ping) :
     1435                $tb_ping = trim($tb_ping);
     1436                if ( !in_array($tb_ping, $pinged) ) {
     1437                        trackback($tb_ping, $post_title, $excerpt, $post_id);
     1438                        $pinged[] = $tb_ping;
     1439                } else {
     1440                        $wpdb->query("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, '$tb_ping', '')) WHERE ID = '$post_id'");
     1441                }
     1442        endforeach; endif;
     1443}
     1444
     1445function do_all_pings() {
     1446        global $wpdb;
     1447
     1448        // Do pingbacks
     1449        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")) {
     1450                $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$ping->ID} AND meta_key = '_pingme';");
     1451                pingback($ping->post_content, $ping->ID);
     1452        }
     1453       
     1454        // Do Enclosures
     1455        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")) {
     1456                $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$enclosure->ID} AND meta_key = '_encloseme';");
     1457                do_enclose($enclosure->post_content, $enclosure->ID);
     1458        }
     1459
     1460        // Do Trackbacks
     1461        $trackbacks = $wpdb->get_results("SELECT ID FROM $wpdb->posts WHERE CHAR_LENGTH(TRIM(to_ping)) > 7 AND post_status = 'publish'");
     1462        if ( is_array($trackbacks) ) {
     1463                foreach ( $trackbacks as $trackback ) {
     1464                        do_trackbacks($trackback->ID);
     1465                }
     1466        }
     1467
     1468        //Do Update Services/Generic Pings
     1469        generic_ping();
     1470}
     1471
     1472function wp_proxy_check($ipnum) {
     1473        if ( get_option('open_proxy_check') && isset($ipnum) ) {
     1474                $rev_ip = implode( '.', array_reverse( explode( '.', $ipnum ) ) );
     1475                $lookup = $rev_ip . '.opm.blitzed.org.';
     1476                if ( $lookup != gethostbyname( $lookup ) )
     1477                        return true;
     1478        }
     1479
     1480        return false;
     1481}
     1482
    16031483?>
  • trunk/wp-includes/post-template.php

    r3845 r3851  
    11<?php
    22
    3 function get_the_password_form() {
    4         $output = '<form action="' . get_settings('siteurl') . '/wp-pass.php" method="post">
    5         <p>' . __("This post is password protected. To view it please enter your password below:") . '</p>
    6         <p><label>' . __("Password:") . ' <input name="post_password" type="password" size="20" /></label> <input type="submit" name="Submit" value="' . __("Submit") . '" /></p>
    7         </form>
    8         ';
    9         return $output;
    10 }
    11 
     3//
     4// "The Loop" post functions
     5//
    126
    137function the_ID() {
    … …  
    1610}
    1711
     12
    1813function get_the_ID() {
    1914        global $id;
    2015        return $id;
    2116}
     17
    2218
    2319function the_title($before = '', $after = '', $echo = true) {
    … …  
    4339}
    4440
     41function the_guid( $id = 0 ) {
     42        echo get_the_guid($id);
     43}
    4544
    4645function get_the_guid( $id = 0 ) {
    … …  
    4948        return apply_filters('get_the_guid', $post->guid);
    5049}
    51 
    52 
    53 function the_guid( $id = 0 ) {
    54         echo get_the_guid($id);
    55 }
    56 
    5750
    5851function the_content($more_link_text = '(more...)', $stripteaser = 0, $more_file = '') {
    … …  
    191184
    192185
    193 /*
    194 Post-meta: Custom per-post fields.
    195 */
    196 
    197 
    198 function get_post_custom( $post_id = 0 ) {
    199         global $id, $post_meta_cache, $wpdb;
    200 
    201         if ( ! $post_id )
    202                 $post_id = $id;
    203 
    204         if ( isset($post_meta_cache[$post_id]) )
    205                 return $post_meta_cache[$post_id];
    206 
    207         if ( $meta_list = $wpdb->get_results("SELECT post_id, meta_key, meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' ORDER BY post_id, meta_key", ARRAY_A) ) {
    208                 // Change from flat structure to hierarchical:
    209                 $post_meta_cache = array();
    210                 foreach ( $meta_list as $metarow ) {
    211                         $mpid = $metarow['post_id'];
    212                         $mkey = $metarow['meta_key'];
    213                         $mval = $metarow['meta_value'];
    214 
    215                         // Force subkeys to be array type:
    216                         if ( !isset($post_meta_cache[$mpid]) || !is_array($post_meta_cache[$mpid]) )
    217                                 $post_meta_cache[$mpid] = array();
    218 
    219                         if ( !isset($post_meta_cache[$mpid]["$mkey"]) || !is_array($post_meta_cache[$mpid]["$mkey"]) )
    220                                 $post_meta_cache[$mpid]["$mkey"] = array();
    221 
    222                         // Add a value to the current pid/key:
    223                         $post_meta_cache[$mpid][$mkey][] = $mval;
    224                 }
    225                 return $post_meta_cache[$mpid];
    226         }
    227 }
    228 
    229 
    230 function get_post_custom_keys() {
    231         $custom = get_post_custom();
    232 
    233         if ( ! is_array($custom) )
    234                 return;
    235 
    236         if ( $keys = array_keys($custom) )
    237                 return $keys;
    238 }
    239 
    240 
    241 function get_post_custom_values( $key = '' ) {
    242         $custom = get_post_custom();
    243 
    244         return $custom[$key];
    245 }
     186//
     187// Post-meta: Custom per-post fields.
     188//
    246189
    247190
    … …  
    275218
    276219
    277 /*
    278 Pages
    279 */
     220//
     221// Pages
     222//
     223
     224function wp_dropdown_pages($args = '') {
     225        if ( is_array($args) )
     226                $r = &$args;
     227        else
     228                parse_str($args, $r);
     229
     230        $defaults = array('depth' => 0, 'child_of' => 0, 'selected' => 0, 'echo' => 1,
     231                'name' => 'page_id');
     232        $r = array_merge($defaults, $r);
     233        extract($r);
     234
     235        $pages = get_pages($r);
     236        $output = '';
     237
     238        if ( ! empty($pages) ) {
     239                $output = "<select name='$name'>\n";
     240                $output .= walk_page_dropdown_tree($pages, $depth, $r);
     241                $output .= "</select>\n";
     242        }
     243
     244        $output = apply_filters('wp_dropdown_pages', $output);
     245
     246        if ( $echo )
     247                echo $output;
     248
     249        return $output;
     250}
     251
     252function wp_list_pages($args = '') {
     253        if ( is_array($args) )
     254                $r = &$args;
     255        else
     256                parse_str($args, $r);
     257
     258        $defaults = array('depth' => 0, 'show_date' => '', 'date_format' => get_settings('date_format'),
     259                'child_of' => 0, 'title_li' => __('Pages'), 'echo' => 1);
     260        $r = array_merge($defaults, $r);
     261
     262        $output = '';
     263
     264        // Query pages.
     265        $pages = get_pages($r);
     266
     267        if ( !empty($pages) ) {
     268                if ( $r['title_li'] )
     269                        $output .= '<li class="pagenav">' . $r['title_li'] . '<ul>';
     270
     271                global $wp_query;
     272                $current_page = $wp_query->get_queried_object_id();
     273                $output .= walk_page_tree($pages, $r['depth'], $current_page, $r['show_date'], $r['date_format']);
     274
     275                if ( $r['title_li'] )
     276                        $output .= '</ul></li>';
     277        }
     278
     279        $output = apply_filters('wp_list_pages', $output);
     280
     281        if ( $r['echo'] )
     282                echo $output;
     283        else
     284                return $output;
     285}
     286
     287//
     288// Page helpers
     289//
    280290
    281291function walk_page_tree() {
    … …  
    291301}
    292302
    293 function &get_page_children($page_id, $pages) {
    294         global $page_cache;
    295 
    296         if ( empty($pages) )
    297                 $pages = &$page_cache;
    298 
    299         $page_list = array();
    300         foreach ( $pages as $page ) {
    301                 if ( $page->post_parent == $page_id ) {
    302                         $page_list[] = $page;
    303                         if ( $children = get_page_children($page->ID, $pages) )
    304                                 $page_list = array_merge($page_list, $children);
    305                 }
    306         }
    307         return $page_list;
    308 }
    309 
    310 
    311 function &get_pages($args = '') {
    312         global $wpdb;
    313 
    314         if ( is_array($args) )
    315                 $r = &$args;
    316         else
    317                 parse_str($args, $r);
    318 
    319         $defaults = array('child_of' => 0, 'sort_order' => 'ASC', 'sort_column' => 'post_title',
    320                                 'hierarchical' => 1, 'exclude' => '', 'include' => '', 'meta_key' => '', 'meta_value' => '');
    321         $r = array_merge($defaults, $r);
    322         extract($r);
    323 
    324         $inclusions = '';
    325         if ( !empty($include) ) {
    326                 $child_of = 0; //ignore child_of, exclude, meta_key, and meta_value params if using include
    327                 $exclude = ''; 
    328                 $meta_key = '';
    329                 $meta_value = '';
    330                 $incpages = preg_split('/[\s,]+/',$include);
    331                 if ( count($incpages) ) {
    332                         foreach ( $incpages as $incpage ) {
    333                                 if (empty($inclusions))
    334                                         $inclusions = ' AND ( ID = ' . intval($incpage) . ' ';
    335                                 else
    336                                         $inclusions .= ' OR ID = ' . intval($incpage) . ' ';
    337                         }
    338                 }
    339         }
    340         if (!empty($inclusions))
    341                 $inclusions .= ')';     
    342 
    343         $exclusions = '';
    344         if ( !empty($exclude) ) {
    345                 $expages = preg_split('/[\s,]+/',$exclude);
    346                 if ( count($expages) ) {
    347                         foreach ( $expages as $expage ) {
    348                                 if (empty($exclusions))
    349                                         $exclusions = ' AND ( ID <> ' . intval($expage) . ' ';
    350                                 else
    351                                         $exclusions .= ' AND ID <> ' . intval($expage) . ' ';
    352                         }
    353                 }
    354         }
    355         if (!empty($exclusions))
    356                 $exclusions .= ')';
    357 
    358         $query = "SELECT * FROM $wpdb->posts " ;
    359         $query .= ( empty( $meta_key ) ? "" : ", $wpdb->postmeta " ) ;
    360         $query .= " WHERE (post_type = 'page' AND post_status = 'publish') $exclusions $inclusions " ;
    361         $query .= ( empty( $meta_key ) | empty($meta_value)  ? "" : " AND ($wpdb->posts.ID = $wpdb->postmeta.post_id AND $wpdb->postmeta.meta_key = '$meta_key' AND $wpdb->postmeta.meta_value = '$meta_value' )" ) ;
    362         $query .= " ORDER BY " . $sort_column . " " . $sort_order ;
    363 
    364         $pages = $wpdb->get_results($query);
    365         $pages = apply_filters('get_pages', $pages, $r);
    366 
    367         if ( empty($pages) )
    368                 return array();
    369 
    370         // Update cache.
    371         update_page_cache($pages);
    372 
    373         if ( $child_of || $hierarchical )
    374                 $pages = & get_page_children($child_of, $pages);
    375 
    376         return $pages;
    377 }
    378 
    379 function wp_dropdown_pages($args = '') {
    380         if ( is_array($args) )
    381                 $r = &$args;
    382         else
    383                 parse_str($args, $r);
    384 
    385         $defaults = array('depth' => 0, 'child_of' => 0, 'selected' => 0, 'echo' => 1,
    386                 'name' => 'page_id');
    387         $r = array_merge($defaults, $r);
    388         extract($r);
    389 
    390         $pages = get_pages($r);
    391         $output = '';
    392 
    393         if ( ! empty($pages) ) {
    394                 $output = "<select name='$name'>\n";
    395                 $output .= walk_page_dropdown_tree($pages, $depth, $r);
    396                 $output .= "</select>\n";
    397         }
    398 
    399         $output = apply_filters('wp_dropdown_pages', $output);
    400 
    401         if ( $echo )
    402                 echo $output;
    403 
    404         return $output;
    405 }
    406 
    407 function wp_list_pages($args = '') {
    408         if ( is_array($args) )
    409                 $r = &$args;
    410         else
    411                 parse_str($args, $r);
    412 
    413         $defaults = array('depth' => 0, 'show_date' => '', 'date_format' => get_settings('date_format'),
    414                 'child_of' => 0, 'title_li' => __('Pages'), 'echo' => 1);
    415         $r = array_merge($defaults, $r);
    416 
    417         $output = '';
    418 
    419         // Query pages.
    420         $pages = get_pages($r);
    421 
    422         if ( !empty($pages) ) {
    423                 if ( $r['title_li'] )
    424                         $output .= '<li class="pagenav">' . $r['title_li'] . '<ul>';
    425 
    426                 global $wp_query;
    427                 $current_page = $wp_query->get_queried_object_id();
    428                 $output .= walk_page_tree($pages, $r['depth'], $current_page, $r['show_date'], $r['date_format']);
    429 
    430                 if ( $r['title_li'] )
    431                         $output .= '</ul></li>';
    432         }
    433 
    434         $output = apply_filters('wp_list_pages', $output);
    435 
    436         if ( $r['echo'] )
    437                 echo $output;
    438         else
    439                 return $output;
    440 }
     303//
     304// Attachments
     305//
    441306
    442307function the_attachment_link($id = 0, $fullsize = false, $max_dims = false) {
    … …  
    562427}
    563428
     429//
     430// Misc
     431//
     432
     433function get_the_password_form() {
     434        $output = '<form action="' . get_settings('siteurl') . '/wp-pass.php" method="post">
     435        <p>' . __("This post is password protected. To view it please enter your password below:") . '</p>
     436        <p><label>' . __("Password:") . ' <input name="post_password" type="password" size="20" /></label> <input type="submit" name="Submit" value="' . __("Submit") . '" /></p>
     437        </form>
     438        ';
     439        return $output;
     440}
     441
    564442?>
  • trunk/wp-includes/post.php

    r3849 r3851  
    11<?php
    22
    3 /**** DB Functions ****/
    4 
    5 /*
    6  * generic function for inserting data into the posts table.
    7  */
     3//
     4// Post functions
     5//
     6
     7function get_attached_file($attachment_id) {
     8        return get_post_meta($attachment_id, '_wp_attached_file', true);
     9}
     10
     11function &get_children($post = 0, $output = OBJECT) {
     12        global $post_cache, $wpdb;
     13
     14        if ( empty($post) ) {
     15                if ( isset($GLOBALS['post']) )
     16                        $post_parent = & $GLOBALS['post']->post_parent;
     17                else
     18                        return false;
     19        } elseif ( is_object($post) ) {
     20                $post_parent = $post->post_parent;
     21        } else {
     22                $post_parent = $post;
     23        }
     24
     25        $post_parent = (int) $post_parent;
     26
     27        $query = "SELECT * FROM $wpdb->posts WHERE post_parent = $post_parent";
     28
     29        $children = $wpdb->get_results($query);
     30
     31        if ( $children ) {
     32                foreach ( $children as $key => $child ) {
     33                        $post_cache[$child->ID] =& $children[$key];
     34                        $kids[$child->ID] =& $children[$key];
     35                }
     36        } else {
     37                return false;
     38        }
     39
     40        if ( $output == OBJECT ) {
     41                return $kids;
     42        } elseif ( $output == ARRAY_A ) {
     43                foreach ( $kids as $kid )
     44                        $weeuns[$kid->ID] = get_object_vars($kids[$kid->ID]);
     45                return $weeuns;
     46        } elseif ( $output == ARRAY_N ) {
     47                foreach ( $kids as $kid )
     48                        $babes[$kid->ID] = array_values(get_object_vars($kids[$kid->ID]));
     49                return $babes;
     50        } else {
     51                return $kids;
     52        }
     53}
     54
     55// get extended entry info (<!--more-->)
     56function get_extended($post) {
     57        list($main,$extended) = explode('<!--more-->', $post, 2);
     58
     59        // Strip leading and trailing whitespace
     60        $main = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$main);
     61        $extended = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$extended);
     62
     63        return array('main' => $main, 'extended' => $extended);
     64}
     65
     66// Retrieves post data given a post ID or post object.
     67// Handles post caching.
     68function &get_post(&$post, $output = OBJECT) {
     69        global $post_cache, $wpdb;
     70
     71        if ( empty($post) ) {
     72                if ( isset($GLOBALS['post']) )
     73                        $_post = & $GLOBALS['post'];
     74                else
     75                        $_post = null;
     76        } elseif ( is_object($post) ) {
     77                if ( 'page' == $post->post_type )
     78                        return get_page($post, $output);
     79                if ( !isset($post_cache[$post->ID]) )
     80                        $post_cache[$post->ID] = &$post;
     81                $_post = & $post_cache[$post->ID];
     82        } else {
     83                if ( $_post = wp_cache_get($post, 'pages') )
     84                        return get_page($_post, $output);
     85                elseif ( isset($post_cache[$post]) )
     86                        $_post = & $post_cache[$post];
     87                else {
     88                        $query = "SELECT * FROM $wpdb->posts WHERE ID = '$post' LIMIT 1";
     89                        $_post = & $wpdb->get_row($query);
     90                        if ( 'page' == $_post->post_type )
     91                                return get_page($_post, $output);
     92                        $post_cache[$post] = & $_post;
     93                }
     94        }
     95
     96        if ( defined(WP_IMPORTING) )
     97                unset($post_cache);
     98
     99        if ( $output == OBJECT ) {
     100                return $_post;
     101        } elseif ( $output == ARRAY_A ) {
     102                return get_object_vars($_post);
     103        } elseif ( $output == ARRAY_N ) {
     104                return array_values(get_object_vars($_post));
     105        } else {
     106                return $_post;
     107        }
     108}
     109
     110// Takes a post ID, returns its mime type.
     111function get_post_mime_type($ID = '') {
     112        $post = & get_post($ID);
     113
     114        if ( is_object($post) )
     115                return $post->post_mime_type;
     116
     117        return false;
     118}
     119
     120function get_post_status($ID = '') {
     121        $post = get_post($ID);
     122
     123        if ( is_object($post) ) {
     124                if ( ('attachment' == $post->post_type) && $post->post_parent && ($post->ID != $post->post_parent) )
     125                        return get_post_status($post->post_parent);
     126                else
     127                        return $post->post_status;
     128        }
     129
     130        return false;
     131}
     132
     133function get_post_type($post = false) {
     134        global $wpdb, $posts;
     135
     136        if ( false === $post )
     137                $post = $posts[0];
     138        elseif ( (int) $post )
     139                $post = get_post($post, OBJECT);
     140
     141        if ( is_object($post) )
     142                return $post->post_type;
     143
     144        return false;
     145}
     146
     147
     148//
     149// Post meta functions
     150//
     151
     152function add_post_meta($post_id, $key, $value, $unique = false) {
     153        global $wpdb, $post_meta_cache;
     154
     155        if ( $unique ) {
     156                if ( $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
     157= '$key' AND post_id = '$post_id'") ) {
     158                        return false;
     159                }
     160        }
     161
     162        $original = $value;
     163        if ( is_array($value) || is_object($value) )
     164                $value = $wpdb->escape(serialize($value));
     165
     166        $wpdb->query("INSERT INTO $wpdb->postmeta (post_id,meta_key,meta_value) VALUES ('$post_id','$key','$value')");
     167
     168        $post_meta_cache['$post_id'][$key][] = $original;
     169
     170        return true;
     171}
     172
     173function delete_post_meta($post_id, $key, $value = '') {
     174        global $wpdb, $post_meta_cache;
     175
     176        if ( empty($value) ) {
     177                $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
     178post_id = '$post_id' AND meta_key = '$key'");
     179        } else {
     180                $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
     181post_id = '$post_id' AND meta_key = '$key' AND meta_value = '$value'");
     182        }
     183
     184        if ( !$meta_id )
     185                return false;
     186
     187        if ( empty($value) ) {
     188                $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
     189AND meta_key = '$key'");
     190                unset($post_meta_cache['$post_id'][$key]);
     191        } else {
     192                $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
     193AND meta_key = '$key' AND meta_value = '$value'");
     194                $cache_key = $post_meta_cache['$post_id'][$key];
     195                if ($cache_key) foreach ( $cache_key as $index => $data )
     196                        if ( $data == $value )
     197                                unset($post_meta_cache['$post_id'][$key][$index]);
     198        }
     199
     200        unset($post_meta_cache['$post_id'][$key]);
     201
     202        return true;
     203}
     204
     205function get_post_meta($post_id, $key, $single = false) {
     206        global $wpdb, $post_meta_cache;
     207
     208        if ( isset($post_meta_cache[$post_id][$key]) ) {
     209                if ( $single ) {
     210                        return maybe_unserialize( $post_meta_cache[$post_id][$key][0] );
     211                } else {
     212                        return maybe_unserialize( $post_meta_cache[$post_id][$key] );
     213                }
     214        }
     215
     216        $metalist = $wpdb->get_results("SELECT meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' AND meta_key = '$key'", ARRAY_N);
     217
     218        $values = array();
     219        if ( $metalist ) {
     220                foreach ($metalist as $metarow) {
     221                        $values[] = $metarow[0];
     222                }
     223        }
     224
     225        if ( $single ) {
     226                if ( count($values) ) {
     227                        $return = maybe_unserialize( $values[0] );
     228                } else {
     229                        return '';
     230                }
     231        } else {
     232                $return = $values;
     233        }
     234
     235        return maybe_unserialize($return);
     236}
     237
     238function update_post_meta($post_id, $key, $value, $prev_value = '') {
     239        global $wpdb, $post_meta_cache;
     240
     241        $original_value = $value;
     242        if ( is_array($value) || is_object($value) )
     243                $value = $wpdb->escape(serialize($value));
     244
     245        $original_prev = $prev_value;
     246        if ( is_array($prev_value) || is_object($prev_value) )
     247                $prev_value = $wpdb->escape(serialize($prev_value));
     248
     249        if (! $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
     250= '$key' AND post_id = '$post_id'") ) {
     251                return false;
     252        }
     253
     254        if ( empty($prev_value) ) {
     255                $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
     256meta_key = '$key' AND post_id = '$post_id'");
     257                $cache_key = $post_meta_cache['$post_id'][$key];
     258                if ( !empty($cache_key) )
     259                        foreach ($cache_key as $index => $data)
     260                                $post_meta_cache['$post_id'][$key][$index] = $original_value;
     261        } else {
     262                $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
     263meta_key = '$key' AND post_id = '$post_id' AND meta_value = '$prev_value'");
     264                $cache_key = $post_meta_cache['$post_id'][$key];
     265                if ( !empty($cache_key) )
     266                        foreach ($cache_key as $index => $data)
     267                                if ( $data == $original_prev )
     268                                        $post_meta_cache['$post_id'][$key][$index] = $original_value;
     269        }
     270
     271        return true;
     272}
     273
     274
     275function get_post_custom( $post_id = 0 ) {
     276        global $id, $post_meta_cache, $wpdb;
     277
     278        if ( ! $post_id )
     279                $post_id = $id;
     280
     281        if ( isset($post_meta_cache[$post_id]) )
     282                return $post_meta_cache[$post_id];
     283
     284        if ( $meta_list = $wpdb->get_results("SELECT post_id, meta_key, meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' ORDER BY post_id, meta_key", ARRAY_A) ) {
     285                // Change from flat structure to hierarchical:
     286                $post_meta_cache = array();
     287                foreach ( $meta_list as $metarow ) {
     288                        $mpid = $metarow['post_id'];
     289                        $mkey = $metarow['meta_key'];
     290                        $mval = $metarow['meta_value'];
     291
     292                        // Force subkeys to be array type:
     293                        if ( !isset($post_meta_cache[$mpid]) || !is_array($post_meta_cache[$mpid]) )
     294                                $post_meta_cache[$mpid] = array();
     295
     296                        if ( !isset($post_meta_cache[$mpid]["$mkey"]) || !is_array($post_meta_cache[$mpid]["$mkey"]) )
     297                                $post_meta_cache[$mpid]["$mkey"] = array();
     298
     299                        // Add a value to the current pid/key:
     300                        $post_meta_cache[$mpid][$mkey][] = $mval;
     301                }
     302                return $post_meta_cache[$mpid];
     303        }
     304}
     305
     306function get_post_custom_keys( $post_id = 0 ) {
     307        $custom = get_post_custom( $post_id );
     308
     309        if ( ! is_array($custom) )
     310                return;
     311
     312        if ( $keys = array_keys($custom) )
     313                return $keys;
     314}
     315
     316
     317function get_post_custom_values( $key = '', $post_id = 0 ) {
     318        $custom = get_post_custom($post_id);
     319
     320        return $custom[$key];
     321}
     322
     323function wp_delete_post($postid = 0) {
     324        global $wpdb, $wp_rewrite;
     325        $postid = (int) $postid;
     326
     327        if ( !$post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $postid") )
     328                return $post;
     329
     330        if ( 'attachment' == $post->post_type )
     331                return wp_delete_attachment($postid);
     332
     333        do_action('delete_post', $postid);
     334
     335        if ( 'publish' == $post->post_status && 'post' == $post->post_type ) {
     336                $categories = wp_get_post_categories($post->ID);
     337                if( is_array( $categories ) ) {
     338                        foreach ( $categories as $cat_id ) {
     339                                $wpdb->query("UPDATE $wpdb->categories SET category_count = category_count - 1 WHERE cat_ID = '$cat_id'");
     340                                wp_cache_delete($cat_id, 'category');
     341                        }
     342                }
     343        }
     344
     345        if ( 'page' == $post->post_type )
     346                $wpdb->query("UPDATE $wpdb->posts SET post_parent = $post->post_parent WHERE post_parent = $postid AND post_type = 'page'");
     347
     348        $wpdb->query("DELETE FROM $wpdb->posts WHERE ID = $postid");
     349
     350        $wpdb->query("DELETE FROM $wpdb->comments WHERE comment_post_ID = $postid");
     351
     352        $wpdb->query("DELETE FROM $wpdb->post2cat WHERE post_id = $postid");
     353
     354        $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = $postid");
     355
     356        if ( 'page' == $post->type ) {
     357                wp_cache_delete('all_page_ids', 'pages');
     358                $wp_rewrite->flush_rules();
     359        }
     360
     361        return $post;
     362}
     363
     364function wp_get_post_categories($post_ID = 0) {
     365        global $wpdb;
     366
     367        $post_ID = (int) $post_ID;
     368
     369        $sql = "SELECT category_id
     370                FROM $wpdb->post2cat
     371                WHERE post_id = '$post_ID'
     372                ORDER BY category_id";
     373
     374        $result = $wpdb->get_col($sql);
     375
     376        if ( !$result )
     377                $result = array();
     378
     379        return array_unique($result);
     380}
     381
     382function wp_get_recent_posts($num = 10) {
     383        global $wpdb;
     384
     385        // Set the limit clause, if we got a limit
     386        if ($num) {
     387                $limit = "LIMIT $num";
     388        }
     389
     390        $sql = "SELECT * FROM $wpdb->posts WHERE post_type = 'post' ORDER BY post_date DESC $limit";
     391        $result = $wpdb->get_results($sql,ARRAY_A);
     392
     393        return $result?$result:array();
     394}
     395
     396function wp_get_single_post($postid = 0, $mode = OBJECT) {
     397        global $wpdb;
     398
     399        $post = get_post($postid, $mode);
     400
     401        // Set categories
     402        if($mode == OBJECT) {
     403                $post->post_category = wp_get_post_categories($postid);
     404        }
     405        else {
     406                $post['post_category'] = wp_get_post_categories($postid);
     407        }
     408
     409        return $post;
     410}
     411
    8412function wp_insert_post($postarr = array()) {
    9413        global $wpdb, $wp_rewrite, $allowedtags, $user_ID;
    … …  
    223627        return $post_ID;
    224628}
     629
     630function wp_update_post($postarr = array()) {
     631        global $wpdb;
     632
     633        if ( is_object($postarr) )
     634                $postarr = get_object_vars($postarr);
     635
     636        // First, get all of the original fields
     637        $post = wp_get_single_post($postarr['ID'], ARRAY_A);
     638
     639        // Escape data pulled from DB.
     640        $post = add_magic_quotes($post);
     641
     642        // Passed post category list overwrites existing category list if not empty.
     643        if ( isset($postarr['post_category']) && is_array($postarr['post_category'])
     644                         && 0 != count($postarr['post_category']) )
     645                $post_cats = $postarr['post_category'];
     646        else
     647                $post_cats = $post['post_category'];
     648
     649        // Drafts shouldn't be assigned a date unless explicitly done so by the user
     650        if ( 'draft' == $post['post_status'] && empty($postarr['edit_date']) && empty($postarr['post_date']) &&
     651             ('0000-00-00 00:00:00' == $post['post_date']) )
     652                $clear_date = true;
     653        else
     654                $clear_date = false;
     655
     656        // Merge old and new fields with new fields overwriting old ones.
     657        $postarr = array_merge($post, $postarr);
     658        $postarr['post_category'] = $post_cats;
     659        if ( $clear_date ) {
     660                $postarr['post_date'] = '';
     661                $postarr['post_date_gmt'] = '';
     662        }
     663
     664        if ($postarr['post_type'] == 'attachment')
     665                return wp_insert_attachment($postarr);
     666
     667        return wp_insert_post($postarr);
     668}
     669
     670function wp_publish_post($post_id) {
     671        $post = get_post($post_id);
     672
     673        if ( empty($post) )
     674                return;
     675
     676        if ( 'publish' == $post->post_status )
     677                return;
     678
     679        return wp_update_post(array('post_status' => 'publish', 'ID' => $post_id));     
     680}
     681
     682function wp_set_post_categories($post_ID = 0, $post_categories = array()) {
     683        global $wpdb;
     684        // If $post_categories isn't already an array, make it one:
     685        if (!is_array($post_categories) || 0 == count($post_categories))
     686                $post_categories = array(get_option('default_category'));
     687
     688        $post_categories = array_unique($post_categories);
     689
     690        // First the old categories
     691        $old_categories = $wpdb->get_col("
     692                SELECT category_id
     693                FROM $wpdb->post2cat
     694                WHERE post_id = $post_ID");
     695
     696        if (!$old_categories) {
     697                $old_categories = array();
     698        } else {
     699                $old_categories = array_unique($old_categories);
     700        }
     701
     702        // Delete any?
     703        $delete_cats = array_diff($old_categories,$post_categories);
     704
     705        if ($delete_cats) {
     706                foreach ($delete_cats as $del) {
     707                        $wpdb->query("
     708                                DELETE FROM $wpdb->post2cat
     709                                WHERE category_id = $del
     710                                        AND post_id = $post_ID
     711                                ");
     712                }
     713        }
     714
     715        // Add any?
     716        $add_cats = array_diff($post_categories, $old_categories);
     717
     718        if ($add_cats) {
     719                foreach ($add_cats as $new_cat) {
     720                        $wpdb->query("
     721                                INSERT INTO $wpdb->post2cat (post_id, category_id)
     722                                VALUES ($post_ID, $new_cat)");
     723                }
     724        }
     725
     726        // Update category counts.
     727        $all_affected_cats = array_unique(array_merge($post_categories, $old_categories));
     728        foreach ( $all_affected_cats as $cat_id ) {
     729                $count = $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->post2cat, $wpdb->posts WHERE $wpdb->posts.ID=$wpdb->post2cat.post_id AND post_status = 'publish' AND post_type = 'post' AND category_id = '$cat_id'");
     730                $wpdb->query("UPDATE $wpdb->categories SET category_count = '$count' WHERE cat_ID = '$cat_id'");
     731                wp_cache_delete($cat_id, 'category');
     732        }
     733}       // wp_set_post_categories()
     734
     735//
     736// Trackback and ping functions
     737//
     738
     739function add_ping($post_id, $uri) { // Add a URI to those already pung
     740        global $wpdb;
     741        $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
     742        $pung = trim($pung);
     743        $pung = preg_split('/\s/', $pung);
     744        $pung[] = $uri;
     745        $new = implode("\n", $pung);
     746        $new = apply_filters('add_ping', $new);
     747        return $wpdb->query("UPDATE $wpdb->posts SET pinged = '$new' WHERE ID = $post_id");
     748}
     749
     750function get_enclosed($post_id) { // Get enclosures already enclosed for a post
     751        global $wpdb;
     752        $custom_fields = get_post_custom( $post_id );
     753        $pung = array();
     754        if ( !is_array( $custom_fields ) )
     755                return $pung;
     756
     757        foreach ( $custom_fields as $key => $val ) {
     758                if ( 'enclosure' != $key || !is_array( $val ) )
     759                        continue;
     760                foreach( $val as $enc ) {
     761                        $enclosure = split( "\n", $enc );
     762                        $pung[] = trim( $enclosure[ 0 ] );
     763                }
     764        }
     765        $pung = apply_filters('get_enclosed', $pung);
     766        return $pung;
     767}
     768
     769function get_pung($post_id) { // Get URIs already pung for a post
     770        global $wpdb;
     771        $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
     772        $pung = trim($pung);
     773        $pung = preg_split('/\s/', $pung);
     774        $pung = apply_filters('get_pung', $pung);
     775        return $pung;
     776}
     777
     778function get_to_ping($post_id) { // Get any URIs in the todo list
     779        global $wpdb;
     780        $to_ping = $wpdb->get_var("SELECT to_ping FROM $wpdb->posts WHERE ID = $post_id");
     781        $to_ping = trim($to_ping);
     782        $to_ping = preg_split('/\s/', $to_ping, -1, PREG_SPLIT_NO_EMPTY);
     783        $to_ping = apply_filters('get_to_ping',  $to_ping);
     784        return $to_ping;
     785}
     786
     787// do trackbacks for a list of urls
     788// accepts a comma-separated list of trackback urls and a post id
     789function trackback_url_list($tb_list, $post_id) {
     790        if (!empty($tb_list)) {
     791                // get post data
     792                $postdata = wp_get_single_post($post_id, ARRAY_A);
     793
     794                // import postdata as variables
     795                extract($postdata);
     796
     797                // form an excerpt
     798                $excerpt = strip_tags($post_excerpt?$post_excerpt:$post_content);
     799
     800                if (strlen($excerpt) > 255) {
     801                        $excerpt = substr($excerpt,0,252) . '...';
     802                }
     803
     804                $trackback_urls = explode(',', $tb_list);
     805                foreach($trackback_urls as $tb_url) {
     806                    $tb_url = trim($tb_url);
     807                    trackback($tb_url, stripslashes($post_title), $excerpt, $post_id);
     808                }
     809    }
     810}
     811
     812//
     813// Page functions
     814//
     815
     816function get_all_page_ids() {
     817        global $wpdb;
     818
     819        if ( ! $page_ids = wp_cache_get('all_page_ids', 'pages') ) {
     820                $page_ids = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE post_type = 'page'");
     821                wp_cache_add('all_page_ids', $page_ids, 'pages');
     822        }
     823
     824        return $page_ids;
     825}
     826
     827
     828// Retrieves page data given a page ID or page object.
     829// Handles page caching.
     830function &get_page(&$page, $output = OBJECT) {
     831        global $wpdb;
     832
     833        if ( empty($page) ) {
     834                if ( isset($GLOBALS['page']) ) {
     835                        $_page = & $GLOBALS['page'];
     836                        wp_cache_add($_page->ID, $_page, 'pages');
     837                } else {
     838                        $_page = null;
     839                }
     840        } elseif ( is_object($page) ) {
     841                if ( 'post' == $page->post_type )
     842                        return get_post($page, $output);
     843                wp_cache_add($page->ID, $page, 'pages');
     844                $_page = $page;
     845        } else {
     846                if ( isset($GLOBALS['page']) && ($page == $GLOBALS['page']->ID) ) {
     847                        $_page = & $GLOBALS['page'];
     848                        wp_cache_add($_page->ID, $_page, 'pages');
     849                } elseif ( $_page = $GLOBALS['post_cache'][$page] ) {
     850                        return get_post($page, $output);
     851                } elseif ( $_page = wp_cache_get($page, 'pages') ) {
     852                        // Got it.
     853                } else {
     854                        $query = "SELECT * FROM $wpdb->posts WHERE ID= '$page' LIMIT 1";
     855                        $_page = & $wpdb->get_row($query);
     856                        if ( 'post' == $_page->post_type )
     857                                return get_post($_page, $output);
     858                        wp_cache_add($_page->ID, $_page, 'pages');
     859                }
     860        }
     861
     862        if ( $output == OBJECT ) {
     863                return $_page;
     864        } elseif ( $output == ARRAY_A ) {
     865                return get_object_vars($_page);
     866        } elseif ( $output == ARRAY_N ) {
     867                return array_values(get_object_vars($_page));
     868        } else {
     869                return $_page;
     870        }
     871}
     872
     873function get_page_by_path($page_path, $output = OBJECT) {
     874        global $wpdb;
     875        $page_path = rawurlencode(urldecode($page_path));
     876        $page_path = str_replace('%2F', '/', $page_path);
     877        $page_path = str_replace('%20', ' ', $page_path);
     878        $page_paths = '/' . trim($page_path, '/');
     879        $leaf_path  = sanitize_title(basename($page_paths));
     880        $page_paths = explode('/', $page_paths);
     881        foreach($page_paths as $pathdir)
     882                $full_path .= ($pathdir!=''?'/':'') . sanitize_title($pathdir);
     883
     884        $pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_name = '$leaf_path' AND post_type='page'");
     885
     886        if ( empty($pages) )
     887                return NULL;
     888
     889        foreach ($pages as $page) {
     890                $path = '/' . $leaf_path;
     891                $curpage = $page;
     892                while ($curpage->post_parent != 0) {
     893                        $curpage = $wpdb->get_row("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE ID = '$curpage->post_parent' and post_type='page'");
     894                        $path = '/' . $curpage->post_name . $path;
     895                }
     896
     897                if ( $path == $full_path )
     898                        return get_page($page->ID, $output);
     899        }
     900
     901        return NULL;
     902}
     903
     904function &get_page_children($page_id, $pages) {
     905        global $page_cache;
     906
     907        if ( empty($pages) )
     908                $pages = &$page_cache;
     909
     910        $page_list = array();
     911        foreach ( $pages as $page ) {
     912                if ( $page->post_parent == $page_id ) {
     913                        $page_list[] = $page;
     914                        if ( $children = get_page_children($page->ID, $pages) )
     915                                $page_list = array_merge($page_list, $children);
     916                }
     917        }
     918        return $page_list;
     919}
     920
     921//fetches the pages returned as a FLAT list, but arranged in order of their hierarchy, i.e., child parents
     922//immediately follow their parents
     923function get_page_hierarchy($posts, $parent = 0) {
     924        $result = array ( );
     925        if ($posts) { foreach ($posts as $post) {
     926                if ($post->post_parent == $parent) {
     927                        $result[$post->ID] = $post->post_name;
     928                        $children = get_page_hierarchy($posts, $post->ID);
     929                        $result += $children; //append $children to $result
     930                }
     931        } }
     932        return $result;
     933}
     934
     935function &get_pages($args = '') {
     936        global $wpdb;
     937
     938        if ( is_array($args) )
     939                $r = &$args;
     940        else
     941                parse_str($args, $r);
     942
     943        $defaults = array('child_of' => 0, 'sort_order' => 'ASC', 'sort_column' => 'post_title',
     944                                'hierarchical' => 1, 'exclude' => '', 'include' => '', 'meta_key' => '', 'meta_value' => '');
     945        $r = array_merge($defaults, $r);
     946        extract($r);
     947
     948        $inclusions = '';
     949        if ( !empty($include) ) {
     950                $child_of = 0; //ignore child_of, exclude, meta_key, and meta_value params if using include
     951                $exclude = ''; 
     952                $meta_key = '';
     953                $meta_value = '';
     954                $incpages = preg_split('/[\s,]+/',$include);
     955                if ( count($incpages) ) {
     956                        foreach ( $incpages as $incpage ) {
     957                                if (empty($inclusions))
     958                                        $inclusions = ' AND ( ID = ' . intval($incpage) . ' ';
     959                                else
     960                                        $inclusions .= ' OR ID = ' . intval($incpage) . ' ';
     961                        }
     962                }
     963        }
     964        if (!empty($inclusions))
     965                $inclusions .= ')';     
     966
     967        $exclusions = '';
     968        if ( !empty($exclude) ) {
     969                $expages = preg_split('/[\s,]+/',$exclude);
     970                if ( count($expages) ) {
     971                        foreach ( $expages as $expage ) {
     972                                if (empty($exclusions))
     973                                        $exclusions = ' AND ( ID <> ' . intval($expage) . ' ';
     974                                else
     975                                        $exclusions .= ' AND ID <> ' . intval($expage) . ' ';
     976                        }
     977                }
     978        }
     979        if (!empty($exclusions))
     980                $exclusions .= ')';
     981
     982        $query = "SELECT * FROM $wpdb->posts " ;
     983        $query .= ( empty( $meta_key ) ? "" : ", $wpdb->postmeta " ) ;
     984        $query .= " WHERE (post_type = 'page' AND post_status = 'publish') $exclusions $inclusions " ;
     985        $query .= ( empty( $meta_key ) | empty($meta_value)  ? "" : " AND ($wpdb->posts.ID = $wpdb->postmeta.post_id AND $wpdb->postmeta.meta_key = '$meta_key' AND $wpdb->postmeta.meta_value = '$meta_value' )" ) ;
     986        $query .= " ORDER BY " . $sort_column . " " . $sort_order ;
     987
     988        $pages = $wpdb->get_results($query);
     989        $pages = apply_filters('get_pages', $pages, $r);
     990
     991        if ( empty($pages) )
     992                return array();
     993
     994        // Update cache.
     995        update_page_cache($pages);
     996
     997        if ( $child_of || $hierarchical )
     998                $pages = & get_page_children($child_of, $pages);
     999
     1000        return $pages;
     1001}
     1002
     1003function generate_page_uri_index() {
     1004        global $wpdb;
     1005
     1006        //get pages in order of hierarchy, i.e. children after parents
     1007        $posts = get_page_hierarchy($wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page'"));
     1008        //now reverse it, because we need parents after children for rewrite rules to work properly
     1009        $posts = array_reverse($posts, true);
     1010
     1011        $page_uris = array();
     1012        $page_attachment_uris = array();
     1013
     1014        if ($posts) {
     1015
     1016                foreach ($posts as $id => $post) {
     1017
     1018                        // URI => page name
     1019                        $uri = get_page_uri($id);
     1020                        $attachments = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = '$id'");
     1021                        if ( $attachments ) {
     1022                                foreach ( $attachments as $attachment ) {
     1023                                        $attach_uri = get_page_uri($attachment->ID);
     1024                                        $page_attachment_uris[$attach_uri] = $attachment->ID;
     1025                                }
     1026                        }
     1027
     1028                        $page_uris[$uri] = $id;
     1029                }
     1030
     1031                update_option('page_uris', $page_uris);
     1032
     1033                if ( $page_attachment_uris )
     1034                        update_option('page_attachment_uris', $page_attachment_uris);
     1035        }
     1036}
     1037
     1038//
     1039// Attachment functions
     1040//
    2251041
    2261042function wp_insert_attachment($object, $file = false, $post_parent = 0) {
    … …  
    4051221}
    4061222
    407 function wp_get_single_post($postid = 0, $mode = OBJECT) {
    408         global $wpdb;
    409 
    410         $post = get_post($postid, $mode);
    411 
    412         // Set categories
    413         if($mode == OBJECT) {
    414                 $post->post_category = wp_get_post_categories($postid);
    415         }
    416         else {
    417                 $post['post_category'] = wp_get_post_categories($postid);
    418         }
    419 
    420         return $post;
    421 }
    422 
    423 function wp_get_recent_posts($num = 10) {
    424         global $wpdb;
    425 
    426         // Set the limit clause, if we got a limit
    427         if ($num) {
    428                 $limit = "LIMIT $num";
    429         }
    430 
    431         $sql = "SELECT * FROM $wpdb->posts WHERE post_type = 'post' ORDER BY post_date DESC $limit";
    432         $result = $wpdb->get_results($sql,ARRAY_A);
    433 
    434         return $result?$result:array();
    435 }
    436 
    437 function wp_update_post($postarr = array()) {
    438         global $wpdb;
    439 
    440         if ( is_object($postarr) )
    441                 $postarr = get_object_vars($postarr);
    442 
    443         // First, get all of the original fields
    444         $post = wp_get_single_post($postarr['ID'], ARRAY_A);
    445 
    446         // Escape data pulled from DB.
    447         $post = add_magic_quotes($post);
    448 
    449         // Passed post category list overwrites existing category list if not empty.
    450         if ( isset($postarr['post_category']) && is_array($postarr['post_category'])
    451                          && 0 != count($postarr['post_category']) )
    452                 $post_cats = $postarr['post_category'];
    453         else
    454                 $post_cats = $post['post_category'];
    455 
    456         // Drafts shouldn't be assigned a date unless explicitly done so by the user
    457         if ( 'draft' == $post['post_status'] && empty($postarr['edit_date']) && empty($postarr['post_date']) &&
    458              ('0000-00-00 00:00:00' == $post['post_date']) )
    459                 $clear_date = true;
    460         else
    461                 $clear_date = false;
    462 
    463         // Merge old and new fields with new fields overwriting old ones.
    464         $postarr = array_merge($post, $postarr);
    465         $postarr['post_category'] = $post_cats;
    466         if ( $clear_date ) {
    467                 $postarr['post_date'] = '';
    468                 $postarr['post_date_gmt'] = '';
    469         }
    470 
    471         if ($postarr['post_type'] == 'attachment')
    472                 return wp_insert_attachment($postarr);
    473 
    474         return wp_insert_post($postarr);
    475 }
    476 
    477 function wp_publish_post($post_id) {
    478         $post = get_post($post_id);
    479 
    480         if ( empty($post) )
    481                 return;
    482 
    483         if ( 'publish' == $post->post_status )
    484                 return;
    485 
    486         return wp_update_post(array('post_status' => 'publish', 'ID' => $post_id));     
    487 }
    488 
    489 function wp_get_post_categories($post_ID = 0) {
    490         global $wpdb;
    491 
    492         $post_ID = (int) $post_ID;
    493 
    494         $sql = "SELECT category_id
    495                 FROM $wpdb->post2cat
    496                 WHERE post_id = '$post_ID'
    497                 ORDER BY category_id";
    498 
    499         $result = $wpdb->get_col($sql);
    500 
    501         if ( !$result )
    502                 $result = array();
    503 
    504         return array_unique($result);
    505 }
    506 
    507 function wp_set_post_categories($post_ID = 0, $post_categories = array()) {
    508         global $wpdb;
    509         // If $post_categories isn't already an array, make it one:
    510         if (!is_array($post_categories) || 0 == count($post_categories))
    511                 $post_categories = array(get_option('default_category'));
    512 
    513         $post_categories = array_unique($post_categories);
    514 
    515         // First the old categories
    516         $old_categories = $wpdb->get_col("
    517                 SELECT category_id
    518                 FROM $wpdb->post2cat
    519                 WHERE post_id = $post_ID");
    520 
    521         if (!$old_categories) {
    522                 $old_categories = array();
    523         } else {
    524                 $old_categories = array_unique($old_categories);
    525         }
    526 
    527         // Delete any?
    528         $delete_cats = array_diff($old_categories,$post_categories);
    529 
    530         if ($delete_cats) {
    531                 foreach ($delete_cats as $del) {
    532                         $wpdb->query("
    533                                 DELETE FROM $wpdb->post2cat
    534                                 WHERE category_id = $del
    535                                         AND post_id = $post_ID
    536                                 ");
    537                 }
    538         }
    539 
    540         // Add any?
    541         $add_cats = array_diff($post_categories, $old_categories);
    542 
    543         if ($add_cats) {
    544                 foreach ($add_cats as $new_cat) {
    545                         $wpdb->query("
    546                                 INSERT INTO $wpdb->post2cat (post_id, category_id)
    547                                 VALUES ($post_ID, $new_cat)");
    548                 }
    549         }
    550 
    551         // Update category counts.
    552         $all_affected_cats = array_unique(array_merge($post_categories, $old_categories));
    553         foreach ( $all_affected_cats as $cat_id ) {
    554                 $count = $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->post2cat, $wpdb->posts WHERE $wpdb->posts.ID=$wpdb->post2cat.post_id AND post_status = 'publish' AND post_type = 'post' AND category_id = '$cat_id'");
    555                 $wpdb->query("UPDATE $wpdb->categories SET category_count = '$count' WHERE cat_ID = '$cat_id'");
    556                 wp_cache_delete($cat_id, 'category');
    557         }
    558 }       // wp_set_post_categories()
    559 
    560 function wp_delete_post($postid = 0) {
    561         global $wpdb, $wp_rewrite;
    562         $postid = (int) $postid;
    563 
    564         if ( !$post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $postid") )
    565                 return $post;
    566 
    567         if ( 'attachment' == $post->post_type )
    568                 return wp_delete_attachment($postid);
    569 
    570         do_action('delete_post', $postid);
    571 
    572         if ( 'publish' == $post->post_status && 'post' == $post->post_type ) {
    573                 $categories = wp_get_post_categories($post->ID);
    574                 if( is_array( $categories ) ) {
    575                         foreach ( $categories as $cat_id ) {
    576                                 $wpdb->query("UPDATE $wpdb->categories SET category_count = category_count - 1 WHERE cat_ID = '$cat_id'");
    577                                 wp_cache_delete($cat_id, 'category');
    578                         }
    579                 }
    580         }
    581 
    582         if ( 'page' == $post->post_type )
    583                 $wpdb->query("UPDATE $wpdb->posts SET post_parent = $post->post_parent WHERE post_parent = $postid AND post_type = 'page'");
    584 
    585         $wpdb->query("DELETE FROM $wpdb->posts WHERE ID = $postid");
    586 
    587         $wpdb->query("DELETE FROM $wpdb->comments WHERE comment_post_ID = $postid");
    588 
    589         $wpdb->query("DELETE FROM $wpdb->post2cat WHERE post_id = $postid");
    590 
    591         $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = $postid");
    592 
    593         if ( 'page' == $post->type ) {
    594                 wp_cache_delete('all_page_ids', 'pages');
    595                 $wp_rewrite->flush_rules();
    596         }
    597 
    598         return $post;
    599 }
    600 
    601 /**** /DB Functions ****/
    602 
    603 /**** Misc ****/
    604 
    605 // get permalink from post ID
    606 function post_permalink($post_id = 0, $mode = '') { // $mode legacy
    607         return get_permalink($post_id);
    608 }
    609 
    610 // Get author's preferred display name
    611 function get_author_name( $auth_id ) {
    612         $authordata = get_userdata( $auth_id );
    613 
    614         return $authordata->display_name;
    615 }
    616 
    617 // get extended entry info (<!--more-->)
    618 function get_extended($post) {
    619         list($main,$extended) = explode('<!--more-->', $post, 2);
    620 
    621         // Strip leading and trailing whitespace
    622         $main = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$main);
    623         $extended = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$extended);
    624 
    625         return array('main' => $main, 'extended' => $extended);
    626 }
    627 
    628 // do trackbacks for a list of urls
    629 // borrowed from edit.php
    630 // accepts a comma-separated list of trackback urls and a post id
    631 function trackback_url_list($tb_list, $post_id) {
    632         if (!empty($tb_list)) {
    633                 // get post data
    634                 $postdata = wp_get_single_post($post_id, ARRAY_A);
    635 
    636                 // import postdata as variables
    637                 extract($postdata);
    638 
    639                 // form an excerpt
    640                 $excerpt = strip_tags($post_excerpt?$post_excerpt:$post_content);
    641 
    642                 if (strlen($excerpt) > 255) {
    643                         $excerpt = substr($excerpt,0,252) . '...';
    644                 }
    645 
    646                 $trackback_urls = explode(',', $tb_list);
    647                 foreach($trackback_urls as $tb_url) {
    648                     $tb_url = trim($tb_url);
    649                     trackback($tb_url, stripslashes($post_title), $excerpt, $post_id);
    650                 }
    651     }
    652 }
    653 
    654 function wp_blacklist_check($author, $email, $url, $comment, $user_ip, $user_agent) {
    655         global $wpdb;
    656 
    657         do_action('wp_blacklist_check', $author, $email, $url, $comment, $user_ip, $user_agent);
    658 
    659         if ( preg_match_all('/&#(\d+);/', $comment . $author . $url, $chars) ) {
    660                 foreach ($chars[1] as $char) {
    661                         // If it's an encoded char in the normal ASCII set, reject
    662                         if ( 38 == $char )
    663                                 continue; // Unless it's &
    664                         if ($char < 128)
    665                                 return true;
    666                 }
    667         }
    668 
    669         $mod_keys = trim( get_settings('blacklist_keys') );
    670         if ('' == $mod_keys )
    671                 return false; // If moderation keys are empty
    672         $words = explode("\n", $mod_keys );
    673 
    674         foreach ($words as $word) {
    675                 $word = trim($word);
    676 
    677                 // Skip empty lines
    678                 if ( empty($word) ) { continue; }
    679 
    680                 // Do some escaping magic so that '#' chars in the
    681                 // spam words don't break things:
    682                 $word = preg_quote($word, '#');
    683 
    684                 $pattern = "#$word#i";
    685                 if ( preg_match($pattern, $author    ) ) return true;
    686                 if ( preg_match($pattern, $email     ) ) return true;
    687                 if ( preg_match($pattern, $url       ) ) return true;
    688                 if ( preg_match($pattern, $comment   ) ) return true;
    689                 if ( preg_match($pattern, $user_ip   ) ) return true;
    690                 if ( preg_match($pattern, $user_agent) ) return true;
    691         }
    692 
    693         if ( isset($_SERVER['REMOTE_ADDR']) ) {
    694                 if ( wp_proxy_check($_SERVER['REMOTE_ADDR']) ) return true;
    695         }
    696 
    697         return false;
    698 }
    699 
    700 function wp_proxy_check($ipnum) {
    701         if ( get_option('open_proxy_check') && isset($ipnum) ) {
    702                 $rev_ip = implode( '.', array_reverse( explode( '.', $ipnum ) ) );
    703                 $lookup = $rev_ip . '.opm.blitzed.org.';
    704                 if ( $lookup != gethostbyname( $lookup ) )
    705                         return true;
    706         }
    707 
    708         return false;
    709 }
    710 
    711 function do_trackbacks($post_id) {
    712         global $wpdb;
    713 
    714         $post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $post_id");
    715         $to_ping = get_to_ping($post_id);
    716         $pinged  = get_pung($post_id);
    717         if ( empty($to_ping) ) {
    718                 $wpdb->query("UPDATE $wpdb->posts SET to_ping = '' WHERE ID = '$post_id'");
    719                 return;
    720         }
    721 
    722         if (empty($post->post_excerpt))
    723                 $excerpt = apply_filters('the_content', $post->post_content);
    724         else
    725                 $excerpt = apply_filters('the_excerpt', $post->post_excerpt);
    726         $excerpt = str_replace(']]>', ']]&gt;', $excerpt);
    727         $excerpt = strip_tags($excerpt);
    728         if ( function_exists('mb_strcut') ) // For international trackbacks
    729         $excerpt = mb_strcut($excerpt, 0, 252, get_settings('blog_charset')) . '...';
    730         else
    731                 $excerpt = substr($excerpt, 0, 252) . '...';
    732 
    733         $post_title = apply_filters('the_title', $post->post_title);
    734         $post_title = strip_tags($post_title);
    735 
    736         if ($to_ping) : foreach ($to_ping as $tb_ping) :
    737                 $tb_ping = trim($tb_ping);
    738                 if ( !in_array($tb_ping, $pinged) ) {
    739                         trackback($tb_ping, $post_title, $excerpt, $post_id);
    740                         $pinged[] = $tb_ping;
    741                 } else {
    742                         $wpdb->query("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, '$tb_ping', '')) WHERE ID = '$post_id'");
    743                 }
    744         endforeach; endif;
    745 }
    746 
    747 function get_pung($post_id) { // Get URIs already pung for a post
    748         global $wpdb;
    749         $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
    750         $pung = trim($pung);
    751         $pung = preg_split('/\s/', $pung);
    752         $pung = apply_filters('get_pung', $pung);
    753         return $pung;
    754 }
    755 
    756 function get_enclosed($post_id) { // Get enclosures already enclosed for a post
    757         global $wpdb;
    758         $custom_fields = get_post_custom( $post_id );
    759         $pung = array();
    760         if ( !is_array( $custom_fields ) )
    761                 return $pung;
    762 
    763         foreach ( $custom_fields as $key => $val ) {
    764                 if ( 'enclosure' != $key || !is_array( $val ) )
    765                         continue;
    766                 foreach( $val as $enc ) {
    767                         $enclosure = split( "\n", $enc );
    768                         $pung[] = trim( $enclosure[ 0 ] );
    769                 }
    770         }
    771         $pung = apply_filters('get_enclosed', $pung);
    772         return $pung;
    773 }
    774 
    775 function get_to_ping($post_id) { // Get any URIs in the todo list
    776         global $wpdb;
    777         $to_ping = $wpdb->get_var("SELECT to_ping FROM $wpdb->posts WHERE ID = $post_id");
    778         $to_ping = trim($to_ping);
    779         $to_ping = preg_split('/\s/', $to_ping, -1, PREG_SPLIT_NO_EMPTY);
    780         $to_ping = apply_filters('get_to_ping',  $to_ping);
    781         return $to_ping;
    782 }
    783 
    784 function add_ping($post_id, $uri) { // Add a URI to those already pung
    785         global $wpdb;
    786         $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
    787         $pung = trim($pung);
    788         $pung = preg_split('/\s/', $pung);
    789         $pung[] = $uri;
    790         $new = implode("\n", $pung);
    791         $new = apply_filters('add_ping', $new);
    792         return $wpdb->query("UPDATE $wpdb->posts SET pinged = '$new' WHERE ID = $post_id");
    793 }
    794 
    795 //fetches the pages returned as a FLAT list, but arranged in order of their hierarchy, i.e., child parents
    796 //immediately follow their parents
    797 function get_page_hierarchy($posts, $parent = 0) {
    798         $result = array ( );
    799         if ($posts) { foreach ($posts as $post) {
    800                 if ($post->post_parent == $parent) {
    801                         $result[$post->ID] = $post->post_name;
    802                         $children = get_page_hierarchy($posts, $post->ID);
    803                         $result += $children; //append $children to $result
    804                 }
    805         } }
    806         return $result;
    807 }
    808 
    809 function generate_page_uri_index() {
    810         global $wpdb;
    811 
    812         //get pages in order of hierarchy, i.e. children after parents
    813         $posts = get_page_hierarchy($wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page'"));
    814         //now reverse it, because we need parents after children for rewrite rules to work properly
    815         $posts = array_reverse($posts, true);
    816 
    817         $page_uris = array();
    818         $page_attachment_uris = array();
    819 
    820         if ($posts) {
    821 
    822                 foreach ($posts as $id => $post) {
    823 
    824                         // URI => page name
    825                         $uri = get_page_uri($id);
    826                         $attachments = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = '$id'");
    827                         if ( $attachments ) {
    828                                 foreach ( $attachments as $attachment ) {
    829                                         $attach_uri = get_page_uri($attachment->ID);
    830                                         $page_attachment_uris[$attach_uri] = $attachment->ID;
    831                                 }
    832                         }
    833 
    834                         $page_uris[$uri] = $id;
    835                 }
    836 
    837                 update_option('page_uris', $page_uris);
    838 
    839                 if ( $page_attachment_uris )
    840                         update_option('page_attachment_uris', $page_attachment_uris);
    841         }
    842 }
    843 
    844 function get_post_status($ID = '') {
    845         $post = get_post($ID);
    846 
    847         if ( is_object($post) ) {
    848                 if ( ('attachment' == $post->post_type) && $post->post_parent && ($post->ID != $post->post_parent) )
    849                         return get_post_status($post->post_parent);
    850                 else
    851                         return $post->post_status;
    852         }
    853 
    854         return false;
    855 }
    856 
    857 function get_post_type($post = false) {
    858         global $wpdb, $posts;
    859 
    860         if ( false === $post )
    861                 $post = $posts[0];
    862         elseif ( (int) $post )
    863                 $post = get_post($post, OBJECT);
    864 
    865         if ( is_object($post) )
    866                 return $post->post_type;
    867 
    868         return false;
    869 }
    870 
    871 // Takes a post ID, returns its mime type.
    872 function get_post_mime_type($ID = '') {
    873         $post = & get_post($ID);
    874 
    875         if ( is_object($post) )
    876                 return $post->post_mime_type;
    877 
    878         return false;
    879 }
    880 
    881 function get_attached_file($attachment_id) {
    882         return get_post_meta($attachment_id, '_wp_attached_file', true);
    883 }
    884 
    885 function wp_mkdir_p($target) {
    886         // from php.net/mkdir user contributed notes
    887         if (file_exists($target)) {
    888                 if (! @ is_dir($target))
    889                         return false;
    890                 else
    891                         return true;
    892         }
    893 
    894         // Attempting to create the directory may clutter up our display.
    895         if (@ mkdir($target)) {
    896                 $stat = @ stat(dirname($target));
    897                 $dir_perms = $stat['mode'] & 0007777;  // Get the permission bits.
    898                 @ chmod($target, $dir_perms);
    899                 return true;
    900         } else {
    901                 if ( is_dir(dirname($target)) )
    902                         return false;
    903         }
    904 
    905         // If the above failed, attempt to create the parent node, then try again.
    906         if (wp_mkdir_p(dirname($target)))
    907                 return wp_mkdir_p($target);
    908 
    909         return false;
    910 }
    911 
    912 // Returns an array containing the current upload directory's path and url, or an error message.
    913 function wp_upload_dir() {
    914         $siteurl = get_settings('siteurl');
    915         //prepend ABSPATH to $dir and $siteurl to $url if they're not already there
    916         $path = str_replace(ABSPATH, '', trim(get_settings('upload_path')));
    917         $dir = ABSPATH . $path;
    918         $url = trailingslashit($siteurl) . $path;
    919 
    920         if ( $dir == ABSPATH ) { //the option was empty
    921                 $dir = ABSPATH . 'wp-content/uploads';
    922         }
    923 
    924         if ( defined('UPLOADS') ) {
    925                 $dir = ABSPATH . UPLOADS;
    926                 $url = trailingslashit($siteurl) . UPLOADS;
    927         }
    928 
    929         if ( get_settings('uploads_use_yearmonth_folders')) {
    930                 // Generate the yearly and monthly dirs
    931                 $time = current_time( 'mysql' );
    932                 $y = substr( $time, 0, 4 );
    933                 $m = substr( $time, 5, 2 );
    934                 $dir = $dir . "/$y/$m";
    935                 $url = $url . "/$y/$m";
    936         }
    937 
    938         // Make sure we have an uploads dir
    939         if ( ! wp_mkdir_p( $dir ) ) {
    940                 $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), $dir);
    941                 return array('error' => $message);
    942         }
    943 
    944     $uploads = array('path' => $dir, 'url' => $url, 'error' => false);
    945         return apply_filters('upload_dir', $uploads);
    946 }
    947 
    948 function wp_upload_bits($name, $type, $bits) {
    949         if ( empty($name) )
    950                 return array('error' => "Empty filename");
    951 
    952         $upload = wp_upload_dir();
    953 
    954         if ( $upload['error'] !== false )
    955                 return $upload;
    956 
    957         $number = '';
    958         $filename = $name;
    959         $path_parts = pathinfo($filename);
    960         $ext = $path_parts['extension'];
    961         if ( empty($ext) )
    962                 $ext = '';
    963         else
    964                 $ext = ".$ext";
    965         while ( file_exists($upload['path'] . "/$filename") ) {
    966                 if ( '' == "$number$ext" )
    967                         $filename = $filename . ++$number . $ext;
    968                 else
    969                         $filename = str_replace("$number$ext", ++$number . $ext, $filename);
    970         }
    971 
    972         $new_file = $upload['path'] . "/$filename";
    973         if ( ! wp_mkdir_p( dirname($new_file) ) ) {
    974                 $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), dirname($new_file));
    975                 return array('error' => $message);
    976         }
    977 
    978         $ifp = @ fopen($new_file, 'wb');
    979         if ( ! $ifp )
    980                 return array('error' => "Could not write file $new_file.");
    981 
    982         $success = @ fwrite($ifp, $bits);
    983         fclose($ifp);
    984         // Set correct file permissions
    985         $stat = @ stat(dirname($new_file));
    986         $perms = $stat['mode'] & 0007777;
    987         $perms = $perms & 0000666;
    988         @ chmod($new_file, $perms);
    989 
    990         // Compute the URL
    991         $url = $upload['url'] . "/$filename";
    992 
    993         return array('file' => $new_file, 'url' => $url, 'error' => false);
    994 }
    995 
    996 function do_all_pings() {
    997         global $wpdb;
    998 
    999         // Do pingbacks
    1000         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")) {
    1001                 $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$ping->ID} AND meta_key = '_pingme';");
    1002                 pingback($ping->post_content, $ping->ID);
    1003         }
    1004        
    1005         // Do Enclosures
    1006         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")) {
    1007                 $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$enclosure->ID} AND meta_key = '_encloseme';");
    1008                 do_enclose($enclosure->post_content, $enclosure->ID);
    1009         }
    1010 
    1011         // Do Trackbacks
    1012         $trackbacks = $wpdb->get_results("SELECT ID FROM $wpdb->posts WHERE CHAR_LENGTH(TRIM(to_ping)) > 7 AND post_status = 'publish'");
    1013         if ( is_array($trackbacks) ) {
    1014                 foreach ( $trackbacks as $trackback ) {
    1015                         do_trackbacks($trackback->ID);
    1016                 }
    1017         }
    1018 
    1019         //Do Update Services/Generic Pings
    1020         generic_ping();
    1021 }
    1022 
    1023 /**
    1024  * Places a textarea according to the current user's preferences, filled with $content.
    1025  * Also places a script block that enables tabbing between Title and Content.
    1026  *
    1027  * @param string Editor contents
    1028  * @param string (optional) Previous form field's ID (for tabbing support)
    1029  */
    1030 function the_editor($content, $id = 'content', $prev_id = 'title') {
    1031         $rows = get_settings('default_post_edit_rows');
    1032         if (($rows < 3) || ($rows > 100))
    1033                 $rows = 12;
    1034 
    1035         $rows = "rows='$rows'";
    1036 
    1037         the_quicktags();
    1038 
    1039         if ( user_can_richedit() )
    1040                 add_filter('the_editor_content', 'wp_richedit_pre');
    1041 
    1042         $the_editor = apply_filters('the_editor', "<div><textarea class='mceEditor' $rows cols='40' name='$id' tabindex='2' id='$id'>%s</textarea></div>\n");
    1043         $the_editor_content = apply_filters('the_editor_content', $content);
    1044 
    1045         printf($the_editor, $the_editor_content);
    1046 
    1047         ?>
    1048         <script type="text/javascript">
    1049         //<!--
    1050         edCanvas = document.getElementById('<?php echo $id; ?>');
    1051         <?php if ( user_can_richedit() ) : ?>
    1052         // This code is meant to allow tabbing from Title to Post (TinyMCE).
    1053         if ( tinyMCE.isMSIE )
    1054                 document.getElementById('<?php echo $prev_id; ?>').onkeydown = function (e)
    1055                         {
    1056                                 e = e ? e : window.event;
    1057                                 if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
    1058                                         var i = tinyMCE.selectedInstance;
    1059                                         if(typeof i ==  'undefined')
    1060                                                 return true;
    1061                                         tinyMCE.execCommand("mceStartTyping");
    1062                                         this.blur();
    1063                                         i.contentWindow.focus();
    1064                                         e.returnValue = false;
    1065                                         return false;
    1066                                 }
    1067                         }
    1068         else
    1069                 document.getElementById('<?php echo $prev_id; ?>').onkeypress = function (e)
    1070                         {
    1071                                 e = e ? e : window.event;
    1072                                 if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
    1073                                         var i = tinyMCE.selectedInstance;
    1074                                         if(typeof i ==  'undefined')
    1075                                                 return true;
    1076                                         tinyMCE.execCommand("mceStartTyping");
    1077                                         this.blur();
    1078                                         i.contentWindow.focus();
    1079                                         e.returnValue = false;
    1080                                         return false;
    1081                                 }
    1082                         }
    1083         <?php endif; ?>
    1084         //-->
    1085         </script>
    1086         <?php
    1087 }
    1088 
    10891223?>
  • trunk/wp-includes/template-functions-author.php

    r3848 r3851  
    156156}
    157157
     158// Get author's preferred display name
     159function get_author_name( $auth_id ) {
     160        $authordata = get_userdata( $auth_id );
     161
     162        return $authordata->display_name;
     163}
     164
    158165function wp_list_authors($args = '') {
    159166        if ( is_array($args) )
  • trunk/wp-includes/template-functions-general.php

    r3740 r3851  
    695695}
    696696
     697function wp_head() {
     698        do_action('wp_head');
     699}
     700
     701function wp_footer() {
     702        do_action('wp_footer');
     703}
     704
    697705function rsd_link() {
    698706        echo '<link rel="EditURI" type="application/rsd+xml" title="RSD" href="' . get_bloginfo('wpurl') . "/xmlrpc.php?rsd\" />\n";
    … …  
    704712                echo '<meta name="robots" content="noindex,nofollow" />' . "\n";
    705713}
     714
     715/**
     716 * Places a textarea according to the current user's preferences, filled with $content.
     717 * Also places a script block that enables tabbing between Title and Content.
     718 *
     719 * @param string Editor contents
     720 * @param string (optional) Previous form field's ID (for tabbing support)
     721 */
     722function the_editor($content, $id = 'content', $prev_id = 'title') {
     723        $rows = get_settings('default_post_edit_rows');
     724        if (($rows < 3) || ($rows > 100))
     725                $rows = 12;
     726
     727        $rows = "rows='$rows'";
     728
     729        the_quicktags();
     730
     731        if ( user_can_richedit() )
     732                add_filter('the_editor_content', 'wp_richedit_pre');
     733
     734        $the_editor = apply_filters('the_editor', "<div><textarea class='mceEditor' $rows cols='40' name='$id' tabindex='2' id='$id'>%s</textarea></div>\n");
     735        $the_editor_content = apply_filters('the_editor_content', $content);
     736
     737        printf($the_editor, $the_editor_content);
     738
     739        ?>
     740        <script type="text/javascript">
     741        //<!--
     742        edCanvas = document.getElementById('<?php echo $id; ?>');
     743        <?php if ( user_can_richedit() ) : ?>
     744        // This code is meant to allow tabbing from Title to Post (TinyMCE).
     745        if ( tinyMCE.isMSIE )
     746                document.getElementById('<?php echo $prev_id; ?>').onkeydown = function (e)
     747                        {
     748                                e = e ? e : window.event;
     749                                if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
     750                                        var i = tinyMCE.selectedInstance;
     751                                        if(typeof i ==  'undefined')
     752                                                return true;
     753                                        tinyMCE.execCommand("mceStartTyping");
     754                                        this.blur();
     755                                        i.contentWindow.focus();
     756                                        e.returnValue = false;
     757                                        return false;
     758                                }
     759                        }
     760        else
     761                document.getElementById('<?php echo $prev_id; ?>').onkeypress = function (e)
     762                        {
     763                                e = e ? e : window.event;
     764                                if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
     765                                        var i = tinyMCE.selectedInstance;
     766                                        if(typeof i ==  'undefined')
     767                                                return true;
     768                                        tinyMCE.execCommand("mceStartTyping");
     769                                        this.blur();
     770                                        i.contentWindow.focus();
     771                                        e.returnValue = false;
     772                                        return false;
     773                                }
     774                        }
     775        <?php endif; ?>
     776        //-->
     777        </script>
     778        <?php
     779}
     780
    706781?>
  • trunk/wp-includes/template-functions-links.php

    r3708 r3851  
    8585}
    8686
     87// get permalink from post ID
     88function post_permalink($post_id = 0, $mode = '') { // $mode legacy
     89        return get_permalink($post_id);
     90}
     91
    8792function get_page_link($id = false) {
    8893        global $post, $wp_rewrite;
  • trunk/wp-settings.php

    r3845 r3851  
    125125
    126126require (ABSPATH . WPINC . '/functions-formatting.php');
    127 require (ABSPATH . WPINC . '/functions-post.php');
    128127require (ABSPATH . WPINC . '/capabilities.php');
    129128require (ABSPATH . WPINC . '/classes.php');
    … …  
    133132require (ABSPATH . WPINC . '/template-functions-links.php');
    134133require (ABSPATH . WPINC . '/template-functions-author.php');
    135 require (ABSPATH . WPINC . '/template-functions-post.php');
     134require (ABSPATH . WPINC . '/post.php');
     135require (ABSPATH . WPINC . '/post-template.php');
    136136require (ABSPATH . WPINC . '/category.php');
    137137require (ABSPATH . WPINC . '/category-template.php');
Note: See TracChangeset for help on using the changeset viewer.