Admin rozhraním disponuje v súčasnosti každá väčšia web aplikácia, a keďže v našom seriáli tvoríme CMS nebude tomu inak ani u nás.

V CakePHP máme v podstate dve možnosti, ktorými môžeme vytvoriť admin rozhranie pre našu aplikáciu. Jednou z možností je vytvoriť admin rozhranie ako samostatnú aplikáciu, druhou možnosťou je použiť predpripravené riešenie, ktoré ponúka CakePHP.

Admin rozhranie ako samostatná aplikácia

Najprv si poďme predstaviť riešenie, kde bude admin rozhranie fungovať ako samostatná aplikácia. V rámci nášho projektu si vytvoríme novú aplikáciu, ktorú nazveme admin (novú aplikáciu môžeme vytvoriť pomocou dostupných konzolových nástrojov v CakePHP alebo skopírovaním obsahu adresára app do adresára admin). Adresárová štruktúra projektu po vytvorení novej aplikácie admin by mohla vypadať následovne

/web
|_ admin
   |_ webroot
   |_ controllers
   |_ views
   |_ models
   |_ ...
|_ app
   |_ webroot
   |_ controllers
   |_ views
   |_ models
   |_ ...
|_ cake

Predstavme si, že adresár web je koreňový adresár našej web aplikácie a adresár admin je naša nová aplikácia v rámci nášho projektu s kompletnou stromovou štruktúrou CakePHP aplikácie. Keďže sa v našom adresári admin nachádza kompletná CakePHP aplikácia, ktorá nám môže slúžiť ako admin rozhranie, môžeme k nej pristupovať prostredníctvom adresy http:example.com/ad­min/* //

Ako už určite tušíte, takýto prístup má jednú veľkú nevýhodu a tou je samotný fakt, že sa jedná o samostatnú aplikáciu. Tým že máme vytvorenú samostatnú aplikáciu pre náš frontend a samostatnú aplikáciu pre admin rozhranie, nebudeme môcť medzi týmito aplikáciami zdieľať žiadne komponenty, helpery atď.

Tento spôsob tvorby admin rozhrania by som neodporúčal, pretože nedodržuje pravidlo DRY a veľa rovnakého kódu budete musieť písať a upravovať na dvoch miestach osobitne, tak ako vo frontende, tak i v admin aplikácii.

Admin rozhranie s pomocou CakePHP

Druhý spôsob, oveľa jednoduchší a inteligentnejší, je využiť riešenie, ktoré nám priamo ponúka CakePHP. Základom tohto riešenia je nastaviť admin routovanie v súbore app/config/co­re.php odkomentovaním ri­adku následovne

Configure::write('Routing.admin', 'admin');

Týmto sme dali CakePHP najavo, že za adresou http:example.com/ad­min// sa bude skrývať naše admin rozhranie. Od tejto chvíle bude CakePHP automaticky rozpoznávať akcie v controlleri a k nim príslušné view podľa predpony admin_.

Pozrime sa radšej na konkrétny príklad a poďme si teda doplniť našu aplikáciu o potrebné admin rozhranie. Pre názornosť si uveďme skrátený výpis zdrojového kódu ArticlesContro­ller v súbore app/controller­s/articles_con­troller.php (kompletné zdrojové kódy nájdete v prílohe k článku)

<?php
class ArticlesController extends AppController {

        var $name = 'Articles';
        var $helpers = array('Html', 'Form');

        function view($id = null) {
                if (!$id) {
                        $this->Session->setFlash(__('Invalid Article.', true));
                        $this->redirect(array('action'=>'index'));
                }
                $this->set('article', $this->Article->read(null, $id));
        }

        function admin_add() {
                if (!empty($this->data)) {
                        $this->Article->create();
                        if ($this->Article->save($this->data)) {
                                $this->Session->setFlash(__('The Article has been saved', true));
                                $this->redirect(array('action'=>'index'));
                        } else {
                                $this->Session->setFlash(__('The Article could not be saved. Please, try again.', true));
                        }
                }
                $tags = $this->Article->Tag->find('list');
                $users = $this->Article->User->find('list');
                $this->set(compact('tags', 'users'));
        }

}
?>

V našom controlleri máme dve akcie, jedna z nich je pomenovaná view a druhá admin_add. Rozdiel medzi týmito akciami je v spôsobe prístupu k nim. Kým k akcii view pristupuje cez URL tak ako sme zvyknutý napr. example.com/ar­ticles/view/10, ku akcii admin_add pristupujeme cez URL example.com/ad­min/articles/add

Nesmieme však zabudnúť na správne pomenovanie view súborov. Kedže každá akcia v controlleri je automaticky zviazaná s príslušným view súborom, vyššie spomenuté konvencie musíme dodržiavať aj pri view súboroch. Pozrime sa, ako by vyzerala adresárová štruktúra nášho príkladu

/web
|_ app
   |_ controllers
      |_ articles_controller.php
   |_ views
      |_ articles
         |_ view.ctp
         |_ admin_add.ctp
   |_ models
   |_ ...

Teraz nám je jasné, že ak vytvárame admin akciu v controlleri, musíme k nej vytvoriť aj admin view s rovnakým prefixom a to admin_. Síce už vieme úspešne vytvoriť admin rozhranie, avšak doposiaľ sme nijakým spôsobom nekontrolovali prístup k admin rozhraniu. A keďže určite nechceme admin rozhranie sprístupniť každému, poďme sa teda pozrieť, aké možnosti nám ponúka CakePHP.

Autentifikácia

O autentifikáciu sa v CakePHP stará komponenta „AuthComponent“:http://api.cakephp.org/…mponent.html Táto komponenta disponuje množstvom užitočných metód a my sa na ne pozrieme priamo v našom ukážkovom príklade.

Našou úlohou bude, aby k našim admin akciám mal prístup len prihlásený užívateľ (keďže je náš systém veľmi jednoduchý, nebudeme riešiť žiadnu autorizáciu užívateľov a vystačíme si len s prihlasovaním užívateľov). Tzn. že pre vstup do admin rozhrania nám bude stačiť úspešné overenie mena a hesla.

Nastavenie Auth komponenty

Prvým krokom je nastavenie databázovej tabuľky. Tabuľku v databáze nazveme users (my už ju máme z predchádzajúcich častí vytvorenú) a jej štruktúra bude nasledovná

CREATE TABLE users (
    id integer auto_increment,
    username char(50),
    password char(50),
    PRIMARY KEY (id)
);

Ďalším krokom je načítanie tejto komponenty. Komponentu musíme načítať v niektorom z našich existujúcich controllerov, my ju budeme volať z AppController v súbore app/app_contro­ller.php aby bola komponenta dostupná pre všetky zdedené controllery

class AppController extends Controller {
    var $components = array('Auth');
}

Komponentu máme načítaný, následne môžeme začať s prihlasovaním užívateľov.

Prihlasujeme užívateľa

Najprv si musíme nastaviť potrebné premenné v komponente a tým zabezpečiť jej inicializáciu. Postupne určíme, na akú adresu nás aplikácia presmeruje po úspešnom prihlásení resp. po úspešnom odhlásení, taktiež je potrebné určiť, ktorá časť systému bude prístupná len prihlásenému užívateľovi. Tieto nastavenia nastavíme v AppController v súbore app/app_contro­ller.php

function beforeFilter() {
    $this->Auth->loginRedirect = array('controller' => 'articles', 'action' => 'index');
    $this->Auth->logoutRedirect = '/';
    $this->Auth->authorize = 'controller';
    $this->Auth->allow(array('index','view'));
}

function isAuthorized() {
    return true;
}

Direktívou $this->Auth->authorize = ‚controller‘ sme určili, že komponenta bude overovať prístup ku controlleru a jeho akciám. Tento spôsob je najjednoduchší, preto ho použijeme, avšak medzi možnosti patrí aj overovanie prístupu k modelu.

Direktívou $this->Auth->allow(array(‚in­dex‘,‚view‘)); sme určili, že akcie view a index nebudú vyžadovať prihlásenie užívateľa, všetky ostatné akcie následne prihlásenie budú vyžadovať.

Ešte treba spomenúť metódu isAuthorized(), ktorá musí byť implementovaná, ak používame spôsob overovania controller. Do tejto metódy môžeme dať nejaké rozšírujúce podmienky súvisiace s overovaním užívateľa, napr. po úspešnom overení mena a hesla užívateľa môžeme skontrolovať, či užívateľ je administrátor a pod. V našom prípade žiadne doplňujúce podmienky nemáme, takže metóda vracia priamo hodnotu true a jedinou podmienkou pre prihlásenie je úspešné overenie mena a hesla.

Aby sa mohol užívateľ úspešne prihlásiť, musíme ešte vytvoriť formulár na prihlasovanie a príslušné akcie v controlleri UsersController v súbore app/controller­s/users_contro­ller.php.

V súbore app/view/admin_lo­gin.ctp vytvoríme formulár pre prihlásenie užívateľa

<?php
if  ($session->check('Message.auth')) $session->flash('auth');
echo $form->create('User', array('action' => 'login'));
echo $form->input('username');
echo $form->input('password');
echo $form->end('Login');
?>

V súbore app/controller­s/users_contro­llers.php doplníme potrebné akcie

function admin_login() {
}

function logout() {
    $this->redirect($this->Auth->logout());
}

Teraz máme všetko pripravené pre úspešné prihlasovanie a odhlasovanie užívateľov. Ak si teraz skúsime zadať adresu example.com/ad­min/articles/add systém nás automaticky presmeruje na prihlasovací formulár na adrese example.com/ad­min/users/login a nedovolí nám bez prihlásenia a úspešného overenia mena a hesla vstúpiť na túto adresu. Po zadaní adresy example.com/u­sers/logout budeme odhlásení a presmerovaní na adresu example.com/ar­ticles presne tak, ako sme si to určili v AppController v metóde beforeFilter() direktívou $this->Auth->logoutRedirect = array(‚controller‘ ⇒ ‚articles‘,‚action‘ ⇒ ‚index‘)

V článku sme si predstavili dva možné spôsoby, ako vytvoriť admin rozhranie pre našu aplikáciu. Myslím si, že spôsob s pred pripraveným riešením CakePHP je oveľa praktickejší a poskytuje nám väčšiu flexibilitu. Taktiež sme si ukázali jednoduchý prihlasovací mechanizmus pomocou Auth komponenty.

Týmto je základná funkčnosť našej aplikácie kompletná a v budúcich častiach si ukážeme pokročilejšiu prácu v CakePHP, ako napríklad prácu s helpermi, ajaxom atď.

Na záver ešte poznamenám, že v prílohe sa nachádza kompletná ukážková aplikácia. Inštalačný skript pre databázu sa nachádza v súbore app/config/sql/in­stall.sql a prístup k databáze je potrebné nastaviť v súbore app/config/da­tabase.php

Rád uvítam vaše námety a pripomienky v diskusii k článku.

Na stiahnutie: zaciname-s-cakephp-6

Ako som už spomínal, v predchadzajúcej časti seriálu sme si controller stručne predstavili, v tomto prípade sme si ukázali použitie tzv. scaffolding. V tejto časti si controller predstavíme podrobne.

URL ako rozhranie aplikácie

Controller je tá časť aplikácie, ktorá ako prvá prichádza do styku s požiadavkami, ktoré prichádzajú do našej aplikácie z vonkajšieho sveta. Najčastejším prípadom takéhoto požiadavku z vonkajšieho sveta je URL adresa. Ak teda budeme pristupovať k našej aplikácii prostredníctvom URL, potrebujeme nejaký mechanizmus, ktorý nám na základe tejto URL určí, že aplikácia „pozná“ na aké prvky aplikácie má smerovať dané požiadavky. Takýto mechanizmus sa nazýva routing.

V minulosti sa formátu URL adresy veľká pozornosť nevenovala. Často sme boli svedkami podobných URL ako môžeme vidieť na ukážke

http://www.example.com/index.php?action=list&template=comments&page=2&order=DESC

URL adresa v takomto tvare bola možno jednoduchá pre programátora, určite však nie pre užívateľa. V súčasnosti je trend iný a hlavne moderné frameworky sa snažia vytvárať a používať tzv. user friendly url. Príklad takejto adresy môžeme vidieť na ukážke

http://www.example.com/articles/mvc-model-view-controller-v-cakephp

Určite nám je jasné, že takáto adresa je oveľa viac čitateľnejšia a zrozumiteľnejšia nie len pre užívateľa. Bližšie štúdium o tejto problematike ponechám na samotných čitateľov, pretože by to presahovalo záber tohto článku. Avšak výhody takýchto URL sú nespochybniteľné. Ako sme už určite vytušili, CakePHP používa taktiež user friendly url. Poďme sa teda bližšie pozrieť, akým spôsobom pristupujeme v CakePHP k našej aplikácii prostredníctvom url

V našom prípade by url adresa pre zobraznie článku v aplikácii v CakePHP mohla napríklad vypadať tak, ako môžeme vidieť na obrázku vyššie. Z url nám môže byť napríklad hneď jasné, že sa bude jednať o zobrazenie určitého článku. Obrázok taktiež demonštruje fungovanie routingu v samotnom CakePHP. Prvá časť adresy označená zelenou farbou nám určuje konkrétny controller v našej aplikácii, druhá časť označená červenou farbou nám určuje konkrétnu akciu v controlleri a posledná časť označená modrou farbou nám určuje parameter vkladaný do tejto akcie. Aby sme si vedeli túto situáciu predstaviť konkrétne, pozrime sa na nasledovný kód, ktorý by bol vykonaný pri použití url adresy z obrázku

class ArticlesController extends AppController{
     var $name="Articles";
     function show($id){
           $this­>set("article",$this­>Article­>findById($id));

     }
}

Mechanizmus routingu by zabezpečil, že by sa zavolala metóda show triedy ArticlesContro­ller a zároveň by bol metóde predaný parameter s hodnotou 43.

Url 100-krát inak

CakePHP nám v súvislosti s routingom ponúka ešte jednú veľmi užitočnú vlastnosť a to sú tzv. routovacie pravidlá. Na základe týchto pravidiel môžeme ovplyvňovať samotné routovanie a v neposlednom rade nás routovacie pravidlá zbavujú povinnosti ručne modifikovať súbory .htaccess, čím nám značne uľahčujú prácu, pretože používajú oveľa prehľadnejšiu syntaxu. Treba však poznamenať, že routavacie pravidlá zďaleka nenahradzajú možnosti súboru .htaccess, pretože to nie je ani ich cieľom. Ich cieľom je poskytnúť z jednodušenú syntaxu pri pravidlách, ktoré sa týkajú routovania a spracovávania samotných url adries.

Samotné routovacie pravidlá sa definujú v súbore app/config/rou­tes.php. Pozrime sa na ukážkový kód

Router::connect('/sites/*', array('controller' => 'articles', 'action' => 'index'));
Router::connect('/', array('controller' => 'articles', 'action' => 'index'));

Pomocou vyššie uvedených pravidiel sme určili, že url v tvare www.example.com/sites/* (kde znak * značí ľubovoľný tvar zvyšku adresy) bude routovaná na controller articles a že sa bude v tomto controlleri volať metóda index. Taktiež sme určili, že url v tvare www.example.com bude routovaná na vyšie spomínaný controller articles a jeho metódu index. Podrobné vysvetlenie všetkých možností použitia routovacích pravidiel je nad rámec tohto článku, ale určite v budúcnosti pripravím článok, ktorý vás kompletne prevedie svetom routovacích pravidiel v CakePHP.

Na záver tejto časti pripomeniem, že celý mechanizmus spracovávania požiadavku v CakePHP som rozoberal v článku MVC model view controller v CakePHP.

Vytvárame controller

Od minulého článku máme vytvorené jednotlivé controllere a to konkrétne ArticlesContro­ller, UsersController, CommentsContro­ller a TagsController. Avšak ako môžeme vidieť, naše controllere neobsahujú žiadne metódy resp. akcie, ktoré sú potrebné na správne fungovanie aplikácie tak, ako sme to spomínali v časti preberanej vyššie (aplikácia nám samozrejme fungovala aj tak, pretože sme využili scaffolding). Poďme si preto jednotlivé metódy vytvoriť a pripraviť si tak pôdu pre ich zobrazenie vo view.

V controlleri ArticlesContro­ller si vytvoríme dve metódy index a view, kde prvá bude reprezentovať akciu zobrazenie všetkých článkov a druhá bude reprezentovať akciu zobrazenie konkrétneho článku. Kód bude vypadať následovne

class ArticlesController extends AppController {

        var $name = 'Articles';
        var $helpers = array('Html', 'Form');

        function index() {
                $this->set('articles', $this->paginate());
        }

        function view($id = null) {
                if (!$id) {
                        $this->Session->setFlash(__('Invalid Article.', true));
                        $this->redirect(array('action'=>'index'));
                }
                $this->set('article', $this->Article->read(null, $id));
        }
}

V controlleri CommentsContro­ller si vytvoríme 3 metódy, kde metóda index sa bude starať o zobrazenie všetkých komentárov, druhou metódou bude metóda view, ktorá sa bude starať o zobrazenie konkrétneho komentára a poslednou treťou metódou bude metóda add ktorá nám pridá nový komentár. Kód bude vypadať následovne

class CommentsController extends AppController {

        var $name = 'Comments';
        var $helpers = array('Html', 'Form');

        function index() {
                $this->Comment->recursive = 0;
                $this->set('comments', $this->paginate());
        }

        function view($id = null) {
                if (!$id) {
                        $this->Session->setFlash(__('Invalid Comment.', true));
                        $this->redirect(array('action'=>'index'));
                }
                $this->set('comment', $this->Comment->read(null, $id));
        }

        function add() {
                if (!empty($this->data)) {
                        $this->Comment->create();
                        if ($this->Comment->save($this->data)) {
                                $this->Session->setFlash(__('The Comment has been saved', true));
                                $this->redirect(array('action'=>'index'));
                        } else {
                                $this->Session->setFlash(__('The Comment could not be saved. Please, try again.', true));
                        }
                }
                $articles = $this->Comment->Article->find('list');
                $this->set(compact('articles'));
        }
}

Posledným upravovaným controllerom bude controller TagsController, ktorému pre jednoduchosť vytvoríme len dve metódy, metóda index ktorá nám zobrazí všetky dostupné tagy a metóda view, ktorá nám zobrazí všetky články prislúchajúce k danému tagu. Kód bude vypadať následovne

class TagsController extends AppController {

        var $name = 'Tags';
        var $helpers = array('Html', 'Form');

        function index() {
                $this->Tag->recursive = 0;
                $this->set('tags', $this->paginate());
        }

        function view($id = null) {
                if (!$id) {
                        $this->Session->setFlash(__('Invalid Tag.', true));
                        $this->redirect(array('action'=>'index'));
                }
                $this->set('tag', $this->Tag->read(null, $id));
        }
}

K vyššie uvedeným kódom bližšie vysvetlím význam niektorých použitých metód, ktoré majú pre správne pochopenie celého mechanizmu zásadný význam. Metódou set() posielame dáta do view. Metóda prijíma dva parametre, kde prvý označuje názov premennej vo view a druhý parameter sú samotné dáta uložené do premennej s názvom určenom v prvom parametri (bližšie si túto časť vysvetlíme neskôr, kedy budeme dáta zobrazovať). Metóda paginate() sa nám stará o stránkovanie veľkého množstva dát (túto vlastnosť si predstavíme v niektorej z ďalších častí nášho seriálu). Metóda Session->setFlash() nám nastaví chybovú hlášku pre layout, ktorú môžeme jednoducho v našom layoute zobraziť na mieste, kde budeme chcieť. Metóda redirect() sa postará o presmerovanie behu našej aplikácie buď pomocou zadanej url adresy alebo pomocou určenia controllera a akcie. Premenná $this->data reprezentuje dáta odoslané formulárom z view.

Určite vás napadlo, že sme v našich controlleroch nikde neuvádzali akcie pre pridanie článku, pridanie tagu, administrácie užívateľov atď. Je to náš zámer, pretože dané akcie patria do administračného rozhrania, ktorému sa budeme venovať v nasledujúcej časti seriálu.

Zobrazujeme dáta

Už sme si spomenuli metódu, ktorá nám posiela dáta do view pochádzajúce z našich modelov. Správne tušíte, že sa jedná o metódu set() a pochopenie jej práce je pre ďalšie časti kľúčové. Ako som spomenul, príjíma dva parametre, prvý parameter je názov premennej vo view a druhým parametrom sú samotné dáta, ktoré sa vložia do premennej s názvom určenom v prvom parametri. Aby sme neostali len pri teórii, poďme si ich význam ukázať na príklade.

Zoberme kód nášho controllera ArticlesContro­ller a jeho metódu view, ktorá reprezentuje akciu pre zobrazenie konkrétneho článku. Užívateľ zadá do prehliadača url www.example.com/articles/view/1 čím určí, že chce zobraziť článok s id 1. Mechanizmus routingu správne vyhodnotí url a určí, že sa vykoná metóda view v controlleri ArticlesContro­ller. Táto metóda najprv otestuje, či sme zadali nejaké id článku, ak áno, pomocou modelu vyberie dáta z tabuľky articles ($this->Article->read(null, $id)) a následne ich vloží do view pod premennou article ($this->set(‚article‘, $this->Article->read(null, $id))). Potom už je naša práca veľmi jednoduchá a dáta možeme zobraziť.

Súbory s našimi šablónami sa ukladajú do adresára app/views. V našom prípade pre zobrazenie článku to bude adresár app/views/arti­cles/view.ctp. Náš súbor view.ctp, ktorý zobrazuje konkrétny článok, by mohol vypadať následovne

<div class="articles view">
<h2><?php  __('Article');?></h2>
        <dl><?php $i = 0; $class = ' class="altrow"';?>

                <dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Id'); ?></dt>
                <dd<?php if ($i++ % 2 == 0) echo $class;?>>
                        <?php echo $article['Article']['id']; ?>
                        &nbsp;
                </dd>

                <dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Title'); ?></dt>
                <dd<?php if ($i++ % 2 == 0) echo $class;?>>
                        <?php echo $article['Article']['title']; ?>
                        &nbsp;
                </dd>

                <dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Text'); ?></dt>
                <dd<?php if ($i++ % 2 == 0) echo $class;?>>
                        <?php echo $article['Article']['text']; ?>
                        &nbsp;
                </dd>

                <dt<?php if ($i % 2 == 0) echo $class;?>><?php __('User'); ?></dt>
                <dd<?php if ($i++ % 2 == 0) echo $class;?>>
                        <?php echo $html->link($article['User']['id'], array('controller'=> 'users', 'action'=>'view', $article['User']['id'])); ?>

                        &nbsp;
                </dd>
                <dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Created'); ?></dt>
                <dd<?php if ($i++ % 2 == 0) echo $class;?>>
                        <?php echo $article['Article']['created']; ?>

                        &nbsp;
                </dd>
        </dl>
</div>

Teraz nám už je jasné, akým spôsobom zobraziť dáta vo view. V controlleri sme si vložili do view dáta pod premennou article a vo view sme na základe tejto premennej dáta jednoducho zobrazovali (napr. $article[‚Arti­cle‘][‚title‘] zobrazí titulok článku). Ešte poznamenám, že nám nemusí byť jasné, aký význam má metóda __(‚Created‘). Táto metóda súvisí s internaciona­lizáciou stránky a CakePHP na toto myslí už od počiatku vývoja aplikácie. Bližšie sa o internaciona­lizácii môžete dočítať v článku Viacjazyčný web v cakePHP.

Formát zobrazovaných dát

Už vieme ako vložiť dáta do view, poďme sa pozrieť nato, v akom formáte sa nám dáta z modelu do view dostávajú. Model všeobecne mapuje dáta do viacrozmerných polí. V podstate nám nastávajú dve možnosti pri vkladaní dát z modelu do view. Prvou možnosťou je, že nám model vráti jeden záznam a druhou možnosťou je, že nám model vráti viac záznamov. Obidva prípady si ukážeme priamo na príklade.

Pozrime sa na situáciu, kedy nám model vráti jeden záznam. Predstavme si, že chceme zobraziť jeden článok, formát dát bude nasledovný

Array
(
    [Article] => Array
        (
            [id] => 46
            [seo_link] => 5-tvorime-cms-s-cakephp-controller-a-view
            [title] => 5. Tvoríme CMS s CakePHP - Controller a View
            [intro_text] => V predchádzajúcej časti seriálu sme si navrhli a vytvorili databázu...
        )
)

Ako môžeme vidieť vyššie, model nám vratil dvojrozmerné pole, kde prvý index je názov modelu, z ktorého data pochádzajú a druhý index je názov stĺpca v databázovej tabuľke.

Odlišná situácia nastane, keď nám model vracia viac záznamov. Predstavme si, že chceme zobraziť zoznam článkov, formát dát bude nasledovný

Array
(
    [0] => Array
        (
            [Article] => Array
                (
                    [id] => 46
                    [seo_link] => 5-tvorime-cms-s-cakephp-controller-a-view
                    [title] => 5. Tvoríme CMS s CakePHP - Controller a View
                    [intro_text] => V predchádzajúcej časti seriálu sme si navrhli a vytvorili databázu...
                 )
         )
    [1] => Array
        (
            [Article] => Array
                (
                    [id] => 41
                    [seo_link] => ako-poslat-email-s-prilohou
                    [title] => Ako poslať email s prílohou
                    [intro_text] => Nedávno som v jednom z mojich projektov riešil situáciu, kedy bolo potrebné k odosielanému emailu pripojiť aj prílohu...
                 )
         )
)

Ako môžeme vidieť vyššie, model nám vrátil trojrozmerné pole, kde prvý index určuje index záznamu v poli v rozmädzí od [0;n-1], kde n-1 je počet vrátených záznamov. Druhý index je názov modelu, z ktorého dáta pochádzajú a posledný tretí index je názov stĺpca v databázovej tabuľke.

Treba ešte poznamenať, že model nám môže vrátiť aj zložitejšie štruktúry, avšak práca s nimi je obdobná. Keď si nebudeme istý formátom dát vo view, môžeme použiť metódu var_dump() resp. pri zapnutom debug móde metódu debug() priamo z CakePHP.

Týmto je táto časť nášho seriálu u konca. Jej cieľom bolo pochopenie základných princípov archiktúry MVC a to konkrétne controller a view. Nedotkli sme sa niektorých tém, ktoré s danými časťami súvisia, akú sú napr. helpery, komponenty atď. Nemusíte sa obávať, určite sa k nim dostaneme v niektorej z ďalších častí.

Rád uvítam vaše námety a pripomienky k článku.

Konvencie CakePHP

Aby sme vedeli správne navrhnúť databázu, a CakePHP na jej základe správne chápal väzby medzi tabuľkami, je potrebné poznať konvencie pre návrh databáze. Čo myslíme tým, aby CakePHP správne chápal väzby medzi tabuľkami? Znamená to, že ak budeme mať databázu správne navrhnutú, framework bude automaticky rozpoznávať cudzie kľúče, primárne kľúče a väzby medzi tabuľkami, a nebudeme ich musieť pre každú tabuľka explicitne zadávať.

Ešte je dobré poznamenať, že je veľmi rozumné zadávať názvy tabuliek, modelov atď. v anglickom jazyku. CakePHP automaticky chápe anglické jednotné a množné čísla, takže sa vyhneme zbytočným nastavovaniam (samozrejme je možné zadávať názvy aj v národných jazykoch, ale je to práca naviac a my preto budeme používať anglické konvencie).

Názvy tabuliek

Názvy tabuliek sa zapisujú pomenovaním v množnom čísle jednotiek, ktoré uchovávajú. Napríklad máme tabuľku, ktorá uchováva články, preto musí byť táto tabuľka pomenovaná v množnom čísle, v našom prípade articles.

Primárny kľúč

Primárny kľúč sa v tabuľkách označuje pomenovaním id. Taktiež platí, že môžeme používať aj iné pomenovanie pre primárny kľúč, ale opäť to musíme nastaviť.

Cudzie kľúče

Cudzie kľúče sa sa v tabuľkách označujú podľa tabuľky, kde sa pôvodne nachádzajú. Predstavme si, že každý článok má svojho autora. Čiže budeme mať dve tabuľky a to articles a users. V tabuľke articles sa bude potom pochopiteľne nachádzať cudzí kľúč z tabuľky users a to pomenovaním user_id. Čiže nám je hneď zrejmé, že cudzí kľúč sa tvorí podľa konvencie jednotne_cislo_ta­bulky_cudzieho_klu­ca_id.

Názvy atribútov

Ešte spomeniem, že je celkom vhodné, aby sa atribút názov pomenovával ako name. Oceníme to najmä pri generovaní select boxov vo väzbách 1:N, kde si budeme chcieť napríklad pri článku zvoliť kategóriu výberom z niekoľkých možností.

Spojovacia tabuľka pri väzbe N:M

Tabuľky ktoré sú vo väzbe N:M abecedne zoradíme a následne novú tabuľku pomenuje podľa konvencie nazov_prvej_ta­bulky_nazov_dru­hej_tabulky. Predstavme si, že náš článok má N nálepiek a jedna nálepka môže byť v M článkoch. Máme teda tabuľky pomenované articles a tags a následne vytvoríme spojovaciu tabuľku, ktorú pomenujeme articles_tags. Cudzie kľúče do spojovacej tabuľky vytvoríme podľa konvencií, ktoré sme si definovali vyššie.

Navrhujeme databázu

Na obrázku môžeme vidieť našu databázu pre náš nový redakčný systém, ktorú sme navrhli na základe vyššie definovaných konvencií

Modely tabuliek

Databázu už máme správne navrhnutú a môžeme sa pustiť do tej najzaujímavejšej časti, a to je návrh databázovej vrstvy našej aplikácie tzv. Modelu, čo je jedna z troch častí návrhového vzoru Model View Controller. Ako sme si už spomínali v predchádzajúcom článku, modely sa umiestňujú do adresára app/models. V našom prípade vytvoríme 4 modely, i keď máme tabuliek spolu 5. Ako sme si už spomínali, model sa pre spojovaciu tabuľku nevytvára a kedže máme databázu správne navrhnutú, všetku potrebnú prácu v súvislosti so spojovacou tabuľkou vykoná Cake automaticky. Predtým, než začneme vytvárať samotné modely treba poznamenať, že model sa pomenováva ako jednotné číslo názvu tabuľky, čiže napr. pre našu tabuľku articles sa bude model nazývať article a bude umiestnený v súbore app/models/ar­ticle.php

Model Article umiestený v súbore /app/models/ar­ticle.php

<?php
class Article extends AppModel {

        var $name = 'Article';
        var $useTable = 'articles';
        var $validate = array(
                'title' => VALID_NOT_EMPTY,
                'text' => VALID_NOT_EMPTY,
                'user_id' => array('numeric'),
                'created' => array('date')
        );

        var $belongsTo = array('User');
        var $hasAndBelongsToMany = array('Tag');
        var $hasMany = array('Comment');
}
?>

Model User umiestnený v súbore /app/models/u­ser.php

<?php
class User extends AppModel {

        var $name = 'User';
        var $useTable = 'users';
        var $validate = array(
                'username' => VALID_NOT_EMPTY,
                'password' => VALID_NOT_EMPTY
        );

        var $hasMany = array('Article');

}
?>

Model Comment umiestnený v súbore /app/models/com­ment.php

<?php
class Comment extends AppModel {

        var $name = 'Comment';
        var $useTable = 'comments';
        var $validate = array(
                'title' => VALID_NOT_EMPTY,
                'text' => VALID_NOT_EMPTY,
                'username' => VALID_NOT_EMPTY,
                'article_id' => array('numeric')
        );

        var $belongsTo = array('Article');

}
?>

Model Tag umiestnený v súbore /app/models/tag­.php

<?php
class Tag extends AppModel {

        var $name = 'Tag';
        var $useTable = 'tags';
        var $validate = array(
                'name' => VALID_NOT_EMPTY,
                'seo_link' => VALID_NOT_EMPTY
        );

        var $hasAndBelongsToMany = array('Article');

}
?>

Ako môžeme vidieť vyššie, v kóde sme už uviedli aj validačné kritéria, ktoré sme si priblížili už v predchádzajúcej časti seriálu. Využívať ich však budeme až v časti nasledujúcej, v ktorej sa budeme venovať vytváraniu zvyšných dvoch častí architektúry MVC a to Controller a View.

Aby sme si mohli otestovať, či sme našu databázu skutočne navrhli správne, môžeme využiť tzv. scaffolding. Cake nám pomocou scaffolding dokáže na základe vytvorených modelov automaticky skonštruovať ukážkovú aplikáciu, pomocou ktorej môžeme otestovať, či nám väzby v našej tabuľke fungujú správne. Potrebujeme však ku každému modelu vytvoriť Controller, v ktorom určíme, že Cake má používať na vytvorenie aplikácie scaffolding (ako som už spomínal vyššie, controlleru sa budeme venovať v nasledujúcej časti, preto nám teraz stačí bez hlbšieho vysvetlenie skopírovať jednotlivé kódy konkrétnych súborov s controllermi).

Controller Articles umiestnený v súbore /app/controller­s/articles_con­troller.php

<?php
class ArticlesController extends AppController {

        var $name = 'Articles';
        var $scaffold;
}
?>

Controller Users umiestnený v súbore /app/controller­s/users_contro­ller.php

<?php
class UsersController extends AppController {

        var $name = 'Users';
        var $scaffold;
}
?>

Controller Comments umiestnený v súbore /app/controller­s/comments_con­troller.php

<?php
class CommentsController extends AppController {

        var $name = 'Comments';
        var $scaffold;
}
?>

Controller Tags umiestnený v súbore /app/controller­s/tags_contro­ller.php

<?php
class TagsController extends AppController {

        var $name = 'Tags';
        var $scaffold;
}
?>

Skúste si zadať do url prehliadača napríklad adresy

www.tvoja-adresa/articles, www.tvoja-adresa/comments alebo www.tvoja-adresa/users.

Aké jednoduché však? Scaffolding je mocný nástroj tohto frameworku a dokáže nám značne uľahčiť prácu pri návrhu zložitejších vzťahov v databáze, preto určite stojí zato ho v rannom štádiu vývoja používať.

Rád uvítam vaše námety a pripomienky v diskusii k článku.

Na stiahnutie: zaciname-s-cakephp-4

V minulej časti sme si povedali o základnej inštalácii celého frameworku a pre začiatok sme si vysvetlili, ako funguje základné rozloženie stránky. V dnešnej časti si predstavíme srdce celého CakePHP a ukážeme si, ako správne dodržiavať konvencie Cake v súvislosti s návrhom databáze. Samotný návrh databázy príde na radu v nasledujúcej čas­ti.

Active Record

Active Record je srdce CakePHP a dokonale demonštruje princípy, na akých je Cake postavený.

Active Record je návrhový vzor, ktorý mapuje databázové tabuľky na triedy, riadky na objekty a stĺpce na ich atribúty (Toto však v Cake nie je úplne tak, rozdiel je v tom, že aktuálne sa riadky a stĺpce mapujú na dvojrozmerné polia. Mapovanie na objekty je naplánované na verziu 2.0). Z názvu triedy modelu teda jednoducho odvodíme názov tabuľky, napr. máme model Article, a k nemu patrí tabuľka articles (vždy množné číslo od názvu modelu). Zároveň active record umožňuje definovať vzťahy medzi tabuľkami (hasMany, belongsTo, hasManyAndBelon­gsTo…), okrem toho obsahuje výkonné nástroje pre prácu s dátami, ako je zápis, čítanie, validácia.

Čo teda Active Record prináša do našej práce? Najdôležitejšia a podstatná vec je, že nám značne uľahčuje prácu s databázou, kde v konečnom dôsledku nemusíme písať SQL. Koľko práce trávime písaním, ladením sql dotazov, následné mapovanie výsledkov atď. Active Record nám umožňuje pracovať na oveľa vyššej intelektuálnej úrovni. Poďme sa pozrieť na nasledujúci príklad:

Máme tabuľku Articles, v ktorej máme uložené jednotlivé články. Bežným spôsobom chceme vybrať konkrétny článok SELECT * FROM articles WHERE id = 1

+----+-------------+--------------------+--------+---------------------+
| id | title       | text               | user   | created             |
+----+-------------+--------------------+--------+---------------------+
|  1 | Titulok     | Text               | Linus  | 0000-00-00 00:00:00 |
+----+-------------+--------------------+--------+---------------------+

V Cake si vytvoríme triedu Article (uložíme ju do súboru /app/models/ar­ticle.php), ktorá nám bude reprezentovať tabuľku articles (názov tabuľky je množné číslo názvu modelu)

class Article extends AppModel{
  var $name = 'Article';
}

A pomocou príkazu $this->Article->find(1); dostaneme požadovaný výsledok

Article =>
id: 1
title: Titulok
text: Text
user: Linus
created: 0000-00-00 00:00:00

Pôsobivé však? Ako sme si uviedli v prvej časti, konvencia má prednosť pred konfiguráciou, preto Cake automaticky predpokladá, že keď máme model nazvaný Article, v našej databáze existuje tabuľka nazvaná articles. Ak by sme však chceli zmeniť názov tabuľky a nepoužívať tak automatické konvecie, môžeme tak urobiť následovne

class Article extends AppModel{
  var $name = 'Article';
  var $useTable = 'clanky';
}

Vyššie sme si povedali, že Active Record obsahuje efektívne metódy nielen pre čítanie dát, ale aj pre ich manipuláciu. Poďme teda zmeniť titulok nášho článku

$article = $this->Article->find(1);
$article['Article']['title'] = 'nový titulok';
$this->Article->save($article);

po uložení môžeme vidieť obsah tabuľky

+----+-------------+--------------------+--------+---------------------+
| id | title       | text               | user   | created             |
+----+-------------+--------------------+--------+---------------------+
|  1 | nový titulok| Text               | Linus  | 0000-00-00 00:00:00 |
+----+-------------+--------------------+--------+---------------------+

A máme hotovo. Jednoduchšie to už ani nemôže byť. Absolútny rozdiel od spôsobu, kde by sme museli písať sql ako select…, potom update… je značný. Možností využitia Active Record je mnoho

• $this->Article->findById(1) ⇒ vráti článok s id 1
• $this->Article->findAll(null,a­rray(‚title,‘tex­t’),‚Article.cre­ated desc‘) ⇒ vráti články zotriedené podľa dátumu vytvorenia, a vyberú sa len stĺpce title a text
• $this->User->findByName(‚Li­nus‘) ⇒ vráti autora s menom Linus

Bolo by asi zbytočné vypisovať tu ďalšie ukážky a demonštrovať tak silu Active Record. Pre jednotlivé metódy a ich parametre odporúčam pozrieť oficiálnu dokumentáciu. Okrem iného sme si povedali, že Active Record nám nedáva len nástroje pre manipuláciu s dátami, ale poskytuje nám taktiež možnosť validácie vstupných dát a určenie vzťahov medzi tabuľkami.

Validácia vstupných dát je jednou zo základných podmienok bezpečnosti a správnej funkcie webovej aplikácie. Active Record preto obsahuje vstavanú a veľmi prepracovanú validáciu, ktorá nám uľahčí množstvo práce. Chceme určiť, aby titulok článku nebol pri uložení prázdny

class Article extends AppModel{
   var $name = 'Article';
   var $validate = array(
           'title' => VALID_NOT_EMPTY,
           );
}

Týmto sme určili, že pri uložení článku, musí byť vždy atribút title neprázdny. Preto, keď sa pokúsime uložiť článok následovne, dostaneme chybovú hlášku, ktorá nás upozorní, že titulok článku nemôže byť prázdny.

$article = $this->Article->find(1);
$article['Article']['title'] = '';
$this->Article->save($save);

This field cannot be left blank

Používať môžeme aj niekoľko validačných kritérie pre jeden atribút. Chceme napríklad určiť, aby náš titulok nebol prázdny a zároveň, aby mal minimálne 5 znakov a maximálne 100 znakov, nie je nič jednoduchšie

class Article extends AppModel{
   var $name = 'Article';
   var $validate = array(
        'title' => array(
            'required' => VALID_NOT_EMPTY,
            'length' => array( 'rule' => 'validateLength', 'min' => 5, 'max' => 100 )
        ),
   );
}

Sami vidíte, že jednoduchšie to už ani nemôže byť. A k tomu ešte platí, že Cake automaticky vypĺňa hodnotu prvku formulára, pri neúspešnom uložení generuje chybovú hlášku pre každý prvok formulára (podľa určenia validácie v modely) a umožňuje nám určiť taktiež aj iné validačné pravidlá ako VALID_NUMBER, VALID_YEAR, resp. ľubovoľný vlastný regulárny výraz. Z tohto nám musí byť jasné, koľko práce, kódu a starostí máme ušetrených.

Posledná vec, ktorú spomeniem pri Active Record sú vzťahy medzi tabuľkami. Active Record umožňuje mapovať vzťahy medzi tabuľkami ako napríklad 1:N, M:N atď. Vezmime si náš prechádzajúci príklad. Určite budeme chcieť mať autorov v osobitnej tabuľke. Vytvoríme si preto novú tabuľku s názvom users. Každý článok bude mať práve jedného autora a autor môže mať niekoľko článkov, čiže tu máme väzbu 1:N. Kód bude nasledovný

class Article extends AppModel{
  var $name = 'Article';
  var $belongsTo = 'User';
}

class User extends AppModel{
  var $name = 'User';
  var $hasMany = 'Article';
}

Poďme si vytvoriť nového autora a následne nový článok s daným autorom

$user['user']['name'] = 'Linus';
$user['user']['email'] = 'linus@aaa.com';
$this->user->save($user);

+----+-------------+--------------------+
| id | name        | email              |
+----+-------------+--------------------+
|  1 | Linus       | linus@aaa.com      |
+----+-------------+--------------------+

$article['Article']['title'] = 'titulok';
$article['Article']['text'] = 'text';
$article['Article']['user_id] = 1;
$this->Article->save($article);

+----+-------------+--------------------+-----------+---------------------+
| id | title       | text               | user_id | created             |
+----+-------------+--------------------+-----------+---------------------+
|  1 | titulok     | text               | 1         | 0000-00-00 00:00:00 |
+----+-------------+--------------------+-----------+---------------------+

To bolo jednoduché, keď sa teraz pozrieme na článok $this->Article->find(1), vidíme detaily, že nám všetko funguje správne

Article =>
id: 1
title: Titulok
text: Text
user: Linus
created: 0000-00-00 00:00:00
user =>

id: 1
name: Linus
email: linus@aaa.com

Aké jednoduché však? Nemuseli sme písať žiadne dodatočné sql dotazy, stále nám stačí príkaz $this->Article->find(1), jediné, čo je potrebné, je dodržiavať konvencie Cake a správne určiť vzťahy medzi tabuľkami (určiť správny vzťah medzi danými tabuľkami nám značne pomáha tzv. console, venovať sa jej budeme v niektorých z nasledujúcich častí) a v daných tabuľkách správne dodržiavať cudzie kľúče. Poďme sa preto pozrieť, ako vyzerajú dané tabuľky.

Z obrázku je jasné, že cudzí kľúč v tabuľke articles musí byť pomenovaný user_id čo sú dané konvencie Cake, aby framework mohol určiť, že sa jedná o cudzí kľúč z tabuľky users. Čiže vždy platí, že cudzí kľúč v tabuľke je zložený z jednotného číslo názvu tabuľky cudzieho kľúča a príslušného id, teda pre cudzí kľúč autora v tabuľke articles bude user_id.

Ako to bude s väzbou N:M? Opäť to bude veľmi jednoduché. Predstavme si situáciu, že článok môže mať niekoľko autorov a autor može mať niekoľko článkov. Tabuľky sú na sebe nezávislé a ich prepojenie bude zaisťovať špeciálna tabuľka, ktorú môžeme vidieť na obrázku

Opäť musíme dodržiavať konvencie Cake, aby všetko fungovalo správne. Názov tabuľky articles_users sa skladá z názvov tabuliek, ktoré sú vo vzťahu N:M, čiže articles a users a navyše tieto tabuľky musie byť zapísané v abecednom poradí a oddelené podtržítkom. Kód bude potom nasledovný

class Article extends AppModel{
  var $name = 'Article';
  var $hasAndBelongsToMany = array(
          'user' => array('className' => 'user',
                        'joinTable' => 'articles_users',
                        'foreignKey' => 'article_id',
                        'associationForeignKey' => 'user_id',
                           )
       );
}

class user extends AppModel{
  var $name = 'user';
  var $hasAndBelongsToMany = array(
          'Article' => array('className' => 'Article',
                        'joinTable' => 'articles_users',
                        'foreignKey' => 'user_id',
                        'associationForeignKey' => 'article_id',
                           )
       );
}

Ešte treba poznamenať, že model sa pre spojovaciu tabuľku articles_users nevytvára, vďaka dodržiavaniu konvencií Cake to nie je potrebné.

Týmto sme u konca. Dúfam, že sa mi podarilo zachytiť základné rysy a možnosti Active Record v CakePHP. Samotný návrh databáze a jej testovanie príde na radu v nasledujúcom článku.

Rád uvítam vaše námety a pripomienky v diskusii k článku.

V minulej časti sme si niečo málo povedali o základných vlastnostiach a prednostiach CakePHP. Počnúc touto časťou bude každý diel venovaný tvorbe redakčného systému a na konkrétnych ukážkach si predstavíme jednotlivé prednosti a vlastnosti tohto skvelého frameworku.

1. krok – získavame framework

Základný balík si môžete stiahnuť priamo zo stránok CakePHP – download sekcia. V dobe písania tejto časti je aktuálna vývojová verzia 1.2.0.6311-beta. Po stiahnutí balíka rozbalíme príslušné súbory do adresára cakephp a umiestníme ho do zložky, kde bude prístupný webovému serveru (v mojom prípade je to zložka ~/www/cakephp a následne sa môžeme po spustení webového servera napr. Apache odkazovať na adresár prostredníctvom adresy http://localhost/cakephp). Týmto máme všetky potrebné súbory skopírované a framework pripravený k použitiu.

2. krok – prvé kroky

Medzi prvé kroky patrí nastavenie práv pre zápis pre adresár app/tmp/cache a zmena predvoleného hashovacieho stringu v súbore app/config/co­re.php

Configure::write('Security.salt', 'DYhG93b0asdf97473qyJfIxfs2guVoUubWwvniR2G0FgaC9mi');

Po zadaní adresy do webového prehliadača, v našom prípade http://localhost/cakephp, môžeme vidieť úvodnú obrazovku, ktorou nás CakePHP privíta a ktorá zároveň indikuje, že sa nám framework podarilo úspešne nainštalovať.

Ako môžeme vidieť na obrázku, Cake nám taktiež oznamuje, že nemáme nastavený prístup k databáze a to oznámením Your database configuration file is NOT present. Treba nám premenovať súbor app/config/da­tabase.php.de­fault na app/config/da­tabase.php a v ňom upraviť nasledovnú časť (jednotlivé položky sú dosť intuitívne a nemusím ich predstavovať)

var $default = array(
        'driver' => 'mysql',
        'persistent' => false,
        'host' => 'localhost',
        'port' => '',
        'login' => 'user',
        'password' => 'password',
        'database' => 'database_name',
        'schema' => '',
        'prefix' => '',
        'encoding' => ''
);

Ak doplníme správne hodnoty a Cake bude schopný pripojiť sa k databáze, oznámi nám to nasledovnou hláškou Your database configuration file is present. Cake is able to connect to the database. Pre pokročilé možnosti pripojenia k databáze si môžete prečítať článok Pripojujeme sa k databáze v CakePHP

3. krok – upravujeme vzhľad

Na obrázku vyššie môžeme vidieť defaultný vzhľad CakePHP po prvom spustení. My si chceme však vzhľad prispôsobiť podľa vlastných potrieb. Nato, aby sme chápali, ako sa vykresľuje celý vzhľad, pozrime si nasledujúci obrázok

Modrou farbou je vykreslený tzv. layout stránky, ktorý sa vkladá do každej zobrazenej stránky a ak neurčíme inak, je pre všetky zobrazené stránky rovnaký (môžeme si to predstaviť, že na každej stránke so zobrazí napr. logo a práve dané logo bude umiestnené v jednom jedinom súbore, ktorý sa nazýva layout). Žltou farbou môžeme vidieť konkrétny view, pod ktorým si môžeme predstaviť napr. zoznam článkov, komentárov, noviniek atď.

Keď už vieme, ako celý zobrazovací mechanizmus pracuje, môžeme sa pustiť do prvých úprav. Najprv si zmeníme text úvodnej stránky v samotnom view a to vytvorením súboru app/views/pages/ho­me.ctp a vložením skúšobného textu do novovytvoreného súboru. Po úprave môžeme vidieť niečo obdobné

Defaultný layout necháme nezmenený a pre tento seriál budeme používať pôvodný priamo z CakePHP. Ak by sme sa ho však rozhodli zmeniť, vytvorili by sme súbor **app/views/la­youts/default­.ctp” do ktorého by sme umiestnili napr. nasledovný kód

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<?p echo $html -> charset("utf-8"); ?>
<title><?php echo $title_for_layout?></title>
<? echo $html -> css("stylesheet"); ?>
<? echo $javascript -> link("scriptaculous/prototype.js"); ?>

</head>

<body>
<div id="container">
<div id="header">
    <div id="menu">
    </div>
</div>

<?
        if ($session->check('Message.flash')):
                        $session->flash();
        endif;
?>
<div id="content">
        <?php echo $content_for_layout ?>
</div>

<div id="footer">
        <a href="mailto:tibor.pino@gmail.com">Vyrobil Tibor Piňo</a>

</div>
</div>
</body>
</html>

Jednotlivé časti layoutu si vysvetlíme neskôr, ale už aj teraz môžete vidieť, ako sa vkladajú css súbory, javascript súbory, ako sa zobrazuje view v layoute pomocou direktívy <?php echo $content_for_layout ?> atď.

A to by bolo pre túto časť zhruba všetko. V tejto časti sme sa už dostali k prvým úpravám vzhľadu, vysvetlili sme si ako funguje celý princíp zobrazovanie v Cake a taktiež ako si správne nakonfigurovať prístup k databáze. Týchto pár krokov nám stačí k ďalšej plnohodnotnej práci a v ďalšej časti si správne vytvoríme databázové tabuľky, vysvetlíme si vzťahy medzi jednotlivými tabuľkami a celý návrh otestujeme pomocou tzv. lešenia alebo scaffolding

Rád uvítam vaše nápady a pripomienky v diskusii k článku.

Trochu histórie

Začiatky CakePHP siahajú do roku 2005, kedy Michal Tatarynowicz vytvoril minimalistický framework nazvaný Cake. Tento framework vydal neskôr pod licenciou MIT, čím položil základ pre dnešný CakePHP. Mnohí by si mohli myslieť, že napriek krátkej existencii sa nejedná o vyspelý projekt, ale opak je pravdou a aj tento seriál bude ukážkou toho, akým silným nástrojom pri vývoji webových aplikácie CakePHP je.

Dáte si koláč?

Ako som už vyššie spomínal, jedná sa o open source projekt, ktorý vyvíja Cake Software Foundation a oficiálnu stránku projektu môžete nájsť na adrese www.cakephp.org

Jedná sa o framework postavený na skriptovacom jazyku PHP. Jednou z najväčších predností CakePHP je, že v jeho základnej kostre je inšpirovaný zrejme najlepším frameworkom súčasnosti a to Ruby on Rails. Frameworkov, ktorý sa taktiež inšpirovali RoR je mnoho, ale myslím si, že práve CakePHP je z nich najkomplexnejší.

Ak ste o danom frameworku ešte nepočuli, pozrite si najprv krátke video, v ktorom autor za pár minút naprogramuje kompletný blog: The Blog Tutorial. Hotovo? Tak Poďme ďalej. Video je určite pôsobivé a jasne ukazuje, čo prináša CakePHP do sveta PHP. Môžeme vidieť, že aplikácia akoby sa rozvíjala „sama od seba“. Prečo je tomu tak? Pretože sa nesústreďujeme na nudné veci, ako je konfigurácia, mapovanie url a nekonečné písanie sql dotazov. Všetky tieto základné veci fungujú ako keby „samy od seba“, takže sa môžeme sústrediť skutočne na samotnú logiku aplikácie. A prečo to takto funguje?

Konvencia má prednosť pred konfiguráciou

Celý vývoj aplikácií pod CakePHP je tomuto heslu podriadený. Každá webová aplikácia je si v základných rysoch podobná, naše požiadavky a potreby na aplikáciu nie sú nijak unikátne. V každej aplikácii sa pripájate k databáze, vyberáte dáta z databázy, transformujete dáta, ukladáte dáta do databázy, zobrazujete dáta užívateľovi atď.

Začínať písať aplikáciu od príkazu mysql_connect a donekonečna písať stále tie isté sql dotazy je veľmi vyčerpávajúce a neefektívne. Preto v CakePHP platí základné pravidlo konvencia má prednosť pred konfiguráciou. Toto pravidlo znamená to, že v aplikácii nastavujeme len to, v čom sa líši od ostatných, to ostatné funguje „akoby samo“. Vytvoríme napríklad model Article, ten automaticky bude hľadať dáta v tabuľke articles (názov tabuľky v databáze je vždy množné číslo od modelu), zmeniť to samozrejme môžeme, musíme tak urobiť sami.

DRY (Dont repeat yourself)

CakePHP je navrhnutý pre maximálnu efektivitu práce a skutočne umožňuje pracovať tak, aby sme kód napísali jedenkrát, a už ho len používali. Neskôr uvidíme, ako môžeme tento princíp využívať v takmer každej časti našej aplikácie.

Model View Controller

CakePHP je MVC framework. Čo teda to magické MVC znamená. MVC je ustálený návrhový vzor, ktorý nám umožňuje transparentne rozdeliť aplikáciu do niekoľkých vrstiev. Model sa stará o manipuláciu s dátami (ukladanie, výber, aktualizáciu atď) a následne predáva dáta Controlleru. V CakePHP tvorí model Active Record, čo je najdôležitejšia časť celého frameworku a podrobne sa jej budeme venovať v 3. časti seriálu. Controller riadi beh celej aplikácie a podľa požiadaviek zo strany užívateľa rozhoduje o chode celej aplikácie. View je prezentačná vrstva, ktorá dané dáta zobrazuje, čiže sa jedná o grafický výstup celej aplikácie.

Keď sa pozrieme na základnú adresárovú štruktúru aplikácie založenej na CakePHP môžeme vidieť nasledovné. Tieto základné časti tvoria srdce CakePHP aplikácie

• …
• models
  • behaviors
• views
  • helpers
• controllers
  • components

  …

Detailné informácie o implemntácii MVC v CakePHP môžete nájsť v článku MVC model view controller v CakePHP

Active Record

Ako som už vyššie spomínal, jedná sa o najdôležitejšiu časť celej aplikácie. V krátkosti si ukážeme jej možnosti. Predstavme si, že máme tabuľku s novinkami. Chceme vybrať konkrétnu novinku, zmeniť jej titulok a naspäť ju uložiť do databáze.

$news = $this->News->findById(1);
$news['News']['title'] = 'nový titulok';
$this->News->save($news);

Čo poviete? Jednoduché a elegantné. Žiadne zbytočné sql dotazy… Nechajme našu aplikáciu rásť „samú od seba“. Možnosti sú samozrejme široké a konkrétnu prácu si ukážeme neskôr.

Načo sa môžeme tešiť

V tomto seriály si vytvoríme redakčný systém s možnosťou spravovať články, novinky, komentáre, užívateľov… Taktiež si ukážeme základy práce s ajaxom a ďalšie konkrétne prednosti tohto frameworku. Pri vytváraní konkrétnej aplikácie budeme používať verziu 1.2.0.5875 pre-beta.

Táto časť bola trochu o teórii, v ktorej som skutočne iba v krátkosti zhrnul, čo vlastne CakePHP je. To čo môže priniesť do našej práce a efektívnosti, si ukážeme pri vytváraní konkrétnej webovej aplikácie.

Teším sa na vaše námety a pripomienky v diskusii.