Welcome to The Cookbook

Hogyan működnek az ACL-ek?

A legfontosabb, leghatékonyabb dolgokhoz szükséges egyfajta hozzáférés ellenőrzés. Az ACL-ek (Access Control Lists - Hozzáférést Vezérlő Listák) segítségével az alkalmazásunkhoz való hozzáférést apró lépésekben, mégis könnyen kezelhetően és módosíthatóan engedélyezhetjük vagy tilthatjuk. Az ACL-ek két dolgot kezelnek: olyan dolgokat, amik akarnak valamit, és olyan dolgokat amiket mi szeretnénk elérni. Az ACL szaknyelvben a dolgokat (többnyire felhasználók), amik/akik használni szeretnének valamit, ARO-nak (Access Request Object - Hozzáférést Kérő Objektum) hívjuk. A rendszer azon dolgait, amiket el szeretnénk érni (leginkább különféle események illetve adatok), ACO-nak (Access Control Object - Hozzáférést Kontrolláló Objektum) hívjuk.

Azért hívjuk ezeket "objektumnak", mert néha a kérést adó objektum nem egy személy; néha bizonyos Cake vezérlők hozzáférését a rendszer egyéb részeihez is korlátozni kell. Az ACO-k lehetnek egy vezérlő eseményei, egy webszolgáltatás, vagy akár nagymamád blogjának egy bejegyzése - egyszóval bármi, amit felügyelni akarsz.

Hogy az összes rövidítést egyszerre használjuk: az ACL az, amit arra használunk, hogy eldöntsük, mikor tud hozzáférni egy ARO egy ACO-hoz.

Na most, hogy segítsünk a megértésben, vegyünk egy példát a gyakorlatból. Képzelj el egy pillanatra egy számítógépes rendszert, amit kalandorok egy csoportja használ. A csoport vezetője gyorsan akar előrenyomulni a küldetéssel, miközben egy egészséges mértékű magánszférát és biztonságot is fenn akar tartani a többi kalandor számára. Az ARO-k tehát:

Gandalf
Aragorn
Bilbo
Frodo
Gollum
Legolas
Gimli
Pippin
Merry

1. Gandalf
2. Aragorn
3. Bilbo
4. Frodo
5. Gollum
6. Legolas
7. Gimli
8. Pippin
9. Merry

A fentiek olyan elemek, amik ACO-kat fognak kérni a rendszertől. Itt fontos megjegyezni, hogy az ACL nem a felhasználók azonosítására szolgál. Erre a célra már lennie kell egy módszernek, ahogy a felhasználói információkat tárolod, és ahogy ellenőrzöd egy felhasználó személyazonosságát. Csak onnantól tudod az ACL nagyszerű képességeit használni, amikor mindez már megvan. De rendben, most térjünk vissza a kalandunkhoz.

A következő dolog, amit Gandalfnak meg kell tennie, egy lista készítése (ACO-k), amiket a rendszer kezelni fog. Ez a lista kinézhet pl. így:

Fegyverek 
A Gyűrű 
Füstölt hús 
Diplomácia
Sör 

1. Fegyverek
2. A Gyűrű
3. Füstölt hús
4. Diplomácia
5. Sör

Hagyományosan a rendszerek jogosultságai egyfajta mátrixban voltak leírva, ami a felhasználók és az objektumok halmazából állt. Ha mindezt egy táblában tárolnánk, hasonlóképpen nézne ki mint ez (X - hozzáférés megtagadva, O - engedélyezve):

            Fegyverek     A Gyűrű        Füstölt hús     Diplomácia   Sör
Gandalf     X             X              O               O            O
Aragorn     O             X              O               O            O
Bilbo       X             X              X               X            O
Frodo       X             O              X               X            O
Gollum      X             X              O               X            X
Legolas     O             X              O               O            O
Gimli       O             X              O               X            X
Pippin      X             X              X               O            O
Merry       X             X              X               X            O

