web-dev-qa-db-fra.com

wp_insert_term nom unique automatique

Lors de la création d'un nouveau terme dans une taxonomie personnalisée avec wp_insert_term, j'ai remarqué que ce nom devait être unique. Je reçois un message d'erreur wp s'il ne l'est pas:

A term with the name provided already exists with this parent

Je voudrais un moyen de vérifier automatiquement si le nom existe déjà et de l'ajouter si oui.

Alors vérifiez:

get_term_by('name', $term_id, $taxonomy);

et si terme existe, ajoutez le nom.

mais y a-t-il un moyen de le faire avec WP? Comme WP fait avec slug? Pourquoi le nom devrait être unique, ne comprend pas comme la limace est.

merci beaucoup !

François

custom-taxonomyterms
3
Polykrom

MODIFIER

PART DEUX OR PART DEUX - The Dirty Sequal, le terme Saga continue ...

Avant que quiconque ne lise cette section, je vous demanderai instamment de lire tout ce que j'ai expliqué dans RÉPONSE ORIGINALE . wp_insert_term() n'autorise pas les noms de termes en double dans les taxonomies non hiérarchiques ou dans les taxonomies hiérarchiques de la même hiérarchie.

Des commentaires à ma réponse, la réponse de OP et de OP

Ce dont j'ai besoin, c'est d'un moyen d'avoir le même nom dans la hiérarchie de la taxonomie.

Il existe un moyen d'y parvenir: voyons comment:

ATTENTION - attention - ATTENTION - attention !!!!

Je suis allé avec une classe modifiée de la fonction wp_insert_term(). Comme je l'ai dit, il existe une protection dans wp_insert_term() pour éviter les noms de termes en double. Ce que j'ai fait est de supprimer cette protection afin de permettre les noms en double dans la même hiérarchie. En principe, vous devez supprimer la section de vérification du nom, puis la section qui supprime les doublons accidentels lorsque le terme est déjà inséré.

Pour cette raison, cette classe autorisera un nombre illimité de termes du même nom. Elle doit donc être utilisée avec great care . 100 chargements de page accidentels insèreront 100 termes du même nom.

Voici la classe avec quelques notes

NOTE:

  • Cela nécessite au moins PHP 5.4.

  • Bien que j’ai effectué quelques tests pour vérifier le fonctionnement de la classe, je n’ai effectué aucun test complet à ce sujet. PLEASE PLEASE PLEASE: lancez-le d’abord sur une installation de test locale et vérifiez le tout correctement.

  • La classe peut être améliorée et modifiée au besoin. Je pourrais avoir des syntaxes mixtes et du code brouillé. Ceci est juste une colonne vertébrale très basique avec seulement l'essentiel

Regardons le code:

/**
 * WPInsertTerm class
 *
 * Class to insert terms into the db
 * 
 * If term names are identical, in stead of throwing an error like
 * wp_insert_term(), the function will add valid term meta_key
 * 
 * @author   Pieter Goosen
 * @version  1.0.0
 * @access   public
*/ 

class WPInsertTerm 
{
    /**
     * Arguments to hold defaults
     * @since 1.0.0
     * @var array
    */
    protected $defaults = [
        'alias_of' => '', 
        'description' => '', 
        'parent' => 0, 
        'slug' => ''
    ];

    /**
     * Arguments set by user
     * @since 1.0.0
     * @var array
    */
    protected $args = [];

    /**
     * Term to insert
     * @since 1.0.0
     * @var string
    */
    protected $term = null;

    /**
     * Taxonomy the term should belong to
     * @since 1.0.0
     * @var string
    */
    protected $taxonomy = null;

    /**
     * Constructor
     *
     * @param string $term = null
     * @param string $taxonomy = null
     * @param array  $args = []
     * @since 1.0.0
     */     
    public function __construct( $term = null, $taxonomy = null, $args = [] ) 
    {
        $this->term     = $term;
        $this->taxonomy = $taxonomy;
        if ( is_array( $args ) ) {
            $this->args = array_merge( $this->defaults, $args );
        } else { 
            $this->args = $this->defaults;
        }
    }

    /**
     * Public method wpdb()
     *
     * Returns the global wpdb class
     *
     * @since 1.0.0
     * @return $wpdb
     */
    public function wpdb()
    {
        global $wpdb;

        return $wpdb;
    }

