In questo passaggio del tutorial a CodeIgniter vediamo finalmente l’elemento del framework che si occupa della logica dell’applicazione, e cioè il controller. Come vedremo questo elemento è quello che viene eseguito direttamente dall’utente ed è ciò che mette in comunicazione i dati (e cioè i modelli) con l’output (le viste).

CodeIgniter infatti, tramite la classe Routing, si occupa di leggere l’URL digitato e indirizzare all’apposito controller il metodo da eseguire. Ad esempio, digitando l’indirizzo http://www.dominio.com/index.php/nome_controller/nome_metodo/ CodeIgniter andrà a richiamare il controller nome_controller ed eseguirà il metodo nome_metodo. Se invece viene omesso nome_metodo verrà richiamato il metodo di default chiamato index.

Dal punto di vista del codice, un controller non è altro che una classe PHP che eredita dalla classe nativa Controller. Pertanto la sintassi base sarà:

class Mia_classe extends Controller {
    function Mia_classe() { //questo è il costruttore
        parent::Controller(); //richiamo il costruttore della classe “Controller”
    }

    function index() {
        //funzione richiamata di default
    }

    function mia_funzione() {
        //metodo personalizzato
    }
}

i controller vanno di norma salvati nella cartella /system/application/controllers, mentre il nome del file dovrà coincidere col nome della classe, quindi nell’esempio precedente questo dovrà chiamarsi mia_classe.php – Notare l’eliminazione delle maiuscole richiesta dal framework.

Tornando alla nostra applicazione, dato che abbiamo tre entità in gioco avremo bisogno di tre file separati. Ciò non è la regola, in quanto i controller vanno intesi più che altro come azioni da compiere. Nel nostro caso però, dato che andremo ad operare ogni volta su un elemento preciso in maniera abbastanza indipendente, ho preferito separarli in tre controller distinti anziché uno unico.

Partiamo dal controller delle tipologie (che sarà analogo a quello degli stati).

Prendendo come spunto il modello qui sopra, il nostro controller per gli stati sarà del tipo:

class Statuses extends Controller {
    function Statuses() {
        parent::Controller();
        $this->load->model(‘status_model’);
    }

    function index() {
        //funzione richiamata di default
    }
}

Come vedete nel costruttore Statuses() vado a caricare il modello status_model che mi servirà all’interno del controller.

Ora andiamo a popolare il metodo index() che ci servirà per la lista completa degli stati. Per farlo aggiungiamo:

$data[‘statuses’] = $this->status_model->get();
$this->load->view(‘list_statuses’, $data);

La prima riga si occupa di eseguire il metodo get del modello status_model e a salvarne l’output nell’array $data. Nella seconda riga invece andiamo a caricare la vista list_statuses passando i dati da visualizzare. CodeIgniter andrà a cercare la vista list_statuses.php all’interno della cartella /system/application/views. Vedremo in seguito come realizzare la vista, ma per quanto riguarda il Controller abbiamo già ottenuto quello che ci serve.

I prossimi metodi che ci servono sono quelli per interagire col sito. Infatti abbiamo previsto la possibilità di aggiungere, modificare o rimuovere stati direttamente dal sito senza dover accedere al database.

Presupponiamo già di avere un form che invii tramite post i campi necessari (andremo a realizzarlo in una delle viste). Il nostro metodo che chiameremo add() sarà:

function add() {
    if ($this->input->post(‘submit’) {
        //ho fatto il submit...
        $insert[‘name’] = $this->input->post(‘name’);
        $this->status_model->add($insert);
        return $this->index();
    } else {
        //non ho fatto il submit quindi mostro il form...
        $this->load->view(‘add_status’);
    }
}

Innanzitutto vedo se ho già fatto il submit o se invece devo mostrare il form per l’inserimento. Nel primo caso leggo i dati tramite $this->input->post('nome') che è il metodo offerto dalla libreria Input di C.I. per leggere i dati in POST, richiamo il metodo add() del modello per seguire l’inserimento. Una volta concluso mostro la lista degli articoli richiamando il metodo di default $this->index()

La funzione edit() è molto simile, con la differenza che dovendo modificare un preciso stato dovrò specificarlo tramite id. Per farlo basta passare quest’ultimo come parametro al nostro metodo. Nel browser ciò è possibile nella forma: http://www.dominio.com/index.php/mio_controller/metodo/parametro1/parametro2/ etc…

Il metodo diventa quindi:

function edit($id) {
    if ($this->input->post(‘submit’) {
        //ho fatto il submit...
        $insert[‘name’] = $this->input->post(‘name’);
        $this->status_model->edit($insert, $id);
        return $this->index();
    } else {
        //non ho fatto il submit quindi mostro il form...
        $data[‘status’] = $this->status_model->get_single($id);
        $this->load->view(‘add_status’, $data);
    }
}

Come vedete l’unica differenza rispetto all’inserimento sta che nel metodo edit() del modello devo passare anche l’id dell’elemento da modificare. Devo inoltre pre-popolare il form con i valori già esistenti. Posso farlo tramite il metodo get_single($id) del nostro modello, che ci permette di leggere un singolo stato e passarne i dati alla vista.

L’ultimo metodo è quello destinato alla cancellazione di uno stato, ed è molto semplice:

function delete($id) {
    $this->status_model->delete($id);
    return $this->index();
}

Come avrete sicuramente visto non viene effettuato nessun controllo sulla validità dei dati. Questo però sarà facilmente integrabile in un secondo momento tramite ulteriori controlli e la libreria Validation presente in CodeIgniter.

Il controller Types sarà identico a quanto appena visto, con l’unica differenza di nomenclatura tra stati e tipi. Basterà quindi fare copia-incolla dei files e modificare quanto serve.

Anche il controller relativo agli items sarà molto simile, con la differenza che avremo più campi da gestire (non solo il nome) e avremo bisogno di tutti e tre i modelli. Il controller completo è il seguente:

class Items extends Controller {

    function Items() {
        parent::Controller();
        $this->load->model('item_model');
        $this->load->model('type_model');
        $this->load->model('status_model');
    }

    function index() {
        //lista degli elementi nel database
        $data['items'] = $this->item_model->get();
        $this->load->view('list_items', $data);
    }

    function add() {
        if ($this->input->post('submit')) {
            $insert['name']             = $this->input->post('name');
            $insert['code']             = $this->input->post('code');
            $insert['description']      = $this->input->post('description');
            $insert['position']         = $this->input->post('position');
            $insert['type_id']          = $this->input->post('type_id');
            $insert['status_id']        = $this->input->post('status_id');
            $insert['about_the_status'] = $this->input->post('about_the_status');

            $this->item_model->add($insert);
            return $this->index(); //torno all'indice...
        } else {
            $data['types']    = $this->type_model->get();
            $data['statuses'] = $this->status_model->get();
            $this->load->view('add_item', $data);
        }
    }

    function edit($id) {
        if ($this->input->post('submit')) {
            $insert['name']             = $this->input->post('name');
            $insert['code']             = $this->input->post('code');
            $insert['description']      = $this->input->post('description');
            $insert['position']         = $this->input->post('position');
            $insert['type_id']          = $this->input->post('type_id');
            $insert['status_id']        = $this->input->post('status_id');
            $insert['about_the_status'] = $this->input->post('about_the_status');

            $this->item_model->edit($insert, $id);
            return $this->index(); //torno all'indice...
        } else {
            $data['item']     = $this->item_model->get_single($id);
            $data['types']    = $this->type_model->get();
            $data['statuses'] = $this->status_model->get();
            $this->load->view('edit_item', $data);
        }
    }

    function delete($id) {
        $this->item_model->delete($id);
        return $this->index();
    }
}

Anche se più lungo, il concetto è il medesimo dei precedenti. Vorrei soffermarmi semplicemente sulle istruzioni

$data[‘types’] = $this->type_model->get();
$data[‘statuses’] = $this->status_model->get();

presenti sia nel metodo per l’inserimento che per quello per la cancellazione. In pratica andiamo a prepararci in due array l’elenco degli stati e delle tipologie disponibili nel nostro database. Questo ci serve per realizzare delle comode dropdown nei form per i riferimenti esterni. Quando vedremo in dettaglio le viste capiremo meglio come andremo a utilizzarlo.

Nella prossima puntata vedremo in dettaglio le viste, completando il primo step e potendo far funzionare una prima basilare applicazione. In seguito, come già accennato, vedremo come gestire la validazione dei dati.

Puntate precedenti:

1. Introduzione
2. Il database
3. I modelli
4. L’applicazione