root/trunk/wp-includes/post.php

<?php
/**
 * Post functions and post utility function.
 *
 * @package WordPress
 * @subpackage Post
 * @since 1.5.0
 */

/**
 * Retrieve attached file path based on attachment ID.
 *
 * You can optionally send it through the 'get_attached_file' filter, but by
 * default it will just return the file path unfiltered.
 *
 * The function works by getting the single post meta name, named
 * '_wp_attached_file' and returning it. This is a convenience function to
 * prevent looking up the meta name and provide a mechanism for sending the
 * attached filename through a filter.
 *
 * @since 2.0.0
 * @uses apply_filters() Calls 'get_attached_file' on file path and attachment ID.
 *
 * @param int $attachment_id Attachment ID
 * @param bool $unfiltered Whether to apply filters or not
 * @return string The file path to the attached file.
 */
function get_attached_file( $attachment_id, $unfiltered = false ) {
    $file = get_post_meta( $attachment_id, '_wp_attached_file', true );
    // If the file is relative, prepend upload dir
    if ( 0 !== strpos($file, '/') ) {
        $uploads = wp_upload_dir();
        $file = $uploads['basedir'] . "/$file";
    }
         
    if ( $unfiltered )
        return $file;
    return apply_filters( 'get_attached_file', $file, $attachment_id );
}

/**
 * Update attachment file path based on attachment ID.
 *
 * Used to update the file path of the attachment, which uses post meta name
 * '_wp_attached_file' to store the path of the attachment.
 *
 * @since 2.1.0
 * @uses apply_filters() Calls 'update_attached_file' on file path and attachment ID.
 *
 * @param int $attachment_id Attachment ID
 * @param string $file File path for the attachment
 * @return bool False on failure, true on success.
 */
function update_attached_file( $attachment_id, $file ) {
    if ( !get_post( $attachment_id ) )
        return false;

    $file = apply_filters( 'update_attached_file', $file, $attachment_id );

    // Make the file path relative to the upload dir
    if ( ($uploads = wp_upload_dir()) && false === $uploads['error'] ) { // Get upload directory
        if ( 0 === strpos($file, $uploads['basedir']) ) {// Check that the upload base exists in the file path
                $file = str_replace($uploads['basedir'], '', $file); // Remove upload dir from the file path
                $file = ltrim($file, '/');
        }
    }

    return update_post_meta( $attachment_id, '_wp_attached_file', $file );
}

/**
 * Retrieve all children of the post parent ID.
 *
 * Normally, without any enhancements, the children would apply to pages. In the
 * context of the inner workings of WordPress, pages, posts, and attachments
 * share the same table, so therefore the functionality could apply to any one
 * of them. It is then noted that while this function does not work on posts, it
 * does not mean that it won't work on posts. It is recommended that you know
 * what context you wish to retrieve the children of.
 *
 * Attachments may also be made the child of a post, so if that is an accurate
 * statement (which needs to be verified), it would then be possible to get
 * all of the attachments for a post. Attachments have since changed since
 * version 2.5, so this is most likely unaccurate, but serves generally as an
 * example of what is possible.
 *
 * The arguments listed as defaults are for this function and also of the
 * {@link get_posts()} function. The arguments are combined with the
 * get_children defaults and are then passed to the {@link get_posts()}
 * function, which accepts additional arguments. You can replace the defaults in
 * this function, listed below and the additional arguments listed in the
 * {@link get_posts()} function.
 *
 * The 'post_parent' is the most important argument and important attention
 * needs to be paid to the $args parameter. If you pass either an object or an
 * integer (number), then just the 'post_parent' is grabbed and everything else
 * is lost. If you don't specify any arguments, then it is assumed that you are
 * in The Loop and the post parent will be grabbed for from the current post.
 *
 * The 'post_parent' argument is the ID to get the children. The 'numberposts'
 * is the amount of posts to retrieve that has a default of '-1', which is
 * used to get all of the posts. Giving a number higher than 0 will only
 * retrieve that amount of posts.
 *
 * The 'post_type' and 'post_status' arguments can be used to choose what
 * criteria of posts to retrieve. The 'post_type' can be anything, but WordPress
 * post types are 'post', 'pages', and 'attachments'. The 'post_status'
 * argument will accept any post status within the write administration panels.
 *
 * @see get_posts() Has additional arguments that can be replaced.
 * @internal Claims made in the long description might be inaccurate.
 *
 * @since 2.0.0
 *
 * @param mixed $args Optional. User defined arguments for replacing the defaults.
 * @param string $output Optional. Constant for return type, either OBJECT (default), ARRAY_A, ARRAY_N.
 * @return array|bool False on failure and the type will be determined by $output parameter.
 */