    /**
     * Private method validateVersion()
     *
     * Validate the current WordPress version
     *
     * @since 1.0.0
     * @return $validateVersion
     */
    private function validateVersion()
    {
        global $wp_version;

        $validateVersion = false;

        if ( '4.4' > $wp_version ) {
            throw new InvalidArgumentException( 
                sprintf(
                    __( 'Your WordpPress version is too old. A minimum version of WordPress 4.4 is expected. Please upgrade' ),
                    __METHOD__
                )
            );
        }

        return $validateVersion = true;
    }

    /**
     * Private method validateTaxonomy()
     *
     * Validate the $taxonomy value
     *
     * @since 1.0.0
     * @return $validateTaxonomy
     */
    private function validateTaxonomy()
    { 
        $validateTaxonomy = filter_var( $this->taxonomy, FILTER_SANITIZE_STRING );
        // Check if taxonomy is valid
        if ( !taxonomy_exists( $validateTaxonomy )  ) {
            throw new InvalidArgumentException( 
                sprintf(
                    __( 'Your taxonomy does not exists, please add a valid taxonomy' ),
                    __METHOD__
                )
            );
        }

        return $validateTaxonomy;
    }

    /**
     * Private method validateTerm()
     *
     * Validate the $term value
     *
     * @since 1.0.0
     * @return $validateTerm
     */
    private function validateTerm()
    {
        /**
         * Filter a term before it is sanitized and inserted into the database.
         *
         * @since 1.0.0
         *
         * @param string $term     The term to add or update.
         * @param string $taxonomy Taxonomy slug.
         */
        $validateTerm = apply_filters( 'pre_insert_term', $this->term, $this->validateTaxonomy() );     

        // Check if the term is not empty
        if ( empty( $validateTerm ) ) {
            throw new InvalidArgumentException( 
                sprintf(
                    __( '$term should not be empty, please add a valid value' ),
                    __METHOD__
                )
            );
        }

        // Check if term is a valid integer if integer is passed
        if (    is_int( $validateTerm )
             && 0 == $validateTerm
        ){
            throw new InvalidArgumentException( 
                sprintf(
                    __('Invalid term id supplied, please asdd a valid value'),
                    __METHOD__
                )
            );
        }

        // Term is not empty, sanitize the term and trim any white spaces
        $validateTerm = filter_var( trim( $validateTerm ), FILTER_SANITIZE_STRING );
        if ( empty( $validateTerm ) ){
            throw new InvalidArgumentException( 
                sprintf(
                    __( 'Invalid term supplied, please asdd a valid term name' ),
                    __METHOD__
                )
            );
        }

        return $validateTerm;
    }

    /**
     * Private method parentExist()
     *
     * Validate if the parent term exist if passed
     *
     * @since 1.0.0
     * @return $parentexist
     */
    private function parentExist()
    {
        $parentExist = $this->args['parent'];

        if (    $parentExist > 0
             && !term_exists( (int) $parentExist ) 
        ) {
            throw new InvalidArgumentException( 
                sprintf(
                    __( 'Invalid parent ID supplied, no term exists with parent ID passed. Please add a valid parent ID' ),
                    __METHOD__
                )
            );
        }

        return $parentExist;
    }

    /**
     * Private method sanitizeTerm()
     *
     * Sanitize the term to insert
     *
     * @since 1.0.0
     * @return $sanitizeTerm
     */
    private function sanitizeTerm()
    {
        $taxonomy              = $this->validateTaxonomy();
        $arguments             = $this->args;

        $arguments['taxonomy'] = $taxonomy;
        $arguments['name']     = $this->validateTerm();
        $arguments['parent']   = $this->parentExist();

        // Santize the term 
        $arguments = sanitize_term( $arguments, $taxonomy, 'db' );

        // Unslash name and description fields and cast parent to integer
        $arguments['name']        = wp_unslash( $arguments['name'] );
        $arguments['description'] = wp_unslash( $arguments['description'] );
        $arguments['parent']      = (int) $arguments['parent'];

        return (object) $arguments;
    }

