Nella nostra applicazione di gestione di magazzino, possiamo immaginare di avere una tabella che cataloghi tutto il contenuto del magazzino. La tabella, molto semplicemente potrebbe essere:

CREATE TABLE `oggetti` (
`id` int(11) NOT NULL auto_increment,
`nome` varchar(50) collate utf8_unicode_ci NOT NULL,
`scaffale` int(11) NOT NULL,
`quantita` int(11) NOT NULL,
UNIQUE KEY `id` (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

Il modello corrispondente, quindi, potrebbe essere:

class Oggetti extends Model {
  var $nome;
  var $scaffale;
  var $quantita;

  function Oggetti () {
    parent::Model();
  }

  function mostra_tutti () {
    // estrae tutti gli elementi dal database
  }

  function mostra_scaffale ($id_scaffale) {
    // estrae gli elementi filtrandoli per scaffale
  }

  // più i soliti metodi crea, modifica, cancella,...
  function crea ($nome, $scaffale, $quantita) { }
  function modifica ($id, $nome, $scaffale, $quantita) { }
  function cancella ($id) { }
}

Quindi in buona sostanza una classe che implementi i classici metodi CRUD più altri metodi d’utilità.

Per interrogare il DB, CodeIgniter fornisce una versione del pattern Active Record che semplifica la creazione di query e ci permette di scrivere codice indipendente dal tipo di database usato (attualmente i driver disponibili sono mssql, mysql, mysqli, oci8, odbc, postgres e sqlite).

La classe ActiveRecord fornisce metodi per la selezione, la modifica, l’inserimento e la cancellazione di dati. Inoltre sono supportate le funzioni più comuni (sum, avg…), le join, le transazioni e molto altro.

A questo punto possiamo entrare più nel dettaglio delle nostre funzioni e fare qualche esempio pratico:

  function mostra_tutti () {
    $out = array();
    $this->db->select('nome, scaffale, quantita');
    $this->db->order_by('nome');
    $query = $this->db->get('oggetti');
    foreach ($query->result() as $row) {
      $out[] = $row;
    }
    return $out;
  }

Per semplificare la sintassi è anche possibile utilizzare il chaining dei metodi:

$query = $this->db->select('nome, scaffale, quantita')
              ->order_by('nome')
              ->get('oggetti');

Per quanto riguarda la modifica e l’inserimento invece basta passare ai metodi insert() e update() un oggetto o un array di valori. In questo caso passeremo l’oggetto $this, ma potremmo anche creare un array od un oggetto ad hoc.

  function crea ($nome, $scaffale, $quantita) {
    $this->nome = $nome;
    $this->scaffale = $scaffale;
    $this->quantita = $quantita;
    $this->db->insert('oggetti', $this);
  }

 function modifica ($id, $nome, $scaffale, $quantita) {
    $this->nome = $nome;
    $this->scaffale = $scaffale;
    $this->quantita = $quantita;
    $this->db->where('id', $id);
    $this->db->update('oggetti', $this);
  }

Molto semplicemente la cancellazione sarà:

  function cancella ($id) {
    $this->db->where('id', $id);
    $this->db->delete('oggetti');
  }

Rimando come al solito alla guida per un ulteriore approfondimento della classe Database e dell’ActiveRecord. Inoltre consiglio di dare anche un’occhiata al meccanismo di Caching di CodeIgniter che può alleggerire di molto il carico sul database.

A questo punto siamo pronti per il lato di presentazione della nostra applicazione: la view, che affronterò nella prossima lezione.

A Controller is simply a class file that is named in a way that can be associated with a URI.

In realtà il controller nel paradigma MVC è quello che si occupa di gestire l’input e l’output dell’utente creando una sorta di “ponte” tra model e view. In effetti il controller in CodeIgniter è entrambe queste cose.

Immaginiamo di dover scrivere un’applicazione per la gesitione di un magazzino. Scriveremo allora una classe controller chiamata Magazzino simile a questa:

class Magazzino extends Controller {
  function elenco() {
    // elenca tutto il contenuto del magazzino
  }

  function scaffale($codice_scaffale) {
    // elenca il contenuto di un determinato scaffale del magazzino
  }
}

Salvando questa classe nella cartella system/application/controller/magazzino.php automaticamente CodeIgniter renderà disponibile l’output dei due metodi che abbiamo scritto rispettivamente agli indirizzi: misito.com/index.php/magazzino/elenco e miosito.com/index.php/magazzino/scaffale/a12.

In particolare nel secondo caso passerà alla funzione scaffale il codice scaffale ‘a12′.

Ovviamente si possono passare più parametri alle funzioni che ne hanno bisogno continuando ad aggiungerli separati da /. Si può anche migliorare la leggibilità degli indirizzi rimuovendo “index.php” con un htaccess simile a:

RewriteEngine on
RewriteCond $1 !^(index\.php|images|robots\.txt)
RewriteRule ^(.*)$ /index.php/$1 [L]

Ma non basta, perchè CodeIgniter ci permette anche di organizzare i controller in cartelle e sottocartelle o di definire nuove regole di “routing” aggiungendo regole al file system/application/config/routes.php.

Per queste ed altre funzioni avanzate, rimando alla guida ufficiale di CodeIgniter, in particolare alla pagina Controllers e URI Routing.

Alla prossima lezione, in cui parleremo del Model.

Ho dato un’occhiata ai framework più usati ultimamente e ovviamente sono rimasto affascinato da CakePHP. L’uso del pattern MVC e della filosofia “convention over configuration” mi sembravano molto interessanti. Dopo averlo usato un pò, proprio a causa di quest’ultima scelta, ho deciso di cambiare strada e di provare qualcosa che promettesse di meno dal punto di vista di rapidità di sviluppo, ma che mi permettesse qualche libertà in più.

E così sono approdato a CodeIgniter, anche questo un ottimo esempio di implementazione del paradigma MVC, ma in più molto più libero da convenzioni di Cake. In più è semplicissimo da utilizzare (la curva di apprendimento di Cake è molto più ripida), è leggero (anche in termini di kB), funziona anche con PHP4.

Per iniziare a lavorare con CI, è sufficiente:

1. scaricarlo
2. estrarre i contenuti del file zippato sulla root o in una cartella del proprio server
3. modificare i file di configurazione che si trovano nella cartella system/application/config e in particolare config.php (la variabile $config['base_url']) e database.php (per la connessione al DB)

A questo punto tutto è pronto per scrivere il primo controller, argomento che afferonterò nella prossima lezione!