Share
Wenn Sie ein CMS erstellen, benötigen Sie wahrscheinlich verschiedene Benutzerrollen - Superuser, Administratoren und Benutzer - mit unterschiedlichen Berechtigungsstufen. Zu kompliziert zum Code? Geben Sie die ACL (Zugriffskontrolllisten) von CakePHP ein. Mit dem richtigen Setup prüfen Sie die Benutzerberechtigungen mit nur einer Zeile.
Mit der ACL können Sie eine Hierarchie von Benutzern mit ihren jeweiligen Rollen erstellen. Hier ist ein kurzes Beispiel.
In diesem Lernprogramm richten wir eine ACL für ein einfaches Blog ein. Wenn Sie sich noch nicht auf Nettuts + über Erste Schritte mit CakePHP (und Teil 2) informiert haben, tun Sie dies bitte und kehren Sie dann zurück, da wir die Grundlagen des Frameworks selbstverständlich voraussetzen.
Mit dieser Hierarchie können wir für jede Rolle mehrere Berechtigungen vergeben:
Jede Berechtigung wird der Gruppe erteilt, nicht dem Benutzer. Wenn also Benutzer # 6 zum Admin befördert wird, wird er gegen die Gruppenberechtigung - nicht seine - geprüft. Diese Rollen und untergeordneten Knoten (Benutzer) werden als Zugriffsanforderungsobjekte oder AROs bezeichnet.
Auf der anderen Seite haben wir nun die Access Control Objects oder ACOs. Dies sind die zu kontrollierenden Objekte. Oben habe ich Posts und Benutzer erwähnt. Normalerweise sind diese Objekte direkt mit den Modellen verknüpft. Wenn wir ein Post-Modell haben, benötigen wir ein ACO für dieses Modell.
Jedes ACO verfügt über vier grundlegende Berechtigungen: Erstellen, Lesen, Aktualisieren und Löschen. Sie können sich mit dem Schlüsselwort daran erinnern CRUD. Es gibt eine fünfte Berechtigung, den Stern, eine Verknüpfung für den vollständigen Zugriff.
Wir werden nur zwei ACOs für dieses Tutorial verwenden: Post und User, aber Sie können so viele erstellen, wie Sie benötigen.
Fahren wir fort, um die Datenbanktabellen zu erstellen. Sie finden diesen Code in db_acl.sql in Ihrer App config / sql Verzeichnis.
CREATE TABLE acos (ID INTEGER (10) UNSIGNED NICHT NULL AUTO_INCREMENT, parent_id INTEGER (10) DEFAULT NULL, Modell VARCHAR (255) DEFAULT ", Auslandsschlüssel INTEGER (10) UNSIGNED DEFAULT NULL, Alias VARCHAR (255) DEFAULT", DEFAULT ") 10) DEFAULT NULL, rechts 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, _ CHAR erstellen (2) NOT NULL DEFAULT 0, _read CHAR (2) NOT NULL 0, _update CHAR (2) NOT NULL DEFAULT 0, _delete CHAR (2) NOT NULL DEFAULT 0, PRIMARY KEY (id)); CREATE TABLE aros (id INTEGER (10) UNSIGNED NICHT NULL AUTO_INCREMENT, parent_id INTEGER (10) DEFAULT NULL, Modell VARCHAR (255) DEFAULT ", Auslandsschlüssel INTEGER (10) UNSIGNED DEFAULT NULL, Alias VARCHAR (255) DEFAULT", DEFAULT ") 10) DEFAULT NULL, rechts INTEGER (10) DEFAULT NULL, PRIMARY KEY (id));
Wir können jetzt damit beginnen, ARO- und ACO-Knoten zu erstellen, aber hey, wir haben keine Benutzer! Wir müssen ein grundlegendes Authentifizierungssystem erstellen.
Da dieses Tutorial für CakePHP-Entwickler gedacht ist, die über grundlegende Kenntnisse des Frameworks verfügen, gebe ich Ihnen den Code und eine kurze Erklärung. Das Authentifizierungssystem ist jedoch nicht das Ziel dieses Tutorials.
Die MySQL-Tabelle:
CREATE TABLE Benutzer (ID INTEGER (10) UNSIGNED AUTO_INCREMENT KEY, Benutzername TEXT, Kennwort TEXT);
Das Benutzermodell (models / user.php)
Der Benutzer-Controller (controller / users_controller.php)
Accentsconagua
Auth-> userModel = 'Benutzer'; $ this-> Auth-> allow ('*'); function register () if (! empty ($ this-> data)) // Hier sollten Sie den Benutzernamen (min. Länge, max. Länge, keine Sonderzeichen enthalten, nicht bereits vorhanden usw.) validieren. // Auch als Passwort if ($ this-> User-> validates ()) $ this-> User-> save ($ this-> data); // Lass uns die Daten lesen, die wir gerade eingefügt haben $ data = $ this-> User-> read (); // Verwenden Sie es, um den Benutzer zu authentifizieren. $ This-> Auth-> login ($ data); // Dann umleiten $ this-> redirect ('/'); function login () if (! empty ($ this-> data)) // Wenn Benutzername / Passwort übereinstimmen, wenn ($ this-> Auth-> login ($ this-> data)) $ this -> Weiterleitung ('/'); else $ this-> User-> invalidate ('Benutzername', 'Kombination aus Benutzername und Passwort ist falsch!'); function logout () $ this-> Auth-> logout (); $ this-> redirect ('/'); ?> Da wir neue Elemente haben, lassen Sie uns diese überprüfen. Zuerst setzen wir ein $ Komponenten Variable. Diese Variable enthält alle Komponenten im Array. Wir werden das brauchen Auth Eine Komponente, die eine Kernkomponente darstellt, wie auch HTML- und Formular-Helfer. Da sie jedoch nicht standardmäßig von Cake enthalten ist, müssen Sie sie manuell hinzufügen.
Die Auth-Komponente behandelt einige grundlegende Authentifizierungsmechanismen: Sie hilft uns bei der Anmeldung eines Benutzers und der Sitzung eines authentifizierten Benutzers für uns sowie der Abmeldung und der grundlegenden Berechtigung für Gäste. Außerdem wird das Passwort automatisch gehasht. In den folgenden Absätzen werde ich erklären, wie die einzelnen Funktionen aufgerufen werden.
Als Nächstes erstellen wir eine Funktion namens vorFilter. Dies ist eine Rückruffunktion, mit der wir einige Aktionen festlegen können, bevor die gesamte Steuerungslogik verarbeitet wird. Die Auth-Komponente erfordert die Angabe eines zu verwendenden Modells, in diesem Fall des Benutzers. Standardmäßig wird dann allen Benutzern der Zugriff verweigert, die nicht angemeldet sind. Wir müssen dieses Verhalten mit überschreiben ermöglichen() was erfordert einen Parameter. Dieser Parameter kann ein Sternchen sein, der angibt, dass nicht authentifizierte Benutzer auf alle Methoden innerhalb des Controllers zugreifen können. Oder es kann ein Array mit den Funktionen übergeben werden, auf die nicht authentifizierte Benutzer zugreifen können. Da wir nur drei Funktionen haben, sind die folgenden Zeilen in diesem Fall dasselbe.
$ this-> Auth-> allow ('*'); $ this-> Auth-> allow (array ('register', 'login', 'logout')); Für die Anmeldung() Bei dieser Funktion übernimmt die Auth-Komponente alle Anmeldemechanismen für uns. Wir müssen die Funktion nur mit einem Array mit zwei Schlüsseln versehen: dem Benutzernamen und dem Passwort. Diese Schlüssel können geändert werden, jedoch standardmäßig beide Nutzername und Passwort Felder werden mit der Datenbank abgeglichen und geben true zurück, wenn der Benutzer authentifiziert wurde.
Schließlich versucht die Anmeldefunktion des Controllers, eine Kombination aus Benutzername und Kennwort mit der Datenbank abzugleichen.
Bitte beachten Sie, dass dieser Code sehr einfach ist. Sie müssen die Zeichen des Benutzernamens überprüfen, wenn der Benutzername vorhanden ist, die Mindestlänge für das Kennwort usw..
Die Registeransicht (Ansichten / Benutzer / register.ctp)
Registriere dein Konto
Die Login-Ansicht (Ansichten / Benutzer / login.ctp)
Ins Konto einloggen
Öffnen / Benutzer / registrieren in Ihrem Webbrowser und registrieren Sie ein neues Konto. Ich schlage vor Administrator als Benutzername und 123 als Passwort und wenn Ihre Sitzung abläuft, gehen Sie zu / Benutzer / Login und geben Sie die richtige Kombination aus Benutzername und Passwort ein.
Wir arbeiten nicht einmal mit ACL, aber wir können das Posten, Bearbeiten und Löschen von Beiträgen bereits ablehnen. Öffnen Sie Ihren Postcontroller und fügen Sie die Auth-Komponente hinzu.
var $ components = Array ('Auth'); Gehen Sie jetzt zu / Beiträge in Ihrem Webbrowser. Wenn Sie angemeldet sind, sollten Sie die Beiträge sehen. Wenn dies nicht der Fall ist, werden Sie zu weitergeleitet / Benutzer / Login. Durch einfaches Hinzufügen der Auth-Komponente werden alle Aktionen standardmäßig für Gäste verweigert. Wir müssen drei Aktionen für nicht autorisierte Benutzer ablehnen: Erstellen, Bearbeiten und Löschen. In anderen Worten müssen wir Index und View zulassen.
function beforeFilter () $ this-> Auth-> userModel = 'Benutzer'; $ this-> Auth-> allow (array ('index', 'view')); Gehe zur Bearbeitung oder erstelle einen Beitrag. Wenn Sie nicht angemeldet sind, sollten Sie zu weitergeleitet werden / Benutzer / Login. Es scheint alles gut zu laufen, aber wie sieht es mit den Aussichten aus? Die Links zum Bearbeiten und Löschen werden allen angezeigt. Wir sollten eine Bedingung machen.
Bevor wir jedoch näher darauf eingehen, wollen wir sehen, wie Auths user () funktioniert. Kopieren Sie diese Zeilen und fügen Sie sie in die Indexfunktion ein.
$ user = $ this-> Auth-> user (); pr ($ user);
Öffne dein / Beiträge in Ihrem Browser und, falls angemeldet, der pr () werde so etwas werfen.
Array ([Benutzer] => Array ([id] => 1 [Benutzername] => admin))
Das Nutzer() Funktion gibt ein Array genauso zurück, wie es ein Modell tun würde. Wenn wir mehr als drei Felder hatten (das Kennwort ist nicht enthalten), werden sie im Array angezeigt. Wenn Sie nicht angemeldet sind, ist das Array leer. Sie können also wissen, dass ein Benutzer bei Auth angemeldet ist Nutzer() Array ist nicht leer.
Auth ist nun eine Komponente, die in einer Steuerung verwendet werden soll. Wir müssen aus einer Sicht wissen, ob ein Benutzer angemeldet ist, vorzugsweise über einen Helfer. Wie können wir eine Komponente in einem Helfer verwenden? CakePHP ist so großartig und flexibel, dass es möglich ist.
Sitzung = $ this-> Sitzung; $ user = $ auth-> user (); return! empty ($ user); ?>
Speichern Sie dieses Snippet in Ansichten / Helfer wie access.php. Nun sehen wir uns den Code Zeile für Zeile an. Zunächst richten wir ein $ Helfer var. Helfer können andere Helfer aufnehmen, genau wie $ Komponenten können. Die Session-Komponente ist für die Auth-Komponente erforderlich, aber wir haben keinen Zugriff auf diese Komponente in einem Helper. Glücklicherweise haben wir einen Session-Helfer, der uns helfen wird.
Als Nächstes erstellen wir eine Funktion und verwenden diese App :: import Dadurch können wir ein Element importieren, auf das wir normalerweise keinen Zugriff haben. Die nächste Zeile erstellt die Auth-Komponente in a $ auth variabel und jetzt ein wenig schmutziger Hack; Da die Auth-Komponente die Sitzung liest, um zu wissen, ob wir protokolliert sind oder nicht, ist die Sitzungskomponente erforderlich. Da wir sie jedoch von einem Ort importieren, zu dem sie nicht gehören sollte, müssen wir ihr ein neues Session-Objekt zuweisen. Schließlich verwenden wir Nutzer() und setzen es auf $ Benutzer und true zurückgeben, wenn die Variable nicht leer ist, andernfalls false.
Gehen wir zurück zum Beitragscontroller und fügen Sie den Helfer hinzu.
var $ helpers = array ('Access'); Die Zugriffshilfe ist jetzt in der Ansicht verfügbar. Öffnen index.ctp im Ansichten / Beiträge und ersetzen Sie diese Zeile.
"> bearbeiten | link ('delete', '/posts/delete/'.$post['Post'(['id'], NULL, 'Sind Sie sicher?'); ?> Mit diesem.
isLoggedin ()):?>"> bearbeiten | link ('delete', '/posts/delete/'.$post['Post'(['id'], NULL, 'Sind Sie sicher?'); ?> Gehen Sie zurück zu Ihrem Webbrowser, laden Sie die Indexseite neu. Wenn Sie angemeldet sind, werden die Links zum Bearbeiten und Löschen für jeden Beitrag angezeigt. Sonst sehen Sie nichts.
Dies reicht zwar aus, wenn Sie eine App mit einem oder zwei Benutzern haben, es reicht jedoch nicht aus, wenn Sie Registrierungen geöffnet haben.
Öffnen Sie den Benutzercontroller und fügen Sie die ACL-Komponente hinzu.
var $ components = array ('Auth', 'Acl'); Als Nächstes erstellen wir eine Funktion zum Installieren der ACOs und AROs-Knoten.
function install () if ($ this-> Acl-> Ar-> findByAlias ("Admin")) $ this-> redirect ('/'); $ aro = new aro (); $ aro-> create (); $ aro-> save (array ('model' => 'User', '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' => 'User', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'User')); $ aro-> create (); $ aro-> save (array ('model' => 'User', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Suspended')); $ aco = new Aco (); $ aco-> create (); $ aco-> save (array ('model' => 'User', 'foreign_key' => null, 'parent_id' => null, 'alias' => 'User')); $ 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 ('Benutzer', 'Post', array ('create')); Durch den Import der ACL-Komponente können wir auf das ACO- und ARO-Modell zugreifen. Wir beginnen mit der Erstellung einer ARO, die die Objekte anfordert. Mit anderen Worten, wer greift auf die Objekte zu. Das wäre der Benutzer (daher die Benutzerzeichenfolge im Modell). Wir schaffen verschiedene Rollen. Super, Admin, Benutzer und Suspended.
Als Nächstes machen wir dasselbe mit ACOs, da wir nur zwei Objekte (Posts und Benutzer) verwalten müssen, und wir erstellen jeweils zwei Objekte.
Nun eine kurze Notiz. Das Array, das wir sowohl für ACOs als auch für AROs speichern, hat vier Felder: den Modellnamen, den Fremdschlüssel (was nützlich ist, wenn Sie Zugriff auf einen ARO (wie einen von ihm erstellten Beitrag) geben möchten), die übergeordnete ID (die später verwendet wird) und ist die grundlegende Beziehung zwischen übergeordneten und untergeordneten Knoten (wir erstellen Benutzer unterhalb dieser Rollen) und den Aliasnamen (ein schnelles Formular zum Auffinden der Objekte)..
Schließlich verwenden wir ACLs ermöglichen() Funktion. Der erste Parameter ist der ACO-Alias. zweitens der ARO-Alias und drittens die Berechtigungen, die der ARO erteilt wurden. Ein Superuser hat vollen Zugriff auf die Post- und Benutzermodelle, ein Administrator hat vollen Zugriff auf das Post-Modell, und ein Benutzer kann nur Posts erstellen.
Zu Beginn der Funktion erklärte ich eine Bedingung, um zu überprüfen, ob die Admin-Rolle in ACOs vorhanden ist. Sie möchten dasselbe nicht mehr als einmal installieren, oder? Es würde die Datenbank ziemlich durcheinander bringen.
Öffnen / Benutzer / installieren in Ihrem Webbrowser, und da wir keine Ansicht haben, gibt CakePHP einen Fehler aus, aber überprüfen Sie einfach den MySQL-Dump. Alle Beziehungen wurden erfolgreich erstellt. Es ist an der Zeit, mit den untergeordneten Knoten zu arbeiten.
Reinigen wir das Benutzer Tabelle. Öffnen Sie phpMyAdmin, wählen Sie Ihre Datenbank aus Benutzer Tabelle und klicken Sie auf leer. Wir kommen zurück zum registrieren() Funktion auf dem Users Controller. Direkt unterhalb dieser Zeile:
$ this-> Auth-> login ($ data);
Fügen Sie diesen Code ein:
// Setze die Benutzerrollen $ aro = new Aro (); $ parent = $ aro-> findByAlias ($ this-> User-> find ('count')> 1? 'User': 'Super'); $ aro-> create (); $ aro-> save (array ('model' => 'User', 'foreign_key' => $ this-> User-> id, 'parent_id' => $ parent ['Aro'] ['id'], ' alias '=>' User :: '. $ this-> User-> id)); In der ersten Zeile erstellen wir ein neues ARO-Objekt. Dann erhalten wir den übergeordneten Knoten, in dem der Benutzer erstellt wird. Wenn sich in der Datenbank ein Datensatz befindet, setzen wir ihn auf die Benutzer-ARO. Andernfalls sollte der erste Benutzer der Super-Benutzer sein.
Dann speichern wir eine neue ARO. Das Modell ist das, an dem wir gerade arbeiten, Nutzer, das Unbekannter Schlüssel ist die ID des letzten Datensatzes, die wir gerade erstellt haben. Das Eltern ID ist der Knoten, mit dem wir begonnen haben; Wir übergeben einfach die ID und schließlich den Alias. Es ist eine gute Idee, es anzurufen Modellname, dann ein Trennzeichen ::, und dann die Kennung. Es wird viel einfacher sein, es zu finden.
Jetzt sind wir fertig. Erstellen Sie vier Benutzer: Superuser, Adminuser, Normaluser und Suspenduser. Ich empfehle denselben Benutzernamen und dasselbe Passwort zu Testzwecken. Vergessen Sie nicht, dass bis zu diesem Punkt nur der Superuser eine Super-Rolle hat. Alle übrigen werden Benutzer sein!
Da es sich bei der ACL um eine Komponente handelt, ist sie nur innerhalb des Controllers zugänglich. Später wird es auch in der Ansicht sein; aber zuerst die ersten sachen. Fügen Sie die ACL-Komponente in den Post-Controller ein, wie wir es im Users-Controller getan haben. Jetzt können Sie die Berechtigungen prüfen. Gehen wir zur Editierfunktion und machen Sie einen kurzen Test. Fügen Sie dies in der ersten Zeile der Methode hinzu.
$ user = $ this-> Auth-> user (); if (! $ this-> Acl-> check ('User ::'. $ user ['User'] ['id'], 'Post', 'update')) die ('Sie sind nicht autorisiert'); ACLs prüfen() Die Funktion benötigt drei Parameter: den ARO, den ACO und die Aktion. Gehe und bearbeite einen Beitrag, und wenn du nicht als Superuser angemeldet bist, stirbt das Skript. Gehe zu / Benutzer / Login und als Super-Benutzer zugreifen und zur Bearbeitung zurückkehren. Sie sollten den Beitrag bearbeiten können. Schauen Sie unter dem MySQL-Dump nach, um die Magie zu sehen. Vier Datenbankabfragen: Das ist sicher nicht skalierbar.
Wir haben zwei Probleme. Zuerst, zwei Linien für die Berechtigungsprüfung. Zweitens werden die ACLs nicht zwischengespeichert. Und vergessen Sie nicht, dass alle angemeldeten Benutzer den Bearbeitungslink sehen können, auch wenn nur der Super-Benutzer es verwenden kann.
Lassen Sie uns eine neue Komponente erstellen. Nennen wir es Access.
user = $ this-> Auth-> user (); ?>
Speichern Sie es in Steuerungen / Komponenten wie access.php. Die Klasse $ Benutzer var wird beim Laden der Komponente gestartet und Anlaufen() ist eine Rückruffunktion, daher ist sie jetzt in der Klasse festgelegt. Lass uns jetzt unsere erstellen prüfen() Funktion.
Funktionsprüfung ($ aco, $ action = '*') if (! empty ($ this-> user) && $ this-> Acl-> check ('User ::'. $ this-> user ['User' ] ['id'], $ aco, $ action)) return true; else return false; Unsere prüfen() Die Methode benötigt nur zwei Parameter: den ACO und die Aktion (die optional ist). Der ARO ist der aktuelle Benutzer für jede Sitzung. Der Aktionsparameter lautet standardmäßig *, Das ist uneingeschränkter Zugriff für die ARO. Die Funktion beginnt mit der Prüfung, ob $ this-> Benutzer ist nicht leer (was wirklich aussagt, wenn ein Benutzer angemeldet ist) und dann gehen wir zur ACL. Wir haben das bereits behandelt.
Wir können jetzt die Access-Komponente in unseren Postcontroller aufnehmen und die Berechtigungen mit nur einer Zeile überprüfen.
if (! $ this-> Access-> check ('Post', 'update')) die ('Sie sind nicht autorisiert'); Das gleiche Ergebnis wird mit weniger Code erzielt, die Fehlermeldung ist jedoch hässlich. Du solltest besser das ersetzen sterben() mit dem CakePHP-Fehlerhandler:
$ this-> cakeError ('error404'); Das mag hässlich sein, aber es funktioniert. Wir müssen einen Helfer erstellen, der eine Komponente mit einer benutzerdefinierten Methode für den Helfer lädt.
Fügen Sie diese Funktion in der Access-Komponente hinzu (controller / components / access.php).
Funktion checkHelper ($ aro, $ aco, $ action = "*") App :: import ('Component', 'Acl'); $ acl = new AclComponent (); return $ acl-> check ($ aro, $ aco, $ action); Jetzt schreiben wir den Access Helper neu (views / helpers / access.php).
Access = new AccessComponent (); App :: import ('Component', 'Auth'); $ this-> Auth = new AuthComponent (); $ this-> Auth-> Session = $ this-> Session; $ this-> user = $ this-> Auth-> user (); Funktionsprüfung ($ aco, $ action = '*') if (leer ($ this-> user)) return false; $ this-> Access-> checkHelper zurückgeben ('User ::'. $ this-> user ['User'] ['id'], $ aco, $ action); function isLoggedin () return! empty ($ this-> user); ?> Das beforeRender () Methode ist ein Rückruf, ähnlich wie bei der Komponente Anlaufen(). Wir laden zwei Komponenten, und da diese in den meisten Funktionen verwendet werden, ist es eine gute Idee, alle auf einmal zu starten, anstatt sie jedes Mal manuell zu starten, wenn die Methode aufgerufen wird.
Nun zu deinem index.ctp Ansicht in Ansichten / Beiträge Sie können diese Zeile ersetzen.
"> bearbeiten | link ('delete', '/posts/delete/'.$post['Post'(['id'], NULL, 'Sind Sie sicher?'); ?> Mit diesem.
check ('Post')):?>"> bearbeiten | link ('delete', '/posts/delete/'.$post['Post'(['id'], NULL, 'Sind Sie sicher?'); ?> Vergessen Sie nicht, die Berechtigungen sowohl in den Ansichten als auch in den Controllern zu überprüfen!
Mit können Sie auf die Benutzerdaten eines protokollierten Benutzers zugreifen Nutzer() Methode in der Auth-Komponente. Dann können Sie auf das Array zugreifen und die gewünschten Informationen abrufen. Aber es muss einen besseren Weg geben. Fügen wir die folgende Funktion in die Access-Komponente ein.
Funktion getmy ($ what) return! empty ($ this-> Benutzer) && isset ($ this-> user ['User'] [$ what])? $ this-> user ['user'] [$ what]: false;
Dies ist sehr nützlich, wenn Sie einen Beitrag mit einem speichern möchten Benutzeridentifikation Beziehung.
$ this-> data ['Post'] ['user_id'] = $ this-> Access-> getmy ('id'); Und in der Ansicht können wir mit dem Helfer etwas Ähnliches machen.
Funktion getmy ($ what) return! empty ($ this-> Benutzer) && isset ($ this-> user ['User'] [$ what])? $ this-> user ['user'] [$ what]: false;
In Ihrer Vorlagendatei können Sie wie folgt vorgehen, um einen Benutzer mit seinem Benutzernamen zu begrüßen.
Herzlich willkommen isLoggedIn ()? $ access-> getmy ('username'): 'Guest'; ?> Nehmen wir an, wir müssen die Rollen für Benutzer 4 wechseln: Er muss ein Super-Benutzer sein. Die Benutzerkennung ist also 4 und die ID von Aro ist 1.
$ user_id = 4; $ user_new_group = 1;
Jetzt müssen wir den Aro des Benutzers finden, um seinen übergeordneten Aro zu ändern.
$ aro_user = $ this-> Acl-> Aro-> find ('first', array ('conditions' => array ('Aro.parent_id! =' => NULL, 'Aro.model' => 'Benutzer', 'Aro.foreign_key' => $ user_id))); Schließlich, wenn die $ aro_user Variable ist nicht leer, lass uns das aktualisieren Aro.parent_id Feld.
if (! empty ($ aro_user)) $ data ['id'] = $ aro_user ['Aro'] ['id']; $ data ['parent_id'] = $ user_new_group; $ this-> Acl-> Aro-> save ($ data);
Bitte beachten Sie, dass Sie sowohl die Benutzer-ID als auch die ID des neuen Aro überprüfen müssen. Wenn einer davon nicht vorhanden ist, wird in Ihren ACL-Tabellen ein Durcheinander erzeugt.
Obwohl die soeben erstellte Komponente sowohl einfach als auch nützlich ist, wird die Datenbank bei jeder Prüfung abgefragt. Es ist noch nicht fertig für die Produktion. Erstens sollte die Datenbank so wenig wie möglich abgefragt werden. Um dies zu optimieren, sollten wir den Cache von CakePHP nutzen.
Die Verwendung von Cache reduziert die Last ein wenig. Wenn jedoch zehn Beiträge im Index angezeigt werden, überprüfen wir für jeden, ob der Benutzer über Aktualisierungsberechtigungen für Post Aco verfügt Datei, um dasselbe Ergebnis zurückzugeben… zehn Mal für jede Seite, die geladen wird.
Das ist der zweite Punkt: Eine Variable innerhalb der Klasse und einige Bedingungen werden die Arbeit leichter machen, so dass eine wiederholte Anforderung nur einmal gegen Cache geprüft wird.
Diese beiden Änderungen spiegeln sich in wider access_cache.php, in der Steuerungen / Komponenten Verzeichnis. Stellen Sie also sicher, dass Sie die Quelle herunterladen!
Zugriffssteuerungslisten sind grundlegende Funktionen, die die meisten Apps benötigen. CakePHP hat eine schöne Implementierung, aber es fehlt ihm sowohl an guter Dokumentation als auch an Beispielen. Ich hoffe, dass mit diesem Tutorial diese beiden Probleme jetzt behandelt werden. Danke fürs Lesen!