function &get_children($args = '', $output = OBJECT) {
    if ( empty( $args ) ) {
        if ( isset( $GLOBALS['post'] ) ) {
            $args = array('post_parent' => (int) $GLOBALS['post']->post_parent );
        } else {
            return false;
        }
    } elseif ( is_object( $args ) ) {
        $args = array('post_parent' => (int) $args->post_parent );
    } elseif ( is_numeric( $args ) ) {
        $args = array('post_parent' => (int) $args);
    }

    $defaults = array(
        'numberposts' => -1, 'post_type' => '',
        'post_status' => '', 'post_parent' => 0
    );

    $r = wp_parse_args( $args, $defaults );

    $children = get_posts( $r );
    if ( !$children ) {
        $kids = false;
        return $kids;
    }

    update_post_cache($children);

    foreach ( $children as $key => $child )
        $kids[$child->ID] =& $children[$key];

    if ( $output == OBJECT ) {
        return $kids;
    } elseif ( $output == ARRAY_A ) {
        foreach ( (array) $kids as $kid )
            $weeuns[$kid->ID] = get_object_vars($kids[$kid->ID]);
        return $weeuns;
    } elseif ( $output == ARRAY_N ) {
        foreach ( (array) $kids as $kid )
            $babes[$kid->ID] = array_values(get_object_vars($kids[$kid->ID]));
        return $babes;
    } else {
        return $kids;
    }
}

/**
 * Get extended entry info (<!--more-->).
 *
 * There should not be any space after the second dash and before the word
 * 'more'. There can be text or space(s) after the word 'more', but won't be
 * referenced.
 *
 * The returned array has 'main' and 'extended' keys. Main has the text before
 * the <code><!--more--></code>. The 'extended' key has the content after the
 * <code><!--more--></code> comment.
 *
 * @since 1.0.0
 *
 * @param string $post Post content.
 * @return array Post before ('main') and after ('extended').
 */
function get_extended($post) {
    //Match the new style more links
    if ( preg_match('/<!--more(.*?)?-->/', $post, $matches) ) {
        list($main, $extended) = explode($matches[0], $post, 2);
    } else {
        $main = $post;
        $extended = '';
    }

    // Strip leading and trailing whitespace
    $main = preg_replace('/^[\s]*(.*)[\s]*$/', '\\1', $main);
    $extended = preg_replace('/^[\s]*(.*)[\s]*$/', '\\1', $extended);

    return array('main' => $main, 'extended' => $extended);
}

/**
 * Retrieves post data given a post ID or post object.
 *
 * See {@link sanitize_post()} for optional $filter values. Also, the parameter
 * $post, must be given as a variable, since it is passed by reference.
 *
 * @since 1.5.1
 * @uses $wpdb
 * @link http://codex.wordpress.org/Function_Reference/get_post
 *
 * @param int|object $post Post ID or post object.
 * @param string $output Optional, default is Object. Either OBJECT, ARRAY_A, or ARRAY_N.
 * @param string $filter Optional, default is raw. 
 * @return mixed Post data
 */
