Share
Pour beaucoup de projets WordPress de nos jours, nous utilisons des types de publication personnalisés. L’équipe de développement WordPress a créé des méthodes pratiques pour les intégrer à vos projets. Mais lorsque vous utilisez fréquemment des types d'articles, des taxonomies et des méta-boîtes personnalisés, il est fort probable que vous vous répétiez. C'est pourquoi nous allons utiliser la puissance de ces fonctions WordPress pour construire une classe plus puissante, que nous pouvons utiliser pour enregistrer rapidement des types d'article, des taxonomies et des méta-boîtes..
Voici comment nous appelons notre classe quand c'est fait.
Accentsconagua
include ('custom-post-type.php'); $ book = new Custom_Post_Type ('Livre'); $ book-> add_taxonomy ('catégorie'); $ book-> add_taxonomy ('author'); $ book-> add_meta_box ('Informations sur le livre', array ('Year' => 'text', 'Genre' => 'text')); $ book-> add_meta_box ('Informations sur l'auteur', array ('Name' => 'text', 'Nationality' => 'text', 'Birthday' => 'text')); Nous commençons par créer la classe, les propriétés principales, le constructeur et les méthodes. Dans ce tutoriel, nous allons les remplir avec notre logique de programmation.
class Custom_Post_Type public $ post_type_name; public $ post_type_args; public $ post_type_labels; / * Constructeur de classe * / public function __construct () / * Méthode qui enregistre le type de publication * / fonction publique register_post_type () / * Méthode permettant d'attacher la taxonomie au type de publication * / public fonction add_taxonomy () / * Attache des boîtes de méta au type de message * / public function add_meta_box () / * Écoute le moment où le type de message est enregistré * / public function save ()
Dans le constructeur, nous créons des variables importantes, qui sont utilisées dans toute la classe. Nous appelons aussi add_action pour enregistrer le type de message et écouter lorsque le type de message est en cours de sauvegarde afin de pouvoir enregistrer les métadonnées de notre message. Si le type de message existe, le add_action n'est pas appelé, mais le $ post_type_name est défini, afin que nous puissions y ajouter des taxonomies et des méta-boîtes.
fonction publique __construct ($ name, $ args = array (), $ labels = array ()) // Définir des variables importantes $ this-> post_type_name = strtolower (str_replace (", '_', $ name)); $ this-> post_type_args = $ args; $ this-> post_type_labels = $ labels; // Ajout d'une action pour enregistrer le type de publication, si le type de publication n'existe pas déjà si (! post_type_exists ($ this-> post_type_name)) add_action ( 'init', array (& $ this, 'register_post_type')); Ecoutez le point de sauvegarde de la publication $ this-> save (); Dans le register_post_type méthode, qui est appelée par le add_action dans le constructeur, on détermine d'abord le nom (en majuscule) et le pluriel. Avec ce nom et le pluriel, nous construisons nos étiquettes pour le type de publication et les écrasons (et les fusionnons) avec les étiquettes données à partir de $ this-> post_type_labels variable. Ensuite, nous créons nos arguments avec le même principe.
fonction publique register_post_type () // Capitilise les mots et les rend au pluriel $ name = ucwords (str_replace ('_', ", $ this-> post_type_name)); $ plural = $ name. 's'; // Nous avons défini les étiquettes par défaut basées sur le nom du type de message et le pluriel. Nous les écrasons avec les étiquettes données. $ labels = array_merge (// array par défaut ('name' => _x ($ pluriel, 'nom général du type de publication'), 'nom_s singulier '=> _x ($ name,' nom singulier de type de publication '),' add_new '=> _x (' Add New ', strtolower ($ name)),' add_new_item '=> __ (' Add New '. $ name) , 'edit_item' => __ ('Edit'. $ name), 'new_item' => __ ('New'. $ name), 'all_items' => __ ('All'. $ pluriel), 'view_item' = > __ ('Voir'. $ Name), 'search_items' => __ ('Rechercher'. $ Pluriel), 'not_found' => __ ('Non'. Strtolower ($ pluriel). 'Found'), 'not_found_in_trash '=> __ (' No '. Strtolower ($ pluriel).' Trouvé dans la corbeille '),' parent_item_colon '=> ",' menu_name '=> $ pluriel), // Libellés donnés $ this-> post_type_labels); // Même principe que les étiquettes. Nous définissons des valeurs par défaut et les écrasons avec les arguments donnés. $ args = array_merge (// tableau par défaut ('label' => $ pluriel, 'labels' => $ labels, 'public' => true, 'show_ui' => true, 'supports' => array ('title' , 'editor'), 'show_in_nav_menus' => true, '_builtin' => false,), // Arguments donnés $ this-> post_type_args); // Enregistre le type de message register_post_type ($ this-> post_type_name, $ args); Nous vérifions d’abord si le $ name paramètre est vide. Quand ça arrive, on ne fait rien. Lorsque ce n'est pas le cas, nous créons trois variables dans lesquelles nous stockons les informations pour la taxonomie: $ taxonomy_name, $ taxonomy_labels et $ taxonomy_args.
fonction publique add_taxonomy ($ name, $ args = array (), $ labels = array ()) if (! empty ($ name)) // Nous avons besoin de connaître le nom du type de publication afin que la nouvelle taxonomie puisse être jointe à cela. $ post_type_name = $ this-> post_type_name; // Propriétés de taxonomie $ taxonomy_name = strtolower (str_replace (", '_', $ name)); $ taxonomy_labels = $ labels; $ taxonomy_args = $ args; / * Plus de code à venir * / Après avoir effectué les premières vérifications, puis défini certaines variables, nous allons enregistrer le type de publication. Mais d'abord, vérifions si la taxonomie existe déjà.
if (! taxonomy_exists ($ taxonomy_name)) / * Créez une taxonomie et associez-la au type d'objet (type de publication) * / else / * La taxonomie existe déjà. Nous allons attacher la taxonomie existante au type d'objet (type de post) * /
Si la taxonomie n'existe pas, nous l'enregistrons. Nous utilisons un add_action, mais pas de manière normale. Normalement, le deuxième paramètre de la add_action est le nom d'une fonction, mais comme nous utilisons des paramètres différents à chaque fois, nous allons passer une fonction sans nom (Remarque: cette fonctionnalité nécessite PHP 5.3+) et utiliser le utilisation() une fonction. Avec le utilisation() fonction, nous pouvons passer des variables à la fonction sans nom. Cette fois nous devons passer $ taxonomy_name, $ post_type_name et $ taxonomy_args enregistrer la taxonomie.
// Capitilise les mots et les rend au pluriel $ name = ucwords (str_replace ('_', ", $ name)); $ pluriel = $ name. 'S'; // Les étiquettes par défaut, écrasez-les avec les étiquettes données. $ labels = array_merge (// array par défaut ('name' => _x ($ pluriel, 'nom général de taxonomie'), 'nom_s singulier' => _x ($ name, 'nom singulier de taxonomie'), 'éléments_recherche' => __ ( 'Recherche'. $ Plural), 'all_items' => __ ('Tous'. $ Pluriel), 'parent_item' => __ ('Parent'. $ Name), 'parent_item_colon' => __ ('Parent'. $ name. ':'), 'edit_item' => __ ('Edit'. $ name), 'update_item' => __ ('Update'. $ name), 'add_new_item' => __ ('Ajouter nouveau'. $ name), 'new_item_name' => __ ('Nouveau'. $ name. 'Name'), 'menu_name' => __ ($ name),), // Etiquettes données $ taxonomy_labels); // Arguments par défaut, écrasés par les arguments donnés $ args = array_merge (// array par défaut ('label' => $ pluriel, 'labels' => $ labels, 'public' => true, 'show_ui' => true, 'show_in_nav_menus' => true, '_builtin' => false,), // Etant donné $ taxonomy_args); // Ajoutez la taxonomie au type de message add_action ('init', function () use ($ taxonomy_name, $ post_type_name, $ args) register_taxonomy ($ taxonomy_name, $ post_type_name, $ args); ); Lorsque la taxonomie n'existe pas, nous l'attachons uniquement à notre type de publication. Comme auparavant, nous utilisons une fonction sans nom et le utilisation() une fonction. Cette fois nous avons seulement besoin de passer $ taxonomy_name et $ post_type_name.
add_action ('init', function () use ($ nom_ taxonomie, $ nom_type_post) registre_taxonomie_pour_type_objet ($ nom_ taxonomie, $ nom_type_post);); Pour enregistrer des méta-boîtes, nous avons besoin du nom du type de message, nous le déterminons donc tout d'abord. Après cela, nous avons besoin de certaines variables pour la méta-boîte elle-même et nous rendons les méta-champs personnalisés globaux, de manière à pouvoir y accéder via le hook de sauvegarde. Nous ne couvrirons pas trop de détails ici, car Tammy Hart a déjà fait un tutoriel très utile sur les méta-boîtes réutilisables..
fonction publique add_meta_box ($ title, $ fields = array (), $ context = 'normal', $ priority = 'default') if (! empty ($ title)) Nous devons connaître à nouveau le nom du type de message $ post_type_name = $ this-> post_type_name; // Méta variables $ box_id = strtolower (str_replace (", '_', $ title)); $ box_title = ucwords (str_replace ('_',", $ title)); $ box_context = $ context; $ box_priority = $ priority; // Rendre les champs globaux global $ custom_fields; $ custom_fields [$ title] = $ field; / * Plus de code à venir * / Lorsque nous définissons les variables et les globales, nous enregistrons la méta-boîte avec un add_action. Comme auparavant, nous utilisons une fonction sans nom. Cette fois nous avons besoin $ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority et champs $.
add_action ('admin_init', function () use ($ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority, $ fields) add_meta_box ($ box_id, $ box_title, function ($ post, $ data)) global $ post ; // Champ nonce pour certaines validations wp_nonce_field (plugin_basename (__FILE__), 'custom_post_type'); // Récupère toutes les entrées de $ data $ custom_fields = $ data ['args'] [0]; // Récupère les valeurs enregistrées $ meta = get_post_custom ($ post-> ID); // Vérifiez le tableau et parcourez-le si (! empty ($ custom_fields)) / * Parcourez $ custom_fields * / foreach ($ custom_fields en tant que $ label => $ type) $ field_id_name = strtolower (str_replace (", '_', $ data ['id'])). '_'. strtolower (str_replace (", '_', $ label)); echo ''; , $ post_type_name, $ box_context, $ box_priority, array ($ champs)); ); Enregistrez toutes les métadonnées de l'article. Nous les parcourons, en utilisant le global $ custom_fields. C’est aussi une couverture rapide, voir le tutoriel de Tammy Hart sur les boîtes de méta réutilisables..
public function save () // Besoin du nom du type de message à nouveau $ post_type_name = $ this-> post_type_name; add_action ('save_post', function () use ($ post_type_name) // Refuse la fonction d'enregistrement automatique de WordPress if (defini ('DOING_AUTOSAVE') && DOING_AUTOSAVE) return; if (! wp_verify_nonce ($ _POST ['custom_post_type'], plugin __FILE__))) return; global $ post; if (isset ($ _POST) && isset ($ post-> ID) && get_post_type ($ post-> ID) == $ post_type_name) global $ custom_fields; // boucle en boucle de chaque meta box foreach ($ champs_complets comme $ title => champs $) // Boucle dans tous les champs pour chaque chemin ($ champs comme $ label => $ type) $ champ_id_nom = strtolower (str_replace (", '_', $ title) ). '_'. strtolower (str_replace (", '_', $ label)); update_post_meta ($ post-> ID, $ field_id_name, $ _POST ['custom_meta'] [$ field_id_name]);)) ; Comme vous pouvez le voir, nous utilisons strtolower (str_replace (", '_', $ string)) et ucwords (str_replace ('_', ", $ string)) un nombre de fois. La raison de la création de cette classe est que nous ne nous répétons pas, nous ne voulons donc pas le faire dans cette partie non plus. C'est pourquoi nous créons des méthodes d'assistance. De cette façon, nous pouvons faire ceci: $ name = self :: beautify ($ string); au lieu de $ name = strtolower (str_replace (", '_', $ title));
fonction statique publique beautify ($ string) return ucwords (str_replace ('_', ", $ string));; fonction statique publique uglify ($ string) return strtolower (str_replace (", '_', $ string)) ; Un autre point concerne les formes plurielles que nous créons. Nous les créons simplement en ajoutant un 's' au mot. Mais que se passe-t-il lorsque le mot se termine par un «y»? Pour cette raison, nous créons une méthode d'assistance pour déterminer la forme plurielle d'un mot. Maintenant, nous pouvons facilement faire ceci: $ pluriel = self :: pluralize ($ string) et la forme plurielle de notre parole sera déterminée.
fonction statique publique pluralize ($ string) $ last = $ string [strlen ($ string) - 1]; if ($ last == 'y') $ cut = substr ($ string, 0, -1); // convertis y en ies $ pluriel = $ coupé. 'ies'; else // attachez simplement une chaîne s $ plural = $. 's'; return $ pluriel;
Et maintenant nous avons fini. Vous pouvez maintenant utiliser cette classe pour enregistrer facilement des types de message, des taxonomies et des méta-boîtes. Si vous avez des suggestions ou des questions, laissez un commentaire pour que nous puissions en discuter. J'espère vous voir la prochaine fois!
De plus, j'aimerais donner un peu de crédit à Jeffrey Way. J'ai utilisé sa classe comme source d'inspiration pour ma classe et pour ce tutoriel. De plus, j'aimerais remercier Tammy Hart pour avoir construit le didacticiel sur les méta-boîtes réutilisables. Regardez leur travail.
