Nella scorsa parte abbiamo visto come abilitare l’interfaccia di admin. Abbiamo notato però che non tutto era esattamente come ce lo aspettavamo. Per prima cosa tutte le tabelle terminavano con una fastidiosa “s” dovuta al plurale inglese, secondo, gli oggetti venivano visualizzati con un anonimo “Artista Object”, “Genere Object” e così via.

Per sistemare questi punti c’è un modo molto semplice.

• Specificare il metodo __unicode__.
• Aggiungere l’opzione verbose_name_plural come parametro della classe Meta di ogni oggetto del modello.
• Impostare LANGUAGE_CODE = 'it-IT' nel file settings.py

Il metodo unicode specifica come verrà visualizzato un oggetto del modello X al posto della dicitura standard “X Object”. Per chi conosce il python è praticamente equivalente a ridefinire il metodo speciale __str__[/cc] di una classe (il metodo [cci]__str__ dei modelli Django chiamano proprio __unicode__).

La classe Meta, invece, è una classe speciale che permette di passare ai modelli delle opzioni particolari. Vedremo altre opzioni nel corso del tutorial. L’opzione che ci interessa ora è verbose_name_plural : se questo valore è None allora viene usato il suffisso “s” come nel caso inglese, altrimenti viene usato il valore della variabile.

Vediamo quindi qualche esempio:

class Artista(models.Model):

    nome = models.CharField(max_length=50)

    cognome = models.CharField(max_length=50)

    ruoli = models.ManyToManyField(Ruolo)



    def __unicode__(self) :

      return u"%s %s" % (self.nome, self.cognome)



    class Meta:

      verbose_name_plural = "Artisti"

Mostro il caso del modello “Artista”. Allo stesso modo intervenite anche su tutti i modelli restanti. Potete vedere il risultato in figura.

Come potete vedere adesso il risultato è molto più accettabile. La prossima volta vedremo come abbozzare un interfaccia pubblica al nostro sito.

Nella scorsa parte abbiamo visto come abilitare l’interfaccia di admin. Abbiamo notato però che non tutto era esattamente come ce lo aspettavamo. Per prima cosa tutte le tabelle terminavano con...

Come ogni applicazione che si rispetti, abbiamo bisogno di impostare e generare la struttura dati del nostro programma. La primissima cosa da fare è quella di istruire Django ad utilizzare un database.

Per questa guida sceglieremo PostgreSQL. Per configurarlo potete seguire la guida per installare PostgreSQL.

Una volta installato e configurato il database apriamo il file settings.py e cerchiamo la riga DATABASES e modifichiamola nel modo seguente:

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.postgresql_psycopg2',

        'NAME': 'musicdb',

        'USER': 'vostro_nome',

        'PASSWORD': 'password',

        'HOST': '',

        'PORT': '',

    }

}

Dove vostro_nome e password sono l’username e la password che avete impostato nella fase di configurazione del database. Inoltre dovete creare preventivamente un database di nome “musicdb”. Per completezza spieghiamo tutti i parametri:

• ENGINE è il modulo di django di backend che si interfaccia con lo specifico database. Scegliamo quello del nostro database.
• NAME è il nome del database o del file nel caso di SQLite.
• USER è il nome utente per l’accesso al db (non serve nel caso di SQLite).
• PASSWORD è la password di accesso.
• HOST e PORT sono i dati che indicano la posizione e la porta di accesso a db nel caso il database non sia sulla stessa macchina del server.

Assicuratevi anche che sia installato il pacchetto:

python-psycopg2

Necessario per far interfacciare python al DB.

A questo punto non ci resta che creare lo schema del database. Per fare ciò apriamo il file models.py e inseriamo una cosa del tipo:

from django.db import models



# Create your models here.

class Ruolo(models.Model) :

    descrizione = models.CharField(max_length=30)



