Get Done ✅ : Un guide étape par étape pour créer une liste de tâches Django

Introduction

Gérer efficacement les tâches est crucial dans nos vies bien remplies, et une application de liste de tâches peut être un excellent outil pour rester organisé. Cet article de blog vous guide à travers le développement d'une application de liste de tâches à l'aide de Django, un framework Web puissant et polyvalent en Python. Le projet, intitulé django-todoList, est conçu pour aider les utilisateurs à créer, gérer et suivre leurs tâches quotidiennes de manière transparente.

Conditions préalables

Avant de commencer, assurez-vous d'avoir les éléments suivants :

• Python installé (de préférence version 3.8 ou supérieure).

• Django installé. Sinon, vous pouvez l'installer à l'aide de la commande suivante.
  

pip install django

• Une compréhension de base du fonctionnement de Django et une familiarité avec Python et HTML.

Étape 1 : Mise en place du projet

1.1 Créer un projet Django

Tout d'abord, créez un nouveau projet Django à l'aide de la commande :

django-admin startproject mysite

Naviguez dans votre dossier de projet :

cd mysite

1.2 Créer une application Django

Ensuite, créez une application dans le projet. Nous l'appellerons todoList :

python manage.py startapp todoList

Étape 2 : Définir les modèles

Dans Django, les modèles sont utilisés pour définir la structure de vos données. Pour l'application GetDone To-Do, nous avons besoin d'un modèle pour représenter une tâche.

