Añadir un Filtro de Taxonomía a la Lista de Administración para un Tipo de Publicación Personalizado

Solo quería compartir una implementación alternativa. No tenía el increíble tutorial de Mike cuando estaba resolviendo esto, así que mi solución es un poco diferente. Específicamente, voy a simplificar el paso #1 de Mike y eliminar el paso #2 - los otros pasos siguen siendo aplicables.

En el tutorial de Mike, usar wp_dropdown_categories() nos ahorra algo de construcción manual de listas, pero requiere una modificación condicional complicada de la consulta (paso #2) para manejar su uso de ID en lugar de slug. Sin mencionar la dificultad de modificar ese código para manejar otros escenarios, como múltiples filtros de taxonomía.

Otro enfoque es simplemente no usar el defectuoso wp_dropdown_categories() en absoluto, sino construir nuestras propias listas desplegables desde cero. No es tan complicado, toma menos de 30 líneas de código y no requiere enganchar parse_query en absoluto:

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

    // solo mostrar estos filtros de taxonomía en los listados de tipos de publicación personalizados deseados
    global $typenow;
    if ($typenow == 'photos' || $typenow == 'videos') {

        // crear un array de slugs de taxonomía que deseas filtrar - si quieres recuperar todas las taxonomías, podrías usar get_taxonomies() para construir la lista
        $filters = array('plants', 'animals', 'insects');

        foreach ($filters as $tax_slug) {
            // recuperar el objeto de taxonomía
            $tax_obj = get_taxonomy($tax_slug);
            $tax_name = $tax_obj->labels->name;
            // recuperar array de objetos de término por taxonomía
            $terms = get_terms($tax_slug);

            // generar html para el filtro desplegable de taxonomía
            echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
            echo "<option value=''>Mostrar todos $tax_name</option>";
            foreach ($terms as $term) {
                // generar cada opción del select, verificando contra el último $_GET para mostrar la opción actual seleccionada
                echo '<option value='. $term->slug, $_GET[$tax_slug] == $term->slug ? ' selected="selected"' : '','>' . $term->name .' (' . $term->count .')</option>';
            }
            echo "</select>";
        }
    }
}

Simplemente conectando las taxonomías deseadas en el array $filters, puedes generar rápidamente múltiples filtros de taxonomía. Aparecen exactamente igual que en las capturas de pantalla de Mike. Luego puedes continuar con el paso #3 y #4.

Aquí hay una versión que crea y aplica automáticamente filtros de todas las taxonomías que se aplican a todos los tipos de entradas personalizadas que las utilizan. (qué trabalenguas) De todos modos, también lo ajusté para que funcione con wp_dropdown_categories() y WordPress 3.1. El proyecto en el que estoy trabajando se llama ToDo, puedes renombrar las funciones a algo que tenga sentido para ti, pero esto debería funcionar para casi todo automáticamente.

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' => __('Mostrar todos los '.$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');

Ten en cuenta que estoy usando un plugin que añade 'term_order' como una forma de ordenar términos, tendrás que cambiar eso, o eliminar ese argumento para volver al valor por defecto.

Respuesta tardía

Editar

He escrito Filterama, un plugin que añadirá esta funcionalidad de la manera más sencilla posible.

Actualización para WordPress 3.5+

Ahora que las cosas son mucho más fáciles, aquí hay una solución muy simple como plugin o mu-plugin.

Utiliza los mínimos recursos posibles, se carga solo en las pantallas necesarias y añade Columnas + Filtros para cada taxonomía personalizada.

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,
            ) );
        }

    }

}

Y luego solo necesitas una clase Walker personalizada.

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})"
                : ''
        );
    }
}

Solo quería hacer una nota rápida. En versiones más recientes de WP, los listados de entradas en el administrador son manejados por la clase WP_Posts_List_Table. El código apply_filters ahora es el siguiente:

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 );

Así que para añadir nuevas columnas, un hook add_filter debería ser así:

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

Aquí va un ejemplo:

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

Ahora, para las filas de entradas. Este es el código que maneja los datos de columnas en los listados:

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

Para recuperar los datos de nuestras entradas, debemos añadir un action hook así:

add_action( "manage_(aquí_va_tu_tipo_de_entrada)_posts_custom_column", "my_posttype_add_column", 10, 2);

Ejemplo (este ejemplo usa taxonomías, pero podrías consultar cualquier otra 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;
  }
}

