wp_insert_term auto eindeutiger Name

Beim Erstellen eines neuen Begriffs in einer benutzerdefinierten Taxonomie mit wp_insert_term habe ich festgestellt, dass der Name eindeutig sein sollte. Ich bekomme eine wp Fehlermeldung, wenn es nicht ist:

A term with the name provided already exists with this parent 

Ich möchte einen Weg, um automatisch zu überprüfen, ob der Name bereits existiert und ihn anhängen, wenn ja.

Überprüfen Sie also:

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

und wenn der Begriff existiert, fügen Sie den Namen hinzu.

Aber gibt es eine Möglichkeit, dies mit WP zu automatisieren? Wie WP mit Slug? Warum sollte der Name einzigartig sein, nicht verstehen, wie die Schnecke ist.

Danke vielmals !

François

Solutions Collecting From Web of "wp_insert_term auto eindeutiger Name"

BEARBEITEN

TEIL DEUX ODER TEIL DEUX – Die schmutzige Sequal, der Begriff Saga geht weiter …

Bevor jemand diesen Abschnitt liest, möchte ich Sie dringend bitten, alles zu lesen, was ich in ORIGINAL ANTWORT erklärt habe . wp_insert_term() erlaubt keine doppelten wp_insert_term() in nicht hierarchischen Taxonomien oder in hierarchischen Taxonomien innerhalb derselben Hierarchie.

Von den Kommentaren zu meiner Antwort, die Antwort von OP und vom OP

Was ich brauche, ist eine Möglichkeit, denselben Namen in der Taxonomie-Hierarchie zu haben.

Es gibt einen Weg, dies zu erreichen, schauen wir uns an, wie:

VORSICHT – Vorsicht – VORSICHT – Vorsicht !!!!

Ich ging mit einer modifizierten class der function wp_insert_term() . Wie gesagt, es gibt einen Schutz innerhalb von wp_insert_term() um doppelte wp_insert_term() zu vermeiden. Was ich getan habe, ist, diesen Schutz loszuwerden, um doppelte Namen innerhalb derselben Hierarchie zu erlauben. Sie müssen im Grunde den Abschnitt für die Namensüberprüfung entfernen und dann den Abschnitt, der zufällige Duplikate löscht, wenn der Begriff bereits eingefügt wurde.

Aus diesem Grund wird diese class eine unbegrenzte Anzahl von Begriffen mit demselben Namen zulassen, daher sollte sie mit großer Sorgfalt verwendet werden . Bei 100 zufälligen Seitenladungen werden 100 Begriffe mit demselben Namen eingefügt.

Hier ist die class mit ein paar Notizen

HINWEIS:

  • Dies erfordert mindestens PHP 5.4.

  • Obwohl ich ein paar Tests durchgeführt habe, um den Betrieb der class zu überprüfen, habe ich noch keinen vollständigen Test durchgeführt, also bitte BITTE BITTE, führe dies zuerst auf einer lokalen Testinstallation durch und überprüfe alles richtig

  • Die class kann nach Bedarf verbessert und modifiziert werden. Ich könnte gemischte Syntaxen und verschlüsselten Code haben. Dies ist nur ein sehr grundlegendes Rückgrat mit nur dem Wesentlichen

