Sei in HOME > Guide Hosting, Domini e Cloud > Come creare una galleria fotografica > Creare una galleria fotografica con il Cloud Storage di Hostingsolutions.it – parte 4

Creare una galleria fotografica con il Cloud Storage di Hostingsolutions.it – parte 4

Finalmente si comincia a programmare! Certo, sarebbe stato molto avventato cominciare a buttare giù codice, più o meno a casaccio, senza prima aver buttato giù almeno qualche requisito, non vi pare? Ora invece abbiamo pronti i mockup e ci siamo anche fissati alcuni “paletti” per limitare lo sforzo implementativo ed evitare di strafare, col rischio di non concludere un bel niente.

Creazione del database

Il database che utilizzeremo sarà, per il momento, MySql versione 5. In futuro si potrebbe aggiungere il supporto ad altri database, visto che il framework PHP che utilizzeremo (CodeIgniter, vedi oltre) è già in grado di gestirne molti altri: Microsoft SQL Server, Postgres, Oracle, ODBC.

Il nostro schema sarà molto semplice, avrà solamente due tabelle: collections e images. Lo script per creare le tabelle è il seguente:

CREATE TABLE `collections` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(128) NOT NULL,
  `description` text,
  `path` varchar(256),
  `thumbnail_path` varchar(256),
  `thumbnail_width` smallint,
  `thumbnail_height` smallint,

  PRIMARY KEY (`id`)
) ENGINE=InnoDB;

CREATE TABLE `images` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(128),
  `description` text,
  `collection_id` int(11) NOT NULL,
  `path` varchar(256),
  `width` smallint,
  `height` smallint,
  `thumbnail_path` varchar(256),
  `thumbnail_width` smallint,
  `thumbnail_height` smallint,

  PRIMARY KEY (`id`),
  KEY `collection_id` (`collection_id`),
  CONSTRAINT `collection_id` FOREIGN KEY (`collection_id`) REFERENCES `collections` (`id`)
) ENGINE=InnoDB;

 

Da notare l’utilizzo delle tabelle di tipo InnoDB, che ormai è lo standard da MySql versione 5; il vantaggio è che permette di avere un database “vero”: oltre a transazioni e lock a livello di riga, la caratteristica più utile per gli sviluppatori sono le Foreign Key (chiavi esterne), che ci permettono di avere uno schema delle tabelle molto più semplice da capire.

Framework PHP: CodeIgniter

Come framework PHP abbiamo scelto CodeIgniter, per svariati motivi. Ci serviva infatti un framework di tipo MVC (Model-View-Controller) che fosse semplice da imparare, leggero e con pochi requisiti di hosting. CodeIgniter non solo possiede tutte queste caratteristiche, ma ha anche qualcosa in più, di base infatti fornisce una serie di utility per la persistenza su database, la validazione e molto altro. Insomma l’ideale per un progetto che parte “piccolo” ma ha assolutamente intenzione di crescere! Inoltre in passato abbiamo potuto apprezzarne le doti grazie a semplici guide.

L’installazione del framework è un’operazione piuttosto semplice:

  • si scarica l’ultima versione stabile di CodeIgniter, al momento della scrittura di questo articolo siamo alla 2.1.0;
  • si estrae l’archivio;
  • i file estratti vanno copiati nella directory pubblica della nostra web application.

CodeIgniter infatti, come molti framework PHP, Ruby o Python, fornisce struttura di base alla quale dobbiamo aggiungere i nostri sorgenti, file di configurazioni, risorse, librerie e tutto ciò che serve alla nostra applicazione. Le nostre personalizzazioni vanno quindi inserite in una delle sotto-directory di application.

Classi Model

La prassi di CodeIgniter prevede la creazione di una classe Model per ognuna delle tabelle che intendiamo gestire. I sorgenti di queste classi vanno memorizzati nella directory application/models, ed hanno queste caratteristiche:

  • estendono la classe CI_Model, fornita da CodeIgniter;
  • la prima lettera del nome della classe deve essere maiuscola;
  • il nome del file sorgente deve essere la versione in minuscolo del nome della classe, più l’estensione .php;
  • la classe deve definire il metodo __construct(), richiamando il metodo della classe padre.

Nonostante tutte queste regole, la creazione delle classi Model non è affatto difficile. Di seguito i sorgenti dei due Model della nostra applicazione Photocloud, il primo è il modello per la tabella collections:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Collection_model extends CI_Model {

  private static $table_name = 'collections';

  var $id;
  var $name;
  var $description;
  var $path;
  var $thumbnail_path;

  function __construct() {
    parent::__construct();
  }

  public function get_collections($limit = null) {
    // most recent collections
    $this->db->order_by('id', 'desc');
    $query = $this->db->get(Collection_model::$table_name, $limit);
    return $query->result();
  }

  public function get($id) {
    $this->db->where('id', $id);
    $query = $this->db->get(Collection_model::$table_name);
    return $query->row();
  }

  public function insert() {
    $this->db->insert(Collection_model::$table_name, $this);
    $this->id = $this->db->insert_id();
  }

  public function update() {
    $this->db->where('id', $this->id);
    $this->db->update(Collection_model::$table_name, $this);
  }

}

 

Questo invece è il modello per la tabella images:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Image_model extends CI_Model {

  private static $table_name = 'images';

  var $name;
  var $description;
  var $collection_id;
  var $path;
  var $width;
  var $height;
  var $thumbnail_path;
  var $thumbnail_width;
  var $thumbnail_height;

  function __construct() {
    parent::__construct();
  }

  public function get_images($collection_id) {
    $this->db->where('collection_id', $collection_id);
    $this->db->order_by('id', 'asc');
    $query = $this->db->get(Image_model::$table_name);
    return $query->result();
  }

  public function insert() {
    $this->db->insert(Image_model::$table_name, $this);
    $this->id = $this->db->insert_id();
  }

  public function update() {
    $this->db->where('id', $this->id);
    $this->db->update(Image_model::$table_name, $this);
  }
}

 

Come potete notare entrambe le classi sono già dotate di alcuni metodi per l’interazione con il database:

Classe Collection_model:

  • metodo get_collections(): recupera le collezioni dal database, ordinandole per ID discendente. In questo modo vengono mostrate prima le più recenti, inoltre grazie al parametro limit possiamo scegliere quante mostrarne;
  • metodi get(), insert(), update(): classiche operazioni database ovvero carica, iserisci e aggiorna.

Classe Image_model:

  • metodo get_images(): restituisce l’elenco delle immagini di una collezione ordinate per ID (questa volta ascendente).
  • metodo insert() e update(): come sopra.

Sviluppi

Nella prossima puntata vedremo come creare le classi Controller e le View ad essi associate.

Links