class Artista(models.Model):

    nome = models.CharField(max_length=50)

    cognome = models.CharField(max_length=50)

    ruoli = models.ManyToManyField(Ruolo)



class Gruppo(models.Model):

    nome = models.CharField(max_length=50)

    membri = models.ManyToManyField(Artista)



class Genere(models.Model):

    descrizione = models.CharField(max_length=30)



class Traccia(models.Model):

    nome = models.CharField(max_length=50)

    durata = models.TimeField()



class Album(models.Model):

    nome = models.CharField(max_length=50)

    gruppo = models.ForeignKey(Gruppo)

    genere = models.ForeignKey(Genere)

    data = models.DateField()

    tracce = models.ManyToManyField(Traccia)

Questo file specifica la struttura delle tabelle del database. Tutto senza scrivere una sola riga di SQL. Vediamo un po il significato di alcuni campi:

• CharField è un campo di testo semplice. Il parametro max_length specifica il numero massimo di caratteri memorizzabili nel campo.
• ForeignKey specifica un collegamento uno-a-molti verso un altra tabella. Ad esempio un Album ha un unico Gruppo che lo suona ma un Gruppo può avere uno o più Album nella propria discografia.
• DateField specifica una data.
• TimeField specifica un tempo.
• ManyToMany specifica un collegamento molti-a-molti verso un altra tabella. Ad esempio un Gruppo può avere uno o più Artisti che ne fanno parte, ma un Artista può partecipare a uno o più gruppi.

Ora, rendiamo questo modello un database vero e proprio con il comando:

python manage.py syncdb

Se tutto è andato a buon fine e il modello è valido ci verrà chiesto se vogliamo creare una zona del database per gli utenti. Diciamo di si. Ci verrà chiesto di creare il super-user, creiamolo indicando un nome e la password.

A questo punto possiamo provare il nostro database.

Apriamo la shell di django con

python manage.py shell

E all’interno digitiamo:

from musicdb.models import *

freddie = Autore(nome="Freddie, cognome="Mercury")

freddie.save()

Con pgAdmin3 possiamo facilmente vedere che il cantante è stato aggiunto nella giusta tabella.

Ebbene si. Freddie c'è.

Come ogni applicazione che si rispetti, abbiamo bisogno di impostare e generare la struttura dati del nostro programma. La primissima cosa da fare è quella di istruire Django ad utilizzare...

Vi propongo passo passo un tutorial che ci porterà a realizzare una pagina web dinamica contenente informazioni sulla nostra collezione musicale. In questo modo potrete vedere come prende forma un progetto utilizzando quella meraviglia tecnologica che è Django. Gli unici requisiti sono la conoscenza del Python nella sua forma base (for, if, classi, funzioni, tuple, liste e dizionari). Non ci resta che iniziare a impostare la cartella del progetto e verificare che tutto funzioni.

La prima cosa da fare è andare in una cartella e digitare:

django-admin startproject musicz

Verrà creata una cartella di nome musicz che contiene 4 file.

• __init__.py è il file che indica all’interprete python di trattare la cartella come un package. Il file è solitamente vuoto e vuoto deve solitamente rimanere.
• manage.py è un file di servizio che vi offre un interfaccia molto comoda ad alcune “utility” di Django. Ne faremo largamente uso da ora in avanti.
• setting.py è il file che contiene tutti i settaggi che faremo all’applicazione.
• urls.py è il file che contiene la specifica mappatura degli urls verso le funzioni del programma.

La cartella contenente i nostri 4 file.

Se tutto è stato fatto correttamente vi basterà digitare

python manage.py runserver

Per avviare il web-server di prova. A questo punto non vi resta che andare all’indirizzo http://localhost:8000/ per vedere un rassicurante messaggio da parte di Django.

Django ci dice che va tutto ok!

Vi propongo passo passo un tutorial che ci porterà a realizzare una pagina web dinamica contenente informazioni sulla nostra collezione musicale. In questo modo potrete vedere come prende forma un...