Ein öffentlicher Link

Teil des Abschnitts Benutzer und Konten der Django-Journey von Coddy. Lektion 16 von 16.

Eine geteilte Notiz braucht eine Adresse, die jede Person öffnen kann, unabhängig davon, ob sie angemeldet ist oder nicht, und die nur die Notiz anzeigt. Auf der Seite des Eigentümers gibt es „Bearbeiten“ und „Löschen“; auf dieser Seite darf es das nicht geben.

Du hast bereits alle Bausteine verwendet. Die Seite muss drei Dinge entscheiden: wer sie öffnen darf, welche Notizen sie finden darf und welche Vorlage sie verwendet.

Teste sie mit drei Personen: dem Eigentümer, einem anderen Benutzer und einem abgemeldeten Besucher.

Aufgabe

Mittel

Gib freigegebenen Notizen eine öffentliche Seite.

Füge in notes/urls.py shared/<int:pk>/ mit dem Namen shared für shared_note hinzu.
Schreibe in notes/views.py shared_note mit @login_not_required. Die Funktion findet nur freigegebene Notizen; bei jeder anderen Notiz wird 404 zurückgegeben.
Rendere notes/shared_note.html: Titel, Inhalt und Eigentümer, ohne Links zum Bearbeiten oder Löschen.
Verlinke in note_detail.html im Abschnitt für freigegebene Notizen Share link mit notes:shared.

Melde dich ab und öffne /shared/2/: Pancakes wird angezeigt, und /shared/1/ gibt 404 zurück.

Probier es selbst

from django.contrib.auth import login
from django.contrib.auth.decorators import login_not_required, permission_required
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404, redirect, render

from .forms import NoteForm
from .models import Note


def note_list(request):
    notes = Note.objects.filter(owner=request.user)
    return render(request, "notes/note_list.html", {"notes": notes})


def note_detail(request, pk):
    note = get_object_or_404(Note, pk=pk, owner=request.user)
    return render(request, "notes/note_detail.html", {"note": note})


def note_create(request):
    if request.method == "POST":
        form = NoteForm(request.POST)
        if form.is_valid():
            note = form.save(commit=False)
            note.owner = request.user
            note.save()
            return redirect("notes:detail", pk=note.pk)
    else:
        form = NoteForm()
    return render(request, "notes/note_form.html", {"form": form})


def note_edit(request, pk):
    note = get_object_or_404(Note, pk=pk, owner=request.user)
    if request.method == "POST":
        form = NoteForm(request.POST, instance=note)
        if form.is_valid():
            form.save()
            return redirect("notes:detail", pk=note.pk)
    else:
        form = NoteForm(instance=note)
    return render(request, "notes/note_form.html", {"form": form, "note": note})


def note_delete(request, pk):
    note = get_object_or_404(Note, pk=pk, owner=request.user)
    if request.method == "POST":
        note.delete()
        return redirect("notes:list")
    return render(request, "notes/note_confirm_delete.html", {"note": note})


@login_not_required
def signup(request):
    if request.method == "POST":
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)
            return redirect("notes:list")
    else:
        form = UserCreationForm()
    return render(request, "notes/signup.html", {"form": form})


def stats(request):
    if not request.user.is_staff:
        raise PermissionDenied
    context = {"user_count": User.objects.count(), "note_count": Note.objects.count()}
    return render(request, "notes/stats.html", context)


@permission_required("notes.view_note", raise_exception=True)
def all_notes(request):
    notes = Note.objects.select_related("owner")
    return render(request, "notes/all_notes.html", {"notes": notes})


def profile(request):
    note_count = request.user.notes.count()
    return render(request, "notes/profile.html", {"note_count": note_count})