it-swarm.com.de

Get Next/Prev 3 Beiträge in Relation zum aktuellen Post

Ich habe 7 Beiträge, wie folgt:

1
2
3
4 - Dies ist der aktuelle Beitrag
5
6
7

Wie bereits erwähnt, ist Nummer vier der aktuell angezeigte Beitrag. Ich muss eine Abfrage erstellen, mit der ich die vorherigen 3 Beiträge (nach Veröffentlichungsdatum) sowie die drei folgenden Beiträge anzeigen kann. Dies kann mit zwei getrennten Abfragen erfolgen.

Ich konnte den unmittelbar vorherigen oder nächsten Beitrag anzeigen, nur nicht die weiter unten/oben.

Irgendwelche Ideen?

6
Pippin

Dies kann in einer einzelnen Abfrage erfolgen, obwohl ich nicht genau sagen kann, wie gut diese Abfrage ausgeführt wird (ich habe nicht viel mit Unionsabfragen verbracht - hatte bis jetzt noch nie einen Bedarf).

Erstens eine Funktion zum Auswählen von zwei Ergebnissätzen, die jedoch mithilfe von union als einzelne Ergebnismenge zurückgegeben werden.

function get_post_siblings( $limit = 3, $date = '' ) {
    global $wpdb, $post;

    if( empty( $date ) )
        $date = $post->post_date;

    //$date = '2009-06-20 12:00:00'; // test data

    $limit = absint( $limit );
    if( !$limit )
        return;

    $p = $wpdb->get_results( "
    (
        SELECT 
            p1.post_title, 
            p1.post_date,
            p1.ID
        FROM 
            $wpdb->posts p1 
        WHERE 
            p1.post_date < '$date' AND 
            p1.post_type = 'post' AND 
            p1.post_status = 'publish' 
        ORDER by 
            p1.post_date DESC
        LIMIT 
            $limit
    )
    UNION 
    (
        SELECT 
            p2.post_title, 
            p2.post_date,
            p2.ID 
        FROM 
            $wpdb->posts p2 
        WHERE 
            p2.post_date > '$date' AND 
            p2.post_type = 'post' AND 
            p2.post_status = 'publish' 
        ORDER by
            p2.post_date ASC
        LIMIT 
            $limit
    ) 
    ORDER by post_date ASC
    " );
    $i = 0;
    $adjacents = array();
    for( $c = count($p); $i < $c; $i++ )
        if( $i < $limit )
            $adjacents['prev'][] = $p[$i];
        else
            $adjacents['next'][] = $p[$i];

    return $adjacents;
}

Dort steht ein Testdatum. Sie können dieses ignorieren oder Ihren eigenen Wert zum Testen hinzufügen.

Hier ist ein Beispielcode, den Sie in Ihrer single.php -Schleife verwenden können, um die Ergebnisse aufzulisten. Beachten Sie jedoch, dass dies nur ein allgemeines Beispiel ist und die Funktion möglicherweise mehr/andere Daten auswählen muss, die jedoch auf Ihren Informationen basieren Habe vorausgesetzt, ich war mir nicht sicher, was Sie genau wollten, daher dient das Folgende zur Veranschaulichung und als Beispiel zum Testen der Ergebnisse.

<?php 
$siblings = get_post_siblings( 3 ); // This is the same as doing the call below(which is just for illustration)
//$siblings = get_post_siblings( 3, $post->post_date );

$prev = $siblings['prev'];

foreach( $prev as $p )
    echo get_the_time( 'd m Y', $p ) . ': ' . apply_filters( 'the_title', $p->post_title ) . '<br />';

$next = $siblings['next'];

foreach( $next as $p )
    echo get_the_time( 'd m Y', $p ) . ': ' . apply_filters( 'the_title', $p->post_title ) . '<br />';
?>

Erwarte Feedback... :)

3
t31os

Dies kann mit der Eigenschaft date_query der Klasse WP_Query viel besser durchgeführt werden. Dadurch werden die Posts vor dem Veröffentlichungsdatum des aktuellen Posts abgerufen

// WP_Query arguments
$args = array (
    'post_type'              => 'post',
    'post_status'            => 'publish',
     'date_query'    => array(
        'column'  => 'post_date',
        'before'   => get_the_date()
    ),
);

// The Query
$the_query = new WP_Query( $args );

.........

2
raison

3 x get_adjacent_post () :

global $post;
$current_post = $post; // remember the current post

for($i = 1; $i <= 3; $i++){
  $post = get_previous_post(); // this uses $post->ID
  setup_postdata($post);

  // do your stuff here       
  the_title();

}

$post = $current_post; // restore

das gleiche gilt für die nächsten 3 Posts, ändere einfach die Funktion auf get_next_post () ...


Um dies mit einer einzelnen Abfrage zu tun, versuchen Sie, während Sie weiterhin die WP -API verwenden, den Wert LIMIT in den Filtern get_previous_post_sort UND get_next_post_sort in 3 zu ändern.

2
onetrickpony

Wie JanFabry in einer Antwort auf @onetrickpony oben vorschlägt, können Sie get_adjacent_post () ändern. Das habe ich getan. Hier ist die Funktion. Ich habe die Funktionssignatur geändert, weil dies für mich sinnvoller war.

