Creare un applicazione blog con django, parte 2: creare modelli django

 Frank    Feb. 9, 2020    6 min read    6.562

Durante questo tutorial, incontrerai ripetutamente i termini progetto ed applicazione. In Django, un progetto è considerato un'installazione di Django con alcune impostazioni. Un'applicazione è un gruppo di modelli, viste, template ed URL. Le applicazioni interagiscono con il framework per fornire alcune funzionalità specifiche e possono essere riutilizzate in vari progetti. Puoi pensare il progetto come il tuo sito Web, che contiene diverse applicazioni come un blog, wiki o forum, che possono essere utilizzate anche da altri progetti.

Creare applicazione Django

Ora creiamo la nostra prima applicazione Django. Creiamo un'applicazione blog da zero. Dalla directory principale del progetto, esegui il comando seguente:

(venv) mypc:~/venv/mysite$ python manage.py startapp blog

Questo creerà la struttura di base dell'applicazione, che si presenta così:

blog/

  __init__.py
  admin.py
  apps.py
  migrations/
      __init__.py
  models.py
  tests.py
  views.py

Questi file sono i seguenti:

  • admin.py: Qui è dove registri i modelli e includerli nel sito di amministrazione Django, l'utilizzo del sito di amministrazione Django è facoltativo.
  • apps.py: Questo include la configurazione principale dell'applicazione blog.
  • migrazioni: Questa directory contiene migrazioni di database della tua applicazione. Le migrazioni consentono a Django di tenere traccia delle modifiche del modello dei dati e sincronizzare il database di conseguenza.
  • models.py: I modelli dei dati della tua applicazione, tutte le applicazioni Django devono avere un file models.py, ma questo file può essere lasciato vuoto.
  • tests.py: Qui è dove puoi aggiungere i test per la tua applicazione.
  • views.py: La logica dell'applicazione va qui; ogni viste riceve una richiesta HTTP, la elabora e restituisce una risposta.

Creare modelli Django

Iniziamo a progettare lo schema dei dati per il nostro blog definendo i modelli per il nostro blog. Un modello è una classe di Python che sottoclasse django.db.models.Model, in cui ogni attributo rappresenta un campo del database. Django creerà una tabella per ogni modello definito nel file models.py. Quando crei un modello, Django ti fornisce una API (Application Programming Interface) per interrogare facilmente gli oggetti nel database.

Innanzitutto, definiamo un modello Post. Aggiungi le seguenti righe di codice al file blog/models.py della tua applicazione blog:

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User

class Post(models.Model):
   STATUS_CHOICES = (
       ('draft', 'Draft'),
       ('published', 'Published'),
   )
   title = models.CharField(max_length=250)
   slug = models.SlugField(max_length=250,
                           unique_for_date='publish')
   author = models.ForeignKey(User,
                              on_delete=models.CASCADE,
                              related_name='blog_posts')
   body = models.TextField()
   publish = models.DateTimeField(default=timezone.now)
   created = models.DateTimeField(auto_now_add=True)
   updated = models.DateTimeField(auto_now=True)
   status = models.CharField(max_length=10,
                             choices=STATUS_CHOICES,
                             default='draft')

   class Meta:
       ordering = ('-publish',)

   def __str__(self):
       return self.title

Questo è il modello dei dati per il nostro blog. Diamo un'occhiata ai campi che abbiamo appena definito per questo modello:

  • title: Questo è il campo per il titolo di post. Questo campo è CharField, che si traduce in una colonna VARCHAR nel database SQL.
  • slug: Questo è un campo destinato ad essere utilizzato negli URL. Uno slug è un'etichetta corta che contiene solo lettere, numeri, caratteri di sottolineatura o trattini. Useremo il campo slug per creare splendidi URL per i nostri post. Abbiamo aggiunto il parametro unique_for_date a questo campo in modo da poter creare URL per i post utilizzando la loro data di pubblicazione e slug. Django impedirà a più post di avere lo stesso slug per una determinata data.
  • author: Questo campo è una chiave esterna (ForeignKey), utilizzato per specificare una relazione molti-a-uno con un altro modello di database. Qui stiamo dicendo a Django che ogni post è scritto da un utente ed l'utente può scrivere qualsiasi numeri di post. Per questo campo, Django creerà una ForeignKey nel database utilizzando la chiave primaria (Primary Key) del modello correlato. In questo caso, facciamo affidamento sul modello User del sistema di autenticazione Django. Puoi trovare ulteriori informazioni sulla ForeignKey qui .
  • body: Questo è il contenuto del post. Questo campo è un campo di testo, che si traduce in una colonna TEXT nel database SQL.
  • publish: Questo datetime indica quando il post è stato pubblicato. Usiamo il metodo timezone now di Django come valore predefinito. Ciò restituisce il datetime corrente in un formato compatibile con il fuso orario. Puoi considerarlo come il metodo datetime.now di Python.
  • created: Questo datetime indica quando il post è stato creato. Visto che stiamo utilizzando il parametro auto_now_add, la data verrà salvata automaticamente durante la creazione di un oggetto.
  • updated: Questo datetime indica l'ultima volta che il post è stato aggiornato. Visto che stiamo utilizzando il parametro auto_now, la data verrà aggiornata automaticamente quando si salva un oggetto.
  • status: Questo campo mostra lo stato di un post. Usiamo il parametro choices, così il valore di questo campo può essere impostato solo su una delle scelte date.

