Adăugarea unui filtru de taxonomie la lista de administrare pentru un tip de postare personalizat?

Am vrut să împărtășesc o implementare alternativă. Nu am avut incredibilul tutorial al lui Mike când am încercat să rezolv această problemă, așa că soluția mea este puțin diferită. Mai exact, voi simplifica pasul #1 al lui Mike și voi elimina pasul #2 - ceilalți pași rămân valabili.

În tutorialul lui Mike, folosirea funcției wp_dropdown_categories() ne scutește de construirea manuală a listei, dar necesită o modificare condiționată complicată a interogării (pasul #2) pentru a gestiona utilizarea ID-ului în loc de slug. Ca să nu mai vorbim de dificultatea de a modifica acel cod pentru a gestiona alte scenarii, cum ar fi filtrele pentru multiple taxonomii.

O altă abordare este să nu folosim deloc funcția imperfectă wp_dropdown_categories(), ci să construim propriile noastre liste dropdown de la zero. Nu este atât de complicat, necesită mai puțin de 30 de linii de cod și nu necesită deloc utilizarea hook-ului parse_query:

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

    // afișăm aceste filtre de taxonomie doar pe listările dorite de custom post_type
    global $typenow;
    if ($typenow == 'photos' || $typenow == 'videos') {

        // creăm un array de slug-uri de taxonomii pe care vrem să le filtrăm - dacă vrem să preluăm toate taxonomiile, putem folosi get_taxonomies() pentru a construi lista
        $filters = array('plants', 'animals', 'insects');

        foreach ($filters as $tax_slug) {
            // preluăm obiectul taxonomiei
            $tax_obj = get_taxonomy($tax_slug);
            $tax_name = $tax_obj->labels->name;
            // preluăm array-ul de obiecte termen pentru fiecare taxonomie
            $terms = get_terms($tax_slug);

            // generăm html pentru dropdown-ul de filtrare a taxonomiei
            echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
            echo "<option value=''>Afișează tot $tax_name</option>";
            foreach ($terms as $term) {
                // generăm fiecare opțiune selectată, verificând ultima valoare $_GET pentru a afișa opțiunea curentă selectată
                echo '<option value='. $term->slug, $_GET[$tax_slug] == $term->slug ? ' selected="selected"' : '','>' . $term->name .' (' . $term->count .')</option>';
            }
            echo "</select>";
        }
    }
}

Prin simpla introducere a taxonomiilor dorite în array-ul $filters, puteți genera rapid mai multe filtre de taxonomie. Acestea apar exact la fel ca în capturile de ecran ale lui Mike. Apoi puteți continua cu pasul #3 și #4.

Iată o versiune care creează și aplică automat filtre pentru toate taxonomiile care se aplică tuturor tipurilor de postări personalizate care le folosesc. (ce formulare lungi) Oricum, am ajustat-o să funcționeze cu wp_dropdown_categories() și WordPress 3.1. Proiectul la care lucrez se numește ToDo, poți redenumi funcțiile cu ceva care are sens pentru tine, dar acest cod ar trebui să funcționeze pentru aproape orice în mod automat.

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' => __('Afișează Tot '.$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');

Reține că folosesc un plugin care adaugă 'term_order' ca modalitate de ordonare a termenilor, va trebui să modifici acest lucru sau să elimini acel argument pentru a reveni la valoarea implicită.

Răspuns întârziat

Editare

Am creat Filterama, un plugin care va adăuga această funcționalitate în cel mai simplu mod posibil.

Actualizare pentru WordPress 3.5+

Acum că lucrurile sunt mult mai simple, iată o soluție foarte ușoară ca plugin sau mu-plugin.

Folosește cât mai puține resurse, se încarcă doar pe ecranele necesare și adaugă Coloane + Filtre pentru fiecare taxonomie personalizată.

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

    }

}

Apoi aveți nevoie doar de o clasă Walker personalizată.

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

Am vrut să fac o notă rapidă. În versiunile mai noi de WP, afișarea postărilor în administrare este gestionată de clasa WP_Posts_List_Table. Codul apply_filters arată acum astfel:

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

Deci, pentru a adăuga coloane noi, un add_filter ar trebui să arate astfel:

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

Iată un exemplu:

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

Acum, pentru rândurile de postări. Acesta este codul care gestionează datele coloanelor în liste:

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

Pentru a prelua datele postărilor noastre, trebuie să adăugăm un action hook astfel:

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

Exemplu (acest exemplu folosește taxonomii, dar puteți interoga orice altceva):

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

