Struttura del Progetto

Dopo aver installato Django, crea un nuovo progetto con il comando:

1

django-admin startproject nome_progetto

Questo comando creerà una cartella nome_progetto con la seguente struttura:

1
2
3
4
5
6
7
8

nome_progetto/
    manage.py
    nome_progetto/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

Ecco una spiegazione dei file e cartelle principali:

• manage.py: Questo script permette di eseguire vari comandi di gestione del progetto Django, come eseguire il server di sviluppo, eseguire migrazioni del database, e così via.
• nome_progetto/: Questa cartella contiene il codice Python specifico del progetto Django.
  • __init__.py: File vuoto che indica a Python che questa cartella rappresenta un pacchetto.
  • settings.py: Questo file contiene tutte le impostazioni di configurazione per il progetto Django, come le impostazioni del database, le app installate, le impostazioni di sicurezza e così via.
  • urls.py: Questo file definisce gli URL del progetto e le viste corrispondenti a ciascun URL.
  • asgi.py: Questo file contiene la configurazione per l’interfaccia server ASGI (Asynchronous Server Gateway Interface), utilizzata per applicazioni web asincrone e real-time.
  • wsgi.py: Questo file contiene la configurazione per l’interfaccia server WSGI (Web Server Gateway Interface), utilizzata per applicazioni web sincrone.

Dopo aver creato il progetto, è possibile avviare il server di sviluppo di Django con il comando:

1

python manage.py runserver

Questo comando avvierà il server di sviluppo all’indirizzo http://127.0.0.1:8000/. A questo punto, puoi iniziare a creare le tue app e sviluppare il tuo progetto Django.

Creazione delle App

All’interno del progetto, crea tre app separate utilizzando il comando:

1
2
3

python manage.py startapp auth
python manage.py startapp frontend
python manage.py startapp backend

Queste app saranno rispettivamente dedicate all’autenticazione, al frontend e al backend.

Dopo aver creato le app, è necessario registrarle nel progetto Django. Apri il file settings.py nella cartella nome_progetto e aggiungi le nuove app nella variabile INSTALLED_APPS:

1
2
3
4
5
6

INSTALLED_APPS = [
    # ...
    'auth',
    'frontend',
    'backend',
]

Ecco una breve descrizione delle app:

• auth: Questa app conterrà la logica per la gestione dell’autenticazione degli utenti, come la registrazione, il login e il logout.
• frontend: Questa app sarà dedicata alla gestione delle pagine web pubbliche e dell’interfaccia utente del sito.
• backend: Questa app conterrà la logica di backend, come la gestione dei dati, le operazioni di amministrazione e le funzionalità riservate agli utenti autenticati.

Dopo aver registrato le app in settings.py, puoi iniziare a sviluppare le funzionalità desiderate in ciascuna di esse. Django utilizza un approccio basato su app modulari, che consente di separare le diverse componenti dell’applicazione in modo chiaro e organizzato.

Ogni app avrà una propria cartella con i seguenti file:

• __init__.py: File vuoto che indica a Python che questa cartella rappresenta un pacchetto.
• admin.py: Questo file consente di configurare l’interfaccia di amministrazione di Django per l’app.
• apps.py: Questo file contiene la configurazione dell’app stessa.
• models.py: Qui vengono definiti i modelli di dati dell’app.
• tests.py: Questo file contiene i test unitari per l’app.
• views.py: Qui vengono definite le viste, ovvero le funzioni che gestiscono le richieste HTTP e generano le risposte.

Inoltre, ogni app può avere una cartella migrations per le migrazioni del database e una cartella templates per i file HTML dei template.

Con questa struttura, puoi sviluppare separatamente le diverse componenti dell’applicazione, mantenendo un codice ben organizzato e modulare.

Configurazione dell’Autenticazione

Django fornisce un sistema di autenticazione integrato che consente di gestire facilmente la registrazione, il login e il logout degli utenti. In questa sezione, configureremo l’autenticazione utilizzando un modello personalizzato per l’utente.

1. In auth/models.py, crea un modello personalizzato per l’utente estendendo AbstractUser di Django:

1
2
3
4
5

from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    # Aggiungi qui eventuali campi aggiuntivi per l'utente
    pass

Il modello CustomUser eredita da AbstractUser, che fornisce tutti i campi di base necessari per un utente (come username, password, email, ecc.). Puoi aggiungere campi aggiuntivi personalizzati, se necessario.

2. In settings.py, imposta il modello personalizzato come modello di autenticazione predefinito:

1

AUTH_USER_MODEL = 'auth.CustomUser'

Questa impostazione indica a Django di utilizzare il modello CustomUser invece del modello predefinito User.

3. Esegui le migrazioni per creare le tabelle nel database:

1
2

python manage.py makemigrations
python manage.py migrate

Il comando makemigrations creerà i file di migrazione per il nuovo modello personalizzato, mentre migrate eseguirà effettivamente le migrazioni e creerà le tabelle nel database.

4. In auth/views.py, crea le viste per la registrazione e il login degli utenti. Ad esempio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from django.contrib.auth import authenticate, login
from django.contrib.auth.forms import UserCreationForm
from django.shortcuts import render, redirect

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('login')
    else:
        form = UserCreationForm()
    return render(request, 'auth/register.html', {'form': form})

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('home')
    return render(request, 'auth/login.html')

