Ein öffentlicher Link

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

Eine geteilte Notiz benötigt eine Adresse, die jede Person öffnen kann, ob angemeldet 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. Stelle die Fragen, die du zuvor beantwortet hast: Wer darf diese Seite auf einer privaten Website öffnen? Welche Notizen kann sie finden, und was antwortet sie für alle anderen? Welche Vorlage verhindert, dass die Seite auf „Bearbeiten“ und „Löschen“ verlinken kann? Ein Link kann nur dann sicher weitergegeben werden, wenn der Server ihn bei jeder Anfrage überprüft.

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

Aufgabe

Mittel

Eine öffentliche Seite unter /shared/<id>/ mit dem Namen shared, die jede Person öffnen kann. Sie zeigt den Titel und den Text einer geteilten Notiz sowie Shared by mit dem Benutzernamen der besitzenden Person.
Eine private Notiz liefert dort für alle einen 404-Fehler.
Keine Links zum Bearbeiten oder Löschen auf dieser Seite.
Auf der Seite einer geteilten Notiz gibt es einen Link Share link zu dieser Seite.

Klicke auf „Run“, melde dich ab und öffne /shared/2/.

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})