Accédez à todoList/models.py et définissez le modèle de tâche :

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

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    complete = models.BooleanField(default=False)
    created = models.DateTimeField(auto_now_add=True)
    deadline = models.DateTimeField(null=True, blank=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.title

Ce modèle comprend des champs tels que le titre, la description, la date limite et le remplissage pour stocker les détails de chaque tâche. Nous associons également chaque tâche à un utilisateur via la clé étrangère utilisateur.

2.1 Migrer la base de données

Une fois le modèle prêt, lancez les migrations pour créer la table de ce modèle dans la base de données :

python manage.py makemigrations
python manage.py migrate

Étape 3 : Créer des formulaires

Nous avons besoin de formulaires pour gérer les entrées des utilisateurs pour la création et la mise à jour des tâches. Dans todoList/forms.py, créez le TaskForm :

from django import forms
from .models import Task

class TaskForm(forms.ModelForm):
    class Meta:
        model = Task
        fields = ['title', 'description', 'deadline', 'complete']
        widgets = {
            'title': forms.TextInput(attrs={'placeholder': 'Enter task title'}),
            'description': forms.Textarea(attrs={'placeholder': 'Enter task description', 'rows': 4}),
            'deadline': forms.DateTimeInput(attrs={'type': 'datetime-local'}),
            'complete': forms.CheckboxInput(),
        }

    def clean_title(self):
        title = self.cleaned_data.get('title')
        if not title:
            raise forms.ValidationError('Title is required')
        return title

    def clean_description(self):
        description = self.cleaned_data.get('description')
        if not description:
            raise forms.ValidationError('Description is required')
        return description

    def clean_deadline(self):
        deadline = self.cleaned_data.get('deadline')
        if not deadline:
            raise forms.ValidationError('Deadline is required')
        return deadline

Le TaskForm utilise le ModelForm de Django pour créer automatiquement des champs de formulaire pour le modèle Task.

Étape 4 : Définir les vues

Ensuite, nous devons créer des vues pour gérer les demandes des utilisateurs, telles que la création de tâches, leur mise à jour et leur liste.

Dans todoList/views.py, définissez les vues :

from django.shortcuts import render, redirect
from django.views.generic import ListView, CreateView, UpdateView, DeleteView
from django.contrib.auth.views import LoginView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.forms import UserCreationForm
from django.urls import reverse_lazy
from .models import Task
from .forms import TaskForm
from django.contrib import messages
from django.utils import timezone


# Task List View
class TodoListView(LoginRequiredMixin, ListView):
    model = Task
    context_object_name = 'tasks'
    template_name = 'task_list.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        user_tasks = Task.objects.filter(user=self.request.user)
        context['tasks'] = Task.objects.filter(user=self.request.user)
        context['incomplete_tasks_count'] = user_tasks.filter(complete=False).count()  # Count incomplete tasks
        context['now'] = timezone.now()
        return context

# Task Create View
class TaskCreate(LoginRequiredMixin, CreateView):
    model = Task
    form_class = TaskForm
    template_name = 'todoList/task_create.html'
    success_url = reverse_lazy('todoList')

    def form_valid(self, form):
        form.instance.user = self.request.user
        messages.success(self.request, 'Task created successfully!')
        return super(TaskCreate, self).form_valid(form)

# Task Update View
class TaskUpdate(LoginRequiredMixin, UpdateView):
    model = Task
    form_class = TaskForm
    template_name = 'todoList/task_update.html'
    success_url = reverse_lazy('todoList')
    def form_valid(self, form):
        messages.success(self.request, 'Task updated successfully!')
        return super(TaskUpdate, self).form_valid(form)

# Task Delete View
class TaskDelete(LoginRequiredMixin, DeleteView):
    model = Task
    context_object_name = 'task'
    template_name = 'todoList/task_delete.html'
    success_url = reverse_lazy('todoList')
    def dispatch(self, request, *args, **kwargs):
        response = super().dispatch(request, *args, **kwargs)
        if response.status_code == 302:
            messages.success(self.request, 'Task deleted successfully!')
        return response

# User Registration View
class RegisterView(CreateView):
    form_class = UserCreationForm
    template_name = 'todoList/register.html'
    success_url = reverse_lazy('todoList')

    def form_valid(self, form):
        response = super().form_valid(form)
        # Log the user in after successful registration
        from django.contrib.auth import login
        login(self.request, self.object)
        messages.success(self.request, 'Registration successful! Welcome!')
        return response


# Login View
class CustomLoginView(LoginView):
    template_name = 'todoList/login.html'
    fields = '__all__'
    redirect_authenticated_user = True

    def get_success_url(self):
        messages.success(self.request, 'You have logged in successfully!')
        return reverse_lazy('todoList')

-TodoListView : répertorie toutes les tâches de l'utilisateur connecté.
-TaskCreate : gère la création de tâches.
-TaskUpdate : permet aux utilisateurs de mettre à jour une tâche.
-TaskDelete : fournit une page de confirmation pour la suppression d'une tâche.
Le LoginRequiredMixin garantit que seuls les utilisateurs connectés peuvent accéder à ces vues.

Étape 5 : Configurer les URL

Dans todoList/urls.py, mappez les URL à leurs vues respectives :

pip install django

Ces modèles d'URL mapperont chaque vue à une URL spécifique. Par exemple, la liste des tâches est affichée à l'URL racine de l'application et les utilisateurs peuvent créer, modifier ou supprimer des tâches en visitant des URL spécifiques.

Étape 6 : Créer des modèles

Créez les modèles HTML suivants pour afficher les vues :

6.1 base.html

Le modèle de base fournit une mise en page cohérente pour toutes les pages :

django-admin startproject mysite

Étape 8 : Ajouter l'authentification de l'utilisateur

Dans vues.py, vous pouvez utiliser les vues d'authentification utilisateur intégrées de Django pour gérer l'enregistrement et la connexion des utilisateurs. Par exemple, vous pouvez utiliser UserCreationForm pour permettre aux utilisateurs de s'inscrire :

cd mysite

Étape 8 : Exécutez le serveur

Une fois tout configuré, vous pouvez lancer le serveur :

python manage.py startapp todoList

Visitez http://127.0.0.1:8000/todoList pour voir votre application To-Do List en action !

Comprendre settings.py et urls.py dans le dossier mysite

paramètres.py

Le fichier settings.py est une partie cruciale de chaque projet Django. Il contient les paramètres de configuration de votre projet, tels que les paramètres de base de données, les applications installées, le middleware, la configuration des fichiers statiques, etc. Ce fichier contrôle le comportement de votre projet et permet à Django de relier les points entre différents composants.

Voici un bref aperçu des paramètres clés dans settings.py pour votre application GetDone To-Do List :

Sections clés dans settings.py :

Applications installées : dans la liste INSTALLED_APPS, vous enregistrez toutes les applications utilisées dans votre projet. Par exemple :

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

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    complete = models.BooleanField(default=False)
    created = models.DateTimeField(auto_now_add=True)
    deadline = models.DateTimeField(null=True, blank=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.title

Ici, nous avons ajouté todoList, qui est l'application qui gère les tâches, aux côtés des applications par défaut fournies par Django pour l'authentification des utilisateurs, le panneau d'administration et les fichiers statiques.

URL.py

Dans Django, le fichier urls.py gère le routage des requêtes HTTP vers les vues. C'est ici que vous mappez les modèles d'URL (tels que /tasks/, /login/) aux vues correspondantes qui les géreront.

Dans mysite/urls.py, vous incluez généralement les URL de l'ensemble du projet et les liez au fichier urls.py au niveau de l'application.

Voici à quoi ressemble urls.py dans votre application GetDone :

Sections clés dans urls.py :

urls.py au niveau du projet (monsite/urls.py) : le fichier urls.py dans le dossier monsite est le routeur principal de l'ensemble de votre projet Django. Il comprend les URL du panneau d'administration, l'authentification et des liens vers les URL spécifiques de votre application. Voici un exemple :

pip install django

path('admin/', admin.site.urls) : Cette ligne inclut le panneau d'administration de Django.
path('accounts/', include('django.contrib.auth.urls')) : cela inclut les URL d'authentification intégrées pour la connexion, la déconnexion et la gestion des mots de passe.
path('', include('todoList.urls')) : cela inclut les URL spécifiques à l'application (définies dans todoList/urls.py), afin que les utilisateurs puissent naviguer dans les tâches et autres fonctionnalités.
Urls.py au niveau de l'application (todoList/urls.py) : ce fichier mappe des URL spécifiques aux vues de l'application todoList. Il contient des chemins pour afficher les tâches, créer des tâches et d'autres actions liées aux tâches. Par exemple :

django-admin startproject mysite

TodoListView.as_view() : cette vue répertorie toutes les tâches de l'utilisateur connecté.
TaskCreate.as_view() : Cette vue gère le formulaire de création de tâche.
TaskUpdate.as_view() : Cette vue gère le formulaire de mise à jour des tâches.
TaskDelete.as_view() : cette vue gère la page de confirmation de suppression de tâche.

Communication entre fichiers

L'architecture de Django permet une communication fluide entre les différents fichiers et composants :

URL et vues :

Le fichier urls.py mappe les URL aux vues, telles que la création de tâches ou l'affichage de listes. Les vues sont définies dans vues.py.

Modèles et vues :

Les vues interagissent avec les modèles (définis dans models.py) pour récupérer et manipuler des données (tâches). Par exemple, dans TodoListView, la vue récupère les tâches associées à l'utilisateur connecté à l'aide de Task.objects.filter(user=self.request.user).

Formulaires et vues :

Les formulaires (comme TaskForm dans Forms.py) gèrent les entrées des utilisateurs et interagissent avec les modèles pour valider et enregistrer les données.

Modèles :

Les modèles restituent la sortie finale au format HTML, affichant les données transmises à partir des vues et gérant les entrées de l'utilisateur via des formulaires.

Conclusion

Avec ces étapes, vous avez créé une application de liste de tâches entièrement fonctionnelle à l'aide de Django. Vous avez implémenté l'authentification des utilisateurs, la gestion des tâches (créer, modifier, supprimer) et appris comment l'architecture MVC (MTV) de Django facilite la communication fluide entre les modèles, les vues, les modèles et les URL. Ce guide sert de base solide pour créer des applications Django plus complexes à l'avenir.

Le code complet de l'application est disponible pour le cloner sur

cd mysite

Bon codage ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!