È possibile ottenere get_terms per tassonomia E post_type?

Mi è capitato di aver bisogno di qualcosa del genere per un progetto su cui sto lavorando. Ho semplicemente scritto una query per selezionare tutti i post di un tipo personalizzato, poi ho verificato quali sono i termini effettivi della mia tassonomia che stanno utilizzando.

Poi ho ottenuto tutti i termini di quella tassonomia usando get_terms() e ho utilizzato solo quelli presenti in entrambe le liste, ho racchiuso tutto in una funzione e ho finito.

Ma poi avevo bisogno di più che solo gli ID: mi servivano i nomi, quindi ho aggiunto un nuovo argomento chiamato $fields per poter specificare alla funzione cosa restituire. Poi ho pensato che get_terms accetta molti argomenti e la mia funzione era limitata solo ai termini utilizzati da un tipo di post, quindi ho aggiunto un ulteriore if ed ecco qui:

La Funzione:

/* ottiene i termini limitati a un tipo di post 
 @ $taxonomies - (string|array) (obbligatorio) Le tassonomie da cui recuperare i termini. 
 @ $args  -  (string|array) tutti i possibili argomenti di get_terms http://codex.wordpress.org/Function_Reference/get_terms
 @ $post_type - (string|array) i tipi di post a cui limitare i termini
 @ $fields - (string) Cosa restituire (predefinito: all) accetta ID,name,all,get_terms. 
 se vuoi usare gli argomenti di get_terms allora $fields deve essere impostato su 'get_terms'
*/
function get_terms_by_post_type($taxonomies,$args,$post_type,$fields = 'all'){
    $args = array(
        'post_type' => (array)$post_type,
        'posts_per_page' => -1
    );
    $the_query = new WP_Query( $args );
    $terms = array();
    while ($the_query->have_posts()){
        $the_query->the_post();
        $curent_terms = wp_get_object_terms( $post->ID, $taxonomy);
        foreach ($curent_terms as $t){
          //evita duplicati
            if (!in_array($t,$terms)){
                $terms[] = $c;
            }
        }
    }
    wp_reset_query();
    //restituisce un array di oggetti termine
    if ($fields == "all")
        return $terms;
    //restituisce un array di ID dei termini
    if ($fields == "ID"){
        foreach ($terms as $t){
            $re[] = $t->term_id;
        }
        return $re;
    }
    //restituisce un array di nomi dei termini
    if ($fields == "name"){
        foreach ($terms as $t){
            $re[] = $t->name;
        }
        return $re;
    }
    // ottiene i termini con gli argomenti di get_terms
    if ($fields == "get_terms"){
        $terms2 = get_terms( $taxonomies, $args );
        foreach ($terms as $t){
            if (in_array($t,$terms2)){
                $re[] = $t;
            }
        }
        return $re;
    }
}

Utilizzo:

Se hai bisogno solo di una lista di ID dei termini allora:

$terms = get_terms_by_post_type('tag','','snippet','ID');

Se hai bisogno solo di una lista di nomi dei termini allora:

$terms = get_terms_by_post_type('tag','','snippet','name');

Se hai bisogno solo di una lista di oggetti termine allora:

$terms = get_terms_by_post_type('tag','','snippet');

E se hai bisogno di usare argomenti aggiuntivi di get_terms come: orderby, order, hierarchical ...

$args = array('orderby' => 'count', 'order' => 'DESC',  'hide_empty' => 1);
$terms = get_terms_by_post_type('tag',$args,'snippet','get_terms');

Divertiti!

Aggiornamento:

Per correggere il conteggio dei termini per un tipo di post specifico cambia:

foreach ($current_terms as $t){
          //evita duplicati
            if (!in_array($t,$terms)){
                $terms[] = $t;
            }
        }

in:

foreach ($current_terms as $t){
    //evita duplicati
    if (!in_array($t,$terms)){
        $t->count = 1;
        $terms[] = $t;
    }else{
        $key = array_search($t, $terms);
        $terms[$key]->count = $terms[$key]->count + 1;
    }
}

Ottima domanda e risposte solide.

Mi è piaciuto molto l'approccio di @jessica utilizzando il filtro terms_clauses, perché estende la funzione get_terms in modo molto ragionevole.

Il mio codice è una continuazione della sua idea, con un po' di SQL preso da @braydon per ridurre i duplicati. Consente anche di utilizzare un array di post_types:

/**
 * my_terms_clauses
 *
 * filtra le clausole dei termini
 *
 * @param $clauses array
 * @param $taxonomy string
 * @param $args array
 * @return array
 **/
