Get Done ✅: Eine Schritt-für-Schritt-Anleitung zum Erstellen einer Django-To-Do-Liste

Einführung

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.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

• 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

• Ein grundlegendes Verständnis der Funktionsweise von Django und Vertrautheit mit Python und HTML.

Schritt 1: Einrichten des Projekts

1.1 Erstellen Sie ein Django-Projekt

Erstellen Sie zunächst ein neues Django-Projekt mit dem folgenden Befehl:

django-admin startproject mysite

Navigieren Sie in Ihren Projektordner:

cd mysite

1.2 Erstellen Sie eine Django-App

Als nächstes erstellen Sie eine App innerhalb des Projekts. Wir nennen es todoList:

python manage.py startapp todoList

Schritt 2: Modelle definieren

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.

2.1 Migrieren Sie die Datenbank

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

Schritt 3: Formulare erstellen

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.

Schritt 4: Ansichten definieren

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.

Schritt 5: URLs konfigurieren

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.

Schritt 6: Vorlagen erstellen

Erstellen Sie die folgenden HTML-Vorlagen, um die Ansichten zu rendern:

6.1 base.html

Die Basisvorlage bietet ein einheitliches Layout für alle Seiten:

django-admin startproject mysite

Schritt 8: Benutzerauthentifizierung hinzufügen

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

Schritt 8: Führen Sie den Server aus

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!

Grundlegendes zu „settings.py“ und „urls.py“ im mysite-Ordner

Settings.py

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:

Wichtige Abschnitte in „settings.py“:

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.

urls.py

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:

Wichtige Abschnitte in urls.py:

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.

Kommunikation zwischen Dateien

Djangos Architektur ermöglicht eine reibungslose Kommunikation zwischen den verschiedenen Dateien und Komponenten:

URLs und Ansichten:

Die urls.py ordnet URLs Ansichten zu, z. B. der Aufgabenerstellung oder der Listenanzeige. Ansichten werden in „views.py“ definiert.

Modelle und Ansichten:

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 und Ansichten:

Formulare (wie TaskForm in Forms.py) verarbeiten Benutzereingaben und interagieren mit Modellen, um die Daten zu validieren und zu speichern.

Vorlagen:

Vorlagen rendern die endgültige Ausgabe in HTML, zeigen von Ansichten übergebene Daten an und verarbeiten Benutzereingaben über Formulare.

Abschluss

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!