Django viene fornito con diversi tipi di campi che puoi utilizzare per definire i tuoi modelli, scopri di più .

La classe Meta all'interno del modello contiene metadati. Quando eseguiamo una query sul database, diciamo a Django di ordinare i risultati nel campo publish in ordine decrescente. Specifichiamo l'ordine decrescente utilizzando il prefisso negativo. In questo modo, i post pubblicati di recente verranno visualizzati per primi.

Il metodo __str__() è la rappresentazione predefinita leggibile dell'oggetto. Django lo userà in molti posti, soprattutto nel sito di amministrazione.

Attivare tua applicazione

Per consentire a Django di tenere traccia della nostra applicazione ed essere in grado di creare tabelle di database per i suoi modelli, dobbiamo attivarlo. Per fare ciò, modifica il file mysite/settings.py e aggiungi blog.apps.BlogConfig nella voce INSTALLED_APPS, che si presenta così:

INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',

   'polls.apps.BlogConfig', # Nuova riga
]

La classe BlogConfig è la configurazione della tua applicazione. Ora Django sa che la nostra applicazione è attiva per questo progetto e sarà in grado di caricare i suoi modelli.

Creare ed applicare migrazioni

Ora che abbiamo un modello dei dati per il nostro blog, abbiamo bisogno di una tabella di database per questo. Django viene fornito con un sistema di migrazione che tiene traccia delle modifiche apportate ai modelli e consente di propagarle nel database. Il comando migrate applica le migrazioni per tutte le applicazioni elencate in INSTALLED_APPS; esso sincronizza il database con i modelli correnti e le migrazioni esistenti.

Nella directory principale del tuo progetto, esegui il comando seguente:

$ python manage.py makemigrations blog

Vedrai il seguente output nel terminale:

Migrations for 'blog':
 blog/migrations/0001_initial.py
   - Create model Post

Django ha appena creato il file 0001_initial.py all'interno della directory delle migrazioni dell'applicazione blog. È possibile aprire il file per vedere come viene creata una migrazione. Le migrazioni indicano il modo in cui Django archivia le modifiche apportate ai modelli.

Diamo un'occhiata al codice SQL che Django eseguirà nel database per creare la tabella per il nostro modello. Il comando sqlmigrate accetta i nomi di migrazione e restituisce il codice SQL senza eseguirlo. Esegui il comando seguente per ispezionare l'output SQL della nostra prima migrazione:

$ python manage.py sqlmigrate blog 0001

BEGIN;
--
-- Create model Post
--
CREATE TABLE "blog_post" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "title" varchar(250) NOT NULL, "slug"  varchar(250) NOT NULL, "body" text NOT NULL, "publish" datetime NOT NULL, "created" datetime NOT NULL, "updated" datetime NOT NULL, "status" varchar(10) NOT NULL, "author_id" integer NOT NULL REFERENCES "auth_user" ("id") DEFERRABLE INITIALLY DEFERRED);
CREATE INDEX "blog_post_slug_b95473f2" ON "blog_post" ("slug");
CREATE INDEX "blog_post_author_id_dd7a8485" ON "blog_post" ("author_id");
COMMIT;

L'output esatto varia a seconda del database in uso. L'esempio precedente viene generato per SQLite, come si può vedere Django genera i nomi delle tabelle combinando il nome dell'applicazione e il nome in minuscolo del modello blog_post, ma è anche possibile specificare un nome di database personalizzato per il modello nella classe Meta del modello utilizzando il parametro db_table. Django crea automaticamente una chiave primaria per ciascun modello, ma puoi anche sovrascriverla specificando primary_key=True in uno dei campi del tuo modello. La chiave primaria predefinita è una colonna ID, che consiste di un numero intero che viene incrementato automaticamente. Questa colonna corrisponde al campo ID che viene aggiunto automaticamente ai tuoi modelli.

Sincronizziamo il nostro database con il nuovo modello. Esegui il comando seguente per applicare le migrazioni esistenti:

$ python manage.py migrate
Operations to perform:
 Apply all migrations: admin, auth, contenttypes, blog, sessions
Running migrations:
 Applying blog.0001_initial... OK
 Applying sessions.0001_initial... OK

Abbiamo appena applicato le migrazioni per le applicazioni elencate in INSTALLED_APPS, includendo la nostra applicazione blog.

Se modifichi il file * models.py * per aggiungere, rimuovere o modificare i campi di modelli esistenti o se aggiungi nuovi modelli, ricorda di eseguire i seguenti comandi:

  • Esegui python manage.py makemigrations per creare migrazioni per tali modifiche.
  • Esegui python manage.py migrate per applicare tali modifiche al database.

Per ora è tutto. Il prossimo tutorial è creare un sito di amministrazione per la nostra applicazione così possiamo registrare i nostri medelli.

Se ti piace il mio contenuto, supportami! grazie.

Buy me a coffeeOffrimi un caffe'

Post correlati