Share
Souvent, vous devez faire un choix et décider de la manière dont vous allez implémenter une certaine fonctionnalité. WordpPress a une approche assez flexible pour presque tous les problèmes, et dans ce tutoriel, nous allons examiner la flexibilité de l'API de type publication personnalisée..
Il existe de nombreuses choses que vous pouvez faire avec les types de publication personnalisés, notamment la génération et la gestion de certaines publications sur des pages personnalisées, des diaporamas, des galeries, voire même des éléments de portefeuille. Certaines personnes ne savent pas encore qu’elles existent, d’autres ne comprennent pas bien leurs options et leur utilisation. Dans les étapes suivantes, nous allons essayer de créer un plug-in spécifique utilisant au mieux les types de publication personnalisés. Pour être plus précis, nous allons construire un plugin qui crée un type de publication personnalisé, qui crée et gère de manière dynamique d'autres types de publication personnalisés (c'est comme Inception ici!).
Avant même de commencer, nous allons examiner en détail ce que nous allons construire dans ce tutoriel, comment et pourquoi. Le but de ce didacticiel est de vous aider à vous familiariser avec les types de publication personnalisés dans WordPress..
Pour ce faire, nous allons créer un plug-in qui crée un type de publication personnalisé principal, puis utiliser les publications de ce type de publication personnalisée, avec une boîte méta de paramètres, pour créer des types de publication personnalisés dynamiques supplémentaires basés sur les options d'interface de la boîte à méta. Cela vous aidera à comprendre en détail toutes les options de publication personnalisée et certaines des possibilités qu’elle peut offrir. Pour les besoins de ce didacticiel, cela signifie que vous disposez d'un serveur Apache en état de fonctionnement avec PHP et MySQL en cours d'exécution et que WordPress est installé, ce qui vous permet de tester le code du plug-in sur une version 3.0+ de WordPress..
Chaque publication sera interprétée comme un nouveau type de publication personnalisé et nous allons enregistrer les options de configuration de chaque publication dans des champs personnalisés à l'aide d'une boîte méta contenant de nombreux formulaires, cases à cocher, listes déroulantes et zones de texte qui stockeront et afficheront les informations. données, ce qui permet à l'utilisateur de modifier n'importe quoi.
Étant donné que le plug-in comporte 450 lignes de code, toutes les lignes de code n'existeront pas dans le didacticiel, car la plupart du code est répété et seules les variables sont différentes. Mais toutes les fonctionnalités du plugin seront expliquées et le code source donné à titre d'exemple.
Si nous voulons accéder à la fonctionnalité de type de publication personnalisée, à la fonctionnalité metabox, et si nous voulons enregistrer des données lors d'une action de mise à jour ou de publication, nous avons besoin de points d'ancrage et nous devons les implémenter spécifiquement pour obtenir l'effet souhaité..
Accentsconagua
add_action ('save_post', 'cpt_save_postdata'); add_action ('add_meta_boxes', 'cpt_add_meta_boxes'); add_action ('init', 'init_custom_post_types'); Nous allons seulement avoir besoin de trois crochets dans ce tutoriel, pas de filtres, rien d’autre que la fonctionnalité de base. Nous avons d’abord besoin d’un hook pour générer le type de publication personnalisé dans sa fonction de rappel. Pour cela nous allons utiliser le init tag hook et la fonction de rappel par le nom de 'init_custom_post_types'. C’est là que toute la magie se produit: c’est là que nous déclarons nos types de publication personnalisés et que nous les rendons dynamiques en extrayant les valeurs de la base de données et en générant des types de publication personnalisés dynamiques dans une boucle. Cette partie du code sera discutée plus tard.
Un autre crochet dont nous avons besoin est le 'add_meta_boxes' tag hook qui pointe vers la fonction de rappel 'cpt_add_meta_boxes' et est utilisé pour générer les méta-boîtes à l'intérieur du type de publication personnalisé principal qui génère tous les autres types de publication personnalisés. C’est ici que nous créons les formulaires qui stockeront et mettront à jour les données que nous devons manipuler pour créer nos fonctionnalités..
Le dernier crochet que nous utilisons est 'save_post' avec la fonction de rappel de 'cpt_save_postdata' et le but de sauvegarder les données postées de la boîte à méta. Lorsque la page du type de publication personnalisée principale est soumise dans le panneau d'administration par l'utilisateur, tous les champs de formulaire sont soumis. Il s'agit du crochet que nous utilisons pour récupérer ce contenu et le sauvegarder / le mettre à jour dans la base de données pour une utilisation ultérieure..
Premièrement, nous devons créer un type de message personnalisé général qui gérera tout le contenu dynamique. Pour ce faire, nous créons d’abord un type de publication générique personnalisé à l’aide de données codées en dur, comme dans l’exemple suivant. Nous créons d'abord les étiquettes. Le paramètre labels est l'une des principales valeurs d'argument interprétées comme un tableau. Les valeurs du tableau sont données par leurs identificateurs, en particulier prénom pour le nom général principal du type de message personnalisé qui est généralement une chaîne plurielle du nom du type de message personnalisé, singular_name pour le nom d'objet de type poste personnalisé au singulier, add_new l'ajout d'un nouveau texte de chaîne, Ajoute un nouvel objet c'est la valeur par défaut ajouter un nouveau message / texte de page, modifier l'article comme texte par défaut pour le post ou la page d'édition, tous les articles est utilisé pour afficher le texte de tous les noms de type d'article personnalisés à la demande (exemple: toutes les voitures), view_items et éléments_recherche sont utilisés comme l'exemple précédent, uniquement à des fins évidemment différentes, pas trouvé, not_fount_in_trash, parent_item_colon sont également des textes de remplacement utilisés pour certaines pages des publications (types de publication personnalisée), fonctionnalité que vous pouvez modifier pour tout type de publication personnalisée que vous créez..
Dans l'exemple suivant, le étiquettes $ array utilise CPT pour remplacer le texte par défaut post / posts / page / pages. Je suppose que cela n’est pas nécessaire pour certains lecteurs, mais pour être sûr de ne pas rater l’idée, CPT signifie Custom Post Type et est et sera utilisé de différentes manières au cours du didacticiel..
Une note importante, ce code est inséré dans le init_custom_post_types fonction de rappel pour que cela fonctionne correctement.
$ labels = array ('name' => _x ('CPT', 'nom général du type de post'), 'nom_s singulier' => _x ('CPT', 'nom singulier du type de post'), 'add_new' => _x ( 'Ajouter un nouveau CPT', 'CPT'), 'add_new_item' => __ ('Ajouter un nouveau type de message'), 'edit_item' => __ ('Modifier CPT'), 'new_item' => __ ('Nouveau CPT' ), 'all_items' => __ ('All CPT'), 'view_item' => __ ('View CPT'), 'search_items' => __ ('Recherche CPT'), 'not_found' => __ ('Non CPT trouvé '),' not_found_in_trash '=> __ (' Aucun CPT trouvé dans la corbeille '),' parent_item_colon '=> ",' nom_menu '=> __ (' CPT ')); $ args = array (' labels '= > $ labels, 'public' => true, 'public_queryable' => true, 'show_ui' => true, 'show_in_menu' => true, 'query_var' => true, 'rewrite' => true, 'code_fonction' > 'post', 'has_archive' => true, 'hierarchical' => false, 'menu_position' => null, 'supports' => array ('title')); register_post_type ('CPT', $ args); Le tableau principal nécessaire pour générer le type de publication personnalisé est le $ args array, utilisé dans le seul but de définir les options principales du type d'article personnalisé et de gérer ses fonctionnalités.
Publique - une variable booléenne, true ou false, qui représente la disponibilité du type de publication personnalisé, si elle est publique pour l'interface d'administration ou par les utilisateurs frontaux du thème.publiquement interrogeable - encore une fois une valeur booléenne qui définit si le front-end a la capacité d'interroger les résultats du type de post personnalisé.show_ui - un booléen indiquant si le contenu par défaut de l'administrateur est généré pour le type de publication personnalisé ou non.show_in_menu - encore une autre variable booléenne qui nécessite show_ui être vrai pour fonctionner, car son but est de montrer ou non le type de message dans le menu du panneau d'administration WordPress.query_var - crée une clé de requête var pour ce type de publication personnalisé. Vous pouvez l'utiliser comme booléen ou chaîne. S'il est vrai que c'est par défaut, false désactive l'utilisation de la clé var var et que la chaîne définit une clé personnalisée. Dans notre exemple, nous utilisons la valeur par défaut et la définissons sur true.récrire - cela empêche les réécritures pour ce type de message.type de capacité - enfin, une chaîne qui définit si le type de publication personnalisé est une publication ou une page, dans une chaîne de texte brut. Nous utilisons post.has_archive - ce paramètre active les archives et les utilisations de la publication Type de poste par défaut comme slug d'archive.hiérarchique - un booléen qui définit si le type de publication est hiérarchique ou non, c'est-à-dire s'il permet aux parents d'être spécifiés ou non.menu_position - une chaîne représentant la position du type de publication à afficher dans le menu. Les valeurs vont approximativement de 5 à 100.les soutiens - cette valeur a à nouveau une valeur de tableau, cette fois avec des valeurs comme titre, éditeur, vignette, champs personnalisés, rétroliens, révisions, attributs de page et post-formats.Le tableau args principal est utilisé dans la prochaine register_post_type fonction qui a le premier paramètre le nom du type de post personnalisé (dans notre cas CPT) et le second le $ args variable.
Cela couvre à peu près la création de notre type de message personnalisé principal, avec l'exemple donné et expliqué ci-dessus.
Premièrement, nous avons couvert les crochets, l’un des crochets a implémenté une balise dotée d’une fonction de rappel spécialement conçue pour l’implémentation de la boîte méta. Cette fonction ressemble à ceci:
function cpt_add_meta_boxes () add_meta_box ('cpt_meta_id', 'Paramètres de type de message personnalisé', 'cpt_inner_custom_box', 'CPT', 'normal'); À l'intérieur de la fonction, nous avons le add_meta_box fonction qui possède les paramètres par défaut pour l’implémentation d’une boîte méta, à savoir l’id unique de la boîte méta, son titre, la fonction de rappel et le type de message personnalisé auquel elle doit être appliquée, ainsi que la position (nous sommes va le mettre à la normale comme nous le voulons juste sous l'éditeur).
C'est tout pour générer à l'aide de l'API, mais avec quoi la remplissons-nous? Eh bien, nous devons le remplir avec toutes les options de l'étape 3 évoquées précédemment. Pour ce faire, nous allons créer des champs de formulaire et les remplir avec des données en fonction de leur type..
Nous utilisons des cases à cocher pour les arguments de tableau qui nécessitent des valeurs booléennes. Coché est vrai et décoché est faux.
name = "cp_publicly_queryable" /> Publicly Queryable
Certains arguments de tableau nécessitent plusieurs éléments. Pour cela, nous utilisons des listes déroulantes avec des valeurs codées en dur qui répondent à nos besoins..
Position du menu:
Nous allons stocker des valeurs de chaîne dans ces champs de formulaire.
Nom général:
Vous avez peut-être remarqué qu'ils sont remplis de variables PHP et fonctionnent avec des données. Mais d'où viennent ces variables que vous pouvez vous demander, et qu'en est-il des données? Pour répondre à cette question, nous devons passer à l'étape suivante et enregistrer les champs de formulaire créés tout à l'heure. Mais parce que je ne veux pas vous obliger à revenir en arrière, je vous demanderai de supposer que toutes les données sont sauvegardées dans la base de données, je vais vous montrer comment, et tout ce que nous avons à faire, c'est de les extraire. comme dans l'exemple suivant:
global $ post; $ cp_public = get_post_meta ($ post-> ID, 'cp_public', true);
Dans notre fonction de rappel de la méta-boîte, nous déclarons la variable globale $ post pour obtenir l’identifiant de la publication actuelle plus tard et parce que les données sont stockées en tant que publication personnalisée, nous allons utiliser le get_post_meta fonction pour obtenir la valeur de la clé méta stockée pour chaque variable, comme dans l'exemple ci-dessus, où le premier paramètre est l'identifiant de publication, le second est la clé méta et le troisième est un booléen indiquant à la fonction de renvoyer une chaîne et non un tableau.
Un nombre de 27 variables utilisées dans ce didacticiel sont stockées dans des publications personnalisées et se présentent comme suit:
$ cp_public = get_post_meta ($ post-> ID, 'cp_public', true); $ cp_publicly_queryable = get_post_meta ($ post-> ID, 'cp_publicly_queryable', true); $ cp_show_ui = get_post_meta ($ post-> ID, 'cp_show_ui', true); $ cp_show_in_menu = get_post_meta ($ post-> ID, 'cp_show_in_menu', true); $ cp_query_var = get_post_meta ($ post-> ID, 'cp_query_var', true); $ cp_rewrite = get_post_meta ($ post-> ID, 'cp_rewrite', true); $ cp_has_archive = get_post_meta ($ post-> ID, 'cp_has_archive', true); $ cp_hierarchical = get_post_meta ($ post-> ID, 'cp_hierarchical', true); $ cp_capability_type = get_post_meta ($ post-> ID, 'cp_capability_type', true); $ cp_menu_position = get_post_meta ($ post-> ID, 'cp_menu_position', true); $ cp_s_title = get_post_meta ($ post-> ID, 'cp_s_title', true); $ cp_s_editor = get_post_meta ($ post-> ID, 'cp_s_editor', true); $ cp_s_author = get_post_meta ($ post-> ID, 'cp_s_author', true); $ cp_s_thumbnail = get_post_meta ($ post-> ID, 'cp_s_thumbnail', true); $ cp_s_excerpt = get_post_meta ($ post-> ID, 'cp_s_excerpt', true); $ cp_s_comments = get_post_meta ($ post-> ID, 'cp_s_comments', true); $ cp_general_name = get_post_meta ($ post-> ID, 'cp_general_name', true); $ cp_singular_name = get_post_meta ($ post-> ID, 'cp_singular_name', true); $ cp_add_new = get_post_meta ($ post-> ID, 'cp_add_new', true); $ cp_add_new_item = get_post_meta ($ post-> ID, 'cp_add_new_item', true); $ cp_edit_item = get_post_meta ($ post-> ID, 'cp_edit_item', true); $ cp_new_item = get_post_meta ($ post-> ID, 'cp_new_item', true); $ cp_all_items = get_post_meta ($ post-> ID, 'cp_all_items', true); $ cp_view_item = get_post_meta ($ post-> ID, 'cp_view_item', true); $ cp_search_items = get_post_meta ($ post-> ID, 'cp_search_items', true); $ cp_not_found = get_post_meta ($ post-> ID, 'cp_not_found', true); $ cp_not_found_in_trash = get_post_meta ($ post-> ID, 'cp_not_found_in_trash', true); $ cp_parent_item_colon = get_post_meta ($ post-> ID, 'cp_parent_item_colon', true);
Ce que vous devez comprendre, c'est qu'elles sont toutes extraites de la même manière, il n'y a rien de spécial ou de différent dans cette longue liste de variables, à l'exception de leurs valeurs. Bien entendu, l’idée est que ce code récupère les données de la base de données et qu’il soit utilisé ultérieurement dans chaque champ de formulaire pour indiquer ces données dans la boîte méta du panneau d’administration en tant que valeur sélectionnée, en tant que chaîne ou en tant que case à cocher pour les booléens. valeurs. Toutes les fonctionnalités sont mieux visibles dans les fichiers téléchargeables joints.
Jusqu'à présent, voici comment se présente une publication personnalisée du contenu de la boîte à méta de type de publication personnalisée en fonction de notre implémentation..
Toutes les données de formulaire soumises à partir de la boîte méta doivent être enregistrées dans la base de données pour pouvoir être utilisées ultérieurement afin de rendre le type de message personnalisé dynamique et également dans les fonctionnalités de la boîte méta. Pour sauvegarder les données, nous avons le cpt_save_postdata fonctionner comme une fonction de rappel que nous avons créé pour faire exactement cela. Mais cette fonction doit être remplie de fonctionnalités permettant de sauvegarder les données. Alors, comment pouvons-nous sauvegarder les données pour tous ces éléments. La réponse la plus simple et la plus évidente est celle des champs personnalisés. Nous allons stocker toutes ces valeurs dans des champs personnalisés de la publication individuelle principale du type de publication personnalisée, car il est beaucoup plus facile à gérer ultérieurement lorsque nous les extrayons en fonction d'une publication spécifique..
Voici tout le code requis pour s'exécuter dans la fonction spécifiée précédemment afin de sauvegarder toutes les données nécessaires.
global $ post; if ($ _POST ['cpt-hidd'] == 'true') $ cp_public = get_post_meta ($ post-> ID, 'cp_public', true); $ cp_publicly_queryable = get_post_meta ($ post-> ID, 'cp_publicly_queryable', true); $ cp_show_ui = get_post_meta ($ post-> ID, 'cp_show_ui', true); $ cp_show_in_menu = get_post_meta ($ post-> ID, 'cp_show_in_menu', true); $ cp_query_var = get_post_meta ($ post-> ID, 'cp_query_var', true); $ cp_rewrite = get_post_meta ($ post-> ID, 'cp_rewrite', true); $ cp_has_archive = get_post_meta ($ post-> ID, 'cp_has_archive', true); $ cp_hierarchical = get_post_meta ($ post-> ID, 'cp_hierarchical', true); $ cp_capability_type = get_post_meta ($ post-> ID, 'cp_capability_type', true); $ cp_menu_position = get_post_meta ($ post-> ID, 'cp_menu_position', true); $ cp_s_title = get_post_meta ($ post-> ID, 'cp_s_title', true); $ cp_s_editor = get_post_meta ($ post-> ID, 'cp_s_editor', true); $ cp_s_author = get_post_meta ($ post-> ID, 'cp_s_author', true); $ cp_s_thumbnail = get_post_meta ($ post-> ID, 'cp_s_thumbnail', true); $ cp_s_excerpt = get_post_meta ($ post-> ID, 'cp_s_excerpt', true); $ cp_s_comments = get_post_meta ($ post-> ID, 'cp_s_comments', true); $ cp_general_name = get_post_meta ($ post-> ID, 'cp_general_name', true); $ cp_singular_name = get_post_meta ($ post-> ID, 'cp_singular_name', true); $ cp_add_new = get_post_meta ($ post-> ID, 'cp_add_new', true); $ cp_add_new_item = get_post_meta ($ post-> ID, 'cp_add_new_item', true); $ cp_edit_item = get_post_meta ($ post-> ID, 'cp_edit_item', true); $ cp_new_item = get_post_meta ($ post-> ID, 'cp_new_item', true); $ cp_all_items = get_post_meta ($ post-> ID, 'cp_all_items', true); $ cp_view_item = get_post_meta ($ post-> ID, 'cp_view_item', true); $ cp_search_items = get_post_meta ($ post-> ID, 'cp_search_items', true); $ cp_not_found = get_post_meta ($ post-> ID, 'cp_not_found', true); $ cp_not_found_in_trash = get_post_meta ($ post-> ID, 'cp_not_found_in_trash', true); $ cp_parent_item_colon = get_post_meta ($ post-> ID, 'cp_parent_item_colon', true); update_post_meta ($ post-> ID, 'cp_public', $ _POST ['cp_public'], $ cp_public); update_post_meta ($ post-> ID, 'cp_publicly_queryable', $ _POST ['cp_publicly_queryable'], $ cp_publicly_queryable); update_post_meta ($ post-> ID, 'cp_show_ui', $ _POST ['cp_show_ui'], $ cp_show_ui); update_post_meta ($ post-> ID, 'cp_show_in_menu', $ _POST ['cp_show_in_menu'], $ cp_show_in_menu); update_post_meta ($ post-> ID, 'cp_query_var', $ _POST ['cp_query_var'], $ cp_query_var); update_post_meta ($ post-> ID, 'cp_rewrite', $ _POST ['cp_rewrite'], $ cp_rewrite); update_post_meta ($ post-> ID, 'cp_has_archive', $ _POST ['cp_has_archive'], $ cp_has_archive); update_post_meta ($ post-> ID, 'cp_hierarchical', $ _POST ['cp_hierarchical'], $ cp_hierarchical); update_post_meta ($ post-> ID, 'cp_capability_type', $ _POST ['cp_capability_type'], $ cp_capability_type); update_post_meta ($ post-> ID, 'cp_menu_position', $ _POST ['cp_menu_position'], $ cp_menu_position); update_post_meta ($ post-> ID, 'cp_s_title', $ _POST ['cp_s_title'], $ cp_s_title); update_post_meta ($ post-> ID, 'cp_s_editor', $ _POST ['cp_s_editor'], $ cp_s_editor); update_post_meta ($ post-> ID, 'cp_s_author', $ _POST ['cp_s_author'], $ cp_s_author); update_post_meta ($ post-> ID, 'cp_s_thumbnail', $ _POST ['cp_s_thumbnail'], $ cp_s_thumbnail); update_post_meta ($ post-> ID, 'cp_s_excerpt', $ _POST ['cp_s_excerpt'], $ cp_s_excerpt); update_post_meta ($ post-> ID, 'cp_s_comments', $ _POST ['cp_s_comments'], $ cp_s_comments); update_post_meta ($ post-> ID, 'cp_general_name', $ _POST ['cp_general_name'], $ cp_general_name); update_post_meta ($ post-> ID, 'cp_singular_name', $ _POST ['cp_singular_name'], $ cp_singular_name); update_post_meta ($ post-> ID, 'cp_add_new', $ _POST ['cp_add_new'], $ cp_add_new); update_post_meta ($ post-> ID, 'cp_add_new_item', $ _POST ['cp_add_new_item'], $ cp_add_new_item); update_post_meta ($ post-> ID, 'cp_edit_item', $ _POST ['cp_edit_item'], $ cp_edit_item); update_post_meta ($ post-> ID, 'cp_new_item', $ _POST ['cp_new_item'], $ cp_new_item); update_post_meta ($ post-> ID, 'cp_all_items', $ _POST ['cp_all_items'], $ cp_all_items); update_post_meta ($ post-> ID, 'cp_view_item', $ _POST ['cp_view_item'], $ cp_view_item); update_post_meta ($ post-> ID, 'cp_search_items', $ _POST ['cp_search_items'], $ cp_search_items); update_post_meta ($ post-> ID, 'cp_not_found', $ _POST ['cp_not_found'], $ cp_not_found); update_post_meta ($ post-> ID, 'cp_not_found_in_trash', $ _POST ['cp_not_found_in_trash'], $ cp_not_found_in_trash); update_post_meta ($ post-> ID, 'cp_parent_item_colon', $ _POST ['cp_parent_item_colon'], $ cp_parent_item_colon);
Tout d’abord, nous extrayons les variables comme nous l’avions fait précédemment dans la partie supérieure de la fonctionnalité de la boîte méta, puis nous les mettons à jour à l’aide de la commande update_post_meta fonction, que nous donnons aux paramètres: post id, nom de clé méta, nouvelle valeur, ancienne valeur. Voilà, nous avons mis à jour le champ personnalisé d'une valeur. Nous devons répéter le processus, comme vous le voyez dans l'exemple ci-dessus, pour couvrir toutes les valeurs et toutes les options dont nous avons besoin..
Voilà pour la sauvegarde des données.
Alors, comment pouvons-nous prendre toutes les données que nous venons de sauvegarder et les rendre dynamiques? Comment l'utilisons-nous pour générer des types d'articles personnalisés? Facile, nous interrogeons le type de message personnalisé principal et, pour chaque message de boucle, nous extrayons les champs personnalisés et plaçons les données dans le tableau en conséquence..
Voyons comment faire cela. Tout d’abord, nous plaçons ce code juste sous le code de type de message personnalisé principal, à l’intérieur du init_custom_post_types une fonction. Et donc, nous commençons par créer la requête:
$ the_query = new WP_Query (array ('post_type' => array ('CPT'))); while ($ the_query-> have_posts ()): $ the_query-> the_post (); Nous créons une variable nommée $ the_query dans lequel nous stockons le contenu de la fonction de classe principale invoquée wp_query avec les paramètres d'un tableau qui a la valeur du Type de poste le nom du type de poste personnalisé principal, à savoir, CPT. Ensuite, nous commençons la boucle. À l'intérieur de la boucle, nous générons les variables que nous voulons contenir les valeurs dont nous avons besoin en utilisant la même approche pour les extraire de la base de données sous forme de champs personnalisés:
global $ post; // ************************** récupère les valeurs $ cp_public = get_post_meta ($ post-> ID, 'cp_public', true); if ($ cp_public == "on") $ cp_public = true; else $ cp_public = false; $ cp_publicly_queryable = get_post_meta ($ post-> ID, 'cp_publicly_queryable', true); if ($ cp_publicly_queryable == "on") $ cp_publicly_queryable = true; else $ cp_publicly_queryable = false; $ cp_show_ui = get_post_meta ($ post-> ID, 'cp_show_ui', true); if ($ cp_show_ui == "on") $ cp_show_ui = true; else $ cp_show_ui = false; $ cp_show_in_menu = get_post_meta ($ post-> ID, 'cp_show_in_menu', true); // if ($ cp_show_in_menu == "on") $ cp_show_in_menu = true; else $ cp_show_in_menu = false; $ cp_query_var = get_post_meta ($ post-> ID, 'cp_query_var', true); // if ($ cp_query_var == "on") $ cp_query_var = true; else $ cp_query_var = false; $ cp_rewrite = get_post_meta ($ post-> ID, 'cp_rewrite', true); // if ($ cp_rewrite == "on") $ cp_rewrite = true; else $ cp_rewrite = false; $ cp_has_archive = get_post_meta ($ post-> ID, 'cp_has_archive', true); // if ($ cp_has_archive == "on") $ cp_has_archive = true; else $ cp_has_archive = false; $ cp_hierarchical = get_post_meta ($ post-> ID, 'cp_hierarchical', true); if ($ cp_hierarchical == "on") $ cp_hierarchical = true; else $ cp_hierarchical = false; $ cp_capability_type = get_post_meta ($ post-> ID, 'cp_capability_type', true); $ cp_menu_position = get_post_meta ($ post-> ID, 'cp_menu_position', true); $ cp_s_title = get_post_meta ($ post-> ID, 'cp_s_title', true); if ($ cp_s_title == "on") $ cp_s [] = 'titre'; $ cp_s_editor = get_post_meta ($ post-> ID, 'cp_s_editor', true); if ($ cp_s_editor == "on") $ cp_s [] = 'éditeur'; $ cp_s_author = get_post_meta ($ post-> ID, 'cp_s_author', true); if ($ cp_s_author == "on") $ cp_s [] = 'auteur'; $ cp_s_thumbnail = get_post_meta ($ post-> ID, 'cp_s_thumbnail', true); if ($ cp_s_thumbnail == "on") $ cp_s [] = 'vignette'; $ cp_s_excerpt = get_post_meta ($ post-> ID, 'cp_s_excerpt', true); if ($ cp_s_excerpt == "on") array_push ($ cp_s, 'extrait'); $ cp_s_comments = get_post_meta ($ post-> ID, 'cp_s_comments', true); if ($ cp_s_comments == "on") array_push ($ cp_s, 'comments'); $ cp_general_name = get_post_meta ($ post-> ID, 'cp_general_name', true); $ cp_singular_name = get_post_meta ($ post-> ID, 'cp_singular_name', true); $ cp_add_new = get_post_meta ($ post-> ID, 'cp_add_new', true); $ cp_add_new_item = get_post_meta ($ post-> ID, 'cp_add_new_item', true); $ cp_edit_item = get_post_meta ($ post-> ID, 'cp_edit_item', true); $ cp_new_item = get_post_meta ($ post-> ID, 'cp_new_item', true); $ cp_all_items = get_post_meta ($ post-> ID, 'cp_all_items', true); $ cp_view_item = get_post_meta ($ post-> ID, 'cp_view_item', true); $ cp_search_items = get_post_meta ($ post-> ID, 'cp_search_items', true); $ cp_not_found = get_post_meta ($ post-> ID, 'cp_not_found', true); $ cp_not_found_in_trash = get_post_meta ($ post-> ID, 'cp_not_found_in_trash', true); $ cp_parent_item_colon = get_post_meta ($ post-> ID, 'cp_parent_item_colon', true);
Parce que nous sommes maintenant dans la boucle de requête, nous pouvons utiliser un global $ post variable pour obtenir l'ID dont nous avons besoin. Aussi, vous avez peut-être remarqué quelques conditions définies par un if ici et là pour la plupart des variables. Celles-ci existent parce que la vraie valeur booléenne ou certaines autres valeurs de chaîne doivent être converties correctement à partir du "sur" chaîne qu'ils représentent dans la vrai valeur booléenne dont ils ont besoin pour être.
Une fois tout cela réglé, nous insérerons les variables dans le tableau de l'implémentation dynamique de type post personnalisé:
$ labels = array ('name' => _x (get_the_title ($ post-> ID), 'nom général du type de message'), 'singular_name' => _x ($ cp_singular_name, 'post type nom singulier'), 'add_new' => _x ($ cp_add_new, get_the_title ($ post-> ID)), 'add_new_item' => __ ($ cp_add_new_item), 'edit_item' => __ ($ cp_edit_item), 'new_item' => __ ($ cp_new) 'all_items' => __ ($ cp_all_items), 'view_item' => __ ($ cp_view_item), 'search_items' => __ ($ cp_search_items), 'not_found' => __ ($ cp_not_found), 'not_found_in_trash' => ($ cp_not_found_in_trash), 'parent_item_colon' => __ ($ cp_parent_item_colon), 'nom_menu' => __ (get_the_title ($ post-> ID))); $ args = array ('labels' => $ labels, 'public' => $ cp_public, 'public_queryable' => $ cp_publicly_queryable, 'show_ui' => $ cp_show_ui, 'show_in_menu' => $ cp_show_in_menu, 'query_var' => $ cp_query_var, 'rewrite' => $ cp_rewrite, 'capacite_type' => 'post', 'has_archive' => $ cp_has_archive, 'hierarchical' => $ cp_hierarchical, 'menu_position' => $ cp_menu_position, 'soutient' => $ cp_s); register_post_type (get_the_title ($ post-> ID), $ args); en attendant; Le titre de la publication est utilisé comme nom principal du type de publication personnalisé et les paramètres de la boîte à méta comme le reste des propriétés. C'est tout ce dont vous avez besoin pour implémenter les types de publication personnalisés dynamiques dans WordPress. Vous avez peut-être remarqué que nous fermons également la boucle à la fin du code précédent.
Les types de publication personnalisés ne sont pas difficiles à gérer et sont assez flexibles pour toutes les fonctionnalités dont vous pourriez avoir besoin, même avec d'autres hooks, filtres ou fonctions personnalisées. Dans ce tutoriel, nous avons réussi à couvrir une implémentation dynamique spécifique de la gestion de type de message personnalisé dans un seul plugin, avec code et fichiers, pour répondre à vos besoins. Bien sûr, l’utilisation du type de message personnalisé ne se limite pas à ces exemples car elle peut être utilisée dans de nombreux types d’implémentations, de plugins et de thèmes emmêlés dans de nombreux crochets, interrogés de différentes manières, filtrés ou manipulés de nombreuses façons..