1. Fegyverek A Gyűrű Füstölt hús Diplomácia Sör
2. Gandalf X X O O O
3. Aragorn O X O O O
4. Bilbo X X X X O
5. Frodo X O X X O
6. Gollum X X O X X
7. Legolas O X O O O
8. Gimli O X O X X
9. Pippin X X X O O
10. Merry X X X X O

ElsÅ‘ pillanatra ez a rendszer egész jól működhet. A biztonságos hozzáférést be tudjuk tartatni (csak Frodo érheti ek a Gyűrűt), és védelmet nyújt a balesetek ellen (a hobbitok nem nyúlhatnak a füstölt húshoz). Eléggé részletesnek és könnyen megérthetÅ‘nek tűnik, nem?

Nos, egy ilyen kis rendszerhez a mátrix alapú beállítás elég lehet. De egy növekvÅ‘ rendszerben, vagy egy rengeteg erÅ‘forrással (ACO-k) és felhasználóval (ARO-k) rendelkezÅ‘ben, egy tábla mint ez, egész gyorsan kezelhetetlenné válik. Képzeld csak el, hogy több száz háborús táborhelyhez próbálod a hozzáférést szabályozni, és mindezt egyesével teszed. A mátrixok egy másik hátulütÅ‘je, hogy nem igazán lehet logikailag a felhasználókat csoportokba rendezni, illetve hierarchikus jogosultság változtatásokat végrehajtani ezeken a csoportokon. Például tök jó lenne a hobbitoknak automatikusan elérést adni a sörhöz és a húshoz, amint a csatának vége. Egyesével minden felhasználónál beállítani mindezt eléggé fárasztó és könnyen lehet hibázni - míg ezzel szemben egy hierarchikus változtatást az összes 'hobbit'-ra végrehajtani pillanatok műve.

Az ACL többnyire fa-struktúraként van megvalósítva. általában van egy ARO fa, és egy ACO fa. A különféle objektumainkat fa-struktúrába rendezve a jogosultságokat még mindig könnyedén, ugyanakkor a teljes rendszeren egy átfogó képet kapva tudjuk megoldani. Mivel Gandalf egy bölcs vezetÅ‘, ezért ACL-ek segítségével rendezi a különféle objektumait az alábbi módon:

A Gyűrű Szövetsége:
Harcosok
  Aragorn
  Legolas
  Gimli 
Varázslók
  Gandalf 
Hobbitok
  Frodo
  Bilbo
  Merry
  Pippin 
Vendégek
  Gollum 

1. A Gyűrű Szövetsége:
2. Harcosok
3. Aragorn
4. Legolas
5. Gimli
6. Varázslók
7. Gandalf
8. Hobbitok
9. Frodo
10. Bilbo
11. Merry
12. Pippin
13. Vendégek
14. Gollum

Kis csapatunkat ily módon struktúrálva most már megadhatjuk a hozzáféréseket a fához (annak ágaihoz), és ezek érvényesek lesznek a fa levelein is. Alapállapotban mindenhez megtagadjuk a hozzáférést. Ahogy haladsz a fán lefelé, felkapkodod az engedélyeket és alkalmazod őket. Az utolsó engedély (ami az ACO-ra vonatkozik) az, amit megtartasz végül. Egyszóval a következő jogosultságokat aggathatja Gandalf az ARO fánkra:

A Gyűrű Szövetsége: (hozzáférés mindenkinek mindenhez megtagadva)
Harcosok (hozzáférés megengedve a Fegyverekhez, Sörhöz, Elf napiadaghoz, Füstölt húshoz )
  Aragorn
  Legolas
  Gimli 
Varázslók (hozzáférés megengedve a Füstölt húshoz, Diplomáciához, és a Sörhöz)
  Gandalf 
Hobbitok (hozzáférés megengedve a Sörhöz)
  Frodo
  Bilbo
  Merry
  Pippin 
Vendégek (hozzáférés megengedve a Füstölt húshoz)
  Gollum 

