Hoe een WordPress plug-in te bouwen om oude berichten te identificeren

Tijdens het lezen van artikelen op websites, heb ik vastgesteld dat wanneer een bericht ouder is dan vier jaar, een melding dat het bericht oud is, op bepaalde websites wordt weergegeven. Een soortgelijke melding is ook te vinden in de WordPress-invoegmap wanneer een plug-in niet meer dan twee jaar geleden is bijgewerkt.

In dit artikel bouwen we een plug-in die een vergelijkbare melding weergeeft wanneer een bericht is afgelopen X-jaar oud waar "X"een geheel getal dat het aantal jaren aangeeft dat oud is.
De plug-in biedt u de mogelijkheid om uw eigen aangepaste notificatiezin op te geven en het aantal jaren voordat een bericht als oud wordt beschouwd.

Deze plug-in wordt gebouwd met behulp van objectgeoriënteerd programmeren in een poging de code overzichtelijker te maken en zich aan het DRY-principe te houden. Daarom is enige ervaring met objectgeoriënteerd programmeren vereist om deze tutorial te begrijpen.

De plug-in plannen

De plug-in bestaat uit twee beschermde klasse-eigenschappen en tien methoden. De eigenschappen worden hieronder beschreven.

• $ _notification slaat het notificatiebericht op dat is opgehaald uit de database die eerder was ingesteld door de gebruiker van de plug-in.
• $ _yearsslaat het aantal jaren op dat uit de database is opgehaald.
  

Ik zal de rol van elke methode (bekend als functies in procedureel programmeren) en hun respectievelijke code tijdens het reizen uitleggen.

Codering van de plug-in

Laten we eerst de plug-in header toevoegen, de klasse en definieer de eigenschappen:

Bij het schrijven van WordPress-plug-ins in OOP, kunnen alle actie- en filterhaken worden ingesteld in de constructor (die de naam heeft __construct). De constructormethode van onze plugin bestaat uit vijf functies: drie actiehaken, een filterhaak en een register_activation_hook functie.
function __construct () // Initialiseer instellingsopties op activatie register_activation_hook (__FILE__, array ($ this, 'aop_settings_default_values')); // registreer Menu add_action ('admin_menu', array ($ this, 'aop_settings_menu')); // hook plugin sectie en veld om admin_init add_action ('admin_init', array ($ this, 'pluginOption')); // voeg het plug-ins stylesheet toe aan header add_action ('wp_head', array ($ this, 'stylesheet')); // weergavemelding boven bericht add_filter ('the_content', array ($ this, 'displayNotification')); 
 
De register_activation_hook roept de methode op om de standaardinstellingen van de plug-in in te stellen bij activering.
 
De volgende drie add_action functies bellen de haakfuncties om het plug-in menu te registreren, haak de plugin sectie en het veld naar admin_init en voeg de stylesheet van plug-in toe aan de koptekst.
 
De add_filter bel de displayNotification methode die de melding weergeeft wanneer een bericht oud is.
 
Kijken naar de __construct methode hierboven, de register_activation_hook functie roept de aop_settings_default_values methode om de standaard plugin-instellingen in te stellen.
public function aop_settings_default_values ​​() $ aop_plugin_options = array ('notification' => 'Dit bericht is niet meer dan 2 jaar geleden bijgewerkt.', 'jaar' => 2); update_option ('apo_alert_old_post', $ aop_plugin_options); 
De aop_settings_menu methode maakt het plug-in-submenu onder het bestaande instellingen menu.
public function aop_settings_menu () add_options_page ('Alert Post is Old', 'Alert Post is Old', 'manage_options', 'aop-alert-post-old', array ($ this, 'alert_post_old_function')); 
Het derde argument dat is doorgegeven aan de add_options_page functie hierboven is de alert_post_old_function methode die de pagina-inhoud van de instellingen van de plug-in weergeeft.
publieke functie alert_post_old_function () echo '
'; screen_icon (); echo '
Alert Post is oud
'; echo '
'; do_settings_sections (AOP-alert-post-old '); settings_fields (aop_settings_group); verzendknop(); 
Om de plugin-instellingen toe te voegen, gebruiken we WordPress Settings API om de instellingenformulieren toe te voegen.
Eerst definiëren we de sectie, voegen we de instellingenvelden toe en registreren we uiteindelijk de instellingen. Dit alles zal worden gedaan in de pluginOption methode die verslaafd was aan de admin_init actie eerder in de __construct methode.
plug-in voor openbare functies () add_settings_section ('aop_settings_section', 'Plugin Options', null, 'aop-alert-post-old'); add_settings_field ('notification', 'Melding om weer te geven wanneer bericht oud is', array ($ this,' aop_notification '),' aop-alert-post-old ',' aop_settings_section '); add_settings_field ('years', 'Aantal jaren dat een post als oud moet worden beschouwd', array ($ this,' aop_years '),' aop-alert-post-old ',' aop_settings_section '); register_setting ('aop_settings_group', 'apo_alert_old_post'); 
De callback-methode van het instellingenveld: aop_notification en aop_years die vulling vult het veld met de gewenste formulierinvoer en is als volgt.
publieke functie aop_notification () $ this-> databaseValues ​​(); echo ''; echo esc_attr ($ this -> _ notification); echo ''; 
public function aop_years () $ this-> databaseValues ​​(); echo '';
We zullen de pluginkennisgeving en jaarinstellingen ophalen en opslaan in de twee beschermde eigenschappen: $ _notification en $ _years omdat ze van pas zullen komen als we willen bepalen of een bericht ouder is dan de ingestelde leeftijd en wanneer het bericht wordt weergegeven.
public function databaseValues ​​() $ options = get_option ('apo_alert_old_post'); $ this -> _ notification = $ options ['notification']; $ this -> _ years = $ options ['years']; 
De CSS-code die wordt gebruikt bij het opmaken van de melding bevindt zich in de stylesheet methode.
public function stylesheet () echo <<   HTML; 
Ten slotte is de functie die de melding weergeeft boven de postinhoud die als oud werd beschouwd, als volgt:
openbare functie displayNotification ($ content) global $ post; $ This-> databaseValues ​​(); // instellingen krijgen jaar $ setYear = $ dit -> _ jaar; // krijg meldingstekst $ notification = $ this -> _ notification; // bereken post age $ year = date ('Y') - get_post_time ('Y', true, $ post-> ID); // show notificatie alleen op post if (is_single ()): if ($ year> $ setYear) echo '
'; echo ' ! '; echo "$ kennisgeving"; echo"
';  stop als; return $ inhoud; 
Laten we de bovenstaande code bespreken: Eerst halen we het aantal jaren terug dat bepaalt wanneer een bericht oud is, in mindering gebracht op het jaar waarin het bericht van het huidige jaar is geschreven. Als het resultaat groter is dan het jaar dat oud is, wordt de melding weergegeven dat het bericht oud is.
Eindelijk zijn we klaar met het coderen van de plugin-klasse. Om de klas aan het werk te zetten, moeten we hem als volgt instantiëren:
nieuwe AlertOldPost;
Conclusie
In dit artikel hebben we geleerd om de leeftijd van een bericht te berekenen, een melding weer te geven wanneer een bericht als oud wordt beschouwd en dit met behulp van objectgeoriënteerde programmeermethoden..
Ik verzoek u dringend om de code te herzien om een ​​grondige kennis van hoe het werkt te krijgen. Uw vragen, opmerkingen en bijdragen zijn welkom.




		
			
	   
	




Code