Queste sono solo viste di esempio, ma puoi personalizzarle in base alle tue esigenze.

5. In auth/urls.py, definisci gli URL per le viste di autenticazione:

1
2
3
4
5
6
7
8

from django.urls import path
from . import views

urlpatterns = [
    path('register/', views.register, name='register'),
    path('login/', views.login_view, name='login'),
    # Aggiungi altri URL per il logout e altre funzionalità di autenticazione
]

6. Aggiungi gli URL di autenticazione agli URL principali del progetto in nome_progetto/urls.py:

1
2
3
4
5
6

from django.urls import path, include

urlpatterns = [
    # ...
    path('auth/', include('auth.urls')),
]

Dopo aver completato questi passaggi, avrai configurato l’autenticazione utilizzando un modello personalizzato per l’utente. Puoi quindi utilizzare le viste di autenticazione per gestire la registrazione, il login e altre funzionalità correlate all’autenticazione.

espandi ## Sviluppo del Frontend

Sviluppo del Frontend

Il frontend di un’applicazione web Django è responsabile della presentazione dei dati e dell’interfaccia utente. In questa sezione, svilupperemo il frontend dell’applicazione web utilizzando l’app frontend creata in precedenza.

1. In frontend/views.py, crea le viste necessarie per le pagine del sito web. Ad esempio:

1
2
3
4
5
6
7
8
9

from django.shortcuts import render

def home(request):
    return render(request, 'frontend/home.html')

def about(request):
    return render(request, 'frontend/about.html')

# Aggiungi altre viste per le diverse pagine del sito web

2. In frontend/urls.py, definisci gli URL per le viste del frontend:

1
2
3
4
5
6
7
8

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    path('about/', views.about, name='about'),
    # Aggiungi altri URL per le diverse pagine del sito web
]

3. Aggiungi gli URL del frontend agli URL principali del progetto in nome_progetto/urls.py:

1
2
3
4
5
6

from django.urls import path, include

urlpatterns = [
    # ...
    path('', include('frontend.urls')),
]

4. Crea i modelli necessari in frontend/models.py e le relative migrazioni. Ad esempio, se hai bisogno di gestire articoli o prodotti nel tuo sito web, potresti creare un modello come questo:

1
2
3
4
5
6
7
8
9

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')

    def __str__(self):
        return self.title

Dopo aver creato il modello, esegui le migrazioni:

1
2

python manage.py makemigrations frontend
python manage.py migrate

5. Sviluppa i template HTML per le pagine del sito web in frontend/templates/. Ad esempio, per la pagina home, potresti creare un file frontend/templates/frontend/home.html con il seguente contenuto:

1
2
3
4
5
6

{% extends 'base.html' %}

{% block content %}
  <h1>Benvenuto nel sito web</h1>
  <p>Questa è la pagina principale.</p>
{% endblock %}

In questo esempio, il template home.html estende un template base base.html e definisce un blocco content per il contenuto specifico della pagina.

Durante lo sviluppo del frontend, puoi aggiungere ulteriori viste, modelli, template e funzionalità a seconda delle tue esigenze specifiche. Inoltre, puoi integrare il frontend con il sistema di autenticazione implementato in precedenza per gestire le aree pubbliche e private del sito web.

Sviluppo del Backend

Il backend di un’applicazione web Django è responsabile della gestione dei dati, delle operazioni di business e delle funzionalità riservate agli utenti autenticati. In questa sezione, svilupperemo il backend dell’applicazione web utilizzando l’app backend creata in precedenza.

1. In backend/views.py, crea le viste necessarie per la dashboard e le funzionalità di backend. Ad esempio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from django.contrib.auth.decorators import login_required
from django.shortcuts import render

@login_required
def dashboard(request):
    return render(request, 'backend/dashboard.html')

@login_required
def manage_users(request):
    # Logica per gestire gli utenti
    pass

# Aggiungi altre viste per le diverse funzionalità di backend

In questo esempio, la vista dashboard è decorata con @login_required, che significa che solo gli utenti autenticati possono accedervi.

2. In backend/urls.py, definisci gli URL per le viste di backend:

1
2
3
4
5
6
7
8

from django.urls import path
from . import views

urlpatterns = [
    path('dashboard/', views.dashboard, name='dashboard'),
    path('manage-users/', views.manage_users, name='manage_users'),
    # Aggiungi altri URL per le diverse funzionalità di backend
]

3. Aggiungi gli URL di backend agli URL principali del progetto in nome_progetto/urls.py:

1
2
3
4
5
6

from django.urls import path, include

urlpatterns = [
    # ...
    path('admin/', include('backend.urls')),
]

4. Crea i modelli necessari in backend/models.py e le relative migrazioni. Ad esempio, se hai bisogno di gestire ordini o fatture nel tuo backend, potresti creare un modello come questo:

1
2
3
4
5
6
7
8
9

from django.db import models

class Order(models.Model):
    customer_name = models.CharField(max_length=100)
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)
    order_date = models.DateTimeField('date ordered')

    def __str__(self):
        return f"{self.customer_name} - {self.total_amount}"