1. A Gyűrű Szövetsége: (hozzáférés mindenkinek mindenhez megtagadva)
2. Harcosok (hozzáférés megengedve a Fegyverekhez, Sörhöz, Elf napiadaghoz, Füstölt húshoz )
3. Aragorn
4. Legolas
5. Gimli
6. Varázslók (hozzáférés megengedve a Füstölt húshoz, Diplomáciához, és a Sörhöz)
7. Gandalf
8. Hobbitok (hozzáférés megengedve a Sörhöz)
9. Frodo
10. Bilbo
11. Merry
12. Pippin
13. Vendégek (hozzáférés megengedve a Füstölt húshoz)
14. Gollum

Ha az ACL segítségével meg szeretnénk nézni, hogy Pippin hozzáférhet-e a sörhöz, először is megnéznénk a fában a hozzá vezető utat, ami: Szövetség -> Hobbitok -> Pippin. Ezek után megnézzük a különféle jogosultságokat, amik ezekben a pontokban találhatóak, és a Pippinhez és a sörhöz leginkább meghatározott használjuk. Tehát:

1. Szövetség = Sör megtagadva (mivel mindenkinek minden meg van tagadva...)
2. Hobbitok = Sör megengedve
3. Pippin = ? Nincs semmi külön sör-specifikus megadva rá, szóval marad megengedve
4. Végeredmény: Engedjük a sört Pippin-nek.

A fa azonban lehetőseget ad nekünk arra is, hogy sokkal finomabb szinten állítsuk a jogosultságokat - miközben végig megtartjuk a lehetőséget, hogy masszív változtatásokat hajtsunk végre. Például:

A Gyűrű Szövetsége: (hozzáférés mindenkinek mindenhez megtagadva)

Harcosok (hozzáférés megengedve a Fegyverekhez, Sörhöz, Elf napiadaghoz, Füstölt húshoz )
  Aragorn (hozzáférés megengedve a Diplomáciához)
  Legolas
  Gimli 
Varázslók (hozzáférés megengedve a Füstölt húshoz, Diplomáciához, és a Sörhöz)
  Gandalf 
Hobbitok (hozzáférés megengedve a Sörhöz)
  Frodo (hozzáférés megengedve a Gyűrűhöz)
  Bilbo
  Merry (hozzáférés megtagadva a Sörhöz)
  Pippin (hozzáférés megengedve a Diplomáciához) 
Vendégek (hozzáférés megengedve a Füstölt húshoz)
  Gollum 

1. A Gyűrű Szövetsége: (hozzáférés mindenkinek mindenhez megtagadva)
2. Harcosok (hozzáférés megengedve a Fegyverekhez, Sörhöz, Elf napiadaghoz, Füstölt húshoz )
3. Aragorn (hozzáférés megengedve a Diplomáciához)
4. Legolas
5. Gimli
6. Varázslók (hozzáférés megengedve a Füstölt húshoz, Diplomáciához, és a Sörhöz)
7. Gandalf
8. Hobbitok (hozzáférés megengedve a Sörhöz)
9. Frodo (hozzáférés megengedve a Gyűrűhöz)
10. Bilbo
11. Merry (hozzáférés megtagadva a Sörhöz)
12. Pippin (hozzáférés megengedve a Diplomáciához)
13. Vendégek (hozzáférés megengedve a Füstölt húshoz)
14. Gollum

Láthatod, hogy az Aragorn ARO megtartja az összes jogosultságát ami a többi Harcosnak is van, de ezen kívül még külön egyedi módosításokat hajthatsz végre, ha szükséges. A jogosultságok alapállapotban meg vannak tagadva, és csak a fán lefelé haladva változhatnak. Ahhoz, hogy lássuk, Merry elérheti-e a Sört, megnézzük, milyen úton lehet elérni Å‘t: Szövetség -> Hobbitok -> Merry, és lefelé haladva minden sörrel kapcsolatos infót megtartunk útközben:

1. Szövetség = Sör megtagadva (mivel mindenkinek minden meg van tagadva...)
2. Hobbitok = Sör megengedve
3. Merry = Sör megtagadva
4. Végeredmény: Nem engedjük a sört Pippin-nek.

Jogosultságok megadása: A Cake INI-alapú ACL-je

