Share
Vaak moet u een keuze maken en beslissen hoe u een bepaalde functionaliteit gaat implementeren. WordpPress heeft een vrij flexibele aanpak voor bijna elk probleem, en in deze tutorial gaan we kijken hoe flexibel de aangepaste post-type API is.
Er zijn veel dingen die u kunt doen met aangepaste berichttypen, waaronder het genereren en beheren van bepaalde berichten op sommige aangepaste pagina's, diavoorstellingen, galerijen en zelfs portfolio-items. Sommige mensen weten niet dat ze al bestaan, anderen begrijpen hun opties niet volledig en weten niet hoe ze te gebruiken. We gaan proberen in de volgende stappen een specifieke plug-in te bouwen die op zijn best aangepaste berichttypen gebruikt. Om precies te zijn, gaan we een plug-in bouwen die één aangepast berichttype maakt, dat dynamisch en andere aangepaste berichttypen maakt en beheert (het is zoals Inception hier!).
Voordat we zelfs maar beginnen te starten, gaan we in detail kijken naar wat we gaan bouwen in deze tutorial, hoe en waarom. Het doel van deze zelfstudie is om u vertrouwd te maken met aangepaste berichttypen in WordPress.
Om dit te doen, gaan we een plug-in bouwen die één hoofd aangepast posttype maakt en vervolgens de posts in dat aangepaste berichttype gebruiken, met een instellingen-metabox, om extra, dynamische aangepaste berichttypen te maken op basis van de metakastinterfaceopties. Dit zal u helpen om alle aangepaste berichtopties en enkele van de mogelijkheden die het kan geven in detail te begrijpen. Ten behoeve van deze tutorial wordt geïmpliceerd dat u een werkende Apache-server hebt waarop PHP en MySQL worden uitgevoerd en WordPress is geïnstalleerd, zodat u de plugin-code kunt testen in een 3.0+ -versie van WordPress.
Elk bericht zal worden geïnterpreteerd als een nieuw aangepast berichttype en we gaan de configuratie-opties van elk bericht in aangepaste velden opslaan met behulp van een metabox met een heleboel formulieren, checkboxes, dropdown boxes en tekstvakken die de gegevens, waardoor het voor de gebruiker gemakkelijk is om iets aan te passen.
Omdat de plug-in 450 regels code heeft, bestaat niet elke regel code in de zelfstudie omdat de meeste code wordt herhaald en alleen de variabelen verschillend zijn. Maar alle functionaliteit van de plug-in wordt uitgelegd en de broncode wordt als voorbeeld gegeven.
Als we willen werken met de aangepaste functionaliteit van het posttype, de metabox-functionaliteit en we willen gegevens opslaan over update- of publicatieactie, hebben we hooks nodig en moeten we deze specifiek implementeren om het gewenste effect te krijgen.
Accentsconagua
add_action ('save_post', 'cpt_save_postdata'); add_action ('add_meta_boxes', 'cpt_add_meta_boxes'); add_action ('init', 'init_custom_post_types'); We hebben slechts drie hooks nodig in deze tutorial, geen filters, niets anders in de kernfunctionaliteit. Eerst hebben we een haak nodig om het aangepaste berichttype in zijn callback-functie te genereren. Daarvoor gaan we de gebruiken in het tag hook en de callback-functie met de naam van 'Init_custom_post_types'. Dit is waar alle magie gebeurt, namelijk dit is waar we onze aangepaste berichttypen declareren en waar we ze dynamisch maken door de waarden uit de database te extraheren en dynamische aangepaste berichttypen in een lus te genereren. Dit deel van de code zal later worden besproken.
Een andere haak die we nodig hebben is de 'Add_meta_boxes' taghaak die naar de callback-functie wijst 'Cpt_add_meta_boxes' en wordt gebruikt om de metaboxen in het hoofd aangepaste berichttype te genereren dat alle andere aangepaste berichttypen genereert. Hier maken we de formulieren die de gegevens opslaan en bijwerken die we nodig hebben om te manipuleren om onze functionaliteit te creëren.
De laatste haak die we gebruiken is 'Save_post' met de callback-functie van 'Cpt_save_postdata' en het doel van het opslaan van de metabox geposte gegevens. Wanneer de pagina van het belangrijkste aangepaste berichttype door de gebruiker in het adminpaneel wordt ingediend, worden alle formuliervelden ingediend en dit is de haak die we gebruiken om die inhoud te pakken en deze in de database op te slaan / bij te werken voor later gebruik.
Eerst moeten we een algemeen aangepast berichttype maken dat alle dynamische inhoud gaat afhandelen. Om dit te doen, maken we eerst een generiek aangepast berichttype met behulp van hard gecodeerde gegevens zoals in het volgende voorbeeld. Eerst maken we de labels. De parameter labels is een van de belangrijkste argumentwaarden die wordt geïnterpreteerd als een array. De arraywaarden worden specifiek opgegeven op basis van hun ID's naam voor de algemene hoofdnaam van het aangepaste berichttype dat meestal een meervoudsstring is van de naam van het aangepaste berichttype, singular_name voor de aangepaste objecttypenaam in het enkelvoud, add_new de nieuwe tekenreeks toevoegen, Voeg een nieuw item toe dat is de standaard nieuwe bericht- / paginatekst toevoegen, Item bewerken als de standaardtekst voor het bewerken van berichten of pagina's, alle spullen wordt gebruikt voor het tonen van alle aangepaste tekst van de posttypenamen op verzoek (bijvoorbeeld: alle auto's), view_items en search_items worden net als het vorige voorbeeld gebruikt, alleen voor de duidelijk verschillende doeleinden, niet gevonden, not_fount_in_trash, parent_item_colon zijn ook vervangende teksten die worden gebruikt voor bepaalde pagina's van de berichten (aangepaste berichttypen) functionaliteit die u mogelijk wilt wijzigen voor elk aangepast berichttype dat u maakt.
In het volgende voorbeeld, de $ labels array gebruikt CPT bij het vervangen van de standaard berichten / berichten / pagina / pagina's. Ik denk dat het voor sommige lezers niet nodig is, maar om er zeker van te zijn dat ik het idee niet mis, staat CPT voor Custom Post Type en wordt en zal het op een aantal manieren worden gebruikt tijdens de tutorial.
Een belangrijke opmerking, deze code wordt ingevoegd in de init_custom_post_types callback-functie zodat deze correct werkt.
$ labels = array ('naam' => _x ('CPT', 'berichttype algemene naam'), 'singular_name' => _x ('CPT', 'post type singular name'), 'add_new' => _x ( 'Nieuw CPT toevoegen', 'CPT'), 'add_new_item' => __ ('Nieuw berichttype toevoegen'), 'edit_item' => __ ('Edit CPT'), 'new_item' => __ ('Nieuw CPT' ), 'all_items' => __ ('Alle CPT'), 'view_item' => __ ('CPT weergeven'), 'search_items' => __ ('Zoek CPT'), 'not_found' => __ ('Nee CPT gevonden '),' not_found_in_trash '=> __ (' Geen CPT gevonden in Prullenbak '),' parent_item_colon '=> ",' menu_name '=> __ (' CPT ')); $ args = array (' labels '= > $ labels, 'public' => true, 'publicly_queryable' => true, 'show_ui' => true, 'show_in_menu' => true, 'query_var' => true, 'rewrite' => true, 'capability_type' = > 'post', 'has_archive' => true, 'hierarchical' => false, 'menu_position' => null, 'supports' => array ('title')); register_post_type ('CPT', $ args); De hoofdarray die nodig is voor het genereren van het aangepaste berichttype is de $ args array, die uitsluitend wordt gebruikt om de belangrijkste opties van het aangepaste berichttype in te stellen en de functionaliteit ervan te beheren.
openbaar - een Booleaanse variabele, true of false, die de beschikbaarheid van het aangepaste berichttype vertegenwoordigt, als deze openbaar is voor de beheerdersinterface of door front-end gebruikers in het thema.publicly_queryable - opnieuw een Booleaanse waarde die instelt als de front-end de mogelijkheid heeft om de resultaten van het aangepaste berichttype te ondervragen.show_ui - een boolean die aangeeft of standaardbeheerdersinhoud wordt gegenereerd voor het aangepaste berichttype of niet.show_in_menu - nog een andere booleaanse variabele die vereist show_ui om trouw te blijven aan de functie, omdat het doel is om het berichttype al dan niet weer te geven in het menu van het WordPress-adminpaneel.query_var - maakt een vraag var-toets voor dit aangepaste berichttype. U kunt het gebruiken als boolean of tekenreeks, als het waar is, is het standaard, false schakelt het gebruik van queryvarensets uit en reeks stelt een aangepaste sleutel in. In ons voorbeeld gebruiken we de standaardwaarde en stellen deze in op true.herschrijven - dit voorkomt herschrijvingen voor dit berichttype.capability_type - eindelijk een tekenreeks die bepaalt of het aangepaste berichttype een bericht of een pagina is, in een tekenreeks zonder opmaak. We gebruiken post.has_archive - deze parameter maakt postarchieven en gebruiken mogelijk post_type standaard als archiefslak.hiërarchische - een boolean die instelt als het berichttype hiërarchisch is of niet, dat wil zeggen als het toestaat dat ouders worden opgegeven of niet.menu_position - een tekenreeks die de positie vertegenwoordigt voor het berichttype dat in het menu wordt weergegeven. De waarden gaan ongeveer van 5 tot 100.ondersteuningen - deze waarde heeft weer een arraywaarde, deze keer met waarden zoals titel, editor, miniatuur, aangepaste velden, trackbacks, revisies, paginakenmerken en postformaten.De array met de belangrijkste args wordt in de volgende array gebruikt register_post_type functie die de eerste parameter de naam van het aangepaste berichttype heeft (in ons geval CPT) en de tweede de $ args veranderlijk.
Dit komt vrijwel overeen met het maken van ons belangrijkste aangepaste berichttype, met het hierboven gegeven en toegelichte voorbeeld.
Eerst hebben we haken behandeld, een van de hooks heeft een tag geïmplementeerd met een callback-functie die specifiek is gemaakt voor implementatie van de metabox. Die functie ziet er als volgt uit:
functie cpt_add_meta_boxes () add_meta_box ('cpt_meta_id', 'Aangepaste berichttype-instellingen', 'cpt_inner_custom_box', 'CPT', 'normaal'); Binnen de functie hebben we de add_meta_box functie die de standaardparameters heeft voor het implementeren van een metabox, namelijk de unieke metabox-id, de titel ervan, de callback-functie en het aangepaste berichttype waarop deze moet worden toegepast, en last but not least, de positie (we zijn gaat het normaal maken zoals we het willen, direct onder de editor).
Dat is het voor het genereren van het gebruik van de API, maar waarmee vullen we het in? Welnu, we moeten het vullen met alle eerder besproken opties uit stap 3 en om dit te doen, gaan we formuliervelden maken en ze vullen met gegevens, afhankelijk van hun type.
We gebruiken selectievakjes voor de array-argumenten waarvoor booleaanse waarden zijn vereist. Gecontroleerd is waar en ongecontroleerd is false.
name = "cp_publicly_queryable" /> Publicly Queryable
Voor sommige array-argumenten zijn meerdere elementen vereist waaruit u kunt kiezen. Hiervoor gebruiken we drop-down boxen met hard gecodeerde waarden die aan onze behoeften voldoen.
Menupositie:
We gaan stringwaarden opslaan in deze formuliervelden.
Algemene naam:
U hebt misschien gemerkt dat ze vol zitten met PHP-variabelen en functioneren met gegevens. Maar waar komen deze variabelen van u vandaan, dan kunt u zich afvragen, en hoe zit het met de gegevens? Om deze vraag te beantwoorden, moeten we doorgaan naar de volgende stap en de formuliervelden opslaan die zojuist zijn gemaakt. Maar omdat ik niet wil dat je door de stappen heen en weer gaat, zal ik je vragen om aan te nemen dat alle gegevens op een of andere manier in de database zijn opgeslagen, ik zal je laten zien hoe, en alles wat we moeten doen is het uitpakken in variabelen zoals in het volgende voorbeeld:
wereldwijde $ post; $ cp_public = get_post_meta ($ post-> ID, 'cp_public', true);
In onze meta box callback-functie declareren we de globale variabele $ bericht om de huidige post-id later te krijgen en omdat de gegevens worden opgeslagen als aangepaste post, gaan we de get_post_meta functie om de metasleutelwaarde te verkrijgen die is opgeslagen voor elke variabele, zoals het bovenstaande voorbeeld, waarbij de eerste parameter de post-id is, de tweede de meta-sleutel is en de derde een booleaanse functie die een tekenreeks retourneert en niet een array.
Er zijn een aantal van 27 variabelen die in deze tutorial worden gebruikt, opgeslagen als aangepaste berichten en ze zien er als volgt uit:
$ 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);
Wat je moet begrijpen is dat ze allemaal op dezelfde manier worden geëxtraheerd, er is niets bijzonders of anders aan deze lange lijst met variabelen behalve hun waarden. Natuurlijk is het de bedoeling dat deze code de gegevens uit de database haalt en later in elk formulierveld wordt gebruikt om die gegevens in de meta-box van het beheerderspaneel weer te geven als een geselecteerde waarde, als een tekenreeks of als aangevinkt selectievakje voor boolean waarden. Alle functionaliteit is beter te zien in de bijgevoegde downloadbare bestanden.
Als gevolg hiervan is dit hoe een aangepast bericht van de aangepaste inhoud van het post-type metabox eruitziet op basis van onze implementatie.
Alle formuliergegevens die vanuit de metabox zijn ingediend, moeten in de database worden opgeslagen, zodat deze later kan worden gebruikt om het aangepaste berichttype dynamisch te maken en ook in de functionaliteit van de metabox. Om de gegevens op te slaan, hebben we de cpt_save_postdata fungeren als een callback-functie die we hebben gemaakt om precies dat te doen. Maar deze functie moet worden gevuld met functionaliteit die de gegevens daadwerkelijk opslaat. Dus, hoe slaan we de gegevens op voor al deze elementen. Het eenvoudige en meest voor de hand liggende antwoord zijn aangepaste velden. We gaan al deze waarden opslaan in aangepaste velden van het hoofdbericht van het individuele bericht, omdat het veel gemakkelijker is om later te beheren als we ze extraheren op basis van een bepaald opgevraagd bericht.
Hier is alle code die nodig is om in de eerder gespecificeerde functie uit te voeren om alle gegevens op te slaan die we nodig hebben.
wereldwijde $ 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);
Ten eerste extraheren we de variabelen zoals we eerder deden in de top van de metabox-functionaliteit, en vervolgens werken we ze bij met behulp van de update_post_meta functie, dat we de parameters geven: post-id, metasleutelnaam, nieuwe waarde, oude waarde. Voila, we hebben het aangepaste veld van één waarde bijgewerkt. We moeten het proces herhalen zoals u in het bovenstaande voorbeeld ziet om alle waarden en alle opties die we nodig hebben te dekken.
Dat is het voor het opslaan van de gegevens.
Dus hoe nemen we al die gegevens die we zojuist hebben opgeslagen en maken deze dynamisch? hoe gebruiken we het om aangepaste berichttypen te genereren? Eenvoudig, we vragen naar het belangrijkste aangepaste berichttype en voor elke loop-post extraheren we de aangepaste velden en plaatsen de gegevens dienovereenkomstig in de array.
Laten we eens kijken hoe dat te doen. Ten eerste plaatsen we deze code direct onder de hoofdcode van het aangepaste berichttype, binnen de init_custom_post_types functie. En dus beginnen we met het maken van de vraag:
$ the_query = new WP_Query (array ('post_type' => array ('CPT'))); while ($ the_query-> have_posts ()): $ the_query-> the_post (); We maken een variabele genaamd $ the_query waarin we de inhoud van de aangeroepen hoofdklasse-functie opslaan wp_query met de parameters van een array die de waarde van de heeft post_type de naam van het belangrijkste aangepaste berichttype, namelijk, CPT. Dan beginnen we aan de lus. In de loop genereren we de variabelen waarmee we de waarden die we nodig hebben behouden door dezelfde aanpak te gebruiken om ze uit de database te halen als aangepaste velden:
wereldwijde $ post; // ************************* verkrijg de waarden $ 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 [] = 'titel'; $ cp_s_editor = get_post_meta ($ post-> ID, 'cp_s_editor', true); if ($ cp_s_editor == "on") $ cp_s [] = 'editor'; $ 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 [] = 'thumbnail'; $ cp_s_excerpt = get_post_meta ($ post-> ID, 'cp_s_excerpt', true); if ($ cp_s_excerpt == "on") array_push ($ cp_s, 'excerpt'); $ 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);
Omdat we nu in de querylus zitten, kunnen we een globale gebruiken $ bericht variabele om de ID te krijgen die we nodig hebben. Je hebt misschien ook een paar voorwaarden opgemerkt die door een if hier en daar voor de meeste variabelen zijn ingesteld. Deze bestaan omdat de echte Booleaanse waarde of bepaalde andere tekenreekswaarden correct moeten worden geconverteerd vanuit de "op" string die ze vertegenwoordigen in de waar booleaanse waarde die ze moeten zijn.
Nadat dit allemaal is afgehandeld, zullen we de variabelen invoegen in de array van de dynamische implementatie van het aangepaste posttype:
$ labels = array ('naam' => _x (get_the_title ($ post-> ID), 'post type algemene naam'), 'singular_name' => _x ($ cp_singular_name, 'post type singular name'), '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_item), '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), 'menu_name' => __ (get_the_title ($ post-> ID))); $ args = array ('labels' => $ labels, 'public' => $ cp_public, 'publicly_queryable' => $ cp_publicly_queryable, 'show_ui' => $ cp_show_ui, 'show_in_menu' => $ cp_show_in_menu, 'query_var' => $ cp_query_var, 'rewrite' => $ cp_rewrite, 'capability_type' => 'post', 'has_archive' => $ cp_has_archive, 'hierarchical' => $ cp_hierarchical, 'menu_position' => $ cp_menu_position, 'supports' => $ cp_s); register_post_type (get_the_title ($ post-> ID), $ args); endwhile; De berichttitel wordt gebruikt als de hoofdnaam van het aangepaste berichttype en de metaboxinstellingen als de rest van de eigenschappen. Dat is alles, alles wat nodig is om de dynamische aangepaste berichttypen in WordPress te implementeren. Wat je misschien gemerkt hebt is dat we ook de lus sluiten aan het einde van de vorige code.
Aangepaste berichttypen zijn niet moeilijk te hanteren en ze zijn behoorlijk flexibel in elke functionaliteit die je misschien nodig hebt, zelfs met andere haken, filters of aangepaste functies. In deze tutorial zijn we erin geslaagd om een specifieke dynamische implementatie van aangepast posttypebeheer in een enkele plug-in te behandelen, uitgelegd, met code en bestanden, voor uw behoeften. Natuurlijk beperkt het gebruik van aangepast berichttype zich niet tot deze voorbeelden, omdat het kan worden gebruikt in vele soorten implementaties, plug-ins en thema's die in veel haken verward zitten, op verschillende manieren worden ondervraagd, gefilterd of op veel verschillende manieren worden gemanipuleerd.