Dopo aver creato il modello, esegui le migrazioni:

1
2

python manage.py makemigrations backend
python manage.py migrate

5. Sviluppa i template HTML per la dashboard e le altre funzionalità di backend in backend/templates/. Ad esempio, per la dashboard, potresti creare un file backend/templates/backend/dashboard.html con il seguente contenuto:

1
2
3
4
5
6
7

{% extends 'base.html' %}

{% block content %}
  <h1>Dashboard</h1>
  <p>Benvenuto nella dashboard di amministrazione.</p>
  <!-- Aggiungi qui i contenuti specifici della dashboard -->
{% endblock %}

6. Implementa le logiche di business e le operazioni sui dati nelle viste di backend. Ad esempio, nella vista manage_users, potresti recuperare tutti gli utenti dal database e mostrarli in una tabella nella dashboard.

Durante lo sviluppo del backend, puoi aggiungere ulteriori viste, modelli, template e funzionalità a seconda delle tue esigenze specifiche. Inoltre, puoi integrare il backend con il sistema di autenticazione implementato in precedenza per gestire le aree riservate agli utenti autenticati.

Django Forms

Django offre un potente sistema di gestione dei form che semplifica la gestione dei dati inviati dagli utenti. Puoi aggiungere una sezione dedicata all’utilizzo dei form nelle diverse app del tuo progetto.

Ecco un esempio di come potresti integrare i form nella tua guida:

Utilizzo dei Django Forms

Django fornisce un sistema integrato per la gestione dei form, che semplifica la convalida e il salvataggio dei dati inviati dagli utenti. Ecco come puoi utilizzare i form nelle tue app.

Creazione di un modulo di form

In frontend/forms.py (o backend/forms.py a seconda dell’app), crea un modulo di form basato su un modello:

1
2
3
4
5
6
7

from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content']

Utilizzo del form nelle viste

Nelle tue viste in views.py, puoi gestire il form e salvare i dati inviati dall’utente. Ad esempio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from django.shortcuts import render, redirect
from .forms import ArticleForm

def create_article(request):
    if request.method == 'POST':
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('article_list')
    else:
        form = ArticleForm()
    return render(request, 'frontend/create_article.html', {'form': form})

Template HTML

Nei template HTML, puoi renderizzare il form utilizzando il tag {{ form }} o renderizzare i campi del form singolarmente con {{ form.campo }}.

Gestione dei file statici

Django offre un sistema integrato per la gestione dei file statici (CSS, JavaScript, immagini, ecc.) durante lo sviluppo e la distribuzione. Puoi aggiungere una sezione sulla gestione dei file statici nella tua guida.

Gestione dei file statici

Durante lo sviluppo, puoi servire i file statici direttamente dal server di sviluppo di Django. In produzione, tuttavia, è consigliabile servire i file statici in modo più efficiente, ad esempio utilizzando un servizio di hosting di file come Amazon S3.

Configurazione dei file statici

1. In settings.py, imposta le variabili STATIC_URL e STATIC_ROOT:

1
2

STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'

2. Crea una cartella static all’interno di ogni app per contenere i file statici specifici dell’app.

3. In settings.py, aggiungi le cartelle static alle variabili STATICFILES_DIRS:

1
2
3
4

STATICFILES_DIRS = [
    BASE_DIR / 'frontend/static',
    BASE_DIR / 'backend/static',
]

Raccolta dei file statici

Prima del deployment in produzione, esegui il seguente comando per raccogliere tutti i file statici nella cartella STATIC_ROOT:

1

python manage.py collectstatic

Servire i file statici in produzione

Per servire i file statici in produzione, puoi utilizzare un servizio di hosting di file come Amazon S3. Configura le impostazioni del tuo server web (ad esempio, Nginx o Apache) per servire i file statici dalla cartella STATIC_ROOT o direttamente dal servizio di hosting di file.

Gestione dei template HTML

Django utilizza un sistema di template per separare la logica dell’applicazione dall’HTML. Questo consente di mantenere un codice più pulito e riutilizzabile.

Creazione dei template

Ogni app può avere una cartella templates che contiene i file HTML dei template. Ad esempio, in frontend/templates/frontend/, potresti avere un file base.html come template base:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}{% endblock %}</title>
    {% block extra_head %}{% endblock %}
</head>
<body>
    {% block content %}{% endblock %}
    {% block extra_body %}{% endblock %}
</body>
</html>

Altri template possono quindi estendere questo template base e definire i blocchi specifici per il contenuto delle pagine.

Rendering dei template nelle viste

Nelle viste in views.py, puoi renderizzare i template passando i dati del contesto:

1
2
3
4
5
6
7
8

from django.shortcuts import render

def home(request):
    context = {
        'title': 'Pagina Iniziale',
        'articles': Article.objects.all(),
    }
    return render(request, 'frontend/home.html', context)

Utilizzo dei template tag

Django offre diversi template tag e filtri che permettono di aggiungere logica ai template. Ad esempio, puoi utilizzare un ciclo {% for %} per iterare su una lista di articoli nel template home.html:

1
2
3
4

{% for article in articles %}
    <h2>{{ article.title }}</h2>
    <p>{{ article.content }}</p>
{% endfor %}

Integrazione e Testing

Dopo aver sviluppato separatamente le componenti di autenticazione, frontend e backend, è necessario integrarle e testarle per garantire il corretto funzionamento dell’applicazione web completa.

1. Verifica il corretto funzionamento delle viste e degli URL:

   • Avvia il server di sviluppo di Django con il comando python manage.py runserver.
   • Naviga tra le diverse pagine del sito web e della dashboard di backend per assicurarti che le viste e gli URL funzionino correttamente.

2. Effettua test di autenticazione:

   • Crea nuovi utenti utilizzando la vista di registrazione.
   • Effettua il login con gli utenti appena creati e verifica l’accesso alle diverse aree dell’applicazione.
   • Verifica che le aree riservate agli utenti autenticati siano accessibili solo dopo il login.
   • Testa il funzionamento del logout e assicurati che l’utente non possa più accedere alle aree protette dopo il logout.

3. Esegui test unitari e di integrazione:

   • In Django, puoi creare test unitari e di integrazione nella cartella tests.py di ogni app.
   • Scrivi test per verificare il corretto funzionamento delle viste, dei modelli e di altre funzionalità dell’applicazione.
   • Esegui i test con il comando python manage.py test.
   • Risolvi eventuali problemi evidenziati dai test e assicurati che tutti i test passino con successo.

4. Implementa eventuali miglioramenti o funzionalità aggiuntive:

   • In base ai feedback degli utenti o alle esigenze del progetto, potresti dover aggiungere nuove funzionalità o apportare miglioramenti all’applicazione.
   • Segui gli stessi passaggi descritti in precedenza per sviluppare e integrare le nuove funzionalità.

5. Deployment su un server di produzione:

   • Quando l’applicazione è pronta per il rilascio, puoi procedere con il deployment su un server di produzione.
   • Django supporta diversi server web come Apache, Nginx e Gunicorn.
   • Configura il server web e il database di produzione seguendo le istruzioni specifiche per il tuo ambiente di produzione.
   • Esegui le migrazioni del database e raccogli i file statici per il deployment.

Questa fase di integrazione e testing è fondamentale per garantire la qualità e il corretto funzionamento dell’applicazione web completa. È importante effettuare test approfonditi e risolvere eventuali problemi o bug prima del rilascio in produzione.

Durante lo sviluppo, puoi anche sfruttare le funzionalità di Django come il sistema di amministrazione, la gestione dei file statici, la memorizzazione in cache e molte altre per migliorare l’esperienza dell’utente e l’efficienza dell’applicazione.

Ricorda che questa guida fornisce una panoramica generale del processo di sviluppo con Django. In base alle specifiche esigenze del tuo progetto, potrebbero essere necessarie ulteriori configurazioni o personalizzazioni.

Esempio e template di base

Ecco un elenco dei file necessari per creare una semplice app demo con Django, inclusi i contenuti di base per ciascun file:

Crea un nuovo progetto Django con il comando:

1

django-admin startproject nome_progetto

1. manage.py

questo file viene generato automaticamente quando si crea un nuovo progetto Django

2. nome_progetto/settings.py:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Configurazioni di base del progetto

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

Crea le app con i seguenti comandi:

1
2
3

python manage.py startapp auth
python manage.py startapp frontend
python manage.py startapp backend

3. nome_progetto/urls.py:

1
2
3
4
5
6
7
8
9

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('auth/', include('auth.urls')),
    path('', include('frontend.urls')),
    path('backend/', include('backend.urls')),
]

4. auth/models.py:

1
2
3
4

from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    pass

5. auth/views.py:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
from django.shortcuts import render, redirect
from .models import CustomUser

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save(commit=False)
            user.first_name = request.POST.get('first_name')
            user.last_name = request.POST.get('last_name')
            user.email = request.POST.get('email')
            user.save()
            return redirect('login')
    else:
        form = UserCreationForm()
    return render(request, 'auth/register.html', {'form': form})

def login_view(request):
    if request.method == 'POST':
        form = AuthenticationForm(request, data=request.POST)
        if form.is_valid():
            user = form.get_user()
            login(request, user)
            return redirect('home')
    else:
        form = AuthenticationForm()
    return render(request, 'auth/login.html', {'form': form})

def logout_view(request):
    logout(request)
    return redirect('login')

Per la registrazione:

1. Viene utilizzata la classe UserCreationForm fornita da Django per creare un nuovo utente.
2. Se il metodo della richiesta è POST (ovvero, se il form è stato inviato), il form viene validato.
3. Se il form è valido, viene creato un nuovo utente CustomUser (il modello utente personalizzato che abbiamo creato in precedenza).
4. I campi first_name, last_name e email vengono impostati con i valori inviati dal form.
5. Il nuovo utente viene salvato nel database.
6. L’utente viene reindirizzato alla pagina di login.
7. Se il metodo della richiesta non è POST, viene semplicemente mostrato il form di registrazione vuoto.

Per il login:

1. Viene utilizzata la classe AuthenticationForm fornita da Django per autenticare un utente.
2. Se il metodo della richiesta è POST (ovvero, se il form è stato inviato), il form viene validato.
3. Se il form è valido, viene recuperato l’utente utilizzando il metodo get_user().
4. L’utente viene autenticato utilizzando la funzione login() di Django.
5. L’utente viene reindirizzato alla homepage.
6. Se il metodo della richiesta non è POST, viene semplicemente mostrato il form di login vuoto.

Per il logout:

1. La funzione logout_view() utilizza la funzione logout() di Django per deautenticare l’utente corrente.
2. L’utente viene reindirizzato alla pagina di login.

Non dimenticare di aggiungere gli URL per queste viste in auth/urls.py:

1
2
3
4
5
6
7
8

from django.urls import path
from . import views

urlpatterns = [
    path('register/', views.register, name='register'),
    path('login/', views.login_view, name='login'),
    path('logout/', views.logout_view, name='logout'),
]

6. auth/urls.py:

1
2
3
4
5
6
7

from django.urls import path
from . import views

urlpatterns = [
    path('register/', views.register, name='register'),
    path('login/', views.login_view, name='login'),
]

7. frontend/models.py:

1
2
3
4
5
6
7
8
9

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')

    def __str__(self):
        return self.title

8. frontend/views.py:

1
2
3
4
5
6

from django.shortcuts import render
from .models import Article

def home(request):
    articles = Article.objects.all()
    return render(request, 'frontend/home.html', {'articles': articles})

9. frontend/urls.py:

1
2
3
4
5
6

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

10. backend/views.py

1
2
3
4
5
6

from django.contrib.auth.decorators import login_required
from django.shortcuts import render

@login_required
def dashboard(request):
    return render(request, 'backend/dashboard.html')

11. backend/urls.py:

1
2
3
4
5
6

from django.urls import path
from . import views

urlpatterns = [
    path('dashboard/', views.dashboard, name='dashboard'),
]

12. frontend/templates/frontend/base.html:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}{% endblock %}</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css">
    {% block extra_head %}{% endblock %}
</head>
<body>
    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
        <div class="container">
            <a class="navbar-brand" href="{% url 'home' %}">App Demo</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="collapse navbar-collapse" id="navbarNav">
                <ul class="navbar-nav">
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'home' %}">Home</a>
                    </li>
                    {% if user.is_authenticated %}
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'dashboard' %}">Dashboard</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'logout' %}">Logout</a>
                    </li>
                    {% else %}
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'login' %}">Login</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'register' %}">Registrati</a>
                    </li>
                    {% endif %}
                </ul>
            </div>
        </div>
    </nav>

    <div class="container my-4">
        {% block content %}{% endblock %}
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
    {% block extra_body %}{% endblock %}
</body>
</html>

13. frontend/templates/frontend/home.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

{% extends 'frontend/base.html' %}

{% block title %}Home{% endblock %}

{% block content %}
    <h1>Benvenuto nell'App Demo</h1>
    <h2>Articoli</h2>
    {% for article in articles %}
        <div class="card mb-3">
            <div class="card-body">
                <h5 class="card-title">{{ article.title }}</h5>
                <p class="card-text">{{ article.content }}</p>
                <p class="card-text"><small class="text-muted">Pubblicato il {{ article.pub_date }}</small></p>
            </div>
        </div>
    {% endfor %}
{% endblock %}

14. backend/templates/backend/dashboard.html:

1
2
3
4
5
6
7
8

{% extends 'frontend/base.html' %}

{% block title %}Dashboard{% endblock %}

{% block content %}
    <h1>Dashboard</h1>
    <p>Benvenuto nella dashboard di amministrazione.</p>
{% endblock %}

Dopo aver creato questi file, esegui le migrazioni per creare le tabelle nel database:

1
2

python manage.py makemigrations
python manage.py migrate

Quindi, crea un superutente per accedere all’area di amministrazione di Django:

1

python manage.py createsuperuser

Inserisci le credenziali richieste (username, email e password).

A questo punto, puoi avviare il server di sviluppo di Django con il comando:

1

python manage.py runserver

E accedere all’area di amministrazione all’indirizzo http://127.0.0.1:8000/admin/ utilizzando le credenziali del superutente appena create.

Pre-popolamento del database con dati di esempio

Django offre un modo semplice per pre-popolare il database con dati di esempio durante lo sviluppo o durante il processo di deployment. Puoi creare file di dati di esempio (noti come fixture) in formato JSON o XML e caricarli nel database.

1. Creare un file di fixture:

Crea una nuova cartella fixtures all’interno di ogni app in cui desideri aggiungere dati di esempio. Ad esempio, frontend/fixtures e backend/fixtures.

Quindi, crea un nuovo file all’interno della cartella fixtures, ad esempio articles.json per l’app frontend:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

[
  {
    "model": "frontend.article",
    "pk": 1,
    "fields": {
      "title": "Primo articolo",
      "content": "Questo è il contenuto del primo articolo.",
      "pub_date": "2023-05-01T12:00:00Z"
    }
  },
  {
    "model": "frontend.article",
    "pk": 2,
    "fields": {
      "title": "Secondo articolo",
      "content": "Questo è il contenuto del secondo articolo.",
      "pub_date": "2023-05-02T10:30:00Z"
    }
  }
]