A Cake elsÅ‘ ACL implementációja ini fájl alapú volt. Bár hasznos és megbízható, ennek ellenére azt javasoljuk, inkább az adatbázis alapú ACL-t használd. Leginkább azért, mert a program futása közben tudsz újabb ACO-kat és ARO-kat hozzáadni. Az ini fájlos megoldást egyszerű alkalmazásokhoz szántuk - illetve azoknak az emberkéknek, akik valami miatt nem használnak adatbázist. Az ARO/ACO jogosultságok az /app/config/acl.ini.php -ban vannak megadva. A definiálás módja is ennek a fájlnak az elején található:

; acl.ini.php - Cake ACL Configuration
; ---------------------------------------------------------------------
; Ebben a file-ban definiáld a jogosultságokat.
; aco = access control object (valami az alkalmazásban)
; aro = access request object (bármi, ami hozzáférést kér)
;
; Felhasználó rekordok hozzáadása:
;
; [uid]
; groups = group1, group2, group3
; allow = aco1, aco2, aco3
; deny = aco4, aco5, aco6
;
; Csoport (group) rekordok hasonlóképp:
;
; [gid]
; allow = aco1, aco2, aco3
; deny = aco4, aco5, aco6
;
; Az allow, deny és a groups részek mind opcionálisak.
; MEGJEGYZéS: A csoportok nevei sosem egyezhetnek meg egy felhasználó nevével sem!

1. ; acl.ini.php - Cake ACL Configuration
2. ; ---------------------------------------------------------------------
3. ; Ebben a file-ban definiáld a jogosultságokat.
4. ; aco = access control object (valami az alkalmazásban)
5. ; aro = access request object (bármi, ami hozzáférést kér)
6. ;
7. ; Felhasználó rekordok hozzáadása:
8. ;
9. ; [uid]
10. ; groups = group1, group2, group3
11. ; allow = aco1, aco2, aco3
12. ; deny = aco4, aco5, aco6
13. ;
14. ; Csoport (group) rekordok hasonlóképp:
15. ;
16. ; [gid]
17. ; allow = aco1, aco2, aco3
18. ; deny = aco4, aco5, aco6
19. ;
20. ; Az allow, deny és a groups részek mind opcionálisak.
21. ; MEGJEGYZéS: A csoportok nevei sosem egyezhetnek meg egy felhasználó nevével sem!

Az ini fájl segítségével megadhatsz felhasználókat (ARO-k), csoportokat, amikhez tartoznak, illetve a saját egyedi jogosultságaikat. Szintén megadhatsz csoportokat is a saját külön jogosultságaikkal. Ha szeretnéd megtudni, hogyan használhatod a Cake ACL komponensét a jogosultságok ellenőrzésére - ini fájllal - nézd meg a 11.4-es részt.

Jogosultságok megadása: A Cake adatbázis alapú ACL-je

Hogyan kezdjük

Alapállapotban a jogosultsági rendszer adatbázis alapú. Ez a modul (nevezzük dbACL-nek) néhány központi modellbÅ‘l és egy parancssori szkriptbÅ‘l áll. A modelleket a Cake az ACL csomópontok adatbázisba mentésére és olvasására használja. A parancssori szkript segít az elindulásban, illetve használhatod az ACL fa manipulálására is. ElÅ‘ször is meg kell nézned, hogy az /app/config/database.php fájl létezik, és jól be van állítva. Egy új Cake telepítésnél a legegyszerűbben egy böngészÅ‘ben az install könyvtárat kinyitva láthatod ezt. A lap tetejénél - ha mindent jól csináltál - az alábbi üzeneteket kell látnod: "Your database configuration file is present." és "Cake is able to connect to the database.". Nézd meg a 4.1-es részt az adatbázis beállításával kapcsolatos további részletekért. Ezután az ACL parancssori szkriptet használva felkészíted az adatbázist a jogosultsági információk tárolására. Ezt a /cake/scripts/acl.php file segítségével teheted meg, az alábbi módon:

Az adatbázis inicializálása az acl.php -val

$ php acl.php initdb

Initializing Database...
Creating access control objects table (acos)...
Creating access request objects table (acos)...
Creating relationships table (aros_acos)...