Schauen wir uns den Code an:

 /** * 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 ]; } } 

Sie können es dann wie folgt verwenden:

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

Hier fügen wir unserem Begriff ” My Term den übergeordneten Begriff mit der ID 1 in der Taxonomiekategorie category Build category .

Hinweis: Wenn Sie diesen Vorgang 100 Mal My Term unter dem ersten Begriff 100 Begriffe mit dem Namen My Term hinzugefügt.

ZUSÄTZLICHE BEMERKUNGEN

  • Mit dem oben genannten sollten alle Termnamen-bezogenen Abfragen vermieden werden

    • Standardmäßig gibt es bereits ein Problem mit tax_query in einer tax_query in WP_Query . Dieser classnzusatz würde die Verwendung des Namensfeldes absolut unmöglich machen

    • Es sollte auch unbedingt vermieden werden, Namen namentlich zu verwenden, da der falsche Begriff höchstwahrscheinlich zurückgegeben wird.

Ein letzter Hinweis, der mehrere Begriffe mit demselben Namen enthält, wird sehr verwirrend sein und ein paar Dosen fauler Würmer öffnen, also müssen Sie absolut sicher sein, dass dies das ist, was Sie wollen

ORIGINAL ANTWORT

wp_insert_term() ist eine ziemlich ausgelastete function mit vielen wp_insert_term() , die vor dem erfolgreichen Hinzufügen einer Benennung zu einer Taxonomie wp_insert_term() .

Der erste wichtige Abschnitt ist dies:

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

Kurz gesagt, was das heißt, wenn Sie nicht explizit einen Slug gesetzt haben, wird ein Slug aus dem Namen erstellt, der über die function santitize_title() wird. Dies ist die Grundlage, die entscheiden wird, ob ein Begriff hinzugefügt wird oder nicht, da die Schnecke der wichtige Teil ist, der sich vorwärts bewegt.

Wenn wir also einen Begriff mit dem Namen My Term einfügen möchten, würden wir mit einem Slug wie my-term enden, wenn wir keinen Slug gesetzt hätten.

Der nächste wichtige Teil ist der: (Der läuft unabhängig davon, ob die Schnecke wo ist oder nicht )

 /* * 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’]); ) Dies ist der Name, den Sie explizit festgelegt haben. Er wird verwendet, um alle Begriffe mit einem Namen, der $name , mit dem Begriff, den Sie einfügen möchten, zu vergleichen da sind welche. Wenn es Begriffe gibt, die von $name , wird eine genauere Übereinstimmung der Begriffe vorgenommen.

Wie die Beschreibung / der Docblock sagt, unterscheidet get_terms() keine akzentuierten Zeichen , so dass wir möglicherweise Begriffe mit Namen wie my Term und My terM . Alle Buchstaben werden in dieser Übereinstimmung niedriger gesetzt, daher werden alle Termnamen auf my term für die Übereinstimmung gesetzt. Dies ist sinnvoll, denn wenn diese Terme ( oder irgendwelche der zurückgegebenen Terme ) erstellt wurden ( entweder My terM oder Frontend oder programmatisch ), ohne dass ein Slug gesetzt wurde, würden Namen wie my Term und My terM und unser Term My Term alle den erzeugen die gleiche Schnecke, my-term , also müssten wir solche Probleme eliminieren.

Der letzte wichtige Abschnitt hier, bevor ein eindeutiger Slug erstellt und der Begriff eingefügt wird, ist der folgende Abschnitt

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

Dieser Abschnitt wird nur ausgeführt, wenn wir einen anderen Begriff mit dem gleichen Namen positiv identifiziert haben, den wir einfügen möchten. Auch hier läuft dieser Abschnitt unabhängig davon, ob ein Slug gesetzt wurde oder nicht.

Das erste, was dieser Abschnitt tut, ist, einen passenden Ausdruck aus db, der unserem Slug entspricht, von dem Begriff zurückzugeben, den wir einfügen wollen, der aus dem ersten Codeabschnitt in der Antwort kommt. Unsere Schnecke ist my-term . get_term_by() entweder ein get_term_by() zurück, wenn es einen Term gibt, der bereits in db ist, der dem Begriff durch slug des Begriffs entspricht, den wir einfügen möchten, oder false, wenn es keinen Term gibt, der bereits durch slug mit unserem Term übereinstimmt.

Jetzt wird hier eine Menge überprüft, die erste ist eine Bedingung, die die folgenden Überprüfungen ausführt

  • Prüfe, ob wir explizit einen Slug ( ! $slug_provided ) gesetzt haben, true zurück, wenn nicht

  • Wenn der Slug aus einem passenden Begriff ( aus dem zweiten Block des Codes in dieser Antwort ) mit dem Slug aus dem Term übereinstimmt, den wir einfügen wollen ( in diesem Fall my-term ). Retruns True, wenn es eine Übereinstimmung gibt

  • Ob wir ein Term-Objekt von get_term_by() .

Wenn eine dieser drei Bedingungen wahr ist, wird eine Überprüfung durchgeführt, um zu überprüfen, ob unsere Taxonomie hierarchisch ist. Wenn dieses Ergebnis falsch ist, dh unsere Taxonomie nicht hierarchisch wie Tags ist, wird der folgende Fehler zurückgegeben:

In dieser Taxonomie existiert bereits ein Begriff mit dem angegebenen Namen.

ganz offensichtlich, da wir in einer nicht-hierarchischen Taxonomie keine Begriffe mit demselben Namen haben können.

Wenn dies wahr zurückkehrt, dh unsere Taxonomie hierarchisch ist, werden alle gleichgeordneten Begriffe durch Eltern abgefragt ( die entweder 0 oder ein ganzzahliger Wert sein, den wir explizit festgelegt haben ).

wp_insert_term() nun seine letzte Prüfung durch, bevor es sich entscheidet, den Begriff wp_insert_term() oder nicht. Ein Fehler hier würde die Fehlermeldung, auf die Sie in Ihrer Frage verweisen, auslösen

Ein Begriff mit dem angegebenen Namen existiert bereits mit diesem Elternteil

Dies ist, was der letzte Check tut:

Alle direkten untergeordneten Begriffe werden von db aus der gegebenen Taxonomie und dem übergeordneten Element ( das entweder 0 oder der von Ihnen angegebene Wert ist ) abgefragt. Denken Sie daran, dass wir uns immer noch in der Bedingung befinden, die besagt, dass es Begriffe gibt, die mit dem Namen des Begriffs übereinstimmen, den wir einfügen möchten. Beim zurückgegebenen Array der untergeordneten Kategorien werden zwei Prüfungen durchgeführt:

  • Die erste Überprüfung umfasst Folgendes: Der Slug des Begriffs aus dem übereinstimmenden Term $name_match wird mit dem Slug aus unserem Term my-term $name_match ( denken Sie daran, dass dies aus Block eins des Codes in der Antwort stammt ). Auch unser Begriff Name, den wir gesetzt haben, My Term werden gegen alle Namen von den direkten Kindern von unserem Elternteil geprüft.

  • Die zweite Überprüfung ist die folgende: Eine Prüfung wird durchgeführt, um get_term_by() ob ein Ausdruck von get_term_by() und ob der Block des ersten Codeblocks in dieser Antwort mit den Blockierungen der direkten get_term_by() des übergeordneten Begriffs übereinstimmt.

Wenn eine dieser Bedingungen wahr ist, wird die

Ein Begriff mit dem angegebenen Namen existiert bereits mit diesem Elternteil.

Fehlermeldung wird ausgetriggers und der Begriff wird nicht eingefügt. Ein falscher Wille führt wahrscheinlich dazu, dass der Begriff erfolgreich erstellt und eingefügt wird.

Jetzt können wir Ihre Frage betrachten

Warum sollte der Name einzigartig sein, nicht verstehen, wie die Schnecke ist.

Sie können doppelte Namen innerhalb einer hierarchischen Taxonomie nur dann haben, wenn

  • Es gibt keinen Begriff mit einem übereinstimmenden Namen auf derselben Ebene in der Hierarchie. Daher können zwei beliebige Top-Level-Terme oder zwei direkte untergeordnete Elemente aus demselben übergeordneten Term nicht den gleichen Namen haben. Diese Linie:

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

    der Code verbietet das.

  • Sie können die gleichen Namen für Begriffe in einer hierarchischen Taxonomie haben, wenn der Begriff in einem Top-Level-Elternteil, einem Kind zu diesem Top-Level-Elternteil und einem Enkelkind zu diesem bestimmten Kind gehört, und nur dann, wenn ihre Slugs eindeutig sind. Diese Linie

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

    verbietet Begriffe mit demselben Namen, die denselben Slug haben

Sie können keine Begriffe mit demselben Namen in einer nicht hierarchischen Taxonomie haben, da sie keine Beziehungen zwischen Eltern- / Kindtypen haben

Wenn Sie also sicher sind, dass Ihre Taxonomie hierarchisch ist und Sie slug eindeutig sind, bedeutet das nicht, dass Sie denselben Namen haben können, da Sie Eltern berücksichtigen müssen. Wenn Ihr Elternteil gleich bleibt, wird der Begriff nicht eingefügt und die Fehlermeldung, die Sie sehen, wird ausgetriggers

MÖGLICHE UMSTAND, NAME UNIQUE ZU MACHEN

Am besten schreiben Sie eine Wrapper-function, in der Sie die gleiche Logik wie wp_insert_term() um zuerst zu prüfen, ob es bereits einen Begriff mit demselben Namen gibt, und wenn ja, nehmen Sie den Namen und führen Sie eine Art von function aus auf den Namen, um es einzigartig zu machen.

Ich würde Sie ermutigen, alle Logik in dieser Antwort zu nehmen, verwenden Sie es in einer benutzerdefinierten Wrapper-function, um einen eindeutigen Namen zu erstellen, und spielen Sie mit Ideen. Wenn Sie nicht weiterkommen, können Sie gerne eine neue Frage stellen, und ich werde mich freuen, wenn ich Zeit habe.

Viel Glück

Nach @PieterGoosen Ratschläge, ich finde mein Problem, hier ist die komplette function, die prüfen, ob ein Begriff Name bereits in einer Taxonomie existiert.

Es gibt noch keine Namensersetzung, wenn der Name bereits im übergeordneten Begriff existiert.

Ich muss nicht nach der Schnecke suchen, da ich WP automatisch für mich erstellt habe.

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

Ich frage mich, ob es nicht möglich wäre, dem Begriff (neu in WP 4.4) ein eigenes Meta mit dem ursprünglichen Namen anstelle der Namenseigenschaft des Begriffs hinzuzufügen. Also könnte ich dem Begriff name eine eindeutige ID hinzufügen und einen Kategorieselektor erstellen, der das benutzerdefinierte Meta anstelle des Namens anzeigt.

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

und rufen Sie es ab, um meinen Selektor zu füllen:

 get_term_meta($term_id,'name'); 

BEARBEITEN

Ich habe meine Hände in die

 add_term_meta 

und stellen Sie die Vorschläge zusammen, die Sie hier finden können

Wenn wir also den gleichen Namen haben wollen, selbst wenn der Name des Terms anders ist, müssen wir dem Begriff einen eigenen Meta-Realnamen hinzufügen.

Also zuerst registrieren wir das Meta:

 add_action( 'init', 'blaamy_register_meta' ); function blaamy_register_meta() { register_meta( 'term', 'real_name' ); } 

Dann fügen wir unserer Taxonomie eine neue Spalte hinzu, sagen wir, wir haben eine object_category-Taxonomie:

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

Jetzt müssen wir die benutzerdefinierte Spalte verwalten:

 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( '%s', esc_attr( $real_name )); } return $out; } 

Wir brauchen auch etwas, um den Metawert real_name zu erhalten:

 function blaamy_get_term_real_name( $term_id, $hash = false ) { $real_name = get_term_meta( $term_id, 'real_name', true ); return $real_name; } 

Jetzt erstellen wir das echte Namensformularfeld:

 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' ); ?> 
< ?php }

und dann müssen wir das Feld zum Bearbeiten des echten Namens erstellen:

 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; ?>    < ?php wp_nonce_field( basename( __FILE__ ), 'blaamy_term_real_name_nonce' ); ?>    < ?php } 

und schließlich den echten Namen erstellen und aktualisieren functionen:

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

Wir müssen nur eine Combobox oder etwas anderes auf dem Frontend erstellen, das von unserem Real_Name-Meta aufgefüllt wird!