/**
 * Retrieve multiple adjacent posts. Adapted from get_adjacent_post()
 *
 * Can either be next or previous post.
 *
 * @since 2.5.0
 *
 * @param int       $post_id    Optional. Will fall back to loop.
 * @param int       $limit      Optional. Number of posts to return.
 * @param bool          $previous       Optional. Whether to retrieve previous or next posts.
 * @param bool          $in_same_term   Optional. Whether post should be in a same taxonomy term.
 * @param array|string  $excluded_terms Optional. Array or comma-separated list of excluded term IDs.
 * @param string        $taxonomy       Optional. Taxonomy, if $in_same_term is true. Default 'category'.
 * @return mixed        Array of post objects if successful. Null if global $post is not set. Empty string if no corresponding post exists.
 */
function pst_get_adjacent_posts( $post_id = null, $limit = 1, $previous = true, $in_same_term = false, $excluded_terms = '', $taxonomy = 'category' ) {
    global $wpdb;

    if ( ( ! $post = get_post( $post_id ) ) || ! taxonomy_exists( $taxonomy ) )
        return null;

    $current_post_date = $post->post_date;

    $join = '';
    $posts_in_ex_terms_sql = '';
    if ( $in_same_term || ! empty( $excluded_terms ) ) {
        $join = " INNER JOIN $wpdb->term_relationships AS tr ON p.ID = tr.object_id INNER JOIN $wpdb->term_taxonomy tt ON tr.term_taxonomy_id = tt.term_taxonomy_id";

        if ( $in_same_term ) {
            if ( ! is_object_in_taxonomy( $post->post_type, $taxonomy ) )
                return '';
            $term_array = wp_get_object_terms( $post->ID, $taxonomy, array( 'fields' => 'ids' ) );
            if ( ! $term_array || is_wp_error( $term_array ) )
                return '';
            $join .= $wpdb->prepare( " AND tt.taxonomy = %s AND tt.term_id IN (" . implode( ',', array_map( 'intval', $term_array ) ) . ")", $taxonomy );
        }

        $posts_in_ex_terms_sql = $wpdb->prepare( "AND tt.taxonomy = %s", $taxonomy );
        if ( ! empty( $excluded_terms ) ) {
            if ( ! is_array( $excluded_terms ) ) {
                // back-compat, $excluded_terms used to be $excluded_terms with IDs separated by " and "
                if ( false !== strpos( $excluded_terms, ' and ' ) ) {
                    _deprecated_argument( __FUNCTION__, '3.3', sprintf( __( 'Use commas instead of %s to separate excluded terms.' ), "'and'" ) );
                    $excluded_terms = explode( ' and ', $excluded_terms );
                } else {
                    $excluded_terms = explode( ',', $excluded_terms );
                }
            }

            $excluded_terms = array_map( 'intval', $excluded_terms );

            if ( ! empty( $term_array ) ) {
                $excluded_terms = array_diff( $excluded_terms, $term_array );
                $posts_in_ex_terms_sql = '';
            }

            if ( ! empty( $excluded_terms ) ) {
                $posts_in_ex_terms_sql = $wpdb->prepare( " AND tt.taxonomy = %s AND tt.term_id NOT IN (" . implode( $excluded_terms, ',' ) . ')', $taxonomy );
            }
        }
    }

    $adjacent = $previous ? 'previous' : 'next';
    $op = $previous ? '<' : '>';
    $order = $previous ? 'DESC' : 'ASC';

    /**
     * Filter the JOIN clause in the SQL for an adjacent post query.
     *
     * The dynamic portion of the hook name, $adjacent, refers to the type
     * of adjacency, 'next' or 'previous'.
     *
     * @since 2.5.0
     *
     * @param string $join           The JOIN clause in the SQL.
     * @param bool   $in_same_term   Whether post should be in a same taxonomy term.
     * @param array  $excluded_terms Array of excluded term IDs.
     */
    $join  = apply_filters( "get_{$adjacent}_post_join", $join, $in_same_term, $excluded_terms );

    /**
     * Filter the WHERE clause in the SQL for an adjacent post query.
     *
     * The dynamic portion of the hook name, $adjacent, refers to the type
     * of adjacency, 'next' or 'previous'.
     *
     * @since 2.5.0
     *
     * @param string $where          The WHERE clause in the SQL.
     * @param bool   $in_same_term   Whether post should be in a same taxonomy term.
     * @param array  $excluded_terms Array of excluded term IDs.
     */
    $where = apply_filters( "get_{$adjacent}_post_where", $wpdb->prepare( "WHERE p.post_date $op %s AND p.post_type = %s AND p.post_status = 'publish' $posts_in_ex_terms_sql", $current_post_date, $post->post_type), $in_same_term, $excluded_terms );

    /**
     * Filter the ORDER BY clause in the SQL for an adjacent post query.
     *
     * The dynamic portion of the hook name, $adjacent, refers to the type
     * of adjacency, 'next' or 'previous'.
     *
     * @since 2.5.0
     *
     * @param string $order_by The ORDER BY clause in the SQL.
     */
    $sort  = apply_filters( "get_{$adjacent}_post_sort", "ORDER BY p.post_date $order LIMIT $limit" );

    $query = "SELECT p.ID FROM $wpdb->posts AS p $join $where $sort";
    $query_key = 'adjacent_post_' . md5( $query );
    $result = wp_cache_get( $query_key, 'counts' );
    if ( false !== $result ) {
        if ( $result )
            $result = array_map( 'get_post', $result );
        return $result;
    }

    $result = $wpdb->get_col( $query );
    if ( null === $result )
        $result = '';

    wp_cache_set( $query_key, $result, 'counts' );

    if ( $result )
        $result = array_map( 'get_post', $result );

    return $result;
}
0
djb