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 );
}
}
}
}
Si vous avez beaucoup de publications sur votre site WordPress, vous avez probablement utilisé les filtres Catégorie et/ou Balise en haut de la page de liste de publications. Ces filtres sont formidables car ils vous permettent très rapidement de limiter le type de messages affichés et de trouver celui(s) que vous recherchez avec une relative facilité. Eh bien, si vous utilisez des types de publication personnalisés ou des taxonomies personnalisées, vous avez probablement remarqué que ces options ne sont pas disponibles. Je vais donc vous montrer comment ajouter de nouveaux filtres pour vos taxonomies personnalisées à tout type de publication personnalisé que vous avez enregistré sur votre site.
Le processus est assez simple, dans le sens où il ne nécessite pas beaucoup de code et WordPress fait la majeure partie du travail à votre place, mais la fonction elle-même est un peu complexe. Ce que nous allons faire est de configurer une fonction qui crée un menu de sélection déroulant basé sur les termes des taxonomies que nous proposons. Ainsi, si nous définissons la fonction pour afficher un filtre pour la taxonomie « genres », elle récupérera une liste de tous les termes de cette taxonomie (tous les termes qui ne sont pas vides), puis affichera chacun de ces termes en option dans le menu déroulant. Si nous fournissons plusieurs taxonomies, via un tableau, alors la fonction créera une liste déroulante pour chaque ensemble de termes de taxonomie.
<?php
function pippin_add_taxonomy_filters() {
global $typenow;
// an array of all the taxonomyies you want to display. Use the taxonomy name or slug
$taxonomies = array('faq_topics');
// must set this to the post type you want the filter(s) displayed on
if( $typenow == 'faqs' ){
foreach ($taxonomies as $tax_slug) {
$tax_obj = get_taxonomy($tax_slug);
$tax_name = $tax_obj->labels->name;
$terms = get_terms($tax_slug);
if(count($terms) > 0) {
echo "<select name='$tax_slug' id='$tax_slug' class='postform'>";
echo "<option value=''>Show All $tax_name</option>";
foreach ($terms as $term) {
echo '<option value='. $term->slug, $_GET[$tax_slug] == $term->slug ? ' selected="selected"' : '','>' . $term->name .' (' . $term->count .')</option>';
}
echo "</select>";
}
}
}
}
add_action( 'restrict_manage_posts', 'pippin_add_taxonomy_filters' );
La fonction est ensuite transmise via le hook d’action « restrict_manage_posts » afin que les menus de sélection soient affichés dans la page de liste de publications.
Si tout a fonctionné correctement, vous devriez voir quelque chose comme ceci :
Notez que dans la fonction, il existe une vérification du type de publication actuel. Si vous ne définissez pas l’instruction conditionnelle $typenow sur le type de publication sur lequel vous souhaitez afficher le filtre, il s’affichera sur TOUTES les pages de type de publication, et comme tous vos types de publication ne peuvent pas avoir la taxonomie personnalisée, ce n’est généralement pas une bonne idée.
