Ecco il mio codice

$my_wp_query = new WP_Query();
$all_wp_pages = $my_wp_query->query(array('post_type' => 'page','post_parent'=>$parid,'orderby'=>'title','order'=>'ASC' ));

Visualizza solo le sottopagine di primo livello. Ho bisogno di tutta la sottopagina, sottopagina secondaria ... e tutto. Ho cercato una soluzione e posso ottenere tutte le pagine secondarie usando get_pages e wp_list_pages.

Ma ho davvero bisogno di ordinare l'ordine per meta valore post personalizzato. Quindi devo usare una query personalizzata.

per favore aiuto. Grazie

Perché non usare solo get_pages()?

per esempio

<?php
// Determine parent page ID
$parent_page_id = ( '0' != $post->post_parent ? $post->post_parent : $post->ID );
// Get child pages as array
$page_tree_array = get_pages( array(
    'child_of' => $parent_page_id;
) );
?>

Ma se deve davvero essere un WP_Query()oggetto, usa un metodo simile:

<?php
// Determine parent page ID
$parent_page_id = ( '0' != $post->post_parent ? $post->post_parent : $post->ID );
// Build WP_Query() argument array
$page_tree_query_args = array(
    'post_parent' => $parent_page_id;
);
// Get child pages as a WP_Query() object
$page_tree_query = new WP_Query( $page_tree_query_args );
?>

Il problema

Quello che stai riscontrando problemi nella comprensione è "Come posso fare X?" Questa non è un'azione in 1 passaggio, è un processo a più fasi e deve essere suddiviso.

Non è necessario farlo:

get all the posts that are a child of X ordered by meta

Devi fare questo:

get all the posts that are a child of X
    for each child, get all the posts that are a child
        foreach child of that child get all the posts that are a child
            ...
                hmmm we don't have any more children left

Take our list of posts and order them by meta

La soluzione generale

Quindi, per capire come farlo all'infinito fino a raggiungere la fine, senza codificarlo, è necessario comprendere le funzioni ricorsive.

per esempio

function make_zero( $amount ) {
    $amount = $amount - 1;
    if ( $amount > 1 ){
        return make_zero( $amount );
    }
    return $amount;
}

Applicazione della ricorsione a questo problema per una soluzione

Quindi lo è il tuo genitore $paride il tuo meta post ha una chiave di $metakey.

Passiamo a una funzione per afferrare i suoi figli.

$children = get_children_with_meta( $parid, $metakey );

Quindi ordineremo l'array $ children, le chiavi saranno gli ID dei post e i valori saranno i meta-valori.

asort($children);

e definiamo la funzione come:

function get_children_with_meta( $parent_id, $metakey ) {
    $q = new WP_Query( array( 'post_parent' => $parent_id, 'meta_key' => $metakey ));
    if ( $q->have_posts() ) {
        $children - array();
        while ( $q->have_posts() ) {
            $q->the_post();
            $meta_value = get_post_meta(get_the_ID(), $metakey, true );
            $children[get_the_ID() ] = $meta_value;
        }
        return $children;
    } else {
        // there are no children!!
        return array();
    }
}

Questo ti dà una serie di ID post e valori, ordinati dal più basso al più alto. Puoi usare altre funzioni di ordinamento PHP per farlo dal più alto al più basso.

Ora che dire dei bambini?

Nel mezzo del nostro ciclo, dobbiamo effettuare una chiamata ricorsiva, passando il figlio anziché l'ID genitore.

Così questo:

$q->the_post();
$meta_value = get_post_meta(get_the_ID(), $metakey, true );
$children[get_the_ID() ] = $meta_value;

Diventa questo:

$q->the_post();
$meta_value = get_post_meta(get_the_ID(), $metakey, true );
$children[get_the_ID() ] = $meta_value;

// now get the childrens children
$grandchildren = get_children_with_meta( get_the_ID(), $metakey );

// merge the grandchildren and the children into the same list
$children = array_merge( $children, $grandchildren );

Con questa modifica la funzione ora recupera i bambini, i bambini dei bambini, i bambini dei bambini ..... ecc

Alla fine è possibile tagliare i valori sull'array per ottenere ID come questo:

$post_ids = array_keys( $children );
$q = new WP_Query( array( 'post__in' => $post_ids );
// etc

Utilizzando questa strategia è possibile sostituire il valore della meta chiave con qualsiasi altra metrica o utilizzare le funzioni ricorsive in altri modi.

Dal momento che il codice completo richiede solo pochi secondi di comprensione di base e una copia rapida incolla, non insulterò la tua intelligenza con un blocco completo di codice copia incolla.

vantaggi

• Con la modifica funziona per qualsiasi tipo di post e forma di dati
• Può essere modificato per generare markup nidificato
• Facilmente cache per accelerare mettendo gli array restituiti in transitori
• Può essere impostato con il paging applicando il paging alla fine WP_Query

Problemi che incontrerai

• Non hai modo di sapere quanti bambini ci sono fino a quando non li hai trovati, quindi i costi delle prestazioni non aumentano
• Ciò che desideri genererà molte query ed è intrinsecamente costoso a causa delle potenziali profondità coinvolte.

La mia raccomandazione

Ti consiglierei di appiattire la gerarchia di pagine o utilizzare invece una tassonomia. Ad esempio, se stai valutando post, hai una tassonomia di Page Rating con i termini 1,2,3,4 e 5 ecc. Questo ti fornirà un elenco di post pronto all'uso.

In alternativa, utilizzare i menu di navigazione e aggirare completamente questo problema

Ricorsivamente ottiene tutte le sottopagine correnti

Ecco un approccio ricorsivo utilizzando get_children. Inserisci quanto segue nel tuo functions.php:

function get_all_subpages($page, $args = '', $output = OBJECT) {
    // Validate 'page' parameter
    if (! is_numeric($page))
        $page = 0;

    // Set up args
    $default_args = array(
        'post_type' => 'page',
    );
    if (empty($args))
        $args = array();
    elseif (! is_array($args))
        if (is_string($args))
            parse_str($args, $args);
        else
            $args = array();
    $args = array_merge($default_args, $args);
    $args['post_parent'] = $page;

    // Validate 'output' parameter
    $valid_output = array(OBJECT, ARRAY_A, ARRAY_N);
    if (! in_array($output, $valid_output))
        $output = OBJECT;

    // Get children
    $subpages = array();
    $children = get_children($args, $output);
    foreach ($children as $child) {
        $subpages[] = $child;

        if (OBJECT === $output)
            $page = $child->ID;
        elseif (ARRAY_A === $output)
            $page = $child['ID'];
        else
            $page = $child[0];

        // Get subpages by recursion
        $subpages = array_merge($subpages, get_all_subpages($page, $args, $output));
    }

    return $subpages;
}

Come usarlo

Usa la funzione sopra dove vuoi, ad esempio in questo modo:

$all_current_subpages = get_all_subpages(0);

La funzione supporta un argsparametro (stringa di query o matrice) e un outputtipo (vedere sopra).

Quindi potresti anche usarlo in questo modo:

$args = array(
    'post_status' => 'private',
    'order_by' => 'post_date',
    'order' => 'DESC',
);
$all_current_subpages = get_all_subpages(42, $args, ARRAY_A);

E a causa della dipendenza get_children=> get_posts=> WP_Queryè possibile utilizzare i meta valori, come inizialmente richiesto dall'autore di questa domanda.

Non sono sicuro se questo è esattamente quello che stai cercando, ma potresti utilizzare la funzione wp_list_pages e utilizzare i parametri 'child_of' e 'depth'.

Vedere la seguente pagina sul Codice per ulteriori informazioni: http://codex.wordpress.org/Function_Reference/wp_list_pages

Ho creato una funzione ricorsiva che ottiene tutti gli ID figlio di una pagina padre. Dopo che abbiamo gli ID, facciamo una query per le pagine e possiamo ordinare i risultati per meta chiave / valore.

// Gets all the children ids of post_parent
function _get_children_ids( $post_parent ) {
    $results = new WP_Query( array(
        'post_type' => 'page',
        'post_parent' => $post_parent
    ) );

    $child_ids = array();
    if ( $results->found_posts > 0 )
        foreach ( $results->posts as $post ) // add each child id to array
            $child_ids[] = $post->ID;

    if ( ! empty( $child_ids ) )
        foreach ( $child_ids as $child_id ) // add further children to array
            $child_ids = array_merge( $child_ids, _get_children_ids( $child_id ) );

    return $child_ids;
}

$children_ids = _get_children_ids( 9 ); // use your numeric page id or get_the_id()

$results = new WP_Query( array(
    'post_type'   => 'page',
    'post__in'   => $children_ids
    #'meta_key'   => 'meta_key', // your meta key
    #'orderby'    => 'meta_key',
    /* 'meta_query' => array( // optional meta_query
        array(
            'key' => 'meta_key', // key
            'value' => array(3, 4), // values
            'compare' => 'IN', // operator
        )
    ) */
) );

var_dump( $results );

Se è necessario ordinare i figli in base alla meta chiave / valore in modo gerarchico, è necessario passare i valori meta_key e order_by a WP_Query nella funzione _get_children_ids (anziché WP_Query finale).

In caso contrario, un metodo più semplice per ottenere tutto l'id figlio è:

$children = get_pages( 'child_of=9');

$children_ids = array();
if ( ! empty( $children ) )
    foreach ( $children as $post )
        $children_ids[] = $post->ID;

FACCIO CHE FUNZIONA, COPIA SOLO IL CODICE INCOLLATO SUL FILE PAGINA.PHP

//REDIRECT TO FIRST CHILD FROM PARENT PAGE

// Build WP_Query() argument array
$page_tree_query_args = array(
    'post_parent' => $post -> ID,
    'post_type' => 'page',
    'order' => 'asc'
);
// Get child pages as a WP_Query() object
$page_tree_query = new WP_Query( $page_tree_query_args );
if(!empty($page_tree_query -> posts)){
    $first_subpage = $page_tree_query -> posts[0] -> ID;
    wp_redirect( get_permalink( $first_subpage ) );
    exit;   
}