Aggiungere un Filtro Tassonomia alla Lista Admin per un Custom Post Type

Volevo solo condividere un'implementazione alternativa. Quando ho cercato di risolvere questo problema, non avevo a disposizione l'incredibile tutorial di Mike, quindi la mia soluzione è un po' diversa. Nello specifico, semplificherò il passo #1 di Mike ed eliminerò il passo #2 - gli altri passaggi rimangono comunque validi.

Nel tutorial di Mike, l'uso di wp_dropdown_categories() ci evita di costruire manualmente le liste, ma richiede una modifica condizionale complessa della query (passo #2) per gestire il suo utilizzo dell'ID invece dello slug. Senza contare la difficoltà di modificare quel codice per gestire altri scenari, come i filtri multipli per tassonomia.

Un altro approccio è semplicemente non utilizzare affatto il problematico wp_dropdown_categories(), ma invece costruire da zero le nostre liste a discesa. Non è così complicato, richiede meno di 30 righe di codice e non necessita affatto dell'hook parse_query:

add_action( 'restrict_manage_posts', 'my_restrict_manage_posts' );
function my_restrict_manage_posts() {

    // mostra questi filtri di tassonomia solo negli elenchi dei post type desiderati
    global $typenow;
    if ($typenow == 'photos' || $typenow == 'videos') {

        // crea un array di slug di tassonomie che vuoi filtrare - se vuoi recuperare tutte le tassonomie, potresti usare get_taxonomies() per costruire la lista
        $filters = array('plants', 'animals', 'insects');

        foreach ($filters as $tax_slug) {
            // recupera l'oggetto della tassonomia
            $tax_obj = get_taxonomy($tax_slug);
            $tax_name = $tax_obj->labels->name;
            // recupera l'array di oggetti term per tassonomia
            $terms = get_terms($tax_slug);

            // genera l'html per il filtro a discesa della tassonomia
            echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
            echo "<option value=''>Mostra Tutti $tax_name</option>";
            foreach ($terms as $term) {
                // genera ogni opzione del select, verificando l'ultimo $_GET per mostrare l'opzione corrente selezionata
                echo '<option value='. $term->slug, $_GET[$tax_slug] == $term->slug ? ' selected="selected"' : '','>' . $term->name .' (' . $term->count .')</option>';
            }
            echo "</select>";
        }
    }
}

Semplicemente inserendo le tassonomie desiderate nell'array $filters, puoi generare rapidamente filtri multipli per tassonomia. Appaiono esattamente come quelli negli screenshot di Mike. Poi puoi procedere con i passi #3 e #4.

Ecco una versione che crea e applica automaticamente filtri da tutte le tassonomie che si applicano a tutti i tipi di post personalizzati che le utilizzano. (Che boccone!) In ogni caso, l'ho anche modificata per funzionare con wp_dropdown_categories() e WordPress 3.1. Il progetto su cui sto lavorando si chiama ToDo, puoi rinominare le funzioni con qualcosa che abbia senso per te, ma questo dovrebbe funzionare praticamente per tutto automaticamente.

function todo_restrict_manage_posts() {
    global $typenow;
    $args=array( 'public' => true, '_builtin' => false ); 
    $post_types = get_post_types($args);
    if ( in_array($typenow, $post_types) ) {
    $filters = get_object_taxonomies($typenow);
        foreach ($filters as $tax_slug) {
            $tax_obj = get_taxonomy($tax_slug);
            wp_dropdown_categories(array(
                'show_option_all' => __('Mostra Tutti '.$tax_obj->label ),
                'taxonomy' => $tax_slug,
                'name' => $tax_obj->name,
                'orderby' => 'term_order',
                'selected' => $_GET[$tax_obj->query_var],
                'hierarchical' => $tax_obj->hierarchical,
                'show_count' => false,
                'hide_empty' => true
            ));
        }
    }
}
function todo_convert_restrict($query) {
    global $pagenow;
    global $typenow;
    if ($pagenow=='edit.php') {
        $filters = get_object_taxonomies($typenow);
        foreach ($filters as $tax_slug) {
            $var = &$query->query_vars[$tax_slug];
            if ( isset($var) ) {
                $term = get_term_by('id',$var,$tax_slug);
                $var = $term->slug;
            }
        }
    }
    return $query;
}
add_action( 'restrict_manage_posts', 'todo_restrict_manage_posts' );
add_filter('parse_query','todo_convert_restrict');

