Die effektive Verwaltung von Aufgaben ist in unserem geschäftigen Leben von entscheidender Bedeutung, und eine To-Do-Listen-Anwendung kann ein hervorragendes Werkzeug sein, um organisiert zu bleiben. Dieser Blogbeitrag führt Sie durch die Entwicklung einer To-Do-Listen-Anwendung mit Django, einem leistungsstarken und vielseitigen Web-Framework in Python. Das Projekt mit dem Titel django-todoList soll Benutzern helfen, ihre täglichen Aufgaben nahtlos zu erstellen, zu verwalten und zu verfolgen.
Python installiert (vorzugsweise Version 3.8 oder höher).
Django installiert. Wenn nicht, können Sie es mit dem folgenden Befehl installieren.
pip install django
Erstellen Sie zunächst ein neues Django-Projekt mit dem folgenden Befehl:
django-admin startproject mysite
Navigieren Sie in Ihren Projektordner:
cd mysite
Als nächstes erstellen Sie eine App innerhalb des Projekts. Wir nennen es todoList:
python manage.py startapp todoList
In Django werden Modelle verwendet, um die Struktur Ihrer Daten zu definieren. Für die GetDone To-Do-App benötigen wir ein Modell zur Darstellung einer Aufgabe.
Navigieren Sie zu todoList/models.py und definieren Sie das Aufgabenmodell:
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
Dieses Modell enthält Felder wie Titel, Beschreibung, Frist und Vollständigkeit, um Details zu jeder Aufgabe zu speichern. Außerdem verknüpfen wir jede Aufgabe über den Benutzerfremdschlüssel mit einem Benutzer.
Sobald das Modell fertig ist, führen Sie die Migrationen aus, um die Tabelle für dieses Modell in der Datenbank zu erstellen:
python manage.py makemigrations python manage.py migrate
Wir benötigen Formulare, um Benutzereingaben zum Erstellen und Aktualisieren von Aufgaben zu verarbeiten. Erstellen Sie in todoList/forms.py das 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
Das TaskForm verwendet Djangos ModelForm, um automatisch Formularfelder für das Task-Modell zu erstellen.
Als nächstes müssen wir Ansichten erstellen, um Benutzeranfragen zu bearbeiten, z. B. Aufgaben zu erstellen, zu aktualisieren und aufzulisten.
Definieren Sie in todoList/views.py die Ansichten:
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: Listet alle Aufgaben für den angemeldeten Benutzer auf.
-TaskCreate: Verwaltet die Aufgabenerstellung.
-TaskUpdate: Ermöglicht Benutzern das Aktualisieren einer Aufgabe.
-TaskDelete: Stellt eine Bestätigungsseite zum Löschen einer Aufgabe bereit.
Das LoginRequiredMixin stellt sicher, dass nur angemeldete Benutzer auf diese Ansichten zugreifen können.
Ordnen Sie in todoList/urls.py URLs ihren jeweiligen Ansichten zu:
pip install django
Diese URL-Muster ordnen jede Ansicht einer bestimmten URL zu. Beispielsweise wird die Aufgabenliste unter der Stamm-URL der App angezeigt und Benutzer können Aufgaben erstellen, bearbeiten oder löschen, indem sie bestimmte URLs besuchen.
Erstellen Sie die folgenden HTML-Vorlagen, um die Ansichten zu rendern:
Die Basisvorlage bietet ein einheitliches Layout für alle Seiten:
django-admin startproject mysite
In „views.py“ können Sie die integrierten Benutzerauthentifizierungsansichten von Django verwenden, um die Benutzerregistrierung und -anmeldung zu verwalten. Sie können beispielsweise UserCreationForm verwenden, um Benutzern die Anmeldung zu ermöglichen:
cd mysite
Sobald alles eingerichtet ist, können Sie den Server ausführen:
python manage.py startapp todoList
Besuchen Sie http://127.0.0.1:8000/todoList, um Ihre To-Do-Listen-App in Aktion zu sehen!
Die Datei „settings.py“ ist ein wichtiger Bestandteil jedes Django-Projekts. Es enthält die Konfigurationseinstellungen für Ihr Projekt, wie Datenbankeinstellungen, installierte Apps, Middleware, Konfiguration statischer Dateien und mehr. Diese Datei steuert das Verhalten Ihres Projekts und ermöglicht Django, die Punkte zwischen verschiedenen Komponenten zu verbinden.
Hier ist ein kurzer Überblick über die wichtigsten Einstellungen in Settings.py für Ihre GetDone To-Do List-App:
Installierte Apps: In der Liste INSTALLED_APPS registrieren Sie alle in Ihrem Projekt verwendeten Apps. Zum Beispiel:
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
Hier haben wir todoList hinzugefügt, die App, die die Aufgaben verwaltet, neben den von Django bereitgestellten Standard-Apps für Benutzerauthentifizierung, Admin-Panel und statische Dateien.
In Django übernimmt die Datei urls.py die Weiterleitung von HTTP-Anfragen an Ansichten. Hier ordnen Sie URL-Muster (z. B. /tasks/, /login/) den entsprechenden Ansichten zu, die sie verarbeiten.
In mysite/urls.py fügen Sie normalerweise URLs für das gesamte Projekt ein und verknüpfen sie mit der urls.py-Datei auf App-Ebene.
So sieht urls.py in Ihrer GetDone-App aus:
URLs.py auf Projektebene (mysite/urls.py): Die Datei urls.py im Ordner mysite ist der Hauptrouter für Ihr gesamtes Django-Projekt. Es enthält die URLs für das Admin-Panel, die Authentifizierung und Links zu den spezifischen URLs Ihrer App. Hier ist ein Beispiel:
pip install django
path('admin/', admin.site.urls): Diese Zeile enthält das Django-Admin-Panel.
path('accounts/', include('django.contrib.auth.urls')): Dies umfasst integrierte Authentifizierungs-URLs für die Anmeldung, Abmeldung und Passwortverwaltung.
path('', include('todoList.urls')): Dazu gehören die app-spezifischen URLs (definiert in todoList/urls.py), sodass Benutzer durch Aufgaben und andere Funktionen navigieren können.
App-Level urls.py (todoList/urls.py): Diese Datei ordnet bestimmte URLs Ansichten innerhalb der todoList-App zu. Es enthält Pfade zum Anzeigen von Aufgaben, Erstellen von Aufgaben und anderen aufgabenbezogenen Aktionen. Zum Beispiel:
django-admin startproject mysite
TodoListView.as_view(): Diese Ansicht listet alle Aufgaben für den angemeldeten Benutzer auf.
TaskCreate.as_view(): Diese Ansicht verwaltet das Aufgabenerstellungsformular.
TaskUpdate.as_view(): Diese Ansicht verwaltet das Aufgabenaktualisierungsformular.
TaskDelete.as_view(): Diese Ansicht verwaltet die Bestätigungsseite zum Löschen von Aufgaben.
Djangos Architektur ermöglicht eine reibungslose Kommunikation zwischen den verschiedenen Dateien und Komponenten:
Die urls.py ordnet URLs Ansichten zu, z. B. der Aufgabenerstellung oder der Listenanzeige. Ansichten werden in „views.py“ definiert.
Ansichten interagieren mit Modellen (definiert in models.py), um Daten (Aufgaben) abzurufen und zu bearbeiten. In TodoListView beispielsweise ruft die Ansicht mit Task.objects.filter(user=self.request.user) Aufgaben ab, die dem angemeldeten Benutzer zugeordnet sind.
Formulare (wie TaskForm in Forms.py) verarbeiten Benutzereingaben und interagieren mit Modellen, um die Daten zu validieren und zu speichern.
Vorlagen rendern die endgültige Ausgabe in HTML, zeigen von Ansichten übergebene Daten an und verarbeiten Benutzereingaben über Formulare.
Mit diesen Schritten haben Sie mit Django eine voll funktionsfähige To-Do-Listen-App erstellt. Sie haben die Benutzerauthentifizierung und Aufgabenverwaltung (Erstellen, Bearbeiten, Löschen) implementiert und erfahren, wie die MVC-Architektur (MTV) von Django die reibungslose Kommunikation zwischen Modellen, Ansichten, Vorlagen und URLs erleichtert. Dieser Leitfaden dient als solide Grundlage für die zukünftige Erstellung komplexerer Django-Anwendungen.
Der vollständige Code der Anwendung kann unter
geklont werden
cd mysite
Viel Spaß beim Codieren! ?
Das obige ist der detaillierte Inhalt vonGet Done ✅: Eine Schritt-für-Schritt-Anleitung zum Erstellen einer Django-To-Do-Liste. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