    /**
     * Private method slug()
     *
     * Get or create a slug if no slug is set
     *
     * @since 1.0.0
     * @return $slug
     */
    private function slug()
    {
        $term = $this->sanitizeTerm();
        $new_slug = $term->slug;
        if ( !$new_slug ) {
            $slug = sanitize_title( $term->name );
        } else {
            $slug = $new_slug;
        }

        return $slug;
    }

    /**
     * Public method addTerm()
     *
     * Add the term to db
     *
     * @since 1.0.0
     */
    public function addTerm()
    {
        $wpdb       = $this->wpdb();
        $term       = $this->sanitizeTerm();
        $taxonomy   = $term->taxonomy;
        $name       = $term->name;
        $parent     = $term->parent;
        $term_group = $term->term_group;

        $term_group = 0;

        if ( $term->alias_of ) {
            $alias = get_term_by( 
                'slug', 
                $term->alias_of, 
                $term->taxonomy 
            );
            if ( !empty( $alias->term_group ) ) {
                // The alias we want is already in a group, so let's use that one.
                $term_group = $alias->term_group;
            } elseif ( ! empty( $alias->term_id ) ) {
                /*
                 * The alias is not in a group, so we create a new one
                 * and add the alias to it.
                 */
                $term_group = $wpdb->get_var(
                    "SELECT MAX(term_group) 
                    FROM $wpdb->terms"
                ) + 1;

                wp_update_term( 
                    $alias->term_id, 
                    $this->args['taxonomy'], 
                    [
                        'term_group' => $term_group,
                    ] 
                );
            }
        }

        $slug = wp_unique_term_slug( 
            $this->slug(), 
            $term
        );

        if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) {
            return new WP_Error( 'db_insert_error', __( 'Could not insert term into the database' ), $wpdb->last_error );
        }

        $term_id = (int) $wpdb->insert_id;

        // Seems unreachable, However, Is used in the case that a term name is provided, which sanitizes to an empty string.
        if ( empty( $slug ) ) {
            $slug = sanitize_title( 
                $slug, 
                $term_id 
            );

            /** This action is documented in wp-includes/taxonomy.php */
            do_action( 'edit_terms', $term_id, $taxonomy );
            $wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );

            /** This action is documented in wp-includes/taxonomy.php */
            do_action( 'edited_terms', $term_id, $taxonomy );
        }

        $tt_id = $wpdb->get_var( 
            $wpdb->prepare( "
                SELECT tt.term_taxonomy_id 
                FROM $wpdb->term_taxonomy AS tt 
                INNER JOIN $wpdb->terms AS t 
                ON tt.term_id = t.term_id 
                WHERE tt.taxonomy = %s 
                AND t.term_id = %d
            ", 
            $taxonomy, 
            $term_id 
            ) 
        );

        if ( !empty($tt_id) ) {
            return [
                'term_id'          => $term_id, 
                'term_taxonomy_id' => $tt_id
            ];
        }

        $wpdb->insert( 
            $wpdb->term_taxonomy, 
            compact( 'term_id', 'taxonomy', 'description', 'parent') + ['count' => 0] 
        );
        $tt_id = (int) $wpdb->insert_id;


        /**
         * Fires immediately after a new term is created, before the term cache is cleaned.
         *
         * @since 2.3.0
         *
         * @param int    $term_id  Term ID.
         * @param int    $tt_id    Term taxonomy ID.
         * @param string $taxonomy Taxonomy slug.
         */
        do_action( "create_term", $term_id, $tt_id, $taxonomy );

        /**
         * Fires after a new term is created for a specific taxonomy.
         *
         * The dynamic portion of the hook name, `$taxonomy`, refers
         * to the slug of the taxonomy the term was created for.
         *
         * @since 2.3.0
         *
         * @param int $term_id Term ID.
         * @param int $tt_id   Term taxonomy ID.
         */
        do_action( "create_$taxonomy", $term_id, $tt_id );

        /**
         * Filter the term ID after a new term is created.
         *
         * @since 2.3.0
         *
         * @param int $term_id Term ID.
         * @param int $tt_id   Taxonomy term ID.
         */
        $term_id = apply_filters( 'term_id_filter', $term_id, $tt_id );

        clean_term_cache($term_id, $taxonomy);

        /**
         * Fires after a new term is created, and after the term cache has been cleaned.
         *
         * @since 2.3.0
         *
         * @param int    $term_id  Term ID.
         * @param int    $tt_id    Term taxonomy ID.
         * @param string $taxonomy Taxonomy slug.
         */
        do_action( 'created_term', $term_id, $tt_id, $taxonomy );

        /**
         * Fires after a new term in a specific taxonomy is created, and after the term
         * cache has been cleaned.
         *
         * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
         *
         * @since 2.3.0
         *
         * @param int $term_id Term ID.
         * @param int $tt_id   Term taxonomy ID.
         */
        do_action( "created_$taxonomy", $term_id, $tt_id );

        return [
            'term_id'          => $term_id, 
            'term_taxonomy_id' => $tt_id
        ];      
    }
}

