Share
In onze laatste CakePHP-zelfstudie hebben we gekeken naar het opzetten van het CakePHP-framework en enkele basisbegrippen en -terminologie van het framework geïntroduceerd. Nu gaan we meer over het illustreren van de snelle ontwikkelingscapaciteiten van CakePHP met behulp van een persoonlijke blogtoepassing als voorbeeld. In de volgende reeks tutorials zullen we de blogtoepassing stapsgewijs bouwen, zodat het eenvoudige CakePHP-ontwikkelingsproces duidelijk wordt uiteengezet in plaats van kort genoemd zoals in andere soortgelijke tutorials. In deze zelfstudie starten we met een basisauthenticatiecomponent voor het voorbeeld van de blogtoepassing.
Ons doel is om de componenten van een persoonlijke blogtoepassing te maken. Tegen de tijd dat we het project voltooien, zullen we Web 2.0-effecten toevoegen en integratie bieden met andere services om de applicatie compleet te maken. Voordat we ons project kunnen starten, moeten we echter een ontwikkelingsplan met een soort lijst met functies definiëren om ons te begeleiden.
Hier is een kleine lijst met belangrijkste functies die we zullen bespreken en opnemen in onze voltooide toepassing:
In het artikel van vandaag zullen we ons vooral richten op het gebruikers- / auteursbeheersysteem, omdat het de perfecte plek is om de basisprincipes van controller, model en weergavecode te leren. Zodra we deze basisprincipes leren, kunnen we ze later voor de andere componenten van het grotere systeem implementeren.
Zonder verder oponthoud, laten we CakePHP volgen.
Zoals eerder vermeld, hebben modellen interactie met de onderliggende database van het framework. Standaard wordt CakePHP geleverd met een aantal ingebouwde methoden om ons te redden van het overschrijven van code om algemene functionaliteit te implementeren. Samen met de verwachte methoden voor lezen en schrijven / opslaan, kunt u ook "magische methoden" gebruiken findBy
Ons gebruikerssysteem voor deze iteratie van de applicatie zal vrij eenvoudig zijn. Aangezien het hoofddoel een persoonlijke blog is, hebben we maar één auteur tegelijk. Voor de uitbreidbaarheid zullen we de gebruiker (s) echter in een tabel opslaan voor het geval we later een volledig opgeblazen gebruikers- / toestemmingsysteem willen ontwikkelen, of als we handmatig meer auteurs willen toevoegen. Onze basisfunctionaliteit zal toelaten om in te loggen, uit te loggen en onze persoonlijke informatie bij te werken.
We zullen dit alles doen met een kleine MySQL-tabel geïmplementeerd door de volgende CREATE TABLE-instructie:
Accentsconagua
CREËER TABEL 'authors' ('id' int (11) NOT NULL auto_increment, 'gebruikersnaam' varchar (255) NOT NULL standaard ", 'password' varchar (32) NOT NULL default", 'name' varchar (255) NOT NULL standaard ", 'email' varchar (255) NOT NULL default", 'bio' text NOT NULL, PRIMARY KEY ('id')) 
We zullen ook een basisstartaccount willen, dus we zullen ook een rij invoegen terwijl we bezig zijn (de gebruikersnaam en het wachtwoord voor het startaccount is test / test):
INSERT IN 'authors' ('gebruikersnaam', 'wachtwoord', 'naam', 'email', 'bio') VALUES ('test', '098f6bcd4621d373cade4e832627b4f6', 'Test', '[email protected]', 'Hallo wereld ... '); Het doel van de tabelstructuur is het volgende:
Nu moeten we het model eigenlijk maken. Hiertoe maakt u een nieuw bestand in de / App / modellen / map met de naam author.php met de volgende inhoud:
class Author breidt AppModel uit
var $ name = 'Auteur';
?>
Het model voor deze functionaliteit is eigenlijk vrij eenvoudig. Omdat de functionaliteit die we nodig hebben, zoals findByUsername of opslaan valt al onder de functies in Model (die wordt uitgebreid met AppModel) we zijn klaar met de modelzijde. Met dit algemene bestand kunnen we eenvoudig communiceren met de tabel Auteur.
In latere secties wanneer we beginnen met het toevoegen van postfunctionaliteit, moeten we mogelijk de modellen uitbreiden.
Views zijn voornamelijk een mix van HTML en helpers. In andere systemen zouden we deze sjablonen noemen. Helpers genereren gemeenschappelijke code of helpen met algemene taken. Sommige helpertypen in CakePHP zijn HTML-helpers en helpers voor paginering.
Als u weergaven wilt maken, maakt u een map in / App / views / riep auteurs / dus we kunnen al onze meningen opslaan. Ons eerste beeld zou moeten worden genoemd login.thtml met de volgende inhoud:
Fout
De gebruikersnaam en het wachtwoord komen niet overeen. Probeer het opnieuw en controleer de ingevoerde informatie nogmaals.
formTag ( '/ auteurs / login /'); ?> ingang (auteur / gebruikersnaam "); ?> wachtwoord ( 'Auteur / wachtwoord'); ?>
submit ( "Inloggen"); ?>
In plaats van gebruiken tags gebruiken we een van de helpers om geldige invoervelden te genereren die in onze controllers kunnen worden gebruikt. We plaatsen ook een beetje foutcontrole bovenaan de sjabloon voor het geval de gebruiker een verkeerde gebruikersnaam of wachtwoord invoert. De foutvariabele wordt later in de controller ingesteld.
Nu onze eerste actie een sjabloon heeft, kunnen we verdergaan met de anderen.
Uitloggen heeft eigenlijk geen eigen weergave nodig, omdat we gebruikers gewoon doorverwijzen naar de blogindexpagina en een snel succesbericht weergeven. Het bijwerken van profielinformatie in gebruikersbeheer heeft echter wel een formulier nodig, dus we moeten daar een weergave voor schrijven.
Maak een sjabloon met de naam manage.thtml met de volgende inhoud:
Fout
Zorg ervoor dat alle vereiste informatie is ingevuld.
formTag ( '/ auteurs / beheren /'); ?> ingang ( 'Auteur / name'); ?>
ingang ( 'Auteur / e'); ?>
textarea ('Auteur / bio', array ('cols' => '60', 'rows' => '10')); ?>
submit ( "Werk"); ?>
Deze weergave lijkt veel op ons inlogformulier, behalve dat we een aantal verschillende velden beheren en we gebruiken een andere helpermethode ($ html-> textarea) om een tekstgebied te genereren.
Super goed! Nu onze kleine set weergaven is geschreven, kunnen we overstappen naar controllers.
Controllers gedragen zich als verkeersleiders. Ze accepteren invoer, beslissen wat ermee te doen en geven vervolgens behandelingsinstructies aan de rest van het systeem. Ze vormen het hart van de toepassing omdat ze de gegevens van de modellen nemen en doorgeven om de juiste weergaven weer te geven.
Deze sectie behandelt specifiek het instellen en lezen van een sessie en het bijwerken van de database. We zullen ook een "ouder" -controller maken waarvan al onze toekomstige controllers zullen erven.
Maak eerst een bestand aan app / controllers / genaamd authors_controller.php. Nu zullen we de code stap voor stap doorlopen.
omleiding ('/'); function login () $ this-> set ('error', false); if (! empty ($ this-> data)) $ author = $ this-> Author-> findByUsername ($ this-> data ['Author'] ['username']); if (! empty ($ author ['Author'] ['password']) && $ author ['Author'] ['password'] == md5 ($ this-> data ['Author'] ['wachtwoord'] )) $ this-> Session-> write ('Auteur', $ auteur ['Auteur']); $ this-> redirect ('/'); else $ this-> set ('error', true); Onze indexfunctie is vrij eenvoudig. Voor nu zullen we gewoon doorverwijzen naar de scriptindex met behulp van een ingebouwde CakePHP-functie met de naam "redirect".
Onze inlogfunctie is wat geavanceerder. We stellen eerst de foutvariabele in op false om te voorkomen dat PHP een ongedefinieerde variabele melding terugbrengt. Vervolgens controleren we of er gegevens zijn verzonden. "$ this-> data" bevat alle invoergegevens van het inlogformulier en komt in het formaat $ this-> data ['CONTROLLER'] ['FIELD']. Nu zien we onze magische methode "findByUsername". gebruikt om rijen te vinden die de gebruikersnaam bevatten van de gebruiker die zojuist is ingelogd. Als we wel een gebruikersovereenkomst hebben, vergelijken we wachtwoorden en schrijven we een sessie met de sessie-afhandelaar van CakePHP. Als er een probleem is, stellen we 'error' in op true, zodat ons beeld het bericht kan verwerken. Een inlogsysteem kan niet veel eenvoudiger dan dat!
functie logout () $ this-> Session-> delete ('Author'); $ this-> flash ('U bent uitgelogd', '/'); De uitlogfunctie is nog eenvoudiger. We gebruiken CakePHP's sessieklasse om de sessie volledig te verwijderen en vervolgens gebruiken we de "flash" -methode om door te sturen. De flitsmethode is een beetje anders dan de omleidingsmethode, omdat we een bericht naar het scherm kunnen sturen. Dit wordt handig omdat we gebruikers daadwerkelijk kunnen laten weten dat er iets is gebeurd.
Notitie: omdat we nog steeds in de ontwikkelingsmodus zijn, zal het flash-scherm niet automatisch omleiden. U moet op de tekst klikken om naar het scherm te gaan. Wanneer we ons in de productiemodus bevinden, wordt dit scherm voor ons omgeleid.
function manage () $ this-> set ('error', false); if (empty ($ this-> data)) $ this-> Author-> id = $ this-> Session-> read ('Author.id'); $ this-> data = $ this-> Author-> read (); else if (empty ($ this-> data ['Author'] ['name']) || empty ($ this-> data ['Auteur'] ['email']) || empty ($ this- > data ['Auteur'] ['bio'])) $ this-> set ('error', true); $ this-> Author-> id = $ this-> Session-> read ('Author.id'); $ this-> data = $ this-> Author-> read (); else $ this-> Author-> id = $ this-> Session-> read ('Author.id'); if ($ this-> Author-> save ($ this-> data ['Author'])) $ this-> flash ('Uw accountgegevens zijn bijgewerkt.', '/ authors / manage /'); Onze meest geavanceerde functie voor deze controller is de beheren functie. Veel van de functionaliteit wordt geïmplementeerd met behulp van de technieken die we zojuist hebben geïntroduceerd. Een ding om op te merken in deze functie is het instellen van de $ this-> author-> id-variabele voor het opslaan en het lezen. Dit vertelt het model welke rij moet worden afgehandeld, dus het probeert niet om een hele nieuwe rij op te slaan of in te voegen. We behandelen ook meer sessiefunctionaliteit door de id van de hash te lezen.
Onze laatste stap is om de beheerpagina te beschermen. We willen alleen dat ingelogde gebruikers deze pagina kunnen bekijken en we kunnen bescherming bieden met een eenvoudige controlefunctie. Dit is een stukje functionaliteit die we ook nodig zullen hebben voor toekomstige schermen, dus we moeten het op een gedeelde plek opslaan. Zoals eerder vermeld, erven alle CakePHP-controllers van een controller genaamd "AppController" die nu een leeg bestand is dat in de cake directory ...
We zullen een applicatiespecifieke AppController maken door een bestand met de naam "app_controller.php" in de app / map en vul de volgende inhoud in:
Sessie-> controle ('Auteur')) $ this-> flash ('U moet ingelogd zijn om dat te doen.', '/ Authors / login'); Uitgang; ?> We controleren eenvoudigweg de sessie en als deze er niet is, sturen we de gebruiker naar het inlogscherm. Deze functie kan nu worden gebruikt in elke controlemechanismemethode.
Onze laatste stap is om de functie te bellen vanuit onze beheerfunctie. We openen onze app / controller / authors_controller.php bestand en vind:
function manage () $ this-> set ('error', false); en voeg toe
$ This-> isLoggedIn ();
precies daaronder.
De acties kunnen worden getest en geopend met de volgende URL's:
De gebruikersnaam voor het account is test en het wachtwoord is een test.
Dit artikel was bedoeld om enkele belangrijke CakePHP-functies te introduceren met voorbeelden in de context van het bouwen van een persoonlijke blogtoepassing. We zijn begonnen met een aantal gebruikers / auteurspagina-functionaliteit om de basisconcepten van applicatie-ontwikkeling met CakePHP te introduceren voordat we (in de volgende tutorial) overgaan op het schrijven van de post-controller. Op die manier zullen we een beter begrip hebben van hoe alles in het raamwerk bij elkaar past. We hebben nog een lange weg te gaan voordat onze blogtoepassing compleet is, dus maak je klaar om diep in CakePHP te duiken, zodat we alle posts en opmerkingen van de blog de volgende keer kunnen gebruiken!
