E’ finalmente giunto il momento di cominciare ad usare CodeIgniter. Come detto nel precedente step vediamo come strutturare i modelli della nostra applicazione all’interno del framework CodeIgniter, seguendo il pattern MVC su cui si basa.

Non mi dilungherò nel spiegare la struttura di CodeIgniter o in generale il pattern MVC. Per capire la struttura del primo e il significato del secondo vi consiglio di visitare la guida completa di codigniter e la pagina di wikipedia rispettivamente.

Vi ricordo soltanto che dobbiamo lavorare sempre all’interno della cartella /system/application.

Prima di cominciare dobbiamo però dire a CodeIgniter di precaricare la libreria “Database” dato che ci servirà pressoché dappertutto. Per farlo basta modificare il file /config/autoload.php modificando la riga

$autoload['libraries'] = array();

con

$autoload['libraries'] = array('database');

Fatto questo vediamo quindi i modelli della nostra applicazione.

il Modello “Item_model”

Come regola generale nominerò i modelli nella forma Nomemodello_model, quindi il nostro primo modello sarà Item_model e dovrà estendere la classe predefinita per i modelli di CodeIgniter, chiamata appunto “Model”:

<?php
class Item_model extends Model {
    ...
}
?>

All’interno del modello andremo a realizzare i vari metodi che ci servono per operare col nostro database. Ci serviranno i metodi per leggere gli elementi, per aggiungerli, modificarli o cancellarli. Partiamo dal metodo per leggerli:

function get() {
    $query = $this->db->get('items');
    return $query->result_array();
}

Come vedete abbiamo usato la libreria “Database” tramite $this->db e il metodo “get” che accetta come parametro il nome della tabella da cui prelevare i dati. Abbiamo assegnato il risultato di questo metodo alla variabile $query, ma per ottenere i risultati veri e propri dobbiamo richiedere i dati tramite il metodo result_array() che restituisce appunto un array di risultati.

Se avessimo voluto avremmo potuto usare il metodo result() che restituisce invece un oggetto contenente i risultati. Ci sono altri metodi risponibili, ad esempio row() e row_array() che restituiscono l’ultima riga. Fate riferimento alla guida per tutti i dettagli.

Tornando al nostro metodo “get”, questo ritornerà quindi un array con tutti gli elementi nel nostro database. Come ricorderete però sono presenti due chiavi esterne relative al tipo e allo stato, quindi se vogliamo avere tra i risultati anche queste informazioni dobbiamo “unire” queste tabelle tramite il metodo “join”:

function get() {
    $this->db->from('items');
    $this->db->join('types', 'items.type_id = types.id');
    $this->db->join('statuses', items.status_id = statuses.id');
    $query = $this->db->get();
    return $query->result_array();
}

Come potete vedere “join” accetta come primo parametro il nome della tabella e come secondo parametro la relazione tra i campi. Ho anche aggiunto il comando “from” per maggior chiarezza. Avrei infatti potuto ometterlo ed indicare la tabella “items” direttamente nel metodo “get”.

Naturalmente questo metodo non gestisce ancora né la paginazione né nessun tipo di ricerca o filtraggio, tuttavia avremo modo più avanti, in base alle necessità che ci occorrono, di provvedere ad integrare le funzionalità di cui avremo bisogno.

Aggiungiamo ora il metodo per aggiungere un elemento. Dato cheil metodo proposto dalla libreria “Database” accetta come parametro un array associativo con campi e valori, il nostro metodo ugualmente accetterà un array:

function add($item) {
    return $this->db->insert('items', $item);
}

Come potete notare questo metodo non aggiunge niente al metodo predefinito di CodeIgniter, tuttavia se in futuro avremo bisogno di effettuare qualche intervento sui dati prima di inserirli avremo modo di aggiungere le istruzioni, cosa impossibile da fare se avessimo usato direttamente la classe “Database”.

Per la cancellazione e la modifica i metodi sono molto simili:

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

function edit($item, $id) {
    $this->db->where('id', $id);
    return $this->db->update('items', $item);
}

Come vedete ho utilizzato “where” dato che andremo sempre a cancellare o modificare un singolo elemento, identificato tramite l’id.

Ricapitolando quindi la nostra classe al completo sarà

<?php
Class Item_model extends Model {
    function get() {
        $this->db->from('items');
        $this->db->join('types', 'items.type_id = types.id');
        $this->db->join('statuses', items.status_id = statuses.id');
        $query = $this->db->get();
        return $query->result_array();
    }
    function add($item) {
        return $this->db->insert('items', $item);
    }
    function delete($id) {
        $this->db->where('id', $id);
        return $this->db->delete('items');
    }
    function edit($item, $id) {
        $this->db->where('id', $id);
        return $this->db->update('items', $item);
    }
}
?>

I modelli “Status_model” e “Type_model”

Per quanto riguarda i modelli dei tipi e degli stati avremo più o meno le stesse funzionalità. Riporterò quindi direttamente il codice delle classi direttamente:

Class Status_model extends Model {
    function get() {
        $query = $this->db->get('statuses');
        return $query->result_array();
    }
    function add($status) {
        return $this->db->insert('statuses', $status);
    }
    function delete($id) {
        $this->db->where('id', $id);
        return $this->db->delete('statuses');
    }
    function edit($status,$id) {
        $this->db->where('id', $id);
        return $this->db->update('statuses', $status);
    }
}

E per i tipi:

Class Type_model extends Model {
    function get() {
        $query = $this->db->get('types');
        return $query->result_array();
    }
    function add($type) {
        return $this->db->insert('types', $type);
    }
    function delete($id) {
        $this->db->where('id', $id);
        return $this->db->delete('types');
    }
    function edit($type,$id) {
        $this->db->where('id', $id);
        return $this->db->update('types', $type);
    }
}

Ora che abbiamo il codice dobbiamo però salvarlo in qualche file. CodeIgniter ha una suddivisione molto logica dei vari files ed ogni classe ha la propria cartella: i modelli andranno in models, i controlli in controllers e via dicendo.

Per quanto riguarda i nomi dei files, per permettere a CodeIgniter di caricare automaticamente i files necessari basterà utilizzare lo stesso nome, però in minuscolo, del nostro modello. Ad es. “Item_model” dovrà chiamarsi item_model.php e via dicendo.

Questi sono quindi i modelli base da cui partire. Nel prossimo step vedremo come utilizzarli attraverso i controller. Come già accennato andremo probabilmente ad integrare alcune funzionalità nei nostri modelli in base alle necessità (ad esempio per implementare la ricerca). Il vantaggio di sviluppare su un framework o comunque con un pattern MVC è quello di poter intervenire nelle varie entità in gioco in maniera indipendente e trasparente. Paradossalmente se un giorno volessimo ad esempio cambiare totalmente strada e rimpiazzare il database con un file di testo, ci basterebbe cambiare opportunamente i modelli (o addirittura la sola libreria “Database”) e il resto dell’applicazione non se ne accorgerebbe…

Alla prossima!