function &get_post(&$post, $output = OBJECT, $filter = 'raw') {
    global $wpdb;
    $null = null;

    if ( empty($post) ) {
        if ( isset($GLOBALS['post']) )
            $_post = & $GLOBALS['post'];
        else
            return $null;
    } elseif ( is_object($post) ) {
        _get_post_ancestors($post);
        wp_cache_add($post->ID, $post, 'posts');
        $_post = &$post;
    } else {
        $post = (int) $post;
        if ( ! $_post = wp_cache_get($post, 'posts') ) {
            $_post = $wpdb->get_row($wpdb->prepare("SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1", $post));
            if ( ! $_post )
                return $null;
            _get_post_ancestors($_post);
            wp_cache_add($_post->ID, $_post, 'posts');
        }
    }

    $_post = sanitize_post($_post, $filter);

    if ( $output == OBJECT ) {
        return $_post;
    } elseif ( $output == ARRAY_A ) {
        $__post = get_object_vars($_post);
        return $__post;
    } elseif ( $output == ARRAY_N ) {
        $__post = array_values(get_object_vars($_post));
        return $__post;
    } else {
        return $_post;
    }
}

/**
 * Retrieve ancestors of a post.
 *
 * @since 2.5.0
 *
 * @param int|object $post Post ID or post object
 * @return array Ancestor IDs or empty array if none are found.
 */
function get_post_ancestors($post) {
    $post = get_post($post);

    if ( !empty($post->ancestors) )
        return $post->ancestors;

    return array();
}

/**
 * Retrieve data from a post field based on Post ID.
 *
 * Examples of the post field will be, 'post_type', 'post_status', 'content',
 * etc and based off of the post object property or key names.
 *
 * The context values are based off of the taxonomy filter functions and
 * supported values are found within those functions.
 *
 * @since 2.3.0
 * @uses sanitize_post_field() See for possible $context values.
 *
 * @param string $field Post field name
 * @param id $post Post ID
 * @param string $context Optional. How to filter the field. Default is display.
 * @return WP_Error|string Value in post field or WP_Error on failure
 */
function get_post_field( $field, $post, $context = 'display' ) {
    $post = (int) $post;
    $post = get_post( $post );

    if ( is_wp_error($post) )
        return $post;

    if ( !is_object($post) )
        return '';

    if ( !isset($post->$field) )
        return '';

    return sanitize_post_field($field, $post->$field, $post->ID, $context);
}

/**
 * Retrieve the mime type of an attachment based on the ID.
 *
 * This function can be used with any post type, but it makes more sense with
 * attachments.
 *
 * @since 2.0.0
 *
 * @param int $ID Optional. Post ID.
 * @return bool|string False on failure or returns the mime type
 */
function get_post_mime_type($ID = '') {
    $post = & get_post($ID);

    if ( is_object($post) )
        return $post->post_mime_type;

    return false;
}

/**
 * Retrieve the post status based on the Post ID.
 *
 * If the post ID is of an attachment, then the parent post status will be given
 * instead.
 *
 * @since 2.0.0
 *
 * @param int $ID Post ID
 * @return string|bool Post status or false on failure.
 */
function get_post_status($ID = '') {
    $post = get_post($ID);

    if ( is_object($post) ) {
        if ( ('attachment' == $post->post_type) && $post->post_parent && ($post->ID != $post->post_parent) )
            return get_post_status($post->post_parent);
        else
            return $post->post_status;
    }

    return false;
}

/**
 * Retrieve all of the WordPress supported post statuses.
 *
 * Posts have a limited set of valid status values, this provides the
 * post_status values and descriptions.
 *
 * @since 2.5.0
 *
 * @return array List of post statuses.
 */
function get_post_statuses( ) {
    $status = array(
        'draft'            => __('Draft'),
        'pending'        => __('Pending Review'),
        'private'        => __('Private'),
        'publish'        => __('Published')
    );

    return $status;
}

/**
 * Retrieve all of the WordPress support page statuses.
 *
 * Pages have a limited set of valid status values, this provides the
 * post_status values and descriptions.
 *
 * @since 2.5.0
 *
 * @return array List of page statuses.
 */
function get_page_statuses( ) {
    $status = array(
        'draft'            => __('Draft'),
        'private'        => __('Private'),
        'publish'        => __('Published')
    );

    return $status;
}