Done.

1. $ php acl.php initdb
2. Initializing Database...
3. Creating access control objects table (acos)...
4. Creating access request objects table (acos)...
5. Creating relationships table (aros_acos)...
6. Done.

Itt az adatbázisban már látnod kell az új táblákat. Ha igazán kíváncsi vagy, hogy tárolja a fastruktúra adatait a Cake, olvass utána a "módosított fabejárás adatbázisban címszó" alatt az irodalomban. Alapjában a csomópontokat, és azok helyét a fában tároljuk. Az acos és aros táblák tárolják a hozzájuk tartozó csomópontokat, az aros_acos tábla pedig összekapcsolja az ARO-kat azokkal az ACO-kkal, amiket elérhetnek.

Most már létre tudsz hozni ARO és ACO fákat.

ARO-k (Hozzáférést Kérő Objektum) és ACO-k (Hozzáférést Kontrolláló Objektum) létrehozása

Kétféle módon lehet ACO/ARO-kra hivatkozni. Egyrészt lehet egy numerikus értékkel, ami általában a tábla elsődleges kulcsa (primary key), amihez tartoznak. A másik egy tetszőleges sztring alias, amit hozzá lehet rendelni ehhez a számhoz. Ezt a két hivatkozási módot egyszerre is lehet használni.

Új ARO-t az Aro Cake modell megfelelÅ‘ metódusait hívva hozahtunk létre. Az Aro osztály create() metódusa három paramétert vár: $link_id, $parent_id, és $alias. Ez létrehoz egy új ACL objektumot a parent_id által megadott szülÅ‘ alatt, vagy Å‘ maga lesz a kiinduló csomópont, ha a parent_id értéke null. A link_id-val összekapcsolhatsz egy tetszÅ‘leges felhasználói objektumot az ACL struktúrával. Az alias-al pedig elérheted ezt egy sztringgel.

Mielőtt neki tudnánk állni ACO-k és ARO-k gyártásának, be kell tölteni ezeket az osztályokat. Legkönnyebben a vezérlőben behívva (a $components tömbben) a Cake ACL komponensét tudjuk mindezt megtenni.

var $components = array('Acl');

1. var $components = array('Acl');

Most, hogy ezzel is megvagyunk, lássunk egy példát, hogy néz ez ki a gyakorlatban. Az alábbi kódot a vezérlő egy eseményébe helyezhetjük:

$aro = new Aro(); 

   // Először is gyártsunk pár ARO-t
   // Ezeknek most még nincs szülője. 

   $aro->create( 1, null, 'Bob Marley' );
   $aro->create( 2, null, 'Jimi Hendrix');
   $aro->create( 3, null, 'George Washington');
   $aro->create( 4, null, 'Abraham Lincoln'); 

   // Most már csoportokba rendezhetjük a felhasználókat
   // figyeld meg, hogy a csoportok ID-je 0, így ezek
   //    direkt sosem hivatkozhatnak egy felhasználóra 

   $aro->create(0, null, 'Presidents');
   $aro->create(0, null, 'Artists'); 

   // Most kapcsoljuk össze az ARO-kat a megfelelő csoporttal 

   $aro->setParent('Presidents', 'George Washington');
   $aro->setParent('Presidents', 'Abraham Lincoln');
   $aro->setParent('Artists', 'Jimi Hendrix');
   $aro->setParent('Artists', 'Bob Marley'); 

   // Röviden így készítünk egy ARO-t:
   $aro = new Aro();
   $aro->create($user_id, $parent_id, $alias);