function my_terms_clauses($clauses, $taxonomy, $args)
{
  global $wpdb;

  if ($args['post_types'])
  {
    $post_types = implode("','", array_map('esc_sql', (array) $args['post_types']));

    // consente gli array
    if ( is_array($args['post_types']) ) {
      $post_types = implode( "','", $args['post_types'] );
    }
    $clauses['join'] .= " INNER JOIN $wpdb->term_relationships AS r ON r.term_taxonomy_id = tt.term_taxonomy_id INNER JOIN $wpdb->posts AS p ON p.ID = r.object_id";
    $clauses['where'] .= " AND p.post_type IN ('". $post_types. "') GROUP BY t.term_id";
  }
  return $clauses;
}
add_filter('terms_clauses', 'my_terms_clauses', 99999, 3);

Poiché get_terms non ha una clausola per GROUP BY, ho dovuto aggiungerla alla fine della clausola WHERE. Nota che ho impostato la priorità del filtro molto alta, sperando che venga sempre eseguito per ultimo.

Ho scritto una funzione che permette di passare post_type nell'array $args alla funzione get_terms():

Un ringraziamento speciale a @braydon per aver scritto l'SQL.

 /**
 * terms_clauses
 *
 * Filtra le clausole dei termini
 *
 * @param $clauses array
 * @param $taxonomy string
 * @param $args array
 * @return array
**/
function terms_clauses($clauses, $taxonomy, $args)
{
    global $wpdb;

    if ($args['post_type'])
    {
        $clauses['join'] .= " INNER JOIN $wpdb->term_relationships AS r ON r.term_taxonomy_id = tt.term_taxonomy_id INNER JOIN $wpdb->posts AS p ON p.ID = r.object_id";
        $clauses['where'] .= " AND p.post_type='{$args['post_type']}'"; 
    }
    return $clauses;
}
add_filter('terms_clauses', 'terms_clauses', 10, 3);

Non sono riuscito a far funzionare gli argomenti di get_terms con la versione del codice di Gavin sopra riportata, ma alla fine ci sono riuscito cambiando

$terms2 = get_terms( $taxonomy );

in

$terms2 = get_terms( $taxonomy, $args );

come era nella funzione originale di Bainternet.

@Bainternet: Grazie! Ho dovuto modificare leggermente la funzione perché non funzionava (alcuni errori di battitura). L'unico problema ora è che il conteggio dei termini non è corretto. Il conteggio non tiene conto del tipo di post, quindi penso che non si possa usare get_terms() in questo caso.

function get_terms_by_post_type($post_type,$taxonomy,$fields='all',$args){
    $q_args = array(
        'post_type' => (array)$post_type,
        'posts_per_page' => -1
    );
    $the_query = new WP_Query( $q_args );

    $terms = array();

    while ($the_query->have_posts()) { $the_query->the_post();

        global $post;

        $current_terms = get_the_terms( $post->ID, $taxonomy);

        foreach ($current_terms as $t){
            //evita duplicati
            if (!in_array($t,$terms)){
                $t->count = 1;
                $terms[] = $t;
            }else{
                $key = array_search($t, $terms);
                $terms[$key]->count = $terms[$key]->count + 1;
            }
        }
    }
    wp_reset_query();

    //ritorna un array di oggetti term
    if ($fields == "all")
        return $terms;
    //ritorna un array di ID dei termini
    if ($fields == "ID"){
        foreach ($terms as $t){
            $re[] = $t->term_id;
        }
        return $re;
    }
    //ritorna un array di nomi dei termini
    if ($fields == "name"){
        foreach ($terms as $t){
            $re[] = $t->name;
        }
        return $re;
    }
    // ottieni i termini con gli argomenti di get_terms
    if ($fields == "get_terms"){
        $terms2 = get_terms( $taxonomy, $args );

        foreach ($terms as $t){
            if (in_array($t,$terms2)){
                $re[] = $t;
            }
        }
        return $re;
    }
}

MODIFICA: Aggiunte le correzioni. Ma in qualche modo ancora non funziona per me. Il conteggio mostra ancora il valore errato.

Evita duplicati:

//evita duplicati
    $mivalor=$t->term_id;
    $arr=array_filter($terms, function ($item) use ($mivalor) {return isset($item->term_id) && $item->term_id == $mivalor;});

    if (empty($arr)){
    $t->count=1;
            $terms[] = $t;
        }else{
            $key = array_search($t, $terms);
            $terms[$key]->count = $terms[$key]->count + 1;
        }