/**
 * Retrieve the post type of the current post or of a given post.
 *
 * @since 2.1.0
 *
 * @uses $wpdb
 * @uses $posts The Loop post global
 *
 * @param mixed $post Optional. Post object or post ID.
 * @return bool|string post type or false on failure.
 */
function get_post_type($post = false) {
    global $posts;

    if ( false === $post )
        $post = $posts[0];
    elseif ( (int) $post )
        $post = get_post($post, OBJECT);

    if ( is_object($post) )
        return $post->post_type;

    return false;
}

/**
 * Updates the post type for the post ID.
 *
 * The page or post cache will be cleaned for the post ID.
 *
 * @since 2.5.0
 *
 * @uses $wpdb
 *
 * @param int $post_id Post ID to change post type. Not actually optional.
 * @param string $post_type Optional, default is post. Supported values are 'post' or 'page' to name a few.
 * @return int Amount of rows changed. Should be 1 for success and 0 for failure.
 */
function set_post_type( $post_id = 0, $post_type = 'post' ) {
    global $wpdb;

    $post_type = sanitize_post_field('post_type', $post_type, $post_id, 'db');
    $return = $wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET post_type = %s WHERE ID = %d", $post_type, $post_id) );

    if ( 'page' == $post_type )
        clean_page_cache($post_id);
    else
        clean_post_cache($post_id);

    return $return;
}

/**
 * Retrieve list of latest posts or posts matching criteria.
 *
 * The defaults are as follows:
 *     'numberposts' - Default is 5. Total number of posts to retrieve.
 *     'offset' - Default is 0. See {@link WP_Query::query()} for more.
 *     'category' - What category to pull the posts from.
 *     'orderby' - Default is 'post_date'. How to order the posts.
 *     'order' - Default is 'DESC'. The order to retrieve the posts.
 *     'include' - See {@link WP_Query::query()} for more.
 *     'exclude' - See {@link WP_Query::query()} for more.
 *     'meta_key' - See {@link WP_Query::query()} for more.
 *     'meta_value' - See {@link WP_Query::query()} for more.
 *     'post_type' - Default is 'post'. Can be 'page', or 'attachment' to name a few.
 *     'post_parent' - The parent of the post or post type.
 *     'post_status' - Default is 'published'. Post status to retrieve.
 *
 * @since 1.2.0
 * @uses $wpdb
 * @uses WP_Query::query() See for more default arguments and information.
 * @link http://codex.wordpress.org/Template_Tags/get_posts
 *
 * @param array $args Optional. Override defaults.
 * @return array List of posts.
 */
function get_posts($args = null) {
    $defaults = array(
        'numberposts' => 5, 'offset' => 0,
        'category' => 0, 'orderby' => 'post_date',
        'order' => 'DESC', 'include' => '',
        'exclude' => '', 'meta_key' => '',
        'meta_value' =>'', 'post_type' => 'post',
        'post_parent' => 0, 'suppress_filters' => true
    );

    $r = wp_parse_args( $args, $defaults );
    if ( empty( $r['post_status'] ) )
        $r['post_status'] = ( 'attachment' == $r['post_type'] ) ? 'inherit' : 'publish';
    if ( ! empty($r['numberposts']) )
        $r['posts_per_page'] = $r['numberposts'];
    if ( ! empty($r['category']) )
        $r['cat'] = $r['category'];
    if ( ! empty($r['include']) ) {
        $incposts = preg_split('/[\s,]+/',$r['include']);
        $r['posts_per_page'] = count($incposts);  // only the number of posts included
        $r['post__in'] = $incposts;
    } elseif ( ! empty($r['exclude']) )
        $r['post__not_in'] = preg_split('/[\s,]+/',$r['exclude']);

    $r['caller_get_posts'] = true;

    $get_posts = new WP_Query;
    return $get_posts->query($r);

}

//
// Post meta functions
//

/**
 * Add meta data field to a post.
 *
 * Post meta data is called "Custom Fields" on the Administration Panels.
 *
 * @since 1.5.0
 * @uses $wpdb
 * @link http://codex.wordpress.org/Function_Reference/add_post_meta
 *
 * @param int $post_id Post ID.
 * @param string $key Metadata name.
 * @param mixed $value Metadata value.
 * @param bool $unique Optional, default is false. Whether the same key should not be added.
 * @return bool False for failure. True for success.
 */