FUNCȚIONEAZĂ ÎN WP 3.2!

custom_post_type: books custom_taxonomy: genre

Modifică doar unde scrie: // 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' => __("Arată toate {$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');

A trebuit să lucrez la o funcționalitate similară nu cu mult timp în urmă și nefiind mulțumit de răspunsurile existente, iată alternativa mea. Anul este 2021.

Am dorit ceva simplu și ușor de implementat. O modalitate rapidă și eficientă de a obține toate taxonomiile personalizate din fiecare tip de postare personalizată și de a le adăuga ca opțiuni de filtrare.

Erau câteva cerințe preliminare:

• Am vrut să evit utilizarea variabilelor globale.
• Codul trebuia să fie portabil, fără variabile hardcodate, pentru a fi reutilizabil.
• Să aibă o ierarhie vizibilă, perfectă pentru taxonomii cu termeni înrudite.
• Să respecte opțiunile de vizibilitate ale taxonomiei. (ex: argumentul show_admin_column din funcția register_taxonomy.
• Afișarea numărului de postări.
• Aspectul general să se potrivească cu WordPress.

Am transformat-o într-un plugin pentru o integrare mai ușoară, puteți obține ultima versiune la https://wordpress.org/plugins/cpt-admin-taxonomy-filtering/.

Filtrare cu ierarhie de termeni și număr de postări	Filtre multiple pentru tipuri de postări personalizate

Dacă doriți doar să o adăugați în function.php, copiați și lipiți următorul script.

Necesită cel puțin WordPress 4.8.0 și 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() {

        /**
         * Obține obiectul ecranului curent.
         * 
         * @link https://developer.wordpress.org/reference/functions/get_current_screen/
         */
        $screen = get_current_screen();

        // Tipuri de postări implicite WordPress
        $restricted_post_types = array(
            'post',
            'page',
            'attachment',
            'revision',
            'nav_menu_item',
        );

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

            /**
             * Returnează numele sau obiectele taxonomiilor înregistrate pentru obiectul sau tipul de obiect solicitat, cum ar fi un obiect de postare sau numele tipului de postare.
             * 
             * @link https://developer.wordpress.org/reference/functions/get_object_taxonomies/
             */
            $taxonomies = get_object_taxonomies( $screen->post_type, 'objects' );

            // Parcurge fiecare taxonomie
            foreach ( $taxonomies as $taxonomy ) {

                if ( $taxonomy->show_admin_column ) {

                    /**
                     * Afișează sau returnează lista dropdown HTML de categorii.
                     * 
                     * @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,
                        )
                    );

                };

            };

        };

    };

};

Această funcționalitate nu este foarte cunoscută, dar începând cu WordPress 3.5, poți pasa parametrul 'show_admin_column' => true la register_taxonomy. Aceasta face două lucruri:

1. Adaugă coloana taxonomiei în vizualizarea listei tipurilor de postări din panoul de administrare
2. Făcând clic pe numele termenului din coloana taxonomiei, lista va fi filtrată automat după acel termen.

Deci, nu exact la fel ca un câmp de selectare, dar aproape aceeași funcționalitate, cu doar o singură linie de cod.

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

De asemenea, după cum poți citi, există un nou filtru special pentru adăugarea manuală a coloanei taxonomiei (dacă chiar ai nevoie de asta).

Mulțumesc tuturor pentru răspunsuri. Știu că aceasta este o întrebare veche, dar aș dori să adaug soluția mai simplă care poate fi folosită în prezent. Acest lucru va necesita doar 2 pași și va folosi mai multe funcționalități disponibile în nucleu. Sper că acest lucru va ajuta pe cineva.

Pasul 1: adăugați 'show_admin_column' => true în funcția register_taxonomy.

Acest lucru va adăuga o coloană în vizualizarea listă care conține link-uri pentru filtrarea listei după acel termen. Poate fi aplicat atât pentru taxonomii ierarhice, cât și pentru cele neierarhice.

Exemplu:

register_taxonomy( 'custom_cat', array( 'custom_post_type' ), array(
    'hierarchical'      => true,
    'labels'            => array(
        'name'              => __( 'Categorii', 'iside' ),
        'singular_name'     => __( 'Categorie', 'iside' ),
        'search_items'      => __( 'Caută Categorii', 'iside' ),
        'all_items'         => __( 'Toate Categoriile', 'iside' ),
        'parent_item'       => __( 'Categorie Părinte', 'iside' ),
        'parent_item_colon' => __( 'Categorie Părinte:', 'iside' ),
        'edit_item'         => __( 'Editează Categorie', 'iside' ),
        'update_item'       => __( 'Actualizează Categorie', 'iside' ),
        'add_new_item'      => __( 'Adaugă Categorie Nouă', 'iside' ),
        'new_item_name'     => __( 'Nouă Categorie', 'iside' ),
        'menu_name'         => __( 'Categorii', '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, // <-- magia aplicată aici
    'query_var'         => true,
) );

Pasul 2: adăugați dropdown-ul de taxonomie prin filtrul restrict_manage_posts

Acest lucru va adăuga un meniu dropdown de selectare în opțiunile de filtrare din partea de sus. Va folosi funcția implicită wp_dropdown_categories pentru a simplifica procesul. Rețineți că trebuie să setăm numele dropdown-ului la query_var folosit pentru taxonomie. De asemenea, rețineți că value_field trebuie setat la slug (implicit va fi term_id).

Exemplu:

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' =>  __( 'Arată Toate Categoriile', 'iside' ),
            'taxonomy'        =>  'custom_cat',
            'name'            =>  'custom_cat', // <-- asigurați-vă că se potrivește cu query_var
            'orderby'         =>  'name',
            'selected'        =>  $selected,
            'hierarchical'    =>  true,
            'depth'           =>  3,
            'show_count'      =>  true,
            'hide_empty'      =>  true,
            'value_field'     => 'slug', // <-- folosește slug în loc de term_id
        ));
    }
}

Atât. Nu este nevoie să adăugați mai mult :-)

Iată o modalitate de a face acest lucru folosind acțiunea restrict_manage_posts. Pare să funcționeze bine pentru mine și adaugă abilitatea de a filtra după taxonomie pentru toate tipurile de postări și taxonomiile aferente.

// înregistrează fiecare meniu derulant pentru filtrarea după taxonomii
function sunrise_fbt_add_taxonomy_filters() {
    global $typenow;            // tipul curent de postare
    $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) {
              // Verifică dacă e ierarhic - dacă da, construiește meniu derulant ierarhic
              if($tax->hierarchical) {
                $args = array(
                      'show_option_all'    => 'Toate '.$tax->labels->name,
                      'show_option_none'   => 'Selectează '.$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=''>Afișează toate ".$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 );

/**
 * Creează o listă derulantă HTML de Categorii.
 *
 * @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";
        }
} 

O observație - am încercat să limitez adâncimea deoarece unele dintre taxonomiile mele ierarhice sunt destul de mari, dar nu a funcționat - ar putea fi o eroare în funcția wp_dropdown_categories?

Actualizare a răspunsului lui @Drew Gourley pentru WP 3.3.1 (și incorporând codul de la 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' => __('Arată Tot '.$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()
            ));
        }
    }
}


//Clasă pentru filtrarea dropdown. Folosită cu wp_dropdown_categories() pentru a face dropdown-ul să folosească slug-uri în loc de ID-uri.
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";
    }
}

Versiunea ierarhică a răspunsului lui @somatic, la cererea lui @kevin:

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

    // afișează aceste filtre de taxonomie doar pe listările dorite de tipuri personalizate de postări
    global $typenow;
    if ($typenow == 'photos' || $typenow == 'videos') {

        // creează o listă de slug-uri de taxonomii după care dorești să filtrezi - dacă vrei să obții toate taxonomiile, poți folosi get_taxonomies() pentru a construi lista
        $filters = array('plants', 'animals', 'insects');

        foreach ($filters as $tax_slug) {
            // obține obiectul taxonomiei
            $tax_obj = get_taxonomy($tax_slug);
            $tax_name = $tax_obj->labels->name;

            // generează HTML pentru meniul dropdown de filtrare după taxonomie
            echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
            echo "<option value=''>Afișează tot $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) {
        // generează fiecare opțiune pentru select, verifică ultima valoare $_GET pentru a afișa opțiunea curentă selectată
        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);
    }

}
?>

Am eliminat practic codul care crea opțiunile și l-am pus într-o funcție separată. Funcția 'generate_taxonomy_options', pe lângă parametrul tax_slug, mai primește și parametrii parent și level. Funcția presupune că creează opțiuni pentru părintele 0, care va selecta toți termenii de la nivelul rădăcină. În buclă, funcția se va apela recursiv, folosind termenul curent ca părinte și crește nivelul cu unu. Adaugă automat liniuțe pe măsură ce cobori în ierarhie și voila!

Adaugă pur și simplu acest cod în fișierul functions.php sau în codul unui plugin (și înlocuiește YOURCUSTOMTYPE și YOURCUSTOMTAXONOMY). (Am obținut codul de pe generatewp)

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

function filter_backend_by_taxonomies( $post_type, $which ) {
    // Aplică acest filtru doar pentru un anumit tip de postare personalizată (CPT)
    if ( 'YOURCUSTOMTYPE' !== $post_type )
        return;
    // Listă de taxonomii personalizate după care se filtrează
    $taxonomies = array( 'YOURCUSTOMTAXONOMY' );
    foreach ( $taxonomies as $taxonomy_slug ) {
        // Preluare date despre taxonomie
        $taxonomy_obj = get_taxonomy( $taxonomy_slug );
        $taxonomy_name = $taxonomy_obj->labels->name;
        // Preluare termeni ai taxonomiei
        $terms = get_terms( $taxonomy_slug );
        // Afișare HTML pentru filtru
        echo "<select name='{$taxonomy_slug}' id='{$taxonomy_slug}' class='postform'>";
        echo '<option value="">' . sprintf( esc_html__( 'Categorie', '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>';
    }
}

Tutorialul lui Mike pe acest subiect este excelent! Probabil că nu m-aș fi obosit să adaug această funcționalitate în plugin-ul meu Media Categories dacă ar fi trebuit să o descopăr singur.

Cu toate acestea, cred că utilizarea parse_query și apoi interogarea pentru termen nu este necesară. Este mai curat să creezi propria clasă personalizată walker. Poate că acest lucru nu era posibil atunci când a scris postarea sa - are 3 ani la momentul scrierii acestui text.

Verifică acest fragment de cod minunat de pe github. Funcționează perfect, schimbă ID-urile din valorile dropdown-ului în slug-uri, astfel încât funcționează în mod nativ fără a modifica interogarea.

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

Am încercat ambele coduri, de la Mike și somatic, și m-am întrebat cum să obțin un lucru din fiecare tehnică:

Cu codul lui Mike, afișează lista derulantă cu opțiunea ierarhică, ceea ce ajută foarte mult. Dar pentru a afișa două liste derulante a trebuit să duplic instrucțiunea if ($typenow=='produtos') {...} în funcția restrict_listings_by_business() și de asemenea if ($pagenow=='edit.php' && ... } în funcția convert_business_id_to_taxonomy_term_in_query($query), ceea ce acum produce mult cod.

Cu codul lui somatic, trebuie doar să specific taxonomiile pe care doresc să le văd ca liste derulante și funcționează; $filters = array('taxo1', 'taxo2');

Întrebare: pot să folosesc abordarea lui somatic și să am și opțiunea ierarhică?

Mulțumesc mult oricum pentru acest tutorial, a fost de mare ajutor!

Acesta este un fragment de cod util care permite filtrarea postărilor sau a unui tip de postare personalizată după un termen specific dintr-o taxonomie în panoul de administrare WordPress.

/* Filtrează CPT după Taxonomie Personalizată */
function rave_core_backend_by_portfolio_taxonomies( $post_type, $which ) {
    // Aplică acest filtru doar pentru un anumit CPT
    if ( 'portfolio' !== $post_type )
        return;

    // Listă de slug-uri de taxonomii personalizate după care se filtrează
    $taxonomies = array( 'portfolio_cat' );

    foreach ( $taxonomies as $taxonomy_slug ) {

        // Preluare date despre taxonomie
        $taxonomy_obj = get_taxonomy( $taxonomy_slug );
        $taxonomy_name = $taxonomy_obj->labels->name;

        // Preluare termeni din taxonomie
        $terms = get_terms( $taxonomy_slug );

        // Afișare HTML pentru filtru
        echo "<select name='{$taxonomy_slug}' id='{$taxonomy_slug}' class='postform'>";
        echo '<option value="">' . sprintf( esc_html__( 'Toate %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 cer scuze pentru faptul că, fiind un utilizator nou, nu pot posta comentarii, dar pot posta un răspuns...

Începând cu WordPress 3.1 (RC 1), răspunsul lui Mike (care m-a ajutat atât de bine în ultimele luni) nu mai funcționează pentru mine; limitarea după orice termen dintr-o taxonomie copil returnează un rezultat gol.

Am încercat actualizarea lui Somatic și a funcționat excelent; chiar mai bine, funcționează cu interogări multiple de taxonomii, care au fost integrate în această versiune.