1. $aro = new Aro();
2. // Először is gyártsunk pár ARO-t
3. // Ezeknek most még nincs szülője.
4. $aro->create( 1, null, 'Bob Marley' );
5. $aro->create( 2, null, 'Jimi Hendrix');
6. $aro->create( 3, null, 'George Washington');
7. $aro->create( 4, null, 'Abraham Lincoln');
8. // Most már csoportokba rendezhetjük a felhasználókat
9. // figyeld meg, hogy a csoportok ID-je 0, így ezek
10. // direkt sosem hivatkozhatnak egy felhasználóra
11. $aro->create(0, null, 'Presidents');
12. $aro->create(0, null, 'Artists');
13. // Most kapcsoljuk össze az ARO-kat a megfelelő csoporttal
14. $aro->setParent('Presidents', 'George Washington');
15. $aro->setParent('Presidents', 'Abraham Lincoln');
16. $aro->setParent('Artists', 'Jimi Hendrix');
17. $aro->setParent('Artists', 'Bob Marley');
18. // Röviden így készítünk egy ARO-t:
19. $aro = new Aro();
20. $aro->create($user_id, $parent_id, $alias);

ARO-kat a parancssorból is lehet készíteni:

$acl.php create aro <link_id> <szülő_id> <alias>.

1. $acl.php create aro <link_id> <szülő_id> <alias>.

Az ACO-k hasonlóképp készülnek:

<div style="font-family: monospace;">
   $aco = new Aco(); 

   // Készítsünk néhány ACO-t
   $aco->create(1, null, 'Electric Guitar');
   $aco->create(2, null, 'United States Army');
   $aco->create(3, null, 'Fans'); 

   // csoportokat is lehet készíteni, mint az ARO-knál
   // a setParent()-el, de most ezt kihagyjuk 

   // Szóval:
   $aco = new Aco();
   $aco->create($id, $parent, $alias);

1. <div style="font-family: monospace;">
2. $aco = new Aco();
3. // Készítsünk néhány ACO-t
4. $aco->create(1, null, 'Electric Guitar');
5. $aco->create(2, null, 'United States Army');
6. $aco->create(3, null, 'Fans');
7. // csoportokat is lehet készíteni, mint az ARO-knál
8. // a setParent()-el, de most ezt kihagyjuk
9. // Szóval:
10. $aco = new Aco();
11. $aco->create($id, $parent, $alias);

Az ehhez tartozó parancssor:

$acl.php create aco <link_id> <szülő_id> <alias>.

1. $acl.php create aco <link_id> <szülő_id> <alias>.

Jogosultságok hozzárendelése

Miután megvannak az ACO és ARO-ink, végre beállíthatjuk a jogosultságokat a két csoport között. Ezt a Cake Acl komponensével tesszük. A példa:

   // Először is a vezérlőben hozzá kell
   // férnünk a Cake ACL komponenséhez: 

   class SomethingsController extends AppController
   {
       // Ezt lehet hogy inkább az AppController-be kellene rakni,
       // de itt is jól működik. 

       var $components = array('Acl'); 

       // Emlékezz: az ACL mindig mindent megtagad,
       // amiről nincs infója. Ha bármiféle ellenőrzés
       // lenne most, a hozzáférés meg lenne tagadva.
       // Engedjük most meg egy ARO-nak a hozzáférést egy ACO-hoz. 

       function someAction()
       {
           //ENGEDéLYEZéS 

           // így adunk egy ARO-nak teljes hozzáférést egy ACO-hoz:
           $this->Acl->allow('Jimi Hendrix', 'Electric Guitar');
           $this->Acl->allow('Bob Marley',   'Electric Guitar'); 

           // Ugyanezt megtehetjük csoportokkal is...
           $this->Acl->Allow('Presidents', 'United States Army'); 

           // Az allow() függvénynek van egy harmadik, $esemeny paramétere.
           // Ennek segítségével részbeni hozzáférést is megadhatsz.
           // $esemeny értéke lehet: create, read, update, delete.
           // Ha $esemeny nincs megadva, teljes hozzáférése lesz. 

           $this->Acl->allow('George Washington', 'Electric Guitar', 'read');
           $this->Acl->allow('Abraham Lincoln',   'Electric Guitar', 'read'); 

           //TILTáS 

           // Hasonló módon... : 

           // Miután lejárt a mandátuma...
           $this->Acl->deny('Abraham Lincoln', 'United States Army'); 
 

       }
   }

