Share
Als u een CMS aan het maken bent, heeft u waarschijnlijk andere gebruikersrollen nodig - superusers, beheerders, gebruikers - met verschillende bevoegdheidsniveaus. Te ingewikkeld om te coderen? Voer Cake ACP's ACL (Access Control Lists) in. Met de juiste instelling controleert u de gebruikersrechten op slechts één regel.
Met de ACL kunt u een hiërarchie van gebruikers maken met hun respectieve rollen. Hier is een snel voorbeeld.
In deze zelfstudie zullen we een ACL instellen voor een eenvoudige blog. Als je nog niet hebt gecontroleerd hoe je aan de slag kunt gaan met CakePHP (en deel 2) hier op Nettuts +, doe dat dan en keer terug, omdat we de basisbeginselen van het framework als vanzelfsprekend beschouwen..
Met deze hiërarchie kunnen we verschillende rechten toewijzen voor elke rol:
Elke toestemming wordt aan de groep gegeven, niet aan de gebruiker; dus als gebruiker # 6 wordt gepromoveerd tot Admin, wordt hij gecontroleerd tegen de groepstoestemming - niet die van hem. Deze rollen en onderliggende knooppunten (gebruikers) worden toegangsverzoekenobjecten of ARO's genoemd.
Aan de andere kant hebben we de Access Control Objects of ACO's. Dit zijn de objecten die moeten worden gecontroleerd. Hierboven noemde ik Berichten en Gebruikers. Normaal gesproken zijn deze objecten direct gekoppeld aan de modellen, dus als we een Post-model hebben, hebben we een ACO nodig voor dit model.
Elke ACO heeft vier basisrechten: maken, lezen, bijwerken en verwijderen. U kunt ze onthouden met het trefwoord CRUD. Er is een vijfde toestemming, de asterisk, dat is een snelkoppeling voor volledige toegang.
We zullen slechts twee ACO's gebruiken voor deze zelfstudie: Post en Gebruiker, maar je kunt er zoveel maken als je nodig hebt.
Laten we doorgaan met het maken van de databasetabellen. U kunt deze code vinden in db_acl.sql in je app's config / sql directory.
CREATE TABLE acos (id INTEGER (10) UNSIGNED NOT NULL AUTO_INCREMENT, parent_id INTEGER (10) DEFAULT NULL, model VARCHAR (255) DEFAULT ", foreign_key INTEGER (10) UNSIGNED DEFAULT NULL, alias VARCHAR (255) DEFAULT", lft INTEGER ( 10) DEFAULT NULL, rght INTEGER (10) DEFAULT NULL, PRIMARY KEY (id)); CREATE TABLE aros_acos (id INTEGER (10) UNSIGNED NOT NULL AUTO_INCREMENT, aro_id INTEGER (10) UNSIGNED NOT NULL, aco_id INTEGER (10) UNSIGNED NOT NULL, _create CHAR (2) NOT NULL DEFAULT 0, _read CHAR (2) NOT NULL DEFAULT 0, _update CHAR (2) NOT NULL DEFAULT 0, _delete CHAR (2) NOT NULL DEFAULT 0, PRIMARY KEY (id)); MAAK TABLE-aros (id INTEGER (10) UNSIGNED NOT NULL AUTO_INCREMENT, parent_id INTEGER (10) DEFAULT NULL, model VARCHAR (255) DEFAULT ", foreign_key INTEGER (10) UNSIGNED DEFAULT NULL, alias VARCHAR (255) DEFAULT", lft INTEGER ( 10) DEFAULT NULL, rght INTEGER (10) DEFAULT NULL, PRIMARY KEY (id));
We kunnen nu beginnen met het maken van ARO- en ACO-knooppunten, maar ach, we hebben geen gebruikers! We zullen een basis authenticatiesysteem moeten maken.
Omdat deze tutorial bedoeld is voor CakePHP-ontwikkelaars met een basis tot matige kennis van het framework, zal ik de code en een korte uitleg leveren. Het authenticatiesysteem is echter niet het doel van deze zelfstudie.
De MySQL-tabel:
MAAK TABLE-gebruikers (ID INTEGER (10) ONGESCHREVEN AUTO_INCREMENTTOETS, gebruikersnaam TEXT, wachtwoord TEXT);
Het gebruikersmodel (modellen / user.php)
De gebruikerscontroller (controllers / users_controller.php)
Accentsconagua
Auth-> userModel = 'Gebruiker'; $ This-> autoritei-> toestaan ( '*'); function register () if (! empty ($ this-> data)) // Hier moet u de gebruikersnaam valideren (min lengte, max lengte, geen speciale tekens opnemen, niet reeds bestaan, enz.) // Evenals als het wachtwoord als ($ this-> User-> validates ()) $ this-> User-> save ($ this-> data); // Laten we de gegevens lezen die we zojuist hebben ingevoegd $ data = $ this-> User-> read (); // Gebruik het om de gebruiker $ this-> Auth-> login ($ data) te authenticeren; // Stuur $ this-> redirect ('/') om; functie login () if (! empty ($ this-> data)) // Als de gebruikersnaam / het wachtwoord overeenkomt met ($ this-> Auth-> login ($ this-> data)) $ this -> redirect ( '/'); else $ this-> User-> invalidate ('gebruikersnaam', 'Gebruikersnaam en wachtwoord combinatie klopt niet!'); functie logout () $ this-> Auth-> logout (); $ This-> redirect ( '/'); ?> Omdat we nieuwe elementen hebben, laten we ze opnieuw bekijken. Eerst stellen we een $ componenten variabel. Deze variabele bevat alle componenten in de array. We zullen de. Nodig hebben Auth component, wat een kerncomponent is, net als HTML- en Form-helpers, maar omdat het niet standaard door Cake wordt opgenomen, moeten we het handmatig opnemen.
De Auth-component verwerkt enkele basisverificatiemethoden: het helpt ons om een gebruiker aan te melden en het behandelt de sessie van een geverifieerde gebruiker voor ons, evenals de afhandeling en basisautorisatie voor gasten. Ook hashes het wachtwoord automatisch. In de volgende paragrafen zal ik uitleggen hoe ik elke functie moet aanroepen.
Vervolgens creëren we een functie genaamd beforeFilter. Dit is een callback-functie en het laat ons een aantal acties instellen voordat alle logica van de controller is verwerkt. De Auth-component vereist dat we een model specificeren dat moet worden gebruikt, in dit geval de gebruiker. Vervolgens wordt standaard alle toegang geweigerd aan gebruikers die niet zijn aangemeld. We moeten dit gedrag overschrijven met toestaan() waarvoor een parameter nodig is. Die parameter kan een sterretje zijn en geeft aan dat alle methoden in die controller toegankelijk zijn voor niet-geverifieerde gebruikers. Of u kunt een array doorgeven met de functies waartoe onbevoegde gebruikers toegang hebben. In dit geval, aangezien we slechts drie functies hebben, zijn de volgende regels hetzelfde.
$ This-> autoritei-> toestaan ( '*'); $ this-> Auth-> allow (array ('registreer', 'login', 'logout')); Voor de Log in() functie, zal de Auth-component alle login-mechanismen voor ons afhandelen. We zullen de functie gewoon moeten voorzien van een array met twee sleutels: de gebruikersnaam en het wachtwoord. Deze toetsen kunnen worden gewijzigd, maar standaard allebei gebruikersnaam en wachtwoord velden worden vergeleken met de database en zullen true retourneren als de gebruiker is geverifieerd.
Ten slotte zal de inlogfunctie van de controller proberen een combinatie van gebruikersnaam en wachtwoord aan te passen aan de database.
Houd er rekening mee dat deze code erg eenvoudig is. U moet de gebruikersnaamtekens valideren, als de gebruikersnaam bestaat, de minimale lengte van het wachtwoord, enzovoort.
De weergave Registreren (views / users / register.ctp)
Registreer je account
De login-weergave (views / users / login.ctp)
Log in op jouw account
Open / Users / register in uw webbrowser en registreer een nieuw account. ik stel voor beheerder als gebruikersnaam en 123 als wachtwoord en als uw sessie verloopt, gaat u gewoon naar / Users / login en voer de juiste combinatie gebruikersnaam / wachtwoord in die u zojuist hebt gemaakt.
We werken niet eens met ACL, maar we kunnen al weigeren berichten te plaatsen, bewerken en verwijderen. Open je Posts-controller en voeg het Auth-onderdeel toe.
var $ components = array ('Auth'); Ga nu naar / berichten in uw webbrowser. Als u bent ingelogd, zou u de berichten moeten zien, maar als u dat niet bent, wordt u doorgestuurd naar / Users / login. Door simpelweg het Auth-onderdeel op te nemen, worden alle acties standaard geweigerd voor gasten. We moeten drie acties voor ongeautoriseerde gebruikers weigeren: maken, bewerken en verwijderen. Met andere woorden, we moeten index en weergave toestaan.
function beforeFilter () $ this-> Auth-> userModel = 'Gebruiker'; $ this-> Auth-> allow (array ('index', 'view')); Ga naar bewerken of een bericht maken; als u niet bent aangemeld, moet u worden omgeleid naar / Users / login. Alles lijkt redelijk goed te werken, maar hoe zit het met de opvattingen? De koppelingen voor bewerken en verwijderen worden aan iedereen getoond. We zouden een voorwaardelijke moeten maken.
Maar laten we eerst eens kijken hoe de functie user () van Auth werkt. Kopieer en plak deze regels in de indexfunctie.
$ user = $ this-> Auth-> user (); pr ($ user);
Open je / berichten in uw browser en, indien ingelogd, de pr () zal zoiets gooien.
Array ([User] => Array ([id] => 1 [gebruikersnaam] => admin))
De gebruiker() functie retourneert een array, net zoals een model zou doen. Als we meer dan drie velden hadden (wachtwoord is niet inbegrepen), worden deze in de array weergegeven. Als u niet bent aangemeld, is de array leeg, zodat u weet of een gebruiker is aangemeld als deze is geverifieerd gebruiker() array is niet leeg.
Nu is Auth een component, bedoeld om te worden gebruikt in een controller. We moeten in een weergave weten of een gebruiker is ingelogd, bij voorkeur via een helper. Hoe kunnen we een component in een helper gebruiken? CakePHP is zo geweldig en flexibel dat het mogelijk is.
Sessie = $ dit-> sessie; $ user = $ auth-> user (); return! empty ($ user); ?>
Sla dit fragment op views / helpers zoals access.php. Laten we nu de code regel voor regel bekijken. Eerst stellen we een $ helpers var. Helpers kunnen andere helpers omvatten, net als $ componenten kan. De Session-component is vereist voor de Auth-component, maar we hebben geen toegang tot deze component binnen een helper. Gelukkig hebben we een sessiehulp, die ons zal helpen.
Vervolgens maken we een functie en gebruiken App :: import waarmee we een element kunnen importeren waar we normaliter geen toegang toe zouden hebben. De volgende regel maakt de Auth-component in a $ auth variabele, en nu een beetje vuile hack; aangezien de Auth-component de sessie leest om te weten of we zijn aangemeld of niet, is hiervoor de Session-component vereist, maar omdat we deze importeren vanaf een locatie waartoe deze niet behoort, moeten we deze een nieuw Session-object geven. Eindelijk, we gebruiken gebruiker() en instellen op $ user en true retourneren als de variabele niet leeg is, anders false.
Laten we teruggaan naar de berichtencontroller en doorgaan met het toevoegen van de helper.
var $ helpers = array ('Toegang'); De toegangshulpmiddel is nu toegankelijk vanuit het beeld. Open index.ctp in views / berichten en vervang deze lijn.
"> bewerken | link ('delete', '/posts/delete/'.$post['Post']['id'], NULL, 'Weet je het zeker?'); ?> Met deze.
isLoggedin ()):?>"> bewerken | link ('delete', '/posts/delete/'.$post['Post']['id'], NULL, 'Weet je het zeker?'); ?> Ga terug naar uw webbrowser, herlaad de indexpagina en als u bent ingelogd, ziet u de koppelingen voor bewerken en verwijderen voor elk bericht. Anders zie je niets.
Hoewel dit voldoende zou zijn als u een app heeft met één of twee gebruikers, is het niet voldoende als u registraties open hebt staan.
Open de gebruikerscontroller en voeg de ACL-component toe.
var $ components = array ('Auth', 'Acl'); Laten we vervolgens een functie maken om de ACO's en ARO's-knooppunten te installeren.
function install () if ($ this-> Acl-> Aro-> findByAlias ("Admin")) $ this-> redirect ('/'); $ aro = new aro (); $ ArO-> create (); $ aro-> save (array ('model' => 'Gebruiker', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Super')); $ ArO-> create (); $ aro-> save (array ('model' => 'Gebruiker', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Admin')); $ ArO-> create (); $ aro-> save (array ('model' => 'Gebruiker', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Gebruiker')); $ ArO-> create (); $ aro-> save (array ('model' => 'Gebruiker', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Opgeschort')); $ aco = nieuwe Aco (); $ ACO> create (); $ aco-> save (array ('model' => 'Gebruiker', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Gebruiker')); $ ACO> create (); $ aco-> save (array ('model' => 'Post', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Post')); $ this-> Acl-> allow ('Super', 'Post', '*'); $ this-> Acl-> allow ('Super', 'Gebruiker', '*'); $ this-> Acl-> allow ('Admin', 'Post', '*'); $ this-> Acl-> allow ('Gebruiker', 'Post', array ('create')); Door het ACL-onderdeel te importeren, hebben we toegang tot het model van ACO's en ARO's. We beginnen met het creëren van een ARO, die de aanvrager is voor de objecten; met andere woorden, wie krijgt toegang tot de objecten. Dat zou de gebruiker zijn (vandaar de User-string in model). We creëren verschillende rollen; Super, Admin, Gebruiker en Opgeschort.
Vervolgens doen we hetzelfde met ACO's, omdat we slechts twee objecten beheren (Posts en Users), we zullen er twee maken, één voor elke.
Nu een kort berichtje. De array die we opslaan voor zowel ACO's als ARO's hebben vier velden: de modelnaam, foreign key (wat handig is als u toegang wilt geven tot één ARO, zoals een bericht dat hij heeft gemaakt), parent id (die later zal worden gebruikt) en is de basale relatie tussen bovenliggende en onderliggende knooppunten, we maken gebruikers onder deze rollen) en de alias (een snelle vorm om de objecten te vinden).
Ten slotte gebruiken we ACL's toestaan() functie. De eerste parameter is de ACO-alias; ten tweede, de ARO-alias en ten derde de rechten die aan de ARO zijn verleend. Een supergebruiker heeft volledige toegang tot de bericht- en gebruikersmodellen, een beheerder heeft volledige toegang tot het berichtmodel en een gebruiker kan alleen berichten maken.
Aan het begin van de functie heb ik een voorwaardelijke verklaring afgelegd om te controleren of de beheerdersrol bestaat in ACO's. Je wilt niet meer dan één keer hetzelfde installeren, toch? Het zou de database behoorlijk kapot maken.
Open / Gebruikers / install in uw webbrowser, en omdat we geen weergave hebben, zal CakePHP een foutmelding geven, maar kijk gewoon naar de MySQL-dump. Alle relaties zijn succesvol gemaakt, het is tijd om met de onderliggende knooppunten te werken.
Laten we het schoonmaken gebruikers tafel. Open phpMyAdmin, selecteer uw database, de gebruikers tafel en klik leeg. We komen terug bij de registreren() functie op de gebruikerscontroller. Vlak onder deze regel:
$ This-> autoritei-> login ($ data);
Plak deze code:
// Stel de gebruikersrollen $ aro = new Aro () in; $ parent = $ aro-> findByAlias ($ this-> User-> find ('count')> 1? 'Gebruiker': 'Super'); $ ArO-> create (); $ aro-> save (array ('model' => 'Gebruiker', 'foreign_key' => $ this-> User-> id, 'parent_id' => $ parent ['Aro'] ['id'], ' alias '=>' Gebruiker :: '. $ this-> Gebruiker-> id)); In de eerste regel maken we een nieuw ARO-object. Vervolgens krijgen we het bovenliggende knooppunt waarin de gebruiker wordt gemaakt. Als er een record in de database staat, stellen we deze in op de ARO van de gebruiker, anders moet de eerste gebruiker de Super zijn.
Dan zullen we een nieuwe ARO opslaan; het model is degene waar we momenteel aan werken, Gebruiker, de vreemde sleutel is de id van het laatste record dat we zojuist hebben gemaakt. De ouder ID is de knoop waarmee we zijn begonnen; we geven het gewoon het ID en uiteindelijk het alias. Het is een goed idee om het te noemen Modelnaam, dan een scheidingsteken ::, en dan de identifier. Het zal veel gemakkelijker zijn om het te vinden.
Nu zijn we klaar. Maak vier gebruikers aan: superuser, adminuser, normaluser en suspendeduser. Ik suggereer dezelfde gebruikersnaam en hetzelfde wachtwoord voor testdoeleinden. Vergeet niet dat tot nu toe alleen de superuser de rol Super heeft; alle overige zijn Gebruikers!
Omdat ACL een component is, is deze alleen toegankelijk binnen de controller. Later zal het ook in de weergave zijn; maar eerst de dingen eerst. Neem de ACL-component op in de Posts-controller, zoals we deden in de Users-controller. Nu kunt u beginnen met het controleren van machtigingen. Laten we naar de bewerkingsfunctie gaan en een snelle test doen. Voeg in de eerste regel van de methode dit toe.
$ user = $ this-> Auth-> user (); if (! $ this-> Acl-> check ('User ::'. $ user ['User'] ['id'], 'Post', 'update')) die ('you are not authorized'); ACL's controleren() functie heeft drie parameters nodig: de ARO, de ACO en de actie. Ga een bericht bewerken en als je niet bent ingelogd als de supergebruiker, sterft het script. Ga naar / Users / login en toegang als de Super-gebruiker en ga terug naar bewerken. Je zou in staat moeten zijn om het bericht te bewerken. Kijk onder de MySQL-dump om de magie te zien. Vier databasequery's: dat is zeker niet schaalbaar.
We hebben twee problemen. Eerste, twee lijnen voor de machtigingscontrole. Ten tweede worden de ACL's niet in cache opgeslagen. En vergeet niet dat alle ingelogde gebruikers de bewerkingslink kunnen zien, zelfs als alleen de Super-gebruiker het kan gebruiken.
Laten we een nieuw onderdeel maken. Laten we het Access noemen.
user = $ this-> Auth-> user (); ?>
Sla het op controllers / components zoals access.php. De klas $ user var wordt gestart wanneer het onderdeel wordt geladen, en opstarten() is een callback-functie, dus deze is nu in de klas ingesteld. Laten we nu onze maken controleren() functie.
functiecontrole ($ aco, $ action = '*') if (! empty ($ this-> user) && $ this-> Acl-> check ('User ::'. $ this-> user ['Gebruiker' ] ['id'], $ aco, $ actie)) return true; else return false; Onze controleren() methode heeft slechts twee parameters nodig: de ACO en de actie (die optioneel is). De ARO is de huidige gebruiker voor elke sessie. De actieparameter wordt standaard ingesteld op *, welke volledige toegang heeft voor de ARO. De functie begint met het controleren of de $ This-> gebruiker is niet leeg (wat ons echt vertelt of een gebruiker is ingelogd) en dan gaan we naar ACL. We hebben dit al besproken.
We kunnen nu de Access-component opnemen in onze Posts-controller en de rechten controleren met slechts één regel.
if (! $ this-> Access-> check ('Post', 'update')) die ('u bent niet geautoriseerd'); Hetzelfde resultaat wordt bereikt met minder code, maar de foutmelding is lelijk. Je kunt beter de dood gaan() met de CakePHP-foutafhandelingsprogramma:
$ This-> cakeError ( 'error404');
Dit is misschien lelijk, maar het werkt. We moeten een helper maken die een component laadt met een aangepaste methode voor gebruik in de helper.
Voeg deze functie toe in het Access-onderdeel (controllers / components / access.php).
functie checkHelper ($ aro, $ aco, $ action = "*") App :: import ('Component', 'Acl'); $ acl = nieuwe AclComponent (); return $ acl-> check ($ aro, $ aco, $ action); Laten we nu de toegangshelper herschrijven (views / helpers / access.php).
Access = nieuw AccessComponent (); App :: import ('Component', 'Auth'); $ this-> Auth = new AuthComponent (); $ this-> Auth-> Session = $ this-> Session; $ this-> user = $ this-> Auth-> user (); functiecontrole ($ aco, $ action = '*') if (empty ($ this-> user)) return false; return $ this-> Access-> checkHelper ('User ::'. $ this-> user ['User'] ['id'], $ aco, $ action); function isLoggedin () return! empty ($ this-> user); ?> De beforeRender () methode is een callback, vergelijkbaar met de componenten opstarten(). We laden twee componenten en omdat deze in de meeste functies worden gebruikt, is het een goed idee om alles tegelijk te starten, dan om ze handmatig te starten telkens wanneer de methode wordt aangeroepen.
Nu op uw index.ctp bekijken in views / berichten je kunt deze lijn vervangen.
"> bewerken | link ('delete', '/posts/delete/'.$post['Post']['id'], NULL, 'Weet je het zeker?'); ?> Met deze.
check ('Post')):?>"> bewerken | link ('delete', '/posts/delete/'.$post['Post']['id'], NULL, 'Weet je het zeker?'); ?> Vergeet niet om de machtigingen te controleren, zowel in de views als in de controllers!
U hebt toegang tot de gebruikersgegevens voor een geregistreerde gebruiker met de gebruiker() methode in de Auth-component. Vervolgens hebt u toegang tot de array en krijgt u de gewenste info. Maar er moet een betere manier zijn. Laten we de volgende functie toevoegen in het Access-onderdeel.
functie getmy ($ what) return! empty ($ this-> user) && isset ($ this-> user ['User'] [$ what])? $ this-> user ['User'] [$ what]: false;
Dit is erg handig als je een bericht wilt opslaan met een gebruikersnaam verhouding.
$ this-> data ['Post'] ['user_id'] = $ this-> Access-> getmy ('id'); En volgens ons kunnen we iets soortgelijks met de helper doen.
functie getmy ($ what) return! empty ($ this-> user) && isset ($ this-> user ['User'] [$ what])? $ this-> user ['User'] [$ what]: false;
In uw sjabloonbestand kunt u iets als hieronder doen om een gebruiker te begroeten op basis van zijn gebruikersnaam.
Welkom isLoggedIn ()? $ access-> getmy ('gebruikersnaam'): 'Gast'; ?> Laten we zeggen dat we rollen moeten wisselen voor gebruiker # 4: hij moet een supergebruiker zijn. Gebruikers-ID is dus 4 en Aro's id is 1.
$ user_id = 4; $ user_new_group = 1;
Nu moeten we de User's Aro vinden om zijn ouder-Aro te wijzigen.
$ aro_user = $ this-> Acl-> Aro-> find ('first', array ('conditions' => array ('Aro.parent_id! =' => NULL, 'Aro.model' => 'Gebruiker', 'Aro.foreign_key' => $ user_id))); Eindelijk, als het $ aro_user variabele is niet leeg, laten we de Aro.parent_id veld-.
if (! empty ($ aro_user)) $ data ['id'] = $ aro_user ['Aro'] ['id']; $ data ['parent_id'] = $ user_new_group; $ This-> ACL> ArO-> save ($ data);
Houd er rekening mee dat u zowel de id van de gebruiker als de id van de nieuwe aro moet valideren. Als een van deze niet bestaat, maakt dit een puinhoop in uw ACL-tabellen.
Hoewel de zojuist gecreëerde component zowel eenvoudig als nuttig is, wordt de database bij elke controle opgevraagd. Het is nog niet klaar voor productie. Allereerst moet de database zo min mogelijk worden bevraagd. Om dit te optimaliseren, zouden we gebruik moeten maken van de Cache van CakePHP.
Het gebruik van Cache verlaagt de belasting behoorlijk, maar als er tien berichten verschijnen in de index en we controleren voor elke gebruiker of de gebruiker updatemachtigingen heeft voor de Post Aco, dan leest en ontleedt het raamwerk een bestand om hetzelfde resultaat terug te keren ... tien keer voor elke pagina wordt geladen.
Dat is het tweede punt: een variabele in de klas en een aantal conditionals maken het werk lichter, zodat een herhaald verzoek slechts één keer tegen Cache zal controleren.
Beide veranderingen komen terug in access_cache.php, binnen in de controllers / components directory. Dus zorg ervoor dat je de bron downloadt!
Toegangscontrolelijsten zijn basisfuncties die de meeste apps nodig hebben. CakePHP heeft een mooie implementatie, maar mist zowel goede documentatie als voorbeelden. Ik hoop dat met deze tutorial deze twee kwesties nu worden behandeld. Bedankt voor het lezen!