Vous pouvez ensuite l'utiliser comme suit:

$q = new WPInsertTerm( 'My Term', 'category', ['parent' => 1] );
$q->addTerm();

Ici, nous ajoutons notre terme, My Term, au terme parent portant l'ID 1 dans la taxonomie construite category.

Notez que l'exécution de ces 100 fois ajoutera 100 termes appelés My Term sous le terme parent 1.

NOTES COMPLÉMENTAIRES

  • Avec ce qui précède, toutes les requêtes relatives aux noms de termes doivent être évitées

    • Par défaut, il existe déjà un problème avec les noms de terme dans un tax_query dans WP_Query. Cet ajout de classe rendrait l'utilisation du champ name absolument impossible

    • Il faut également éviter à tout prix d’obtenir des termes, car le mauvais terme sera probablement renvoyé.

Une note finale, avoir plusieurs termes avec le même nom sera très très déroutant et pourrait ouvrir quelques boîtes de ver pourris, vous devrez donc être absolument sûr que c'est ce que vous voulez

RÉPONSE ORIGINALE

wp_insert_term() est une fonction assez chargée avec beaucoup de choses qui se passent avant l'ajout réussi d'un terme à une taxonomie.

La première section importante est la suivante:

$slug_provided = ! empty( $args['slug'] );
if ( ! $slug_provided ) {
    $slug = sanitize_title( $name );
} else {
    $slug = $args['slug'];
}

En bref, cela signifie que si vous n'avez pas explicitement défini de slug, un slug sera créé à partir du nom donné via la fonction santitize_title() . C’est la base qui décidera si un terme sera ajouté ou non, car le slug est la partie la plus importante à venir.

Donc, si nous voulions insérer un terme avec le nom My Term, nous nous retrouverions avec un slug tel que my-term si nous n'avions pas défini de slug.

La prochaine partie importante est la suivante: (qui tourne, que slug soit défini ou non)

/*
 * Prevent the creation of terms with duplicate names at the same level of a taxonomy hierarchy,
 * unless a unique slug has been explicitly provided.
 */
$name_matches = get_terms( $taxonomy, array(
    'name' => $name,
    'hide_empty' => false,
) );

/*
 * The `name` match in `get_terms()` doesn't differentiate accented characters,
 * so we do a stricter comparison here.
 */
$name_match = null;
if ( $name_matches ) {
    foreach ( $name_matches as $_match ) {
        if ( strtolower( $name ) === strtolower( $_match->name ) ) {
            $name_match = $_match;
            break;
        }
    }
}

$name ($ name = wp_unslash ($ args ['name']);) qui est le nom que vous avez explicitement défini est utilisé pour renvoyer tous les termes avec un nom correspondant à $name à comparer au terme que vous essayez insérer s'il y en a. S'il existe des termes existants par $name, une correspondance plus exacte est effectuée pour faire correspondre les termes.

Comme le dit la description/docblock _ {get_terms() ne différencie pas les caractères accentués}, nous pourrions donc nous retrouver avec des termes portant des noms tels que my Term et My terM. Toutes les lettres sont réglées de manière à diminuer dans cette correspondance, de sorte que tous les noms de terme sont définis sur my term pour la correspondance. Cela a du sens, car si ces termes (ou l’un des termes renvoyés) ont été créés (back-end ou front-end ou par programme) sans avoir de jeu de slug, des noms tels que my Term et My terM et notre terme My Term produiraient tous le même slug, my-term, nous aurions donc besoin d'éliminer ces problèmes.

La dernière section importante ici avant la création d’un slug unique et l’insertion du terme est la section suivante