Questo file JSON contiene una lista di oggetti che rappresentano i dati da caricare nel database. Ogni oggetto ha una chiave model che specifica il modello Django a cui appartengono i dati, una chiave pk (primary key) per identificare in modo univoco ogni record, e una chiave fields che contiene i valori dei campi del modello.

2. Caricare i dati di esempio nel database:

Per caricare i dati di esempio nel database, utilizza il comando loaddata di Django:

1

python manage.py loaddata frontend/fixtures/articles.json

Questo comando caricherà i dati dal file articles.json nel database.

Puoi creare più file di fixture e caricarli separatamente o tutti insieme:

1

python manage.py loaddata frontend/fixtures/articles.json backend/fixtures/users.json

3. Eliminare i dati di esempio dal database:

Se desideri eliminare i dati di esempio dal database, puoi utilizzare il comando flush di Django:

1

python manage.py flush

Questo comando eliminerà tutti i dati dal database. Assicurati di utilizzarlo solo durante lo sviluppo o il testing, e non in un ambiente di produzione.

4. Caricare i dati di esempio durante il deployment:

Durante il processo di deployment, puoi caricare i dati di esempio nel database utilizzando gli stessi comandi loaddata. Puoi aggiungere questi comandi a uno script di deployment o a un file di configurazione per il tuo server di produzione.

Ad esempio, in un server Ubuntu con Nginx e PostgreSQL, potresti aggiungere il comando loaddata al tuo script di deployment:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Esegui le migrazioni
python manage.py migrate

# Carica i dati di esempio
python manage.py loaddata frontend/fixtures/articles.json backend/fixtures/users.json

# Raccogli i file statici
python manage.py collectstatic

# Restart del server web (ad esempio, Nginx)
sudo systemctl restart nginx

In questo modo, ogni volta che esegui il deployment, il database verrà aggiornato con i dati di esempio più recenti.

Ricorda che i file di fixture sono pensati per essere utilizzati durante lo sviluppo o per pre-popolare il database con dati di esempio iniziali. Per aggiornare i dati in un ambiente di produzione, dovrai sviluppare script personalizzati o utilizzare altre tecniche di migrazione dei dati.

Ubuntu - Nginx - PostgreSQL

1. Installazione delle dipendenze di produzione:

Installa PostgreSQL e Nginx sul tuo server Ubuntu. Puoi utilizzare i seguenti comandi:

1
2

sudo apt-get update
sudo apt-get install postgresql nginx

2. Configurazione del database PostgreSQL:

Crea un nuovo database PostgreSQL e un utente con i privilegi necessari. Puoi utilizzare i seguenti comandi:

1
2
3
4

sudo -u postgres psql
CREATE DATABASE nome_database;
CREATE USER nome_utente WITH PASSWORD 'password';
GRANT ALL PRIVILEGES ON DATABASE nome_database TO nome_utente;

3. Configurazione delle impostazioni di produzione in Django:

In nome_progetto/settings.py, aggiungi una variabile di ambiente per controllare l’ambiente di esecuzione e configura le impostazioni di database di conseguenza. Utilizzando una libreria come python-decouple, puoi gestire le variabili d’ambiente in modo sicuro.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from decouple import config

# Imposta la variabile di ambiente per l'ambiente di esecuzione
ENV = config('ENV', default='development')

if ENV == 'production':
    # Impostazioni di produzione
    DEBUG = False
    ALLOWED_HOSTS = ['tuo_dominio.com', 'tuo_server_ip']

    # Impostazioni del database PostgreSQL
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql',
            'NAME': config('DB_NAME'),
            'USER': config('DB_USER'),
            'PASSWORD': config('DB_PASSWORD'),
            'HOST': config('DB_HOST'),
            'PORT': config('DB_PORT'),
        }
    }
else:
    # Impostazioni di sviluppo (con SQLite)
    DEBUG = True
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': BASE_DIR / 'db.sqlite3',
        }
    }

Assicurati di creare un file .env nella directory principale del progetto e di impostare le variabili d’ambiente necessarie per il database PostgreSQL, ad esempio:

1
2
3
4
5
6

ENV=production
DB_NAME=nome_database
DB_USER=nome_utente
DB_PASSWORD=password
DB_HOST=localhost
DB_PORT=5432

4. Raccolta dei file statici:

Prima del deployment, raccogli i file statici in una cartella specifica utilizzando il comando:

1

python manage.py collectstatic

5. Configurazione di Nginx:

Configura Nginx per servire l’applicazione Django. Crea un file di configurazione in /etc/nginx/sites-available/ e collega il file alla cartella staticfiles di Django.

6. Utilizzo di un server WSGI:

Utilizza un server WSGI come Gunicorn per eseguire l’applicazione Django in produzione. Puoi installare Gunicorn con il comando:

1

pip install gunicorn

Quindi, esegui il server Gunicorn con il comando:

1

gunicorn --bind 0.0.0.0:8000 nome_progetto.wsgi

7. Configurazione di un processo di gestione come Supervisor:

Per mantenere il server Gunicorn in esecuzione e gestire il riavvio automatico in caso di errori, puoi utilizzare un processo di gestione come Supervisor. Configura Supervisor per avviare e monitorare il processo Gunicorn.

8. Esecuzione delle migrazioni di database:

Prima di avviare l’applicazione in produzione, esegui le migrazioni di database con il comando:

1

python manage.py migrate

9. Caricamento dei dati di produzione:

Se necessario, carica i dati di produzione nel database PostgreSQL utilizzando i comandi di Django o script personalizzati.

10. Riavvio di Nginx:

Dopo aver completato la configurazione, riavvia Nginx per applicare le modifiche.

1

sudo systemctl restart nginx

A questo punto, l’applicazione Django dovrebbe essere accessibile tramite il tuo dominio o l’indirizzo IP del server. Ricorda di configurare correttamente le impostazioni di sicurezza, come l’utilizzo di un certificato SSL/TLS e l’abilitazione di altre misure di sicurezza necessarie.

Con questa configurazione, durante lo sviluppo, l’applicazione utilizzerà SQLite come database predefinito, mentre in produzione verrà utilizzato PostgreSQL. La variabile di ambiente ENV controlla quale set di impostazioni deve essere utilizzato. Puoi aggiungere ulteriori impostazioni specifiche per l’ambiente di produzione, come la gestione dei log, la memorizzazione in cache e altre ottimizzazioni.

Ubuntu - Apache - PostgreSQL

1. Installazione delle dipendenze di produzione:

Installa PostgreSQL e Apache sul tuo server Ubuntu. Puoi utilizzare i seguenti comandi:

1
2

sudo apt-get update
sudo apt-get install postgresql apache2 libapache2-mod-wsgi-py3

2. Configurazione del database PostgreSQL:

Crea un nuovo database PostgreSQL e un utente con i privilegi necessari. Puoi utilizzare i seguenti comandi:

1
2
3
4

sudo -u postgres psql
CREATE DATABASE nome_database;
CREATE USER nome_utente WITH PASSWORD 'password';
GRANT ALL PRIVILEGES ON DATABASE nome_database TO nome_utente;

3. Configurazione delle impostazioni di produzione in Django:

In nome_progetto/settings.py, aggiungi una variabile di ambiente per controllare l’ambiente di esecuzione e configura le impostazioni di database di conseguenza. Utilizzando una libreria come python-decouple, puoi gestire le variabili d’ambiente in modo sicuro.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from decouple import config

# Imposta la variabile di ambiente per l'ambiente di esecuzione
ENV = config('ENV', default='development')

if ENV == 'production':
    # Impostazioni di produzione
    DEBUG = False
    ALLOWED_HOSTS = ['tuo_dominio.com', 'tuo_server_ip']

    # Impostazioni del database PostgreSQL
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql',
            'NAME': config('DB_NAME'),
            'USER': config('DB_USER'),
            'PASSWORD': config('DB_PASSWORD'),
            'HOST': config('DB_HOST'),
            'PORT': config('DB_PORT'),
        }
    }
else:
    # Impostazioni di sviluppo (con SQLite)
    DEBUG = True
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': BASE_DIR / 'db.sqlite3',
        }
    }

Assicurati di creare un file .env nella directory principale del progetto e di impostare le variabili d’ambiente necessarie per il database PostgreSQL, ad esempio:

1
2
3
4
5
6

ENV=production
DB_NAME=nome_database
DB_USER=nome_utente
DB_PASSWORD=password
DB_HOST=localhost
DB_PORT=5432

4. Raccolta dei file statici:

Prima del deployment, raccogli i file statici in una cartella specifica utilizzando il comando:

1

python manage.py collectstatic

5. Configurazione di Apache:

Configura Apache per servire l’applicazione Django. Crea un file di configurazione in /etc/apache2/sites-available/ e collega il file alla cartella staticfiles di Django.

Esempio di configurazione Apache:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

<VirtualHost *:80>
    ServerName tuo_dominio.com

    Alias /static /percorso/alla/cartella/staticfiles

    <Directory /percorso/alla/cartella/staticfiles>
        Require all granted
    </Directory>

    <Directory /percorso/al/progetto/nome_progetto>
        <Files wsgi.py>
            Require all granted
        </Files>
    </Directory>

    WSGIDaemonProcess nome_progetto python-path=/percorso/al/progetto:/percorso/alle/python/site-packages
    WSGIProcessGroup nome_progetto
    WSGIScriptAlias / /percorso/al/progetto/nome_progetto/wsgi.py

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Sostituisci /percorso/al/progetto con il percorso effettivo del tuo progetto Django sul server.

6. Esecuzione delle migrazioni di database:

Prima di avviare l’applicazione in produzione, esegui le migrazioni di database con il comando:

1

python manage.py migrate

7. Caricamento dei dati di produzione:

Se necessario, carica i dati di produzione nel database PostgreSQL utilizzando i comandi di Django o script personalizzati.

8. Abilitazione del sito Apache:

Abilita il sito Apache appena configurato con il comando:

1

sudo a2ensite nome_sito

9. Riavvio di Apache:

Dopo aver completato la configurazione, riavvia Apache per applicare le modifiche.