Nota che sto usando un plugin che aggiunge 'term_order' come modo per ordinare i termini, dovrai cambiarlo o rimuovere quell'argomento per tornare al valore predefinito.

Risposta tardiva

Modifica

Ho scritto Filterama, un plugin che aggiungerà questa funzionalità nel modo più semplice possibile.

Aggiornamento per WordPress 3.5+

Ora che le cose sono molto più semplici, ecco una soluzione molto semplice come plugin o mu-plugin.

Utilizza il minor numero di risorse possibile, si carica solo sugli schermi necessari e aggiunge Colonne + Filtri per ogni tassonomia personalizzata.

add_action( 'plugins_loaded', array( 'WCM_Admin_PT_List_Tax_Filter', 'init' ) );
class WCM_Admin_PT_List_Tax_Filter
{
    private static $instance;

    public $post_type;

    public $taxonomies;

    static function init()
    {
        null === self::$instance AND self::$instance = new self;
        return self::$instance;
    }

    public function __construct()
    {
        add_action( 'load-edit.php', array( $this, 'setup' ) );
    }

    public function setup()
    {
        add_action( current_filter(), array( $this, 'setup_vars' ), 20 );

        add_action( 'restrict_manage_posts', array( $this, 'get_select' ) );

        add_filter( "manage_taxonomies_for_{$this->post_type}_columns", array( $this, 'add_columns' ) );
    }

    public function setup_vars()
    {
        $this->post_type  = get_current_screen()->post_type;
        $this->taxonomies = array_diff(
            get_object_taxonomies( $this->post_type ),
            get_taxonomies( array( 'show_admin_column' => 'false' ) )
        );
    }

    public function add_columns( $taxonomies )
    {
        return array_merge( $taxonomies, $this->taxonomies );
    }


    public function get_select()
    {
        $walker = new WCMF_walker;
        foreach ( $this->taxonomies as $tax )
        {
            wp_dropdown_categories( array(
                'taxonomy'        => $tax,
                'hide_if_empty'   => true,
                'show_option_all' => sprintf(
                    get_taxonomy( $tax )->labels->all_items
                ),
                'hide_empty'      => true,
                'hierarchical'    => is_taxonomy_hierarchical( $tax ),
                'show_count'      => true,
                'orderby'         => 'name',
                'selected'        => '0' !== get_query_var( $tax )
                    ? get_query_var( $tax )
                    : false,
                'name'            => $tax,
                'id'              => $tax,
                'walker'          => $walker,
            ) );
        }

    }

}

E poi hai solo bisogno di una classe Walker personalizzata.

class WCMF_walker extends Walker_CategoryDropdown
{
    public $tree_type = 'category';
    public $db_fields = array(
        'parent' => 'parent',
        'id'     => 'term_id',
    );
    public $tax_name;

    public function start_el( &$output, $term, $depth, $args, $id = 0 )
    {
        $pad = str_repeat( ' ', $depth * 3 );
        $cat_name = apply_filters( 'list_cats', $term->name, $term );
        $output .= sprintf(
            '<option class="level-%s" value="%s" %s>%s%s</option>',
            $depth,
            $term->slug,
            selected(
                $args['selected'],
                $term->slug,
                false
            ),
            $pad.$cat_name,
            $args['show_count']
                ? "&nbsp;&nbsp;({$term->count})"
                : ''
        );
    }
}

Volevo solo fare una breve nota. Nelle versioni più recenti di WP, gli elenchi di articoli nell'area di amministrazione sono gestiti dalla classe WP_Posts_List_Table. Il codice apply_filters ora è il seguente:

if ( 'page' == $post_type )
        $posts_columns = apply_filters( 'manage_pages_columns', $posts_columns );
    else
        $posts_columns = apply_filters( 'manage_posts_columns', $posts_columns, $post_type );
    $posts_columns = apply_filters( "manage_{$post_type}_posts_columns", $posts_columns );

Quindi per aggiungere nuove colonne un hook add_filter dovrebbe essere così:

add_filter( 'manage_posts_columns', 'my_add_columns', 10, 2);

Ecco un esempio:

function my_add_columns($posts_columns, $post_type)
{
  if ('myposttype' == $post_type) {
    $posts_columns = array(
      "cb"            => "<input type=\"checkbox\" />",
      "title"         => "Titolo",
      "anothercolumn" => "Bacon",
      "date"          => __( 'Data' )
    );
    return $posts_columns;
  }
} 

Ora, per le righe degli articoli. Questo è il codice che gestisce i dati delle colonne negli elenchi:

default:
            ?>
            <td <?php echo $attributes ?>><?php
                if ( is_post_type_hierarchical( $post->post_type ) )
                    do_action( 'manage_pages_custom_column', $column_name, $post->ID );
                else
                    do_action( 'manage_posts_custom_column', $column_name, $post->ID );
                do_action( "manage_{$post->post_type}_posts_custom_column", $column_name, $post->ID );
            ?></td>
            <?php

Per recuperare i dati dei nostri articoli, dobbiamo aggiungere un action hook in questo modo:

add_action( "manage_(here_goes_your_post_type)_posts_custom_column", "my_posttype_add_column", 10, 2);

Esempio (questo esempio usa tassonomie, ma potresti interrogare qualsiasi altra cosa):

function my_posttype_add_column($column_name, $post_id)
{
  switch ($column_name) {
    case 'anothercolumn':
      $flavours = get_the_terms($post_id, 'flavour');
      if (is_array($flavours)) {
        foreach($flavours as $key => $flavour) {
          $edit_link = get_term_link($flavour, 'flavour');
          $flavours[$key] = '<a href="'.$edit_link.'">' . $flavour->name . '</a>';
        }
        echo implode(' | ',$flavours);
      }
      break;

    default:
      break;
  }
}

FUNZIONA IN WP 3.2!

custom_post_type: books custom_taxonomy: genre

Modificare solo dove indica: // change HERE

function restrict_books_by_genre() {
    global $typenow;
    $post_type = 'books'; // change HERE
    $taxonomy = 'genre'; // change HERE
    if ($typenow == $post_type) {
        $selected = isset($_GET[$taxonomy]) ? $_GET[$taxonomy] : '';
        $info_taxonomy = get_taxonomy($taxonomy);
        wp_dropdown_categories(array(
            'show_option_all' => __("Mostra Tutti {$info_taxonomy->label}"),
            'taxonomy' => $taxonomy,
            'name' => $taxonomy,
            'orderby' => 'name',
            'selected' => $selected,
            'show_count' => true,
            'hide_empty' => true,
        ));
    };
}

add_action('restrict_manage_posts', 'restrict_books_by_genre');


function convert_id_to_term_in_query($query) {
    global $pagenow;
    $post_type = 'books'; // change HERE
    $taxonomy = 'genre'; // change HERE
    $q_vars = &$query->query_vars;
    if ($pagenow == 'edit.php' && isset($q_vars['post_type']) && $q_vars['post_type'] == $post_type && isset($q_vars[$taxonomy]) && is_numeric($q_vars[$taxonomy]) && $q_vars[$taxonomy] != 0) {
        $term = get_term_by('id', $q_vars[$taxonomy], $taxonomy);
        $q_vars[$taxonomy] = $term->slug;
    }
}

add_filter('parse_query', 'convert_id_to_term_in_query');

Ho dovuto lavorare su una funzionalità simile non molto tempo fa, poiché non ero soddisfatto delle risposte esistenti, ecco la mia alternativa. Anno 2021.

Volevo qualcosa di semplice e immediato da implementare. Ottenere rapidamente ed efficientemente tutte le tassonomie personalizzate da ogni tipo di post personalizzato e aggiungerle come opzioni di filtro.