FUNCIONA EN WP 3.2!

Tipo de entrada personalizada: libros Taxonomía personalizada: género

Solo modifica donde dice: // cambia AQUÍ

function restrict_books_by_genre() {
    global $typenow;
    $post_type = 'libros'; // cambia AQUÍ
    $taxonomy = 'género'; // cambia AQUÍ
    if ($typenow == $post_type) {
        $selected = isset($_GET[$taxonomy]) ? $_GET[$taxonomy] : '';
        $info_taxonomy = get_taxonomy($taxonomy);
        wp_dropdown_categories(array(
            'show_option_all' => __("Mostrar todos los {$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 = 'libros'; // cambia AQUÍ
    $taxonomy = 'género'; // cambia AQUÍ
    $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');

Tuve que trabajar en una característica similar no hace mucho tiempo, como no estaba satisfecho con las respuestas, aquí está mi alternativa. Año 2021.

Quería algo sencillo y simple de implementar. Obtener rápida y eficientemente todas las taxonomías personalizadas de cada tipo de entrada personalizada y añadirlas como opciones de filtro.

Había algunos requisitos previos:

• Quería evitar el uso de variables globales.
• El código debía ser portable, sin variables codificadas, para ser reutilizable.
• Tener algún tipo de jerarquía visible, perfecto para taxonomías con términos relacionados complejos.
• Necesitaba respetar la elección de visibilidad de la taxonomía. (ej: parámetro de argumento show_admin_column de la función register_taxonomy.
• Mostrar el conteo de entradas.
• Que la apariencia general coincidiera con WordPress.

Lo convertí en un plugin para una integración más fácil, puedes obtener la última versión en https://wordpress.org/plugins/cpt-admin-taxonomy-filtering/.

Filtro con jerarquía de términos y conteo de entradas	Filtros múltiples para tipos de entrada personalizados

Si solo quieres añadirlo a tu function.php, copia y pega el siguiente script.

Requiere al menos WordPress 4.8.0 y 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() {

        /**
         * Obtiene el objeto de la pantalla actual.
         * 
         * @link https://developer.wordpress.org/reference/functions/get_current_screen/
         */
        $screen = get_current_screen();

        // Filtrar los tipos de entrada predeterminados de WordPress
        $restricted_post_types = array(
            'post',
            'page',
            'attachment',
            'revision',
            'nav_menu_item',
        );

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

            /**
             * Devuelve los nombres u objetos de las taxonomías registradas para el objeto o tipo de objeto solicitado, como un objeto de entrada o nombre de tipo de entrada.
             * 
             * @link https://developer.wordpress.org/reference/functions/get_object_taxonomies/
             */
            $taxonomies = get_object_taxonomies( $screen->post_type, 'objects' );

            // Iterar a través de cada taxonomía
            foreach ( $taxonomies as $taxonomy ) {

                if ( $taxonomy->show_admin_column ) {

                    /**
                     * Muestra o recupera la lista desplegable HTML de categorías.
                     * 
                     * @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,
                        )
                    );

                };

            };

        };

    };

};

Esto no es muy conocido, supongo, pero desde WordPress 3.5, puedes pasar 'show_admin_column' => true a register_taxonomy. Esto hace 2 cosas:

1. Añade la columna de la taxonomía a la vista de lista del tipo de contenido en el admin
2. Al hacer clic en el nombre del término en la columna de taxonomía, filtrará la lista para mostrar solo ese término.

Así que no es exactamente lo mismo que tener un select, pero casi la misma funcionalidad, con solo una línea de código.

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

Además, como puedes leer, hay un nuevo filtro diseñado para añadir manualmente la columna de taxonomía (si realmente lo necesitas).

Gracias a todos por las respuestas. Sé que es una pregunta antigua, pero me gustaría añadir la solución más simple que se puede usar hoy en día. Solo requerirá 2 pasos y aprovechará más las funciones principales disponibles. Espero que esto ayude a alguien.

Paso 1: añadir 'show_admin_column' => true a tu función register_taxonomy.

Esto añadirá una columna a la vista de lista que contiene enlaces para filtrar la lista por ese término. Se puede aplicar tanto para taxonomías jerárquicas como no jerárquicas.

Ejemplo:

register_taxonomy( 'custom_cat', array( 'custom_post_type' ), array(
    'hierarchical'      => true,
    'labels'            => array(
        'name'              => __( 'Categorías', 'iside' ),
        'singular_name'     => __( 'Categoría', 'iside' ),
        'search_items'      => __( 'Buscar Categorías', 'iside' ),
        'all_items'         => __( 'Todas las Categorías', 'iside' ),
        'parent_item'       => __( 'Categoría Padre', 'iside' ),
        'parent_item_colon' => __( 'Categoría Padre:', 'iside' ),
        'edit_item'         => __( 'Editar Categoría', 'iside' ),
        'update_item'       => __( 'Actualizar Categoría', 'iside' ),
        'add_new_item'      => __( 'Añadir Nueva Categoría', 'iside' ),
        'new_item_name'     => __( 'Nueva Categoría', 'iside' ),
        'menu_name'         => __( 'Categorías', '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 aplicada aquí
    'query_var'         => true,
) );

Paso 2: añadir el desplegable de taxonomía mediante el filtro restrict_manage_posts

Esto añadirá un desplegable de selección a las opciones de filtro en la parte superior. Usará la función predeterminada wp_dropdown_categories para hacerlo más fácil. Ten en cuenta que necesitamos establecer el nombre del desplegable al query_var que usamos para la taxonomía. También nota que el value_field debe establecerse al slug (por defecto será el term_id).

Ejemplo:

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' =>  __( 'Mostrar Todas las Categorías', 'iside' ),
            'taxonomy'        =>  'custom_cat',
            'name'            =>  'custom_cat', // <-- asegúrate que coincida con el query_var
            'orderby'         =>  'name',
            'selected'        =>  $selected,
            'hierarchical'    =>  true,
            'depth'           =>  3,
            'show_count'      =>  true,
            'hide_empty'      =>  true,
            'value_field'     => 'slug', // <-- usa slug en lugar de term_id
        ));
    }
}

Eso es todo. No hace falta añadir más :-)

Aquí hay una forma de hacerlo usando la acción restrict_manage_posts. Parece funcionar bien para mí y añade la capacidad de filtrar por taxonomía para todos los tipos de post y sus taxonomías relacionadas.

// Registra cada uno de los desplegables de filtro por taxonomía
function sunrise_fbt_add_taxonomy_filters() {
    global $typenow;            // el tipo de post actual
    $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) {
              // Comprueba si es jerárquico - si es así construye un desplegable jerárquico
              if($tax->hierarchical) {
                $args = array(
                      'show_option_all'    => 'Todos los '.$tax->labels->name,
                      'show_option_none'   => 'Seleccionar '.$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=''>Mostrar todos los ".$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 una lista desplegable HTML de Categorías.
 *
 * @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 - Intenté restringir la profundidad porque algunas de mis taxonomías jerárquicas son bastante grandes pero no funcionó - ¿podría ser un error en la función wp_dropdown_categories?

Actualización de la respuesta de @Drew Gourley para WP 3.3.1 (e incorporando código de 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' => __('Mostrar todos los '.$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()
            ));
        }
    }
}


//Clase para el filtro desplegable. Se usa con wp_dropdown_categories() para que el desplegable resultante use slugs de términos en lugar de IDs.
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";
    }
}

Versión jerárquica de la respuesta de @somatic, como solicitó @kevin:

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

    // solo mostrar estos filtros de taxonomía en los listados de custom post_type deseados
    global $typenow;
    if ($typenow == 'photos' || $typenow == 'videos') {

        // crear un array de slugs de taxonomías que deseas filtrar - si quieres recuperar todas las taxonomías, podrías usar get_taxonomies() para construir la lista
        $filters = array('plants', 'animals', 'insects');

        foreach ($filters as $tax_slug) {
            // recuperar el objeto de taxonomía
            $tax_obj = get_taxonomy($tax_slug);
            $tax_name = $tax_obj->labels->name;

            // generar html para el dropdown de filtro de taxonomía
            echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
            echo "<option value=''>Mostrar todos $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) {
        // generar cada opción del select, verifica contra el último $_GET para mostrar la opción actual seleccionada
        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);
    }

}
?>

Básicamente eliminé el código que creaba las opciones y lo puse en su propia función. La función 'generate_taxonomy_options', además de tomar el tax_slug, también toma parámetros de parent y level. La función asume que está creando opciones para el parent 0, lo que seleccionará todos los términos de nivel raíz. En el bucle, la función se llamará a sí misma recursivamente, usando el término actual como padre e incrementando el nivel en uno. Automáticamente agrega guiones al costado mientras más profundo vayas en el árbol y ¡voilá!

Simplemente añade esto a tu functions.php o código de plugin (y reemplaza YOURCUSTOMTYPE y YOURCUSTOMTAXONOMY). (Obtuve el código de generatewp)

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

function filter_backend_by_taxonomies( $post_type, $which ) {
    // Aplicar esto a un CPT específico
    if ( 'YOURCUSTOMTYPE' !== $post_type )
        return;
    // Una lista de taxonomías personalizadas para filtrar
    $taxonomies = array( 'YOURCUSTOMTAXONOMY' );
    foreach ( $taxonomies as $taxonomy_slug ) {
        // Obtener datos de la taxonomía
        $taxonomy_obj = get_taxonomy( $taxonomy_slug );
        $taxonomy_name = $taxonomy_obj->labels->name;
        // Obtener términos de la taxonomía
        $terms = get_terms( $taxonomy_slug );
        // Mostrar HTML del filtro
        echo "<select name='{$taxonomy_slug}' id='{$taxonomy_slug}' class='postform'>";
        echo '<option value="">' . sprintf( esc_html__( 'Categoría', '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>';
    }
}

¡El tutorial de Mike sobre esto es genial! Probablemente no me habría molestado en agregar esta funcionalidad a mi plugin de Categorías de Medios si hubiera tenido que averiguarlo por mí mismo.

Dicho esto, creo que usar parse_query y luego obtener la consulta del término no es necesario. Es más limpio crear tu propia clase personalizada de walker. Quizás eso no era posible cuando escribió su publicación, tiene 3 años al momento de escribir esto.

Echa un vistazo a este gran fragmento en github. Funciona de maravilla, cambia los IDs en los valores del dropdown por slugs, así que funciona de forma nativa sin modificar la consulta.

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

Acabo de probar ambos códigos, el de Mike y el de somatic, y me preguntaba cómo obtener una cosa de cada técnica:

Con el código de Mike, muestra la lista desplegable con la opción jerárquica, lo cual ayuda mucho. Pero para mostrar dos listas desplegables, tuve que duplicar la declaración if ($typenow=='produtos') {...} en la función restrict_listings_by_business() y también el if ($pagenow=='edit.php' && ... } en la función convert_business_id_to_taxonomy_term_in_query($query), lo que ahora genera mucho código.

Con el código de somatic, solo necesito especificar las taxonomías que me gustaría ver como listas desplegables y listo, funciona: $filters = array('taxo1', 'taxo2');

Pregunta: ¿puedo adoptar el enfoque de somatic y también tener la opción jerárquica?

¡Muchas gracias de todos modos por este tutorial, me ayudó mucho!

Este es un fragmento de código potente y pequeño que permite filtrar tus entradas o tipos de contenido personalizados por un término de taxonomía específico en el administrador de WordPress.

/* Filtrar CPT por Taxonomía Personalizada */
function rave_core_backend_by_portfolio_taxonomies( $post_type, $which ) {
    // Aplicar esto a un CPT específico
    if ( 'portfolio' !== $post_type )
        return;

    // Una lista de slugs de taxonomías personalizadas para filtrar
    $taxonomies = array( 'portfolio_cat' );

    foreach ( $taxonomies as $taxonomy_slug ) {

        // Recuperar datos de la taxonomía
        $taxonomy_obj = get_taxonomy( $taxonomy_slug );
        $taxonomy_name = $taxonomy_obj->labels->name;

        // Recuperar términos de la taxonomía
        $terms = get_terms( $taxonomy_slug );

        // Mostrar HTML del filtro
        echo "<select name='{$taxonomy_slug}' id='{$taxonomy_slug}' class='postform'>";
        echo '<option value="">' . sprintf( esc_html__( 'Todos los %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);

Disculpas por el hecho de que, como usuario nuevo, no puedo publicar comentarios pero sí puedo publicar una respuesta...

A partir de WordPress 3.1 (RC 1) la respuesta de Mike (que me había funcionado tan bien durante los últimos meses) ya no me funciona; restringir por cualquier taxonomía hija devuelve un resultado vacío.

Probé la actualización de Somatic y funcionó genial; aún mejor, funciona con consultas de taxonomía múltiple lo cual ha sido incorporado en esta versión.