In questo articolo forniremo un esempio pratico d'uso del framework CakePHP. L'esempio ci sarà utile per evidenziare la semplicità con cui è possibile sviluppare lo scheletro di molte applicazioni sfruttando le varie funzionalità messe a disposizione da CakePHP. Come ormai tradizione della maggior parte degli articoli che trattano framework per lo sviluppo rapido di applicazione implementeremo un semplicissimo sistema di blogging che potrà successivamente essere esteso per aderire alle proprie esigenze.
Vedremo come configurare CakePHP, impostare il database ed utilizzare lo scaffolding per generare automaticamente la struttura dei nostri script. È vivamente consigliata la lettura dei due precedenti nostri articoli: CakePHP: PHP per il Web 2.0 e CakePHP: il modello MVC.
Configurazione del framework ed impostazione del database
Per prima cosa, dopo aver correttamente installato il framework e configuratolo in base alle proprie esigenze, è necessario implementare la struttura delle tabelle che andremo ad utilizzare nel nostro esempio e configurare i parametri specifici legati al database ed alle opzioni strettamente collegate allo sviluppo della nostra applicazione d'esempio.
Per prima cosa creiamo la tabella che andrà a contenere i nostri post. Per poter sfruttare al massimo le potenzialità del framework utilizzeremo le convenzioni legate ai nomi che sono definite nelle linee guida dello sviluppo con CakePHP:
CREATE TABLE posts
(
id INT UNSIGNED AUTO_INCREMENT NOT NULL,
title VARCHAR(127) NOT NULL,
message TEXT NOT NULL,
created DATETIME DEFAULT NULL,
modified DATETIME DEFAULT NULL,
PRIMARY KEY(id)
);
/* Inseriamo qualche valore d'esempio */
INSERT INTO posts (title, message, created) VALUES ('Il primo post', 'Questo ` il primo post creato, ce ne saranno di altri!', NOW());
INSERT INTO posts (title, message, created) VALUES ('Il secondo post', 'Questo ` il secondo post creato, spero che ce ne saranno altri in futuro!', NOW());
Grazie alle semplici convenzioni adottate verrà automaticamente generato da CakePHP un modello chiamato Post, ed i campi created e modified verranno aggiornati direttamente ogni volta che si accederà in scrittura alla tabella o ad un record di quest'ultima.
Dopo aver eseguito il codice SQL sopra evidenziato, bisogna configurare il framework in modo che sia in grado di accedere correttamente ai dati. Per fare questo basta rinominare il file /app/config/database.php.default in /app/config/database.php e successivamente modificare l'assegnazione alla variabile $default in modo che i dati specificati aderiscano alle impostazioni del nostro server. Come driver è possibile utilizzare mysql, e come valore di connect mysql_pconnect, in modo da mantenere persistente la connessione tra varie sessioni.
Presi questi semplici ma necessari accorgimenti è possibile abilitare la riscrittura degli URL grazie al modulo mod_rewrite, in modo che questi siano più leggibili. Come accennato negli articoli precedenti è buona norma adottare questa soluzione, soprattutto se si desidera una completa indicizzazione del proprio sito ed un meccanismo di URL più semplice da ricordare.
Modelli, viste e controller
Ora è possibile passare a qualcosa di più interessante, come l'implementazione dei modelli, dei controller e delle viste che ci permetteranno di completare la nostra applicazione.
Il modello utilizzato in realtà sarà solamente uno e verrà utilizzato per accedere alla tabella posts precedentemente creata. Fortunatamente il modello è molto semplice e CakePHP fornisce una serie di automatismi che permettono di spendere veramente poco codice per definire un modello di base (che andrà salvato all'interno di /app/models/post.php):
<?php
class Post extends AppModel
{
var $name = 'Post';
var $validate = array(
'title' => VALID_NOT_EMPTY,
'message' => VALID_NOT_EMPTY
);
}
?>
Il modello così definito esporrà automaticamente tutte le funzionalità di cui si è discusso nei capitoli precedenti; per comodità abbiamo aggiunto anche due validatori che controllano che i dati che verranno assegnati a title e message non siano vuoti.
Ora che il modello è stato creato possiamo passare all'implementazione del controller che si occuperà di gestirlo. Il controller esporrà un metodo per visualizzare i post inseriti, uno per aggiungerli ed uno per eliminarli. Come richiesto da CakePHP andrà inserito all'interno di /app/controllers con il nome di post_controller.php:
<?php
class PostsController extends AppController
{
var $name = 'Posts';
function index()
{
$this->set('posts', $this->Post->findAll());
}
function view($id)
{
$this->Post->id = $id;
$this->set('post', $this->Post->read());
}
function add()
{
// ...
}
function delete($id)
{
// ...
}
function edit($id)
{
// ...
}
}
?>
Il controller serve ad esporre i metodi necessari. Dato che abbiamo deciso di seguire le convenzioni sui nomi sarà possibile accedere ai modelli implementati direttamente attraverso $this->NOME_MODELLO. Il metodo index registra un array con tutti i post inseriti utilizzando il metodo set, che rende disponibile questo array alla vista che andremo successivamente a creare; il metodo view invece recupera solamente un determinato post in base al valore passato via URL dopo il path che indica la funzione da richiamare nel controller.
Le viste dei due metodi sono molto semplici e lineari. La prima visualizza la lista dei post iterando la variabile $post:
<h1>Tutti i post</h1>
<table>
<tr>
<th>Id</th>
<th>Titolo</th>
<th>Data</th>
</tr>
<?php foreach ($posts as $post): ?>
<tr>
<td><?php echo $post['Post']['id']; ?></td>
<td>
<?php echo $html->link($post['Post']['title'], '/posts/view/'.$post['Post']['id']);?>
<?php echo $html->link(
'Elimina',
"/posts/delete/{$post['Post']['id']}",
null,
'Sei sicuro ?'
)?>
<?php echo $html->link('Modifica', '/posts/edit/'.$post['Post']['id']);?>
</td>
</td>
<td><?php echo $post['Post']['created']; ?></td>
</tr>
<?php endforeach; ?>
</table>
La seconda invece visualizza le informazioni sul post selezionato:
<h1><?php echo $post['Post']['title']?></h1>
<p>
<small>Data: <?php echo $post['Post']['created']?></small>
</p>
<p>
<?php echo $post['Post']['message']?>
</p>
Passiamo ora all'implementazione degli altri due metodi leggermente più complessi. Il primo (add) si occupa di aggiungere un post alla lista; dato che si è deciso di utilizzare i validatori nel modello, verrà utilizzato l'helper $html per visualizzare automaticamente un errore in caso i dati non siano inseriti in modo corretto.
<?php
class PostsController extends AppController
{
var $name = 'Posts';
// ...
function add()
{
if (!empty($this->data))
{
if ($this->Post->save($this->data))
$this->flash('Nuovo post aggiunto !', '/posts');
}
}
}
?>
Il controller valuta che i dati inviati via POST attraverso la vista non siano vuoti ed in caso affermativo utilizza i metodi del modello post per salvare i dati segnalati. Grazie al metodo flash è possibile visualizzare, nella pagina di destinazione cui verrà reindirizzato il browser, un messaggio all'utente con le informazioni sull'avvenuto salvataggio dei dati. Il layout dei messaggi postati con flash può essere modificato nelle template standard.
La vista che si occupa di aggiungere il post è altrettanto semplice:
<h1>Aggiungi post</h1>
<form method="post" action="<?php echo $html->url('/posts/add')?>">
<p>
Title:
<?php echo $html->input('Post/title', array('size' => '40'))?>
<?php echo $html->tagErrorMsg('Post/title', 'Devi specificare un titolo.') ?>
</p>
<p>
Body:
<?php echo $html->textarea('Post/message', array('rows'=>'10')) ?>
<?php echo $html->tagErrorMsg('Post/message', 'Devi specificare un messaggio.') ?>
</p>
<p>
<?php echo $html->submit('Aggiungi') ?>
</p>
</form>
Grazie alla funzione tagErrorMsg dell'helper $html si può visualizzare un messaggio di errore solamente se la validazione dei dati in input al modello di destinazione non va a buon fine.
Possiamo quindi passare al metodo per eliminare i messaggi:
<?php
class PostsController extends AppController
{
var $name = 'Posts';
// ...
function delete($id)
{
$this->Post->del($id);
$this->flash("Il post è stato rimosso.", "/posts");
}
}
?>
Questo metodo verrà richiamato automaticamente quando l'utente selezionerà il link Elimina nella lista dei messaggi salvati (visualizzata utilizzando /posts/index).
Come ultimo passo ci occupiamo di implementare il metodo per la modifica di un messaggio e la sua vista; anche in questo caso la validazione e l'helper $html ci saranno di grande aiuto per semplificare il processo di inserimento dei dati:
<?php
class PostsController extends AppController
{
var $name = 'Posts';
// ...
function edit($id)
{
if(empty($this->data))
{
$this->Post->id = $id;
$this->data = $this->Post->read();
}
else
{
if ($this->Post->save($this->data['Post']))
$this->flash('Post aggiornato.','/posts');
}
}
}
?>
// Vista
<h1>Modifica</h1>
<form method="post" action="<?php echo $html->url('/posts/edit')?>">
<?php echo $html->hidden('Post/id'); ?>
<p>
Title:
<?php echo $html->input('Post/title', array('size' => '40'))?>
<?php echo $html->tagErrorMsg('Post/title', 'Non hai specificato il titolo.') ?>
</p>
<p>
Body:
<?php echo $html->textarea('Post/message', array('rows'=>'10')) ?>
<?php echo $html->tagErrorMsg('Post/message', 'Non hai specificato il messaggio.') ?>
</p>
<p>
<?php echo $html->submit('Modifica') ?>
</p>
</form>
Conclusioni
Eccoci giunti alla fine dell'articolo. Come avrete potuto constatare, con CakePHP il processo di creazione di uno script per la gestione di un semplice blog è un'operazione che richiede veramente poco tempo. Aggiungere dati al modello, azioni o modificare le viste sono tutte operazioni che, grazie al framework, sono quasi del tutto indipendenti da tutti quei processi ripetitivi e tediosi con cui spesso ci si trova di fronte usando direttamente PHP.