if ( $name_match ) {
    $slug_match = get_term_by( 'slug', $slug, $taxonomy );
    if ( ! $slug_provided || $name_match->slug === $slug || $slug_match ) {
        if ( is_taxonomy_hierarchical( $taxonomy ) ) {
            $siblings = get_terms( $taxonomy, array( 'get' => 'all', 'parent' => $parent ) );

            $existing_term = null;
            if ( $name_match->slug === $slug && in_array( $name, wp_list_pluck( $siblings, 'name' ) ) ) {
                $existing_term = $name_match;
            } elseif ( $slug_match && in_array( $slug, wp_list_pluck( $siblings, 'slug' ) ) ) {
                $existing_term = $slug_match;
            }

            if ( $existing_term ) {
                return new WP_Error( 'term_exists', __( 'A term with the name provided already exists with this parent.' ), $existing_term->term_id );
            }
        } else {
            return new WP_Error( 'term_exists', __( 'A term with the name provided already exists in this taxonomy.' ), $name_match->term_id );
        }
    }
}

Cette section ne fonctionne que lorsque nous avons identifié de manière positive tout autre terme du même nom que celui que nous souhaitons insérer. Encore une fois, cette section fonctionne indépendamment du moment où une limace a été définie ou non.

La première chose que cette section fait est de renvoyer tout terme correspondant de db qui correspond à notre slug du terme que nous voudrions insérer, qui provient de la première section de code de la réponse. Notre slug est my-term. get_term_by() retourne un objet term s'il existe déjà un terme de la base de données qui correspond au terme slug du terme que nous voudrions insérer, ou false si aucun terme ne correspond déjà au terme slug.

Maintenant, beaucoup de contrôles sont effectués ici, la première est une condition qui exécute les contrôles suivants

  • Vérifier si nous avons explicitement défini un slug (! $slug_provided), renvoyer true si non

  • Si le slug d'un terme correspondant (du deuxième bloc de code de cette réponse _) correspond au slug du terme que nous voulons insérer (dans ce cas my-term). Retruns true s'il y a une correspondance

  • Si nous avons un objet terme renvoyé de get_term_by().

Si l'une de ces trois conditions redevient vraie, une vérification est ensuite effectuée pour vérifier si notre taxonomie est hiérarchique. Si cela renvoie false, c'est-à-dire que notre taxonomie est non hiérarchique comme les balises, l'erreur suivante est renvoyée:

Un terme avec le nom fourni existe déjà dans cette taxonomie.

bien évidemment, nous ne pouvons pas avoir de termes du même nom dans une taxonomie non hiérarchique.

Si cela retourne la valeur true, c'est-à-dire que notre taxonomie est hiérarchique, tous les termes frères sont interrogés par parent (qui sera soit 0, soit le nombre entier défini explicitement).

wp_insert_term() fait maintenant sa dernière vérification avant de décider d'insérer ou non le terme. Un échec entraînerait le message d'erreur auquel vous faites référence dans votre question.

Un terme avec le nom fourni existe déjà avec ce parent

Voici ce que fait la dernière vérification:

Tous les termes enfant directs sont interrogés à partir de la base de données de la taxonomie donnée et du parent (qui est soit 0, soit la valeur que vous avez spécifiée _). Rappelez-vous que nous sommes toujours dans la condition qui stipule qu'il existe des termes correspondant au nom du terme que nous voulons insérer. Deux vérifications sont effectuées sur le tableau de catégories enfants renvoyé:

  • La première vérification implique ce qui suit: Le slug du terme correspondant au terme correspondant $name_match est comparé au slug de notre terme, my-term (rappelez-vous que cela provient du bloc de code de la réponse). En outre, nos noms de terme que nous avons définis, My Term, sont comparés à tous les noms des enfants directs de notre parent.

  • La deuxième vérification est la suivante: Une vérification est effectuée pour voir si un terme est retourné par get_term_by() et si le slug du premier bloc de code dans cette réponse correspond aux slugs des enfants directs du terme parent.

Si l’une de ces conditions redevient vraie, le

Un terme portant le nom fourni existe déjà avec ce parent.

un message d'erreur est émis et le terme n'est pas inséré. Une fausse volonté conduira probablement probablement à la création et à l’insertion du terme.