1

sudo systemctl restart apache2

A questo punto, l’applicazione Django dovrebbe essere accessibile tramite il tuo dominio o l’indirizzo IP del server. Ricorda di configurare correttamente le impostazioni di sicurezza, come l’utilizzo di un certificato SSL/TLS e l’abilitazione di altre misure di sicurezza necessarie.

Con questa configurazione, durante lo sviluppo, l’applicazione utilizzerà SQLite come database predefinito, mentre in produzione verrà utilizzato PostgreSQL. La variabile di ambiente ENV controlla quale set di impostazioni deve essere utilizzato. Puoi aggiungere ulteriori impostazioni specifiche per l’ambiente di produzione, come la gestione dei log, la memorizzazione in cache e altre ottimizzazioni.

Microsoft - IIS - Sql Server

1. Installazione delle dipendenze di produzione:

Installa SQL Server sul tuo server Windows. Puoi scaricare l’edizione appropriata dal sito web di Microsoft e seguire le istruzioni di installazione.

Assicurati che IIS sia installato e abilitato sul tuo server Windows.

2. Configurazione del database SQL Server:

Crea un nuovo database SQL Server e un utente con i privilegi necessari. Puoi utilizzare SQL Server Management Studio o eseguire query SQL per creare il database e l’utente.

3. Configurazione delle impostazioni di produzione in Django:

In nome_progetto/settings.py, aggiungi una variabile di ambiente per controllare l’ambiente di esecuzione e configura le impostazioni di database di conseguenza. Utilizzando una libreria come python-decouple, puoi gestire le variabili d’ambiente in modo sicuro.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

from decouple import config

# Imposta la variabile di ambiente per l'ambiente di esecuzione
ENV = config('ENV', default='development')

if ENV == 'production':
    # Impostazioni di produzione
    DEBUG = False
    ALLOWED_HOSTS = ['tuo_dominio.com', 'tuo_server_ip']

    # Impostazioni del database SQL Server
    DATABASES = {
        'default': {
            'ENGINE': 'mssql',
            'NAME': config('DB_NAME'),
            'USER': config('DB_USER'),
            'PASSWORD': config('DB_PASSWORD'),
            'HOST': config('DB_HOST'),
            'PORT': config('DB_PORT'),
            'OPTIONS': {
                'driver': 'ODBC Driver 17 for SQL Server',
            },
        }
    }
else:
    # Impostazioni di sviluppo (con SQLite)
    DEBUG = True
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': BASE_DIR / 'db.sqlite3',
        }
    }

Assicurati di creare un file .env nella directory principale del progetto e di impostare le variabili d’ambiente necessarie per il database SQL Server, ad esempio:

1
2
3
4
5
6

ENV=production
DB_NAME=nome_database
DB_USER=nome_utente
DB_PASSWORD=password
DB_HOST=localhost
DB_PORT=1433

4. Raccolta dei file statici:

Prima del deployment, raccogli i file statici in una cartella specifica utilizzando il comando:

1

python manage.py collectstatic

5. Configurazione di IIS:

Configura IIS per servire l’applicazione Django. Crea un nuovo sito web in IIS e configura il gestore di processo Web (Web Handler) per IIS per utilizzare il server WSGI di Django.

6. Installazione di un server WSGI:

Installa un server WSGI come Daphne o Uvicorn utilizzando pip. Ad esempio, per installare Daphne:

1

pip install daphne

7. Esecuzione delle migrazioni di database:

Prima di avviare l’applicazione in produzione, esegui le migrazioni di database con il comando:

1

python manage.py migrate

8. Caricamento dei dati di produzione:

Se necessario, carica i dati di produzione nel database SQL Server utilizzando i comandi di Django o script personalizzati.

9. Avvio del server WSGI:

Avvia il server WSGI con il comando appropriato. Ad esempio, per Daphne:

1

daphne -b 0.0.0.0 -p 8000 nome_progetto.asgi:application

10. Configurazione di IIS per l’applicazione Django:

In IIS, configura il sito web per l’applicazione Django. Puoi utilizzare l’indirizzo IP e la porta su cui è in esecuzione il server WSGI (ad esempio, http://127.0.0.1:8000).

A questo punto, l’applicazione Django dovrebbe essere accessibile tramite il tuo dominio o l’indirizzo IP del server. Ricorda di configurare correttamente le impostazioni di sicurezza, come l’utilizzo di un certificato SSL/TLS e l’abilitazione di altre misure di sicurezza necessarie.

Con questa configurazione, durante lo sviluppo, l’applicazione utilizzerà SQLite come database predefinito, mentre in produzione verrà utilizzato SQL Server. La variabile di ambiente ENV controlla quale set di impostazioni deve essere utilizzato. Puoi aggiungere ulteriori impostazioni specifiche per l’ambiente di produzione, come la gestione dei log, la memorizzazione in cache e altre ottimizzazioni.

Nota: Assicurati di avere i driver appropriati installati per connetterti a SQL Server da Django. Nell’esempio sopra, viene utilizzato il driver ODBC, ma puoi anche usare altri driver come il driver PyODBC o il driver SQL Server ufficiale di Microsoft.