Share
Si vous construisez un CMS, vous aurez probablement besoin de différents rôles d'utilisateur (superutilisateurs, administrateurs, utilisateurs) avec différents niveaux d'autorisation. Trop compliqué à coder? Entrez ACL (listes de contrôle d'accès) de CakePHP. Avec la bonne configuration, vous pourrez vérifier les autorisations des utilisateurs avec une seule ligne.
La liste de contrôle d'accès vous permet de créer une hiérarchie d'utilisateurs avec leurs rôles respectifs. Voici un exemple rapide.
Dans ce didacticiel, nous allons configurer une liste de contrôle d'accès pour un blog simple. Si vous n'avez pas encore vérifié Premiers pas avec CakePHP (et la partie 2) ici sur Nettuts +, veuillez le faire puis revenir, car nous allons tenir pour acquis les bases du framework..
Avec cette hiérarchie, nous pouvons attribuer plusieurs autorisations pour chaque rôle:
Chaque permission sera donnée au groupe, pas à l'utilisateur. ainsi, si l'utilisateur n ° 6 est promu en tant qu'administrateur, il sera comparé à l'autorisation de groupe - pas la sienne. Ces rôles et nœuds enfants (utilisateurs) sont appelés objets de demandes d'accès ou ARO..
De l'autre côté, nous avons les objets de contrôle d'accès, ou ACO. Ce sont les objets à contrôler. Ci-dessus, j'ai mentionné les publications et les utilisateurs. Normalement, ces objets sont directement liés aux modèles, donc si nous avons un modèle Post, nous aurons besoin d'un ACO pour ce modèle..
Chaque ACO dispose de quatre autorisations de base: créer, lire, mettre à jour et supprimer. Vous pouvez vous en souvenir avec le mot clé CRUD. Il y a une cinquième permission, l'astérisque, qui est un raccourci pour un accès complet.
Nous n'utiliserons que deux ACO pour ce tutoriel: Post et User, mais vous pouvez en créer autant que vous le souhaitez..
Continuons pour créer les tables de la base de données. Vous pouvez trouver ce code dans db_acl.sql dans votre application config / sql annuaire.
CREATE TABLE acos (id INTEGER (10) UNSIGNED NOT NULL AUTO_INCREMENT, parent_id INTEGER (10) DEFAULT NULL, modèle VARCHAR (255) DEFAULT ", foreign_key INTEGER (10) UNSIGNED DEFAULT NULL, alias VARCHAR (255) DEFAULT", lft INTEGER (, lft INTEGER (1), 10) NULL PAR DÉFAUT, droit INTEGER (10) NULL PAR DÉFAUT, 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, _Lead CHAR (2) NON NULL DEFAUT 0, _lead NULL DEFAULT 0, _update CHAR (2) NON NUL PAR DEFAUT 0, _delete CHAR (2) NON NULL PAR DEFAUT 0, PRIMARY KEY (id)); CREATE TABLE aros (id INTEGER (10) UNSIGNED NOT NULL AUTO_INCREMENT, parent_id INTEGER (10) DEFAULT NULL, modèle VARCHAR (255) DEFAULT ", foreign_key INTEGER (10) UNSIGNED DEFAULT NULL, alias VARCHAR (255) DEFAUT", lft INTEGER (, lft INTEGER (1), 10) NULL PAR DÉFAUT, droit INTEGER (10) NULL PAR DÉFAUT, PRIMARY KEY (id));
Nous pouvons commencer maintenant à créer des nœuds ARO et ACO, mais bon, nous n’avons pas d’utilisateurs! Nous devrons créer un système d'authentification de base.
Comme ce tutoriel est destiné aux développeurs CakePHP avec une connaissance de base à modérée du framework, je fournirai le code et une brève explication. Cependant, le système d'authentification n'est pas l'objectif de ce tutoriel.
La table MySQL:
CREATE TABLE utilisateurs (id INTEGER (10) UNSIGNED AUTO_INCREMENT KEY, nom d'utilisateur TEXT, mot de passe TEXT);
Le modèle utilisateur (models / user.php)
Le contrôleur d'utilisateurs (controllers / users_controller.php)
Accentsconagua
Auth-> userModel = 'User'; $ this-> Auth-> allow ('*'); function register () if (! empty ($ this-> data)) // Ici, vous devez valider le nom d'utilisateur (longueur minimale, longueur maximale, pour ne pas inclure les caractères spéciaux, qui n'existent pas déjà, etc.) // Aussi comme mot de passe si ($ this-> utilisateur-> validates ()) $ this-> utilisateur-> save ($ this-> data); // Lisons les données que nous venons d'insérer $ data = $ this-> User-> read (); // Utilisez-le pour authentifier l'utilisateur $ this-> Auth-> login ($ data); // Puis redirection $ this-> redirect ('/'); function login () if (! empty ($ this-> data)) // Si le nom d'utilisateur / mot de passe correspond si ($ this-> Auth-> login ($ this-> data)) $ this -> redirect ('/'); else $ this-> Utilisateur-> invalidate ('nom d'utilisateur', 'La combinaison nom d'utilisateur / mot de passe est incorrecte!'); function logout () $ this-> Auth-> logout (); $ this-> redirect ('/'); ?> Puisque nous avons de nouveaux éléments, examinons-les. Premièrement, nous établissons un composants $ variable. Cette variable inclut tous les composants du tableau. Nous aurons besoin de Auth composant, qui est un composant principal, de même que les aides HTML et les aides de formulaire, mais comme il n'est pas inclus par défaut par Cake, nous devrons l'inclure manuellement..
Le composant Auth gère quelques mécanismes d'authentification de base: il nous aide à connecter un utilisateur et gère la session d'un utilisateur authentifié pour nous, ainsi que la déconnexion et l'autorisation de base des invités. De plus, le mot de passe est haché automatiquement. Je vais expliquer comment appeler chaque fonction dans les paragraphes suivants.
Ensuite, nous créons une fonction appelée avantFilter. C'est une fonction de rappel qui nous permet de définir certaines actions avant que toute la logique du contrôleur ne soit traitée. Le composant Auth nécessite que nous spécifiions un modèle à utiliser, dans ce cas l'utilisateur. Ensuite, par défaut, tous les accès aux utilisateurs non connectés seront refusés. Nous devrons remplacer ce comportement par permettre() qui nécessite un paramètre. Ce paramètre peut être un astérisque, spécifiant que toutes les méthodes de ce contrôleur sont accessibles aux utilisateurs non authentifiés. Vous pouvez également transmettre un tableau contenant les fonctions accessibles aux utilisateurs non authentifiés. Dans ce cas, comme nous n’avons que trois fonctions, les lignes suivantes sont identiques..
$ this-> Auth-> allow ('*'); $ this-> Auth-> allow (array ('register', 'login', 'login', 'logout')); Pour le s'identifier() fonction, le composant Auth gérera tous les mécanismes de connexion pour nous. Nous devrons simplement fournir à la fonction un tableau avec deux clés: le nom d'utilisateur et le mot de passe. Ces clés peuvent être modifiées, mais par défaut, les deux Nom d'utilisateur et mot de passe les champs seront mis en correspondance avec la base de données et renverront true si l'utilisateur a été authentifié.
Enfin, la fonction de connexion du contrôleur essaiera de faire correspondre une combinaison nom d'utilisateur / mot de passe à la base de données..
Veuillez noter que ce code est très basique. Vous devrez valider les caractères du nom d'utilisateur, s'il existe, la longueur minimale du mot de passe, etc..
La vue du registre (views / users / register.ctp)
Enregistrer votre compte
La vue de connexion (vues / utilisateurs / login.ctp)
Connectez-vous à votre compte
Ouvrir / utilisateurs / s'inscrire dans votre navigateur Web et enregistrez un nouveau compte. je suggère admin comme identifiant et 123 comme mot de passe et si votre session expire, il suffit d'aller à / utilisateurs / login et entrez la combinaison nom d'utilisateur / mot de passe que vous venez de créer.
Nous ne travaillons même pas avec ACL, mais nous pouvons déjà refuser la publication, la modification et la suppression de publications. Ouvrez votre contrôleur Posts et ajoutez le composant Auth.
var $ components = array ('Auth'); Maintenant, allez à /des postes dans votre navigateur web. Si vous êtes connecté, vous devriez voir les messages, mais si vous ne l'êtes pas, vous serez redirigé vers / utilisateurs / login. En incluant simplement le composant Auth, toutes les actions sont par défaut refusées aux invités. Nous devons refuser trois actions aux utilisateurs non autorisés: créer, éditer et supprimer. En d'autres termes, nous devrons permettre l'index et la vue.
function beforeFilter () $ this-> Auth-> userModel = 'User'; $ this-> Auth-> allow (array ('index', 'view')); Aller à éditer ou créer un post; si vous n'êtes pas connecté, vous devriez être redirigé vers / utilisateurs / login. Tout semble fonctionner assez bien, mais qu'en est-il des points de vue? Les liens modifier et supprimer sont affichés à tout le monde. Nous devrions faire un conditionnel.
Mais avant d'entrer dans cela, voyons comment fonctionne la fonction user () d'Auth. Copier et coller ces lignes dans la fonction index.
$ user = $ this-> Auth-> user (); pr ($ utilisateur);
Ouvrez votre /des postes dans votre navigateur et, si vous êtes connecté, le pr () va jeter quelque chose comme ça.
Tableau ([Utilisateur] => Tableau ([id] => 1 [nom d'utilisateur] => admin))
le utilisateur() la fonction retourne un tableau comme le ferait un modèle. Si nous avions plus de trois champs (mot de passe n'est pas inclus), ils seront affichés dans le tableau. Si vous n'êtes pas connecté, le tableau sera vide. Vous pourrez ainsi savoir qu'un utilisateur est connecté si Auth utilisateur() tableau n'est pas vide.
Maintenant, Auth est un composant, destiné à être utilisé dans un contrôleur. Nous avons besoin de savoir à partir d'une vue si un utilisateur est connecté, de préférence via un assistant. Comment pouvons-nous utiliser un composant dans un assistant? CakePHP est tellement génial et flexible qu'il est possible.
Session = $ this-> Session; $ user = $ auth-> user (); return! empty ($ user); ?>
Enregistrer cet extrait dans vues / aides comme access.php. Voyons maintenant le code, ligne par ligne. Premièrement, nous mettons en place un $ aides var. Les assistants peuvent inclure d’autres assistants, comme composants $ pouvez. Le composant Session est requis pour le composant Auth, mais nous n'avons pas accès à ce composant dans un assistant. Heureusement, nous avons un assistant de session qui nous aidera.
Ensuite, nous créons une fonction et utilisons App :: import ce qui nous permettra d'importer un élément auquel nous n'aurions normalement pas accès. La ligne suivante crée le composant Auth dans une $ auth variable, et maintenant un peu de bidouille sale; puisque le composant Auth lit la session pour savoir si nous sommes connectés ou non, il nécessite le composant Session, mais comme nous l'importons depuis un emplacement auquel il ne devrait pas appartenir, nous devons lui donner un nouvel objet Session. Enfin, nous utilisons utilisateur() et le mettre à $ utilisateur et retournant true si la variable n'est pas vide, sinon false.
Revenons au contrôleur des publications et ajoutons l’assistant..
var $ helpers = array ('Access'); L'assistant d'accès est maintenant accessible depuis la vue. Ouvrir index.ctp dans vues / messages et remplacer cette ligne.
"> modifier | link ('delete', '/posts/delete/'.$post['Post'][''id'], NULL, 'Êtes-vous sûr?'); ?> Avec celui-ci.
isLoggedin ()):?>"> modifier | link ('delete', '/posts/delete/'.$post['Post'][''id'], NULL, 'Êtes-vous sûr?'); ?> Retournez dans votre navigateur Web, rechargez la page d'index et si vous êtes connecté, vous verrez les liens modifier et supprimer pour chaque message. Sinon, vous ne verrez rien.
Bien que cela soit suffisant si vous avez une application avec un ou deux utilisateurs, cela ne suffit pas si vous avez des inscriptions ouvertes..
Ouvrez le contrôleur d'utilisateurs et ajoutez le composant ACL..
var $ components = array ('Auth', 'Acl'); Ensuite, créons une fonction pour installer les nœuds ACO et ARO.
function install () if ($ this-> Acl-> Aro-> findByAlias ("Admin")) $ this-> redirect ('/'); $ aro = new aro (); $ aro-> create (); $ aro-> save (array ('model' => 'Utilisateur', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Super')); $ aro-> create (); $ aro-> save (array ('model' => 'User', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Admin')); $ aro-> create (); $ aro-> save (array ('model' => 'Utilisateur', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'utilisateur')); $ aro-> create (); $ aro-> save (array ('model' => 'Utilisateur', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Suspendu')); $ aco = new Aco (); $ aco-> create (); $ aco-> save (array ('model' => 'Utilisateur', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'utilisateur')); $ aco-> create (); $ aco-> save (array ('model' => 'Post', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Post')); $ this-> Acl-> allow ('Super', 'Post', '*'); $ this-> Acl-> allow ('Super', 'User', '*'); $ this-> Acl-> allow ('Admin', 'Post', '*'); $ this-> Acl-> allow ('User', 'Post', array ('create')); En important le composant ACL, nous pouvons accéder au modèle ACO et ARO. Nous commençons par créer un ARO, qui est le demandeur des objets; autrement dit, qui accédera aux objets. Ce serait l'utilisateur (d'où la chaîne User dans le modèle). Nous créons différents rôles. Super, Admin, Utilisateur et Suspendu.
Ensuite, nous faisons la même chose avec les ACO, puisque nous n’avons que deux objets à gérer (Posts et Utilisateurs), nous en créerons deux, un pour chacun..
Maintenant, un petit mot. Le tableau que nous sauvegardons pour les ACO et les ARO comporte quatre champs: le nom du modèle, la clé étrangère (utile si vous souhaitez donner accès à un seul ARO, comme un message créé par celui-ci), l'ID parent (qui sera utilisé ultérieurement et est la relation de base entre les nœuds parent et enfant; nous allons créer des utilisateurs sous ces rôles), ainsi que l'alias (qui est un formulaire rapide pour rechercher les objets)..
Enfin, nous utilisons les ACL permettre() une fonction. Le premier paramètre est l'alias ACO; deuxièmement, le pseudonyme ARO et, troisièmement, les autorisations accordées à ce dernier. Un superutilisateur a un accès complet aux modèles Post et User, un administrateur a un accès complet au modèle Post et un utilisateur peut simplement créer des publications..
Au début de la fonction, j'ai déclaré une condition pour vérifier si le rôle Admin existe dans les ACO. Vous ne voulez pas installer la même chose plus d'une fois, n'est-ce pas? La base de données serait mal gâchée.
Ouvrir / utilisateurs / install Dans votre navigateur Web, et, comme nous n’avons pas de vue, CakePHP affichera une erreur, mais vérifiez simplement le vidage MySQL. Toutes les relations ont été créées avec succès, il est temps de travailler avec les nœuds enfants.
Nettoyons le utilisateurs table. Ouvrez phpMyAdmin, sélectionnez votre base de données, le utilisateurs table et cliquez sur vide. Nous reviendrons à la registre() fonction sur le contrôleur d'utilisateurs. Juste en dessous de cette ligne:
$ this-> Auth-> login ($ data);
Collez ce code:
// Définir les rôles de l'utilisateur $ aro = new Aro (); $ parent = $ aro-> findByAlias ($ this-> User-> find ('count')> 1? 'User': 'Super'); $ aro-> create (); $ aro-> save (array ('model' => 'Utilisateur', 'foreign_key' => $ this-> Utilisateur-> id, 'parent_id' => $ parent ['Aro'] ['id'], ' alias '=>' User :: '. $ this-> User-> id)); Dans la première ligne, nous créons un nouvel objet ARO. Nous obtiendrons ensuite le nœud parent dans lequel l'utilisateur sera créé. S'il y a un enregistrement dans la base de données, nous allons le définir sur l'utilisateur ARO, sinon, le premier utilisateur devrait être le super.
Ensuite, nous enregistrerons un nouvel ARO. le modèle est celui sur lequel nous travaillons actuellement, Utilisateur, la clé étrangère est l'identifiant du dernier enregistrement que nous venons de créer. le parent_id est le noeud avec lequel nous avons commencé; nous allons simplement passer l'identifiant et enfin l'alias. C'est une bonne idée de l'appeler Nom du modèle, puis un séparateur ::, et ensuite l'identifiant. Il sera beaucoup plus facile de le trouver.
Maintenant nous avons fini. Créez quatre utilisateurs: superutilisateur, adminuser, utilisateur normal et utilisateur suspendu. Je suggère le même nom d'utilisateur et mot de passe à des fins de test. N'oubliez pas que jusqu'à présent, seul le superutilisateur a le rôle de Super. tout le reste sera des utilisateurs!
Comme ACL est un composant, il n’est accessible que dans le contrôleur. Plus tard, ce sera aussi dans la vue; mais les premières choses d'abord. Incluez le composant ACL dans le contrôleur Posts, comme nous l'avons fait dans le contrôleur Utilisateurs. Vous pouvez maintenant commencer à vérifier les autorisations. Passons à la fonction d'édition et faisons un test rapide. Dans la première ligne de cette méthode, ajoutez ceci.
$ user = $ this-> Auth-> user (); if (! $ this-> Acl-> check ('User ::'. $ user ['User'] ['id'], 'Post', 'update')) die ('Vous n'êtes pas autorisé'); ACL vérifier() fonction a besoin de trois paramètres: l'AR, l'ACO et l'action. Allez modifier un message et, si vous n'êtes pas connecté en tant que super utilisateur, le script mourra. Aller à / utilisateurs / login et accédez en tant que super utilisateur et revenez à l'édition. Vous devriez pouvoir éditer le message. Vérifiez ci-dessous le vidage MySQL pour voir la magie. Quatre requêtes de base de données: ce n'est certainement pas évolutif.
Nous avons deux problèmes. Premier, deux lignes pour la vérification des autorisations. Deuxièmement, les ACL ne sont pas mises en cache. Et n'oubliez pas que tous les utilisateurs connectés peuvent voir le lien d'édition, même si seul le super utilisateur peut l'utiliser.
Créons un nouveau composant. Appelons cela l'accès.
user = $ this-> Auth-> user (); ?>
Enregistrez-le dans contrôleurs / composants comme access.php. La classe $ utilisateur var sera lancé à mesure que le composant est chargé, et Commencez() est une fonction de rappel, elle est donc définie dans la classe. Maintenant, créons notre vérifier() une fonction.
fonction check ($ aco, $ action = '*') if (! empty ($ this-> utilisateur) && $ this-> Acl-> check ('utilisateur ::'. $ this-> utilisateur ['utilisateur' ] ['id'], $ aco, $ action)) return true; else return false; Notre vérifier() Cette méthode n’aura besoin que de deux paramètres: l’ACO et l’action (facultative). L'ARO sera l'utilisateur actuel de chaque session. Le paramètre d'action sera par défaut à *, qui est un accès complet pour l'ARO. La fonction commence par vérifier si le $ this-> utilisateur n'est pas vide (ce qui nous dit vraiment si un utilisateur est connecté) et ensuite nous allons à ACL. Nous avons déjà couvert cette.
Nous pouvons maintenant inclure le composant Access dans notre contrôleur Posts et vérifier les autorisations avec une seule ligne.
if (! $ this-> Access-> check ('Post', 'update')) die ('vous n'êtes pas autorisé'); Le même résultat est obtenu avec moins de code, mais le message d'erreur est laid. Tu ferais mieux de remplacer le mourir() avec le gestionnaire d'erreurs CakePHP:
$ this-> cakeError ('error404'); C'est peut-être moche, mais ça marche. Nous devrons créer un assistant qui charge un composant avec une méthode personnalisée à utiliser dans l'assistant.
Ajoutez cette fonction dans le composant Access (contrôleurs / composants / access.php).
function checkHelper ($ aro, $ aco, $ action = "*") App :: import ('Composant', 'Acl'); $ acl = new AclComponent (); return $ acl-> check ($ aro, $ aco, $ action); Maintenant, réécrivons l’assistant d’accès (views / helpers / access.php).
Access = new AccessComponent (); App :: import ('Composant', 'Auth'); $ this-> Auth = new AuthComponent (); $ this-> Auth-> Session = $ this-> Session; $ this-> user = $ this-> Auth-> user (); function check ($ aco, $ action = '*') if (vide ($ this-> utilisateur)) return false; return $ this-> Access-> checkHelper ('User ::'. $ this-> user ['User'] ['id'], $ aco, $ action); function isLoggedin () return! empty ($ this-> utilisateur); ?> le beforeRender () méthode est un rappel, semblable à celui du composant Commencez(). Nous chargeons deux composants et, comme ils seront utilisés dans la plupart des fonctions, il est judicieux de tout démarrer en même temps, plutôt que de les lancer manuellement chaque fois que la méthode est appelée..
Maintenant sur votre index.ctp vu dans vues / messages vous pouvez remplacer cette ligne.
"> modifier | link ('delete', '/posts/delete/'.$post['Post'][''id'], NULL, 'Êtes-vous sûr?'); ?> Avec celui-ci.
chèque ('Post')):?>"> modifier | link ('delete', '/posts/delete/'.$post['Post'][''id'], NULL, 'Êtes-vous sûr?'); ?> N'oubliez pas de vérifier les autorisations, tant dans les vues que dans les contrôleurs.!
Vous pouvez accéder aux données utilisateur d’un utilisateur connecté avec le utilisateur() méthode dans le composant Auth. Ensuite, vous pouvez accéder au tableau et obtenir les informations souhaitées. Mais il doit y avoir un meilleur moyen. Ajoutons la fonction suivante dans le composant Access.
fonction getmy ($ quoi) retour! vide ($ ceci-> utilisateur) && isset ($ ceci-> utilisateur ['utilisateur'] [$ quoi])? $ this-> user ['User'] [$ what]: false;
Ceci est très utile lorsque vous devez enregistrer une publication avec un identifiant d'utilisateur relation.
$ this-> data ['Post'] ['user_id'] = $ this-> Access-> getmy ('id'); Et dans la vue, nous pouvons faire quelque chose de similaire avec l'aide.
fonction getmy ($ quoi) retour! vide ($ ceci-> utilisateur) && isset ($ ceci-> utilisateur ['utilisateur'] [$ quoi])? $ this-> user ['User'] [$ what]: false;
Dans votre fichier de modèle, vous pouvez faire comme ci-dessous pour saluer un utilisateur par son nom d'utilisateur..
Bienvenue isLoggedIn ()? $ access-> getmy ('nom d'utilisateur'): 'Invité'; ?> Disons que nous devons changer de rôle pour l'utilisateur n ° 4: il doit être un super utilisateur. Donc, l'identifiant de l'utilisateur est 4 et l'identifiant de Aro est 1.
$ user_id = 4; $ user_new_group = 1;
Nous devons maintenant trouver le Aro de l'utilisateur pour pouvoir modifier son Aro parent..
$ aro_user = $ this-> Acl-> Aro-> find ('premier', array ('conditions' => array ('Aro.parent_id! =' => NULL, 'Aro.model' => 'utilisateur', 'Aro.foreign_key' => $ user_id))); Enfin, si le $ aro_user variable n'est pas vide, mettons à jour le Aro.parent_id champ.
if (! empty ($ aro_user)) $ data ['id'] = $ aro_user ['Aro'] ['id']; $ data ['parent_id'] = $ user_new_group; $ this-> Acl-> Aro-> save ($ data);
Veuillez noter que vous devez valider les identifiants de l'utilisateur et du nouvel aro. Si l'un d'entre eux n'existe pas, cela créera un désordre dans vos tables ACL..
Bien que les composants que nous venons de créer soient à la fois simples et utiles, la base de données est interrogée à chaque contrôle. Il n'est pas encore prêt pour la production. Premièrement, la base de données doit être interrogée le moins possible. Pour optimiser cela, nous devrions tirer parti du cache de CakePHP..
Utiliser le cache réduira un peu la charge, mais si dix index apparaissent dans l'index et que, pour chacun d'entre eux, nous vérifions si l'utilisateur dispose des autorisations de mise à jour pour Post Aco, la structure lira et analysera un fichier pour retourner le même résultat… dix fois pour chaque chargement de page.
C'est le deuxième point: une variable à l'intérieur de la classe et certaines conditions vont alléger le travail, ainsi une requête répétée vérifiera le cache une seule fois..
Ces deux changements se reflètent dans access_cache.php, à l'intérieur de contrôleurs / composants annuaire. Alors assurez-vous de télécharger le code source!
Les listes de contrôle d'accès sont des fonctionnalités de base dont la plupart des applications ont besoin. CakePHP a une bonne implémentation, mais manque de bonne documentation et d’exemples. J'espère qu'avec ce tutoriel, ces deux problèmes seront maintenant abordés. Merci d'avoir lu!