C'erano alcuni prerequisiti:

• Volevo evitare di utilizzare variabili globali.
• Il codice doveva essere portatile, senza variabili hardcoded, per essere riutilizzabile.
• Avere una sorta di gerarchia visibile, perfetta per tassonomie con molti termini correlati.
• Doveva rispettare la scelta di visibilità della tassonomia. (es: parametro show_admin_column della funzione register_taxonomy).
• Visualizzare il conteggio dei post.
• L'aspetto generale doveva corrispondere a quello di WordPress.

L'ho trasformato in un plugin per un'integrazione più semplice, puoi ottenere l'ultima versione su https://wordpress.org/plugins/cpt-admin-taxonomy-filtering/.

Filtro con gerarchia di termini e conteggio post	Filtri per più tipi di post personalizzati

Se vuoi semplicemente aggiungerlo al tuo function.php, copia e incolla il seguente script.

Richiede almeno WordPress 4.8.0 & PHP: 4.0.

<?php

add_action( 'restrict_manage_posts', 'cpt_admin_taxonomy_filtering' );

if ( ! function_exists( 'cpt_admin_taxonomy_filtering' ) ) {

    function cpt_admin_taxonomy_filtering() {

        /**
         * Ottiene l'oggetto screen corrente.
         * 
         * @link https://developer.wordpress.org/reference/functions/get_current_screen/
         */
        $screen = get_current_screen();

        // Escludi i tipi di post predefiniti di WordPress
        $restricted_post_types = array(
            'post',
            'page',
            'attachment',
            'revision',
            'nav_menu_item',
        );

        if ( 'edit' === $screen->base && ! in_array( $screen->post_type, $restricted_post_types ) {

            /**
             * Restituisce i nomi o gli oggetti delle tassonomie registrate per l'oggetto o tipo di oggetto richiesto, come un oggetto post o nome del tipo di post.
             * 
             * @link https://developer.wordpress.org/reference/functions/get_object_taxonomies/
             */
            $taxonomies = get_object_taxonomies( $screen->post_type, 'objects' );

            // Scorri ogni tassonomia
            foreach ( $taxonomies as $taxonomy ) {

                if ( $taxonomy->show_admin_column ) {

                    /**
                     * Visualizza o recupera il menu a discesa HTML delle categorie.
                     * 
                     * @link https://developer.wordpress.org/reference/functions/wp_dropdown_categories/
                     */
                    wp_dropdown_categories(
                        array(
                            'show_option_all' => $taxonomy->labels->all_items,
                            'pad_counts' => true,
                            'show_count' => true,
                            'hierarchical' => true,
                            'name' => $taxonomy->query_var,
                            'id' => 'filter-by-' . $taxonomy->query_var,
                            'class' => '',
                            'value_field' => 'slug',
                            'taxonomy' => $taxonomy->query_var,
                            'hide_if_empty' => true,
                        )
                    );

                };

            };

        };

    };

};

Non è molto conosciuto credo, ma a partire da WordPress 3.5, puoi passare 'show_admin_column' => true a register_taxonomy. Questo fa due cose:

1. Aggiunge la colonna della tassonomia alla vista a elenco del tipo di post nell'amministrazione
2. Cliccando sul nome del termine nella colonna della tassonomia, filtra effettivamente l'elenco per quel termine.

Quindi, non esattamente lo stesso che avere un select, ma quasi la stessa funzionalità, con solo una riga di codice.

https://make.wordpress.org/core/2012/12/11/wordpress-3-5-admin-columns-for-custom-taxonomies/

Inoltre, come puoi leggere, c'è un nuovo filtro appositamente per aggiungere manualmente la colonna della tassonomia (se ne hai davvero bisogno).

Grazie a tutti per le risposte. So che è una domanda vecchia, ma vorrei aggiungere la soluzione più semplice che può essere utilizzata oggi. Richiederà solo 2 passaggi e utilizzerà più funzionalità del core disponibili. Spero che questo possa aiutare qualcuno.

Passo 1: aggiungi 'show_admin_column' => true alla tua funzione register_taxonomy.

Questo aggiungerà una colonna alla vista elenco contenente i link per filtrare la lista per quel termine. Può essere applicato sia per tassonomie gerarchiche che non gerarchiche.

Esempio:

register_taxonomy( 'custom_cat', array( 'custom_post_type' ), array(
    'hierarchical'      => true,
    'labels'            => array(
        'name'              => __( 'Categorie', 'iside' ),
        'singular_name'     => __( 'Categoria', 'iside' ),
        'search_items'      => __( 'Cerca Categorie', 'iside' ),
        'all_items'         => __( 'Tutte le Categorie', 'iside' ),
        'parent_item'       => __( 'Categoria Genitore', 'iside' ),
        'parent_item_colon' => __( 'Categoria Genitore:', 'iside' ),
        'edit_item'         => __( 'Modifica Categoria', 'iside' ),
        'update_item'       => __( 'Aggiorna Categoria', 'iside' ),
        'add_new_item'      => __( 'Aggiungi Nuova Categoria', 'iside' ),
        'new_item_name'     => __( 'Nuova Categoria', 'iside' ),
        'menu_name'         => __( 'Categorie', 'iside' ),
    ),
    'public'            => true,
    'publicly_queryable'=> true,
    'show_ui'           => true,
    'show_in_menu'      => true,
    'show_in_nav_menus' => true,
    'show_in_rest'      => true,
    'show_tagcloud'     => false,
    'show_in_quick_edit'=> true,
    'show_admin_column' => true, // <-- la magia applicata qui
    'query_var'         => true,
) );

Passo 2: aggiungi il dropdown della tassonomia tramite il filtro restrict_manage_posts

Questo aggiungerà un menu a tendina alle opzioni di filtro in alto. Utilizzerà la funzione predefinita wp_dropdown_categories per semplificare. Nota che dobbiamo impostare il nome del dropdown al query_var che usiamo per la tassonomia. Inoltre il value_field deve essere impostato sullo slug (di default sarà il term_id).

Esempio:

add_action( 'restrict_manage_posts', 'iside_add_filter_to_admin', 10, 2 );
function iside_add_filter_to_admin( $post_type = 'post', $which = 'top' ) {
    if( $post_type == 'custom_post_type' ) {
        $selected = isset( $_GET['custom_cat'] ) ? esc_attr($_GET['custom_cat']) : 0;
        wp_dropdown_categories(array(
            'show_option_all' =>  __( 'Mostra Tutte le Categorie', 'iside' ),
            'taxonomy'        =>  'custom_cat',
            'name'            =>  'custom_cat', // <-- assicurati che corrisponda al query_var
            'orderby'         =>  'name',
            'selected'        =>  $selected,
            'hierarchical'    =>  true,
            'depth'           =>  3,
            'show_count'      =>  true,
            'hide_empty'      =>  true,
            'value_field'     => 'slug', // <-- usa lo slug invece del term_id
        ));
    }
}

Ecco fatto. Non c'è bisogno di aggiungere altro :-)

Ecco un modo per farlo utilizzando l'azione restrict_manage_posts. Sembra funzionare bene per me e aggiunge la possibilità di filtrare per tassonomia per tutti i tipi di post e le relative tassonomie.

// registra ciascuno dei menu a discesa per il filtro delle tassonomie
function sunrise_fbt_add_taxonomy_filters() {
    global $typenow;            // il tipo di post corrente
    $taxonomies = get_taxonomies('','objects');
    foreach($taxonomies as $taxName => $tax) {
    if(in_array($typenow,$tax->object_type) && $taxName != 'category' && $taxName != 'tags') {
            $terms = get_terms($taxName);
            if(count($terms) > 0) {
              //Controlla se è gerarchica - in tal caso costruisce un menu a discesa gerarchico
              if($tax->hierarchical) {
                $args = array(
                      'show_option_all'    => 'Tutti '.$tax->labels->name,
                      'show_option_none'   => 'Seleziona '.$tax->labels->name,
                      'show_count'         => 1,
                      'hide_empty'         => 0, 
                      'echo'               => 1,
                      'hierarchical'       => 1,
                      'depth'              => 3, 
                      'name'               => $tax->rewrite['slug'],
                      'id'                 => $tax->rewrite['slug'],                      
                      'class'              => 'postform',
                      'depth'              => 0,
                      'tab_index'          => 0,
                      'taxonomy'           => $taxName,
                      'hide_if_empty'      => false);
            $args['walker'] = new Walker_FilterByTaxonomy;
                wp_dropdown_categories($args);
              } else {
                    echo "<select name='".$tax->rewrite['slug']."' id='".$tax->rewrite['slug']."' class='postform'>";
                    echo "<option value=''>Mostra Tutti ".$tax->labels->name."</option>";
                    foreach ($terms as $term) { 
              echo '<option value="' . $term->slug . '"', $_GET[$taxName] == $term->slug ? ' selected="selected"' : '','>' . $term->name .' (' . $term->count .')</option>'; 
            }
                    echo "</select>";
                }
            }
    }
    }
}
add_action( 'restrict_manage_posts', 'sunrise_fbt_add_taxonomy_filters', 100 );

/**
 * Crea un elenco HTML a discesa di Categorie.
 *
 * @package WordPress
 * @since 2.1.0
 * @uses Walker
 */
class Walker_FilterByTaxonomy extends Walker {
    var $tree_type = 'category';
    var $db_fields = array ('parent' => 'parent', 'id' => 'term_id');
    function start_el(&$output, $category, $depth, $args) {
      $args['selected'] = get_query_var( $args['taxonomy'] );
        $pad = str_repeat('&nbsp;', $depth * 3);

        $cat_name = apply_filters('list_cats', $category->name, $category);
        $output .= "\t<option class=\"level-$depth\" value=\"".$category->slug."\"";
        if ( $category->slug == $args['selected'] )
            $output .= ' selected="selected"';
        $output .= '>';
        $output .= $pad.$cat_name;
        if ( $args['show_count'] )
            $output .= '&nbsp;&nbsp;('. $category->count .')';
        if ( $args['show_last_update'] ) {
            $format = 'Y-m-d';
            $output .= '&nbsp;&nbsp;' . gmdate($format, $category->last_update_timestamp);
        }
        $output .= "</option>\n";
        }
} 

Una nota - ho provato a limitare la profondità perché alcune delle mie tassonomie gerarchiche sono piuttosto grandi ma non ha funzionato - potrebbe essere un bug nella funzione wp_dropdown_categories?

Aggiornamento della risposta di @Drew Gourley per WP 3.3.1 (e integrazione del codice da http://wordpress.org/support/topic/wp_dropdown_categories-generating-url-id-number-instead-of-slug?replies=6#post-2529115):

add_action('restrict_manage_posts', 'xyz_restrict_manage_posts');
function xyz_restrict_manage_posts() {
    global $typenow;

    $args = array('public'=>true, '_builtin'=>false); 
    $post_types = get_post_types($args);

    if(in_array($typenow, $post_types)) {
        $filters = get_object_taxonomies($typenow);

        foreach ($filters as $tax_slug) {
            $tax_obj = get_taxonomy($tax_slug);
            $term = get_term_by('slug', $_GET[$tax_obj->query_var], $tax_slug);

            wp_dropdown_categories(array(
                'show_option_all' => __('Mostra Tutti '.$tax_obj->label ),
                'taxonomy' => $tax_slug,
                'name' => $tax_obj->name,
                'orderby' => 'term_order',
                'selected' => $term->term_id,
                'hierarchical' => $tax_obj->hierarchical,
                'show_count' => false,
                // 'hide_empty' => true,
                'hide_empty' => false,
                'walker' => new DropdownSlugWalker()
            ));
        }
    }
}


//Classe per il filtro a discesa. Usata con wp_dropdown_categories() per far sì che il menu a discesa risultante utilizzi gli slug dei termini invece degli ID.
class DropdownSlugWalker extends Walker_CategoryDropdown {

    function start_el(&$output, $category, $depth, $args) {
        $pad = str_repeat(' ', $depth * 3);

        $cat_name = apply_filters('list_cats', $category->name, $category);
        $output .= "\t<option class=\"level-$depth\" value=\"".$category->slug."\"";

        if($category->term_id == $args['selected'])
            $output .= ' selected="selected"';

        $output .= '>';
        $output .= $pad.$cat_name;
        $output .= "</option>\n";
    }
}

Versione gerarchica della risposta di @somatic, come richiesto da @kevin:

<?php
add_action( 'restrict_manage_posts', 'my_restrict_manage_posts' );
function my_restrict_manage_posts() {

    // mostra questi filtri tassonomici solo negli elenchi dei post type desiderati
    global $typenow;
    if ($typenow == 'photos' || $typenow == 'videos') {

        // crea un array di slug di tassonomie da filtrare - se vuoi recuperare tutte le tassonomie, potresti usare get_taxonomies() per costruire la lista
        $filters = array('plants', 'animals', 'insects');

        foreach ($filters as $tax_slug) {
            // recupera l'oggetto tassonomia
            $tax_obj = get_taxonomy($tax_slug);
            $tax_name = $tax_obj->labels->name;

            // output html per il dropdown di filtraggio tassonomico
            echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
            echo "<option value=''>Mostra Tutti $tax_name</option>";
            generate_taxonomy_options($tax_slug,0,0);
            echo "</select>";
        }
    }
}

function generate_taxonomy_options($tax_slug, $parent = '', $level = 0) {
    $args = array('show_empty' => 1);
    if(!is_null($parent)) {
        $args = array('parent' => $parent);
    } 
    $terms = get_terms($tax_slug,$args);
    $tab='';
    for($i=0;$i<$level;$i++){
        $tab.='--';
    }
    foreach ($terms as $term) {
        // output per ogni opzione select, verifica l'ultimo $_GET per mostrare l'opzione corrente selezionata
        echo '<option value='. $term->slug, $_GET[$tax_slug] == $term->slug ? ' selected="selected"' : '','>' .$tab. $term->name .' (' . $term->count .')</option>';
        generate_taxonomy_options($tax_slug, $term->term_id, $level+1);
    }

}
?>

Ho sostanzialmente rimosso il codice che creava le opzioni e l'ho messo in una funzione separata. La funzione 'generate_taxonomy_options', oltre a prendere il tax_slug, accetta anche i parametri parent e level. La funzione assume che stia creando opzioni per il parent 0, che selezionerà tutti i termini di livello root. Nel loop la funzione richiamerà se stessa ricorsivamente, usando il termine corrente come parent e incrementando il livello di uno. Aggiunge automaticamente trattini sul lato più si scende nell'albero ed ecco fatto!

Aggiungi semplicemente questo al tuo functions.php o al codice del plugin (e sostituisci YOURCUSTOMTYPE e YOURCUSTOMTAXONOMY). (Ho preso il codice da generatewp)

add_action( 'restrict_manage_posts', 'filter_backend_by_taxonomies' , 99, 2);

function filter_backend_by_taxonomies( $post_type, $which ) {
    // Applica questo a un CPT specifico
    if ( 'YOURCUSTOMTYPE' !== $post_type )
        return;
    // Una lista di slug di tassonomie personalizzate da filtrare
    $taxonomies = array( 'YOURCUSTOMTAXONOMY' );
    foreach ( $taxonomies as $taxonomy_slug ) {
        // Recupera i dati della tassonomia
        $taxonomy_obj = get_taxonomy( $taxonomy_slug );
        $taxonomy_name = $taxonomy_obj->labels->name;
        // Recupera i termini della tassonomia
        $terms = get_terms( $taxonomy_slug );
        // Mostra l'HTML del filtro
        echo "<select name='{$taxonomy_slug}' id='{$taxonomy_slug}' class='postform'>";
        echo '<option value="">' . sprintf( esc_html__( 'Categoria', 'text_domain' ), $taxonomy_name ) . '</option>';
        foreach ( $terms as $term ) {
            printf(
                '<option value="%1$s" %2$s>%3$s (%4$s)</option>',
                $term->slug,
                ( ( isset( $_GET[$taxonomy_slug] ) && ( $_GET[$taxonomy_slug] == $term->slug ) ) ? ' selected="selected"' : '' ),
                $term->name,
                $term->count
            );
        }
        echo '</select>';
    }
}

Il tutorial di Mike su questo argomento è fantastico! Probabilmente non mi sarei preoccupato di aggiungere questa funzionalità al mio plugin Media Categories se avessi dovuto capirlo da solo.

Detto questo, penso che utilizzare parse_query e poi interrogare il termine non sia necessario. È più pulito creare la propria classe walker personalizzata. Forse non era possibile quando ha scritto il suo post - risale a 3 anni fa al momento in cui scrivo questo.

Dai un'occhiata a questo fantastico snippet su GitHub. Funziona perfettamente, cambia gli ID nei valori del dropdown in slug, quindi funziona in modo nativo senza modificare la query.

https://gist.github.com/stephenh1988/2902509

Ho provato entrambi i codici, quello di Mike e quello di somatic, e mi chiedevo come ottenere una cosa da ciascuna tecnica:

Con il codice di Mike, mostra il menu a discesa con l'opzione gerarchica, che aiuta molto. Ma per visualizzare due menu a discesa ho dovuto duplicare l'istruzione if ($typenow=='produtos') {...} nella funzione restrict_listings_by_business() e anche il if ($pagenow=='edit.php' && ... } nella funzione convert_business_id_to_taxonomy_term_in_query($query) che ora genera molto codice.

Con il codice di somatic mi basta specificare le tassonomie che vorrei vedere come menu a discesa e voilà, funziona; $filters = array('taxo1', 'taxo2');

Domanda: posso ottenere l'approccio di somatic e avere anche l'opzione gerarchica?

Grazie comunque per questo tutorial, è stato di grande aiuto!

Questo è un potente snippet che permette di filtrare i tuoi post o custom post type per un termine specifico di una tassonomia nell'area di amministrazione di WordPress.

/* Filtra CPT tramite Tassonomia Personalizzata */
function rave_core_backend_by_portfolio_taxonomies( $post_type, $which ) {
    // Applica questo filtro solo a un specifico CPT
    if ( 'portfolio' !== $post_type )
        return;

    // Una lista di slug di tassonomie personalizzate da filtrare
    $taxonomies = array( 'portfolio_cat' );

    foreach ( $taxonomies as $taxonomy_slug ) {

        // Recupera i dati della tassonomia
        $taxonomy_obj = get_taxonomy( $taxonomy_slug );
        $taxonomy_name = $taxonomy_obj->labels->name;

        // Recupera i termini della tassonomia
        $terms = get_terms( $taxonomy_slug );

        // Mostra l'HTML del filtro
        echo "<select name='{$taxonomy_slug}' id='{$taxonomy_slug}' class='postform'>";
        echo '<option value="">' . sprintf( esc_html__( 'Tutti i %s', 'rave-core' ), $taxonomy_name ) . '</option>';
        foreach ( $terms as $term ) {
            printf(
                '<option value="%1$s" %2$s>%3$s (%4$s)</option>',
                $term->slug,
                ( ( isset( $_GET[$taxonomy_slug] ) && ( $_GET[$taxonomy_slug] == $term->slug ) ) ? ' selected="selected"' : '' ),
                $term->name,
                $term->count
            );
        }
        echo '</select>';
    }
}

add_action( 'restrict_manage_posts', 'rave_core_backend_by_portfolio_taxonomies' , 99, 2);

Mi scuso per il fatto che, essendo un nuovo utente, non posso pubblicare commenti ma posso pubblicare una risposta...

A partire da WordPress 3.1 (RC 1) la risposta di Mike (che mi è stata così utile negli ultimi mesi) non funziona più per me; limitare per qualsiasi tassonomia figlia restituisce un risultato vuoto.

Ho provato l'aggiornamento di Somatic e ha funzionato alla grande; ancora meglio, funziona con query multiple di tassonomie che sono state integrate in questa versione.