function add_post_meta($post_id, $meta_key, $meta_value, $unique = false) {
    global $wpdb;

    // make sure meta is added to the post, not a revision
    if ( $the_post = wp_is_post_revision($post_id) )
        $post_id = $the_post;

    // expected_slashed ($meta_key)
    $meta_key = stripslashes($meta_key);
    $meta_value = stripslashes($meta_value);

    if ( $unique && $wpdb->get_var( $wpdb->prepare( "SELECT meta_key FROM $wpdb->postmeta WHERE meta_key = %s AND post_id = %d", $meta_key, $post_id ) ) )
        return false;

    $meta_value = maybe_serialize($meta_value);

    $wpdb->insert( $wpdb->postmeta, compact( 'post_id', 'meta_key', 'meta_value' ) );

    wp_cache_delete($post_id, 'post_meta');

    return true;
}

/**
 * Remove metadata matching criteria from a post.
 *
 * You can match based on the key, or key and value. Removing based on key and
 * value, will keep from removing duplicate metadata with the same key. It also
 * allows removing all metadata matching key, if needed.
 *
 * @since 1.5.0
 * @uses $wpdb
 * @link http://codex.wordpress.org/Function_Reference/delete_post_meta
 *
 * @param int $post_id post ID
 * @param string $key Metadata name.
 * @param mixed $value Optional. Metadata value.
 * @return bool False for failure. True for success.
 */
function delete_post_meta($post_id, $key, $value = '') {
    global $wpdb;

    $post_id = absint( $post_id );

    // expected_slashed ($key, $value)
    $key = stripslashes( $key );
    $value = stripslashes( $value );

    if ( empty( $value ) )
        $meta_id = $wpdb->get_var( $wpdb->prepare( "SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s", $post_id, $key ) );
    else
        $meta_id = $wpdb->get_var( $wpdb->prepare( "SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s AND meta_value = %s", $post_id, $key, $value ) );

    if ( !$meta_id )
        return false;

    if ( empty( $value ) )
        $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s", $post_id, $key ) );
    else
        $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = %s AND meta_value = %s", $post_id, $key, $value ) );

    wp_cache_delete($post_id, 'post_meta');

    return true;
}

/**
 * Retrieve post meta field for a post.
 *
 * @since 1.5.0
 * @uses $wpdb
 * @link http://codex.wordpress.org/Function_Reference/get_post_meta
 *
 * @param int $post_id Post ID.
 * @param string $key The meta key to retrieve.
 * @param bool $single Whether to return a single value.
 * @return mixed Will be an array if $single is false. Will be value of meta data field if $single is true.
 */
function get_post_meta($post_id, $key, $single = false) {
    $post_id = (int) $post_id;

    $meta_cache = wp_cache_get($post_id, 'post_meta');

    if ( !$meta_cache ) {
        update_postmeta_cache($post_id);
        $meta_cache = wp_cache_get($post_id, 'post_meta');
    }

    if ( isset($meta_cache[$key]) ) {
        if ( $single ) {
            return maybe_unserialize( $meta_cache[$key][0] );
        } else {
            return array_map('maybe_unserialize', $meta_cache[$key]);
        }
    }

    return '';
}

/**
 * Update post meta field based on post ID.
 *
 * Use the $prev_value parameter to differentiate between meta fields with the
 * same key and post ID.
 *
 * If the meta field for the post does not exist, it will be added.
 *
 * @since 1.5
 * @uses $wpdb
 * @link http://codex.wordpress.org/Function_Reference/update_post_meta
 *
 * @param int $post_id Post ID.
 * @param string $key Metadata key.
 * @param mixed $value Metadata value.
 * @param mixed $prev_value Optional. Previous value to check before removing.
 * @return bool False on failure, true if success.
 */
function update_post_meta($post_id, $meta_key, $meta_value, $prev_value = '') {
    global $wpdb;

    // expected_slashed (