Maintenant, nous pouvons examiner votre question

Pourquoi le nom devrait être unique, ne comprend pas comme la limace est.

Vous pouvez avoir des noms en double dans une taxonomie hiérarchique si, et uniquement si

  • Il n'y a pas de terme avec un nom correspondant au même niveau dans la hiérarchie. Ainsi, deux termes de premier niveau, ou deux enfants directs du même terme parent ne peuvent pas avoir le même nom. Cette ligne:

    if ( $name_match->slug === $slug && in_array( $name, wp_list_pluck( $siblings, 'name' ) ) )

    du code interdit cela.

  • Vous pouvez avoir les mêmes noms pour les termes dans une taxonomie hiérarchique si le terme est dans un parent de niveau supérieur, un enfant dans ce parent de niveau supérieur et un petit-enfant dans cet enfant spécifique, si et uniquement si leurs slug sont unique. Cette ligne

    elseif ( $slug_match && in_array( $slug, wp_list_pluck( $siblings, 'slug' ) ) )

    interdit les termes avec le même nom ayant la même limace

Vous ne pouvez pas avoir de termes portant le même nom dans une taxonomie non hiérarchique car ils n'ont pas de relations de type parent/enfant

Donc, si vous êtes sûr que votre taxonomie est hiérarchique et que votre slug est unique, cela ne signifie toujours pas que vous pouvez avoir le même nom, car vous devez prendre en compte le parent. Si vos parents restent les mêmes, quelle que soit la configuration du slug unique, votre terme ne sera pas inséré et émettra le message d'erreur que vous voyez

Contournement possible pour rendre le nom unique

Le mieux est d’écrire une fonction wrapper dans laquelle vous utilisez la même logique que wp_insert_term() pour vérifier d’abord s'il existe déjà un terme portant le même nom avec le même parent. Si tel est le cas, prenez le nom et exécutez une sorte de fonction nom pour le rendre unique.

Je vous encourage à prendre toute la logique de cette réponse, à l’utiliser dans une fonction d’emballage personnalisée pour créer un nom unique et à jouer avec les idées. Si vous êtes bloqué, n'hésitez pas à poster ce que vous avez dans une nouvelle question et je me ferai un plaisir de l'examiner lorsque j'en aurai le temps.

Bonne chance

3
Pieter Goosen

Après les conseils de @PieterGoosen, je résous mon problème. Voici la fonction complète qui vérifie si un nom de terme existe déjà dans une taxonomie.

Il ne fournit pas encore de substitution de nom si ce nom existe déjà dans le terme parent.

Je n'ai pas besoin de vérifier la limace, car j'ai laissé WP en créer une automatiquement pour moi.

function check_term_name($term_name,$taxonomy,$parent) 
{

$name_matches = get_terms( $taxonomy, array(
    'name' => $term_name,
    'hide_empty' => false,
) );


$name_match = null;
if ( $name_matches ) {
    foreach ( $name_matches as $_match ) {
        if ( strtolower( $term_name ) === strtolower( $_match->name ) ) {
            $name_match = $_match;
            break;
        }
    }
}


if ( $name_match ) {

    if ( is_taxonomy_hierarchical( $taxonomy ) ) {
        $siblings = get_terms( $taxonomy, array( 'get' => 'all', 'parent' => $parent->term_id ) );
        $existing_term = null;
        if ( in_array( $term_name, wp_list_pluck( $siblings, 'name' ) ) ) {
            $existing_term = $name_match;
        }

        if ( $existing_term ) {
            return new WP_Error( 'term_exists', __( 'A term with the name provided already exists with this parent.' ), $existing_term->term_id );
        }
    } else {
        return new WP_Error( 'term_exists', __( 'A term with the name provided already exists in this taxonomy.' ), $name_match->term_id );
    }

}


return $term_name;

}

Je me demande s'il ne serait pas possible d'ajouter une méta personnalisée au terme (nouveauté dans WP 4.4) avec le nom d'origine à la place de la propriété name du terme. Je pourrais donc ajouter un identifiant unique au nom du terme et créer un sélecteur de catégorie qui affiche la méta personnalisée à la place du nom.

add_term_meta($term_id,'name',$name);

et le récupérer pour peupler mon sélecteur:

get_term_meta($term_id,'name');

MODIFIER

J'ai mis mes mains dans le

add_term_meta

et mettre ensemble les suggestions que vous pouvez trouver ici

Donc, si nous voulons avoir le même nom, même si le nom du terme est différent, nous devons ajouter une méta personnalisée 'nom_real' au terme.

Alors tout d'abord, nous enregistrons la méta:

add_action( 'init', 'blaamy_register_meta' );

function blaamy_register_meta() {

    register_meta( 'term', 'real_name' );

}

ensuite nous ajoutons une nouvelle colonne à notre taxonomie, disons que nous avons une taxonomie object_category:

add_filter( 'manage_edit-object_category_columns', 'blaamy_edit_term_columns' );

function blaamy_edit_term_columns( $columns ) {

    $columns['real_name'] = __( 'Real Name', 'blaamy' );

    return $columns;
}

Nous devons maintenant gérer la colonne personnalisée:

add_filter( 'manage_object_category_custom_column', 'blaamy_manage_term_custom_column', 10, 3 );

function blaamy_manage_term_custom_column( $out, $column, $term_id ) {

    if('real_name' === $column){

        $real_name = blaamy_get_term_real_name( $term_id, true );

        if ( ! $real_name )
            $real_name = '';

        $out = sprintf( '<span class="real_name-block">%s</span>', esc_attr( $real_name ));


    }

    return $out;
}

Nous avons également besoin de quelque chose pour obtenir la méta valeur real_name:

function blaamy_get_term_real_name( $term_id, $hash = false ) {

    $real_name = get_term_meta( $term_id, 'real_name', true );

    return $real_name;
}

Maintenant, nous créons le champ de formulaire de nom réel:

add_action( 'object_category_add_form_fields', 'blaamy_new_term_real_name_field' );

function blaamy_new_term_real_name_field() {

    wp_nonce_field( basename( __FILE__ ), 'blaamy_term_real_name_nonce' ); ?>

    <div class="form-field blaamy-term-real-name-wrap">
        <label for="blaamy-term-real-name">Real Name</label>
        <input type="text" name="blaamy_term_real_name" id="blaamy_term_real_name" value="" class="blaamy-real-name-field" data-default-real-name="" />
    </div>
<?php }

et nous devons ensuite créer le champ de formulaire de modification du nom réel:

add_action( 'object_category_edit_form_fields', 'blaamy_edit_term_real_name_field' );

function blaamy_edit_term_real_name_field( $term ) {

    $default = "";
    $real_name   = blaamy_get_term_real_name( $term->term_id, true );

    if ( ! $author )
        $real_name = $real_name; ?>

    <tr class="form-field blaamy-term-real-name-wrap">
        <th scope="row"><label for="blaamy-term-real-name">Real Name</label></th>
        <td>
            <?php wp_nonce_field( basename( __FILE__ ), 'blaamy_term_real_name_nonce' ); ?>
            <input type="text" name="blaamy_term_real_name" id="blaamy-term-real-name" value="<?php echo esc_attr( $real_name ); ?>"  data-default-real-name="<?php echo esc_attr( $default ); ?>" />
        </td>
    </tr>
<?php }

et enfin le vrai nom crée et met à jour des fonctions:

add_action( 'edit_object_category',   'blaamy_save_term_real_name' );
add_action( 'create_object_category', 'blaamy_save_term_real_name' );

function blaamy_save_term_real_name( $term_id ) {

    if ( ! isset( $_POST['blaamy_term_real_name_nonce'] ) || ! wp_verify_nonce( $_POST['blaamy_term_real_name_nonce'], basename( __FILE__ ) ) )
        return;

    $old_real_name = blaamy_get_term_real_name( $term_id );
    $new_real_name = isset( $_POST['blaamy_term_real_name'] ) ? $_POST['blaamy_term_real_name'] : '';

    if ( $old_real_name && '' === $new_real_name )
        delete_term_meta( $term_id, 'real_name' );

    else if ( $old_real_name !== $new_real_name )
        update_term_meta( $term_id, 'real_name', $new_real_name );
}

Nous venons de créer une liste déroulante ou quoi que ce soit d'autre sur le front-end qui est peuplé par notre meta real_name!

1
Polykrom