1. // Először is a vezérlőben hozzá kell
2. // férnünk a Cake ACL komponenséhez:
3. class SomethingsController extends AppController
4. {
5. // Ezt lehet hogy inkább az AppController-be kellene rakni,
6. // de itt is jól működik.
7. var $components = array('Acl');
8. // Emlékezz: az ACL mindig mindent megtagad,
9. // amiről nincs infója. Ha bármiféle ellenőrzés
10. // lenne most, a hozzáférés meg lenne tagadva.
11. // Engedjük most meg egy ARO-nak a hozzáférést egy ACO-hoz.
12. function someAction()
13. {
14. //ENGEDéLYEZéS
15. // így adunk egy ARO-nak teljes hozzáférést egy ACO-hoz:
16. $this->Acl->allow('Jimi Hendrix', 'Electric Guitar');
17. $this->Acl->allow('Bob Marley', 'Electric Guitar');
18. // Ugyanezt megtehetjük csoportokkal is...
19. $this->Acl->Allow('Presidents', 'United States Army');
20. // Az allow() függvénynek van egy harmadik, $esemeny paramétere.
21. // Ennek segítségével részbeni hozzáférést is megadhatsz.
22. // $esemeny értéke lehet: create, read, update, delete.
23. // Ha $esemeny nincs megadva, teljes hozzáférése lesz.
24. $this->Acl->allow('George Washington', 'Electric Guitar', 'read');
25. $this->Acl->allow('Abraham Lincoln', 'Electric Guitar', 'read');
26. //TILTáS
27. // Hasonló módon... :
28. // Miután lejárt a mandátuma...
29. $this->Acl->deny('Abraham Lincoln', 'United States Army');
31. }
32. }

Ennek a vezérlőnek nem sok haszna van, talán csak annyi, hogy megértsd, hogyan működik a folyamat. Az Acl-t a saját felhasználó-kezelő komponenseddel együtt kezelve lehet a legjobb eredményeket elérni. Mihelyst egy felhasználó létrejött, az ARO-ját a fa megfelelő ágára lehet helyezni, a további jogosultságokat pedig (ha szükséges) hozzárendelni a megfelelő ACO-khoz.

A jogosultságokat a Cake parancssori szkriptjeivel is be lehet állítani. A szintaktika hasonló a modell függvényeihez, és meg lehet nézni a $php acl.php help -et futtatva.

4. rész

Jogosultságok ellenőrzése: Az ACL komponens

A jogosultságok ellenőrzése a lekgönnyebb része a Cake féle ACL-nek. Az Acl komponensnek csak egyetlen metódusát kell meghívni, a check()-et. Jó módja az ACL programunkba való beépítésének, ha az AppController-ünkbe rakunk egy eseményt, ami végrehajtja az ellenőrzést. Ha iderakjuk, a programunk bármely részéből elérhetjük ezt a részt. Egy példa:

   class AppController extends Controller
   {
       // Beszerezzük a komponensünket
       var $components = array('Acl'); 

       function checkAccess($aco)
       {
           // Ellenőrizzük a hozzáférést
           $access = $this->Acl->check($this->Session->read('user_alias'), $aco, $action = "*"); 

           // megtagadva
           if ($access === false)
           {
               echo "na húzzá!";
               exit;
           }
           // engedélyezve
           else
           {
               echo "csá tesó!";
               exit;
           }
       }
   }

1. class AppController extends Controller
2. {
3. // Beszerezzük a komponensünket
4. var $components = array('Acl');
5. function checkAccess($aco)
6. {
7. // Ellenőrizzük a hozzáférést
8. $access = $this->Acl->check($this->Session->read('user_alias'), $aco, $action = "*");
9. // megtagadva
10. if ($access === false)
11. {
12. echo "na húzzá!";
13. exit;
14. }
15. // engedélyezve
16. else
17. {
18. echo "csá tesó!";
19. exit;
20. }
21. }
22. }

Az Acl komponenst az AppController-ben elérhetővé téve az Acl használható lesz alkalmazásunk bármelyik vezérlőjében. íme az alap forma:

	$this->Acl->Check($aro, $aco, $action = '*');

1. $this->Acl->Check($aro, $aco, $action = '*');