Lorsqu’il s’agit d’ajouter des champs méta personnalisés à une taxonomie dans WordPress, le processus nécessite généralement trois fonctions distinctes : une pour ajouter le champ à la page “Ajouter un nouveau terme”, une pour ajouter le champ à la page “Modifier le terme”, et une pour enregistrer les valeurs du champ personnalisé sur les deux pages.
Voici comment réaliser cela avec un exemple pratique :
<?/**
* Summary.
*
* Description : Ajout de champs méta personnalisés aux taxonomies
*
* @since Version 1.0.0
*/
// Fonction pour ajouter un champ méta personnalisé à la page "Ajouter un nouveau terme"
function jconcept_taxonomy_add_new_meta_field() {
?>
<div class="form-field">
<label for="term_meta[custom_term_meta]"><?php _e('Exemple de champ méta', 'jconcept'); ?></label>
<input type="text" name="term_meta[custom_term_meta]" id="term_meta[custom_term_meta]" value="">
<p class="description"><?php _e('Entrez une valeur pour ce champ', 'jconcept'); ?></p>
</div>
<?php
}
add_action('category_add_form_fields', 'jconcept_taxonomy_add_new_meta_field', 10, 2);
// Fonction pour ajouter un champ méta personnalisé à la page "Modifier le terme"
function jconcept_taxonomy_edit_meta_field($term) {
$t_id = $term->term_id;
$term_meta = get_option("taxonomy_$t_id");
?>
<tr class="form-field">
<th scope="row" valign="top"><label for="term_meta[custom_term_meta]"><?php _e('Exemple de champ méta', 'jconcept'); ?></label></th>
<td>
<input type="text" name="term_meta[custom_term_meta]" id="term_meta[custom_term_meta]" value="<?php echo esc_attr($term_meta['custom_term_meta']) ? esc_attr($term_meta['custom_term_meta']) : ''; ?>">
<p class="description"><?php _e('Entrez une valeur pour ce champ', 'jconcept'); ?></p>
</td>
</tr>
<?php
}
add_action('category_edit_form_fields', 'jconcept_taxonomy_edit_meta_field', 10, 2);
// Fonction pour enregistrer les valeurs du champ personnalisé
function save_taxonomy_custom_meta($term_id) {
if (isset($_POST['term_meta'])) {
$t_id = $term_id;
$term_meta = get_option("taxonomy_$t_id");
$cat_keys = array_keys($_POST['term_meta']);
foreach ($cat_keys as $key) {
if (isset($_POST['term_meta'][$key])) {
$term_meta[$key] = $_POST['term_meta'][$key];
}
}
update_option("taxonomy_$t_id", $term_meta);
}
}
add_action('edited_category', 'save_taxonomy_custom_meta', 10, 2);
add_action('create_category', 'save_taxonomy_custom_meta', 10, 2);
Ces fonctions ajoutent un champ méta personnalisé à la page “Ajouter un nouveau terme” et à la page “Modifier le terme” pour la taxonomie de catégorie par défaut. Assurez-vous d’ajuster le code en fonction de votre taxonomie spécifique. Ces champs méta peuvent être utilisés pour stocker des informations personnalisées associées à chaque terme de taxonomie.
Lorsque vous utilisez un type de publication personnalisé dans vos plugins ou thèmes, vous pourriez souhaiter associer des taxonomies déjà enregistrées, telles que les balises de publication et les catégories par défaut, à votre type d’objet personnalisé. L’extrait de code suivant vous guide sur la manière d’accomplir cela.
En utilisant la fonction register_taxonomy_for_object_type(), nous spécifions la taxonomie et le type d’objet, puis nous attachons cette fonction à un hook d’initialisation.
add_action('init', 'add_categories_to_cpt'); function add_categories_to_cpt() { register_taxonomy_for_object_type('category', 'post_type_name'); }
Ce code fonctionne généralement bien, mais dans certaines situations, le hook d’initialisation peut ne pas être toujours optimal. Si votre type de publication personnalisé est créé dans un plugin, il peut être préférable d’utiliser le hook plugins_loaded, qui se déclenche une fois que tous les plugins ont été chargés.
add_action('plugins_loaded', 'add_categories_to_cpt'); function add_categories_to_cpt() { register_taxonomy_for_object_type('category', 'post_type_name'); }
En utilisant plugins_loaded, vous vous assurez que votre code s’exécute après le chargement de tous les plugins, évitant ainsi les conflits potentiels. Cette approche est particulièrement utile lorsque votre type de publication personnalisé est défini dans un plugin. N’oubliez pas d’ajuster 'post_type_name' avec le nom de votre type de publication personnalisé.
Pour utiliser la classe WP_Error, vous pouvez suivre ces étapes de base :
Création d’une instance de WP_Error : Vous pouvez créer une instance de la classe en utilisant le constructeur et ajouter des erreurs au moment de la création ou plus tard à l’aide de la méthode add().
// Création d'une instance de WP_Error avec une erreur initiale $wp_error = new WP_Error('custom_code', 'Ceci est un message d'erreur.'); // Ajout d'autres erreurs $wp_error->add('another_code', 'Ceci est une autre erreur.');
Récupération d’informations sur les erreurs : Vous pouvez récupérer différentes informations sur les erreurs, telles que les codes d’erreur, les messages d’erreur, etc.
// Récupération de tous les codes d'erreur $error_codes = $wp_error->get_error_codes(); // Récupération du premier code d'erreur $first_error_code = $wp_error->get_error_code(); // Récupération de tous les messages d'erreur $all_error_messages = $wp_error->get_error_messages(); // Récupération du message d'erreur pour un code spécifique $specific_error_messages = $wp_error->get_error_messages('custom_code');
Vérification de la présence d’erreurs : Vous pouvez vérifier si des erreurs sont présentes à l’aide de la méthode has_errors().
// Vérification de la présence d'erreurs if ($wp_error->has_errors()) { // Gérer les erreurs }
Manipulation des erreurs : Vous pouvez également supprimer des erreurs, fusionner des erreurs à partir d’une autre instance de WP_Error, ou exporter/importer des erreurs.
// Suppression d'une erreur spécifique$wp_error->remove('custom_code'); // Fusion des erreurs avec une autre instance de WP_Error $another_wp_error = new WP_Error('new_code', 'Nouvelle erreur.'); $wp_error->merge_from($another_wp_error); // Exportation des erreurs vers une autre instance de WP_Error $new_wp_error = new WP_Error(); $wp_error->export_to($new_wp_error);
Ces étapes de base vous permettront d’utiliser la classe WP_Error pour gérer les erreurs de manière structurée dans vos applications WordPress.
class WP_Error {
/**
* Stores the list of errors.
*
* @since 2.1.0
* @var array
*/
public $errors = array();
/**
* Stores the most recently added data for each error code.
*
* @since 2.1.0
* @var array
*/
public $error_data = array();
/**
* Stores previously added data added for error codes, oldest-to-newest by code.
*
* @since 5.6.0
* @var array[]
*/
protected $additional_data = array();
/**
* Initializes the error.
*
* If `$code` is empty, the other parameters will be ignored.
* When `$code` is not empty, `$message` will be used even if
* it is empty. The `$data` parameter will be used only if it
* is not empty.
*
* Though the class is constructed with a single error code and
* message, multiple codes can be added using the `add()` method.
*
* @since 2.1.0
*
* @param string|int $code Error code.
* @param string $message Error message.
* @param mixed $data Optional. Error data. Default empty string.
*/
public function __construct( $code = '', $message = '', $data = '' ) {
if ( empty( $code ) ) {
return;
}
$this->add( $code, $message, $data );
}
/**
* Retrieves all error codes.
*
* @since 2.1.0
*
* @return array List of error codes, if available.
*/
public function get_error_codes() {
if ( ! $this->has_errors() ) {
return array();
}
return array_keys( $this->errors );
}
/**
* Retrieves the first error code available.
*
* @since 2.1.0
*
* @return string|int Empty string, if no error codes.
*/
public function get_error_code() {
$codes = $this->get_error_codes();
if ( empty( $codes ) ) {
return '';
}
return $codes[0];
}
/**
* Retrieves all error messages, or the error messages for the given error code.
*
* @since 2.1.0
*
* @param string|int $code Optional. Error code to retrieve the messages for.
* Default empty string.
* @return string[] Error strings on success, or empty array if there are none.
*/
public function get_error_messages( $code = '' ) {
// Return all messages if no code specified.
if ( empty( $code ) ) {
$all_messages = array();
foreach ( (array) $this->errors as $code => $messages ) {
$all_messages = array_merge( $all_messages, $messages );
}
return $all_messages;
}
if ( isset( $this->errors[ $code ] ) ) {
return $this->errors[ $code ];
} else {
return array();
}
}
/**
* Gets a single error message.
*
* This will get the first message available for the code. If no code is
* given then the first code available will be used.
*
* @since 2.1.0
*
* @param string|int $code Optional. Error code to retrieve the message for.
* Default empty string.
* @return string The error message.
*/
public function get_error_message( $code = '' ) {
if ( empty( $code ) ) {
$code = $this->get_error_code();
}
$messages = $this->get_error_messages( $code );
if ( empty( $messages ) ) {
return '';
}
return $messages[0];
}
/**
* Retrieves the most recently added error data for an error code.
*
* @since 2.1.0
*
* @param string|int $code Optional. Error code. Default empty string.
* @return mixed Error data, if it exists.
*/
public function get_error_data( $code = '' ) {
if ( empty( $code ) ) {
$code = $this->get_error_code();
}
if ( isset( $this->error_data[ $code ] ) ) {
return $this->error_data[ $code ];
}
}
/**
* Verifies if the instance contains errors.
*
* @since 5.1.0
*
* @return bool If the instance contains errors.
*/
public function has_errors() {
if ( ! empty( $this->errors ) ) {
return true;
}
return false;
}
/**
* Adds an error or appends an additional message to an existing error.
*
* @since 2.1.0
*
* @param string|int $code Error code.
* @param string $message Error message.
* @param mixed $data Optional. Error data. Default empty string.
*/
public function add( $code, $message, $data = '' ) {
$this->errors[ $code ][] = $message;
if ( ! empty( $data ) ) {
$this->add_data( $data, $code );
}
/**
* Fires when an error is added to a WP_Error object.
*
* @since 5.6.0
*
* @param string|int $code Error code.
* @param string $message Error message.
* @param mixed $data Error data. Might be empty.
* @param WP_Error $wp_error The WP_Error object.
*/
do_action( 'wp_error_added', $code, $message, $data, $this );
}
/**
* Adds data to an error with the given code.
*
* @since 2.1.0
* @since 5.6.0 Errors can now contain more than one item of error data. {@see WP_Error::$additional_data}.
*
* @param mixed $data Error data.
* @param string|int $code Error code.
*/
public function add_data( $data, $code = '' ) {
if ( empty( $code ) ) {
$code = $this->get_error_code();
}
if ( isset( $this->error_data[ $code ] ) ) {
$this->additional_data[ $code ][] = $this->error_data[ $code ];
}
$this->error_data[ $code ] = $data;
}
/**
* Retrieves all error data for an error code in the order in which the data was added.
*
* @since 5.6.0
*
* @param string|int $code Error code.
* @return mixed[] Array of error data, if it exists.
*/
public function get_all_error_data( $code = '' ) {
if ( empty( $code ) ) {
$code = $this->get_error_code();
}
$data = array();
if ( isset( $this->additional_data[ $code ] ) ) {
$data = $this->additional_data[ $code ];
}
if ( isset( $this->error_data[ $code ] ) ) {
$data[] = $this->error_data[ $code ];
}
return $data;
}
/**
* Removes the specified error.
*
* This function removes all error messages associated with the specified
* error code, along with any error data for that code.
*
* @since 4.1.0
*
* @param string|int $code Error code.
*/
public function remove( $code ) {
unset( $this->errors[ $code ] );
unset( $this->error_data[ $code ] );
unset( $this->additional_data[ $code ] );
}
/**
* Merges the errors in the given error object into this one.
*
* @since 5.6.0
*
* @param WP_Error $error Error object to merge.
*/
public function merge_from( WP_Error $error ) {
static::copy_errors( $error, $this );
}
/**
* Exports the errors in this object into the given one.
*
* @since 5.6.0
*
* @param WP_Error $error Error object to export into.
*/
public function export_to( WP_Error $error ) {
static::copy_errors( $this, $error );
}
/**
* Copies errors from one WP_Error instance to another.
*
* @since 5.6.0
*
* @param WP_Error $from The WP_Error to copy from.
* @param WP_Error $to The WP_Error to copy to.
*/
protected static function copy_errors( WP_Error $from, WP_Error $to ) {
foreach ( $from->get_error_codes() as $code ) {
foreach ( $from->get_error_messages( $code ) as $error_message ) {
$to->add( $code, $error_message );
}
foreach ( $from->get_all_error_data( $code ) as $data ) {
$to->add_data( $data, $code );
}
}
}
}
