7.2. Czat 2

Dodawanie, edycja, usuwanie czy przeglądanie danych zgromadzonych w bazie są typowymi czynnościami w aplikacjach internetowych określanymi angielskim skrótem CRUD. Utworzony w scenariuszu Czat 1 kod ilustruje krok po korku obsługę żądań GET i POST oraz niektórych operacji CRUD (odczyt i dodawanie danych).

Django zawiera gotowe rozwiązania, które skracają realizację typowych zadań eliminując również potencjalne błędy. W tym scenariuszu poznasz m. in. widoki wbudowane oparte na klasach służące zarządzaniu użytkownikami oraz odczytywaniu, dodawaniu, edytowaniu i usuwaniu danych.

Uwaga

Wymagane oprogramowanie:

Środowisko wirtualne Pythona v. 3.x

Django v. 5.1.x

Opcjonalnie: interpreter bazy SQLite3

Zalecana wiedza i umiejętności:

Zrealizowany scenariusz Czat 1.

7.2.1. Środowisko pracy 

Do pracy potrzebujemy katalogu z utworzonym środowiskiem wirtualnym Pythona, w którym zainstalowano pakiet Django. Możemy wykorzystać katalog projekty_django ze scenariusza Czat 1 lub przygotować ten katalog od początku zgodnie z instrukcjami (zob. Czat 1 – Środowisko pracy

Następnie w katalogu projekty_django tworzymy nowy projekt o nazwie czat2:

Terminal nr

(.venv) ~/projekty_django$ django-admin startproject czat2
(.venv) ~/projekty_django$ cd czat2

7.2.2. Lista użytkowników 

Na początku zajmiemy się obsługą użytkowników, która realizowana będzie przez osobną aplikację.

W katalogu projekty_django/czat2 tworzymy aplikację o nazwie users:

Terminal nr

(.venv) ~/projekty_django/czat2$ python manage.py startapp users

Następnie tworzymy plik czat2/users/urls.py, w którym umieszczamy poniższy kod:

Plik urls.pyKod nr

from django.urls import path
from . import views

app_name = 'users'  # przestrzeń nazw aplikacji
urlpatterns = [
    path('', views.index, name='index'),
]

W liście urlpatterns definiujemy powiązanie między domyślnym adresem URL aplikacji i widokiem index.

Dalej w pliku czat2/users/views.py umieszczamy kod widoku, czyli funkcję index():

Plik views.pyKod nr

from django.contrib.auth.models import User
from django.shortcuts import render

def index(request):
    users = User.objects.all()
    kontekst = {'users': users}
    return render(request, 'users/index.html', kontekst)

Zadaniem widoku jest pobranie z bazy danych wszystkich użytkowników i przekazanie ich do szablonu.

Kolejnym krokiem jest utworzenie odpowiednich podkatalogów i umieszczenie kodu szablonu w pliku czat2/users/templates/users/index.html:

Plik index.htmlKod nr

<!-- templates/users/index.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Lista użytkowników</title>
</head>
<body>
    <h1>Lista użytkowników</h1>
    <ul>
    {% if users %}
        {% for user in users %}
            <li>{{ user.username }}</li>
        {% endfor %}
    {% else %}
        <p>Brak użytkowników!</p>
    {% endif %}
    </ul>

    {% if user.is_authenticated %}
        <p>Jesteś już zalogowany jako {{ user.username }}.</p>
    {% else %}
        <p><a href="{% url 'users:rejestruj' %}">Utwórz konto</a></p>
    {% endif %}
</body>
</html>

W pierwszym tagu warunkowym {% if users %} sprawdzamy, czy lista users zawiera jakichś użytkowników. Jeżeli tak, za pomocą tagu for wypiszemy ich nazwy, w przeciwnym razie komunikat „Brak użytkowników”.

W drugim tagu warunkowym {% if user.is_authenticated %} sprawdzamy, czy jakiś użytkownik jest zalogowany. Jeżeli tak, wypiszemy komunikat „Jesteś już zalogowany jako …”, w przeciwnym razie wypisany zostanie link do utworzenia konta.

7.2.3. Dodawanie użytkowników 

Użytkownicy będą mogli samodzielnie zakładać konta, logować i wylogowywać się. Inaczej niż w aplikacji Czat 1 zadania te zrealizujemy za pomocą tzw. widoków wbudowanych opartych na klasach (ang. class-based generic views).

W pliku czat2/users/urls.py importujemy formularz tworzenia użytkownika (UserCreationForm) oraz wbudowany widok przeznaczony do dodawania danych (CreateView):

Plik urls.pyKod nr

from django.urls import path
from . import views
from django.contrib.auth.forms import UserCreationForm
from django.views.generic import CreateView

W tym samym pliku czat2/users/urls.py w liście urlpatterns definiujemy adres URL /rejestruj, który obsługiwany będzie przez zaimportowany wyżej widok wywołany jako funkcja.

Plik urls.pyKod nr

    path('rejestruj/', CreateView.as_view(
        template_name='users/rejestruj.html',
        form_class=UserCreationForm,
        success_url='/users/'),
        name="rejestruj"),

Widok CreateView otrzymuje trzy argumenty, które przekazujemy do metody as_view():

template_name – nazwa pliku szablonu, w którym umieścimy formularz tworzenia użytkownika,

form_class – nazwa klasy definiującej formularz tworzenia użytkownika,

success_url – adres, na który nastąpi przekierowanie w przypadku braku błędów, np. po udanej rejestracji.

Zawartość szablonu umieszczamy w pliku templates/users/rejestruj.html:

Plik rejestruj.htmlKod nr

<!-- templates/users/rejestruj.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Rejestracja użytkownika</title>
</head>
<body>
    <h1>Rejestracja użytkownika</h1>
    {% if user.is_authenticated %}
        <p>Jesteś już zalogowany jako {{ user.username }}.</p>
    {% else %}
        <form method="POST">
            {% csrf_token %}
            {{ form.as_p }}
            <button type="submit">Zarejestruj</button>
        </form>
    {% endif %}
  </body>
</html>

Jeżeli zalogowany użytkownik wejdzie na stronę, zobaczy komunikat „Jesteś już zalogowany jako …”, natomiast użytkownik niezalogowany zobaczy formularz zakładania konta.

7.2.3.1. Ćwiczenie

W ustawieniach projektu czat2:
- zarejestruj aplikację users,
- ustaw polską wersję językową,
- zlokalizuj datę i czas.
W konfiguracji adresów URL projektu powiąż adres URL users/ z adresami URL aplikacji users.
Uruchom serwer deweloperski i w przeglądarce wejdź na adres 127.0.0.1:8000/users/.
Dodaj użytkowników adam i ewa z hasłem zaq1@WSX.

../../_images/django_lista_uzytkownikow.png

7.2.4. Wy(logowanie)

Na początku pliku czat2/users/urls.py aplikacji dopisujemy wymagany import:

Plik urls.pyKod nr

from django.contrib.auth.views import LoginView, LogoutView

– a następnie uzupełniamy listę urlpatterns:

Plik urls.pyKod nr

    path('loguj/', LoginView.as_view(
        template_name='users/loguj.html',
        next_page='users:index'),
        name='loguj'),
    path('wyloguj/', LogoutView.as_view(
        next_page='users:index'),
        name='wyloguj'),

Z adresami /loguj i /wyloguj wiążemy wbudowane w Django widoki LoginView i LogoutView zaimportowane z modułu django.contrib.auth.views. Widoki wywołujemy jako funkcje za pomocą metody as_view(), która otrzymuje argumenty:

template_name – nazwę pliku szablonu, w którym umieścimy formularz logowania użytkownika,

next_page – nazwa adresu URL, na który przekierowujemy użytkownika po zalogowaniu lub wylogowaniu się.

Informacja

Adresy, na które zostaje przekierowany użytkownik po zalogowaniu lub wylogowaniu za pomocą widoków wbudowanych, mogą być określane również za pomocą stałych LOGIN_REDIRECT_URL i LOGOUT_REDIRECT_URL zdefiniowanych w pliku ustawień projektu. W naszym przypadku na końcu pliku czat2/settings.py moglibyśmy umieścić kod:

Plik settings.py. Kod nr

LOGIN_REDIRECT_URL = '/users/'
LOGOUT_REDIRECT_URL = '/users/'

Logowanie wymaga szablonu, który tworzymy i zapisujemy w pliku templates/users/loguj.html:

Plik loguj.htmlKod nr

<!-- templates/users/loguj.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Logowanie użytkownika</title>
</head>
<body>
    <h1>Logowanie użytkownika</h1>
    {% if user.is_authenticated %}
        <p>Jesteś już zalogowany jako {{ user.username }}.</p>
        <form method="POST" action="{% url 'users:wyloguj' %}">
            {% csrf_token %}
            <button type="submit">Wyloguj</button>
        </form>
    {% else %}
        <form method="POST">
            {% csrf_token %}
            {{ form.as_p }}
            <button type="submit">Zaloguj</button>
        </form>
    {% endif %}
</body>
</html>

7.2.4.1. Ćwiczenie

W szablonie users/index.html umieść linki służące do logowania i wylogowania. Użyj metody POST.

Zaloguj się jako użytkownik.

Wyloguj się.

7.2.5. Wiadomości 

Chcemy, by zalogowani użytkownicy mogli przeglądać wiadomości wszystkich użytkowników, zmieniać, usuwać i dodawać własne. Podobnie jak w przypadku obsługi użytkowników, w realizacji tych zadań również użyjemy widoków wbudowanych opartych na klasach.

Informacja

Django oferuje wbudowane widoki przeznaczone do typowych operacji:

DetailView i ListView – (ang. generic display view) widoki przeznaczone do prezentowania szczegółów i listy danych;
FormView, CreateView, UpdateView i DeleteView – (ang. generic editing views) widoki przeznaczone do wyświetlania formularzy ogólnych, w szczególności służących dodawaniu, uaktualnianiu, usuwaniu obiektów (danych).

Początek pracy będzie podobny jak w przypadku aplikacji „Czat 1”:

W katalogu projekty_django/czat2 tworzymy aplikację czat.
Rejestrujemy aplikację w projekcie.
Dodajemy model danych, tj. klasę Wiadomości w pliku models.py:

Plik models.pyKod nr

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


class Wiadomosc(models.Model):

    """Klasa reprezentująca wiadomość w systemie"""
    tekst = models.CharField('treść wiadomości', max_length=250)
    data_pub = models.DateTimeField('data publikacji', default=timezone.now)
    autor = models.ForeignKey(User, on_delete=models.CASCADE)

    class Meta:  # ustawienia dodatkowe
        verbose_name = 'wiadomość'  # nazwa obiektu w języku polskim
        verbose_name_plural = 'wiadomości'  # nazwa obiektów w l.m.
        ordering = ['data_pub']  # domyślne porządkowanie danych

    def __str__(self):
        return self.tekst  # "autoprezentacja"

Ostrzeżenie

W porównaniu do modelu użytego w aplikacji Czat 1 w definicji pola data_pub argument auto_now_add=True zastępujemy default=timezone.now, aby użytkownik mógł modyfikować datę dodania wiadomości w formularzu.

Przygotowujemy migrację dla aplikacji „czat” i ją wykonujemy.

Wskazówka

Dla przypomnienia poniżej kolejne polecenia wydawane w aktywnym środowisku wirtualnym w katalogu projekty_django/czat2:

(.venv) ~/projekty_django/czat2$ python manage.py startapp czat
(.venv) ~/projekty_django/czat2$ python manage.py makemigrations czat
(.venv) ~/projekty_django/czat2$ python manage.py migrate
(.venv) ~/projekty_django/czat2$ python manage.py check

Ostatnie wydane polecenie sprawdza poprawność wykonanych czynności i powinno zwrócić komunikat System check identified no issues (0 silenced).

Jeżeli masz problem z wykonaniem powyższych czynności, zajrzyj do punktów 8.1.2 – 8.1.3 ze scenariusza Czat 1.

7.2.6. Strona główna 

Chcemy, żeby aplikacja czat obsługiwała żądanie wyświetlenia strony głównej. W tym celu tworzymy nowy plik projekty_django/czat/urls.py i uzupełniamy go kodem:

Plik czat/urls.py Kod nr

from django.urls import path
from . import views  # import widoków aplikacji

app_name = 'czat'  # przestrzeń nazw aplikacji
urlpatterns = [
    path('', views.index, name='index'),
]

Jak widać adres domyślny aplikacji '' obsługiwany ma być przez widok index. Zatem w pliku czat/views.py umieszczamy kod:

Plik czat/views.py Kod nr

from django.shortcuts import render


def index(request):
    return render(request, 'czat/index.html')

Następnie musimy dodać szablon, który umieszczamy w pliku templates/czat/index.html:

Plik czat/index.html Kod nr

<!-- templates/czat/index.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Aplikacja Czat 2</title>
</head>
<body>
    <h1>Aplikacja Czat 2</h1>
    <nav>
        <a href="{% url 'czat:index' %}">Strona główna</a> &bull;
        <a href="{% url 'users:loguj' %}">Zaloguj się</a> &bull;
        <a href="{% url 'users:rejestruj' %}">Utwórz konto</a> &bull;
        <a href="{% url 'czat:lista' %}">Lista wiadomości</a>
    </nav>
</body>
</html>

Na koniec włączamy konfigurację URL aplikacji do konfiguracji projektu, czyli w pliku projekty_django/czat2/urls.py lista urlpatterns powinna wyglądać następująco:

Plik czat2/urls.py. Kod nr

urlpatterns = [
    path('', include('czat.urls')),
    path('czat/', include('czat.urls')),
    path('users/', include('users.urls')),
    path('admin/', admin.site.urls),
]

7.2.6.1. Ćwiczenie

Uruchamiamy serwer deweloperski i otwieramy w przeglądarce adres domyślny 127.0.0.1:8000, powinniśmy zobaczyć stronę wygenerowaną na podstawie dodanego szablonu:

7.2.7. Lista wiadomości 

W pliku projekty_django/czat/urls.py uzupełniamy importy i dodajemy definicję adresu URL:

Plik czat/urls.py Kod nr

from django.urls import path
from . import views  # import widoków aplikacji
from django.contrib.auth.decorators import login_required
from .models import Wiadomosc

app_name = 'czat'  # przestrzeń nazw aplikacji
urlpatterns = [
    path('', views.index, name='index'),
    path('lista/', login_required(views.ListaWiadomosci.as_view()), name='lista'),

Adres lista/ będzie obsługiwany przez klasę zdefiniowaną w pliku views.py, którą wywołujemy jako funkcję: views.ListaWiadomosci.as_view(). Wywołanie umieszczamy w funkcji login_required(), aby wiadomości mogli oglądać tylko zalogowani użytkownicy.

Adres, na który przekierowany zostanie użytkownik, jeżeli nie będzie zalogowany, definiujemy na końcu pliku czat2/settings.py w stałej LOGIN_URL:

Plik czat2/settings.py Kod nr

LOGIN_URL = '/users/loguj'

Do pliku czat/views.py dodajemy wymagane do wszystkich operacji CRUD importy oraz kod klasy ListaWiadomosci:

Plik czat/views.py Kod nr

from django.shortcuts import render
from django.views.generic import ListView, DeleteView
from django.views.generic.edit import CreateView, UpdateView
from .models import Wiadomosc
from django.utils import timezone
from django.contrib import messages


def index(request):
    return render(request, 'czat/index.html')


class ListaWiadomosci(ListView):
    model = Wiadomosc
    context_object_name = 'wiadomosci'
    paginate_by = 2

Klasę ListaWiadomosci tworzymy na podstawie wbudowanej wbudowanej klasy ListView i dostosowujemy jej właściwości:

model – podajemy model, którego dane zostaną pobrane z bazy;
context_object_name – zmieniamy domyślną nazwę (object_list) listy obiektów przekazanych do szablonu;
paginate_by– określamy ilość obiektów wyświetlanych na stronie.

7.2.7.1. Szablon

Potrzebujemy szablonu, którego klasa ListView szuka pod domyślną nazwą <nazwa modelu>_list.html, czyli w naszym przypadku tworzymy plik templates/czat/wiadomosc_list.html:

Plik wiadomosc_list.htmlKod nr

<!-- templates/czat/wiadomosc_list.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="utf-8">
    <title>Lista wiadomości</title>
</head>
<body>
    <h1>Lista wiadomości</h1>
    <ol>
      {% for wiadomosc in wiadomosci %}
      <li>
        <strong>{{ wiadomosc.autor.username }}</strong> ({{ wiadomosc.data_pub }}):
        <br> {{ wiadomosc.tekst }}
      </li>
      {% endfor %}
    </ol>

    {% if is_paginated %}
      <p>
      {% if page_obj.has_previous %}
        <a href="?page={{ page_obj.previous_page_number }}">Poprzednie</a>
      {% endif %}

        Strona {{ page_obj.number }} z {{ page_obj.paginator.num_pages }}.

      {% if page_obj.has_next %}
        <a href="?page={{ page_obj.next_page_number }}">Następne</a>
      {% endif %}
      </p>
    {% endif %}

  </body>
</html>

Kolejne wiadomości odczytujemy i wyświetlamy w pętli przy użyciu tagu {% for %}. Dostęp do właściwości obiektów umożliwia operator kropki, np.: {{ wiadomosc.autor.username }}.

Linki nawigacyjne tworzymy w instrukcji warunkowej {% if is_paginated %}. Obiekt page_obj zawiera następujące właściwości:

has_previous – zwraca True, jeżeli jest poprzednia strona;
previous_page_number – numer poprzedniej strony;
next_page_number – numer następnej strony;
number – numer aktualnej strony;
paginator.num_pages – ilość wszystkich stron.

Numer strony do wyświetlenia przekazujemy w zmiennej page adresu URL.

7.2.8. Dodawanie wiadomości 

Zadanie to zrealizujemy wykorzystując widok CreateView. Aby ułatwić dodawanie wiadomości dostosujemy klasę widoku tak, aby użytkownik nie musiał wprowadzać pola autor.

Na początek dopiszemy w pliku czat/urls.py skojarzenie adresu URL dodaj/ z wywołaniem zaimportowanej z pliku views.py klasy DodajWiadomosc jako funkcji:

Plik czat/urls.py Kod nr

    path('dodaj/', login_required(views.DodajWiadomosc.as_view()), name='dodaj'),

Dalej w pliku czat/views.py umieszczamy kod:

Plik czat/views.py Kod nr

class DodajWiadomosc(CreateView):
    model = Wiadomosc
    fields = ['tekst', 'data_pub']
    context_object_name = 'wiadomosci'
    success_url = '/lista'

    def get_initial(self):
        initial = super(DodajWiadomosc, self).get_initial()
        initial['data_pub'] = timezone.now()
        return initial

    def form_valid(self, form):
        wiadomosc = form.save(commit=False)
        wiadomosc.autor = self.request.user
        wiadomosc.save()
        messages.success(self.request, "Dodano wiadomość!")
        return super(DodajWiadomosc, self).form_valid(form)

Klasa DodajWiadomosc dziedziczy z klasy CreateView. Określamy jej właściwości i nadpisujemy wybrane metody:

fields – pozwala wskazać pola, które mają znaleźć się na formularzu;
get_initial() – metoda pozwala ustawić domyślne wartości dla wybranych pól. Wykorzystujemy ją do zainicjowania pola data_pub aktualna datą: initial['data_pub'] = timezone.now().
form_valid() – metoda, która sprawdza poprawność przesłanych danych i zapisuje je w bazie:
- wiadomosc = form.save(commit=False) – tworzymy obiekt wiadomości, ale go nie zapisujemy;
- wiadomosc.autor = self.request.user – uzupełniamy dane autora;
- wiadomosc.save() – zapisujemy obiekt;
- messages.success(self.request, "Dodano wiadomość!") – przygotowujemy komunikat, który wyświetlony zostanie po dodaniu wiadomości.

7.2.8.1. Szablon

Domyślny szablon dodawania danych dla klasy CreateView nazywa się <nazwa modelu>_form.html. W nowym pliku wstawiamy poniższą treść i zapisujemy pod nazwą templates/czat/wiadomosc_form.html:

Plik wiadomosc_form.htmlKod nr

<!-- templates/czat/wiadomosc_form.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Dodawanie wiadomości</title>
</head>
<body>
    <h1>Dodaj wiadomość</h1>
    <form method="POST">
      {% csrf_token %}
      {{ form.as_p }}
      <button type="submit">Zapisz</button>
    </form>

    <h2>Lista wiadomości:</h2>
    <ol>
      {% for wiadomosc in wiadomosci %}
      <li>
        <strong>{{ wiadomosc.autor.username }}</strong> ({{ wiadomosc.data_pub }}):
        <br /> {{ wiadomosc.tekst }}
      </li>
      {% endfor %}
    </ol>

    <p><a href="{% url 'czat:wiadomosci' %}">Strona główna</a></p>

  </body>
</html>

W szablonie templates/czat/index.html wstawiamy jeszcze po nagłówku <h1> kod wyświetlający komunikaty:

Plik index.htmlKod nr

{% if messages %}
  <ul>
    {% for komunikat in messages %}
      <li>{{ komunikat|capfirst }}</li>
      {% endfor %}
  </ul>
{% endif %}

7.2.8.2. Ćwiczenie

Umieść link do dodawania wiadomości na końcu strony Lista wiadomości.

Dodaj jakąś wiadomość:

7.2.9. Edycja wiadomości 

Widok pozwalający na edycję wiadomości i jej aktualizację dostępny będzie pod adresem /edytuj/<pk>, gdzie <pk> będzie identyfikatorem obiektu do zaktualizowania. Zaczniemy od uzupełnienia pliku urls.py:

Plik urls.pyKod nr

    path('edytuj/<pk>', login_required(views.EdytujWiadomosc.as_view()), name='edytuj'),

Nowością w powyższym kodzie jest definicja adresu z dodatkowym parametrem <pk> – nazwa jest tu skrótem od ang. primary key, co znaczy „klucz główny”. Zmienna ta zawierać będzie identyfikator wiadomości i dostępna będzie w klasie widoku, który obsłuży edycję wiadomości.

Do pliku views.py dopisujemy kod klasy EdytujWiadomosc, która dostosowuje wbudowany widok UpdateView:

Plik views.pyKod nr

class EdytujWiadomosc(UpdateView):
    model = Wiadomosc
    from .forms import EdytujWiadomoscForm
    form_class = EdytujWiadomoscForm
    context_object_name = 'wiadomosci'
    template_name = 'czat/wiadomosc_form.html'
    success_url = '/lista'

    def get_context_data(self, **kwargs):
        context = super(EdytujWiadomosc, self).get_context_data(**kwargs)
        context['wiadomosci'] = Wiadomosc.objects.filter(
            autor=self.request.user)
        return context

    def get_object(self, queryset=None):
        wiadomosc = Wiadomosc.objects.get(id=self.kwargs['pk'])
        return wiadomosc

Nowe metody to:

get_object() – pobiera i zwraca wskazaną przez identyfikator w zmiennej pk wiadomość: wiadomosc = Wiadomosc.objects.get(id=self.kwargs['pk']).
get_context_data() – pozwala przekazać do szablonu dodatkowe dane, w tym przypadku listę wiadomości, ale tylko zalogowanego użytkownika: (context['wiadomosci'] = Wiadomosc.objects.filter(autor=self.request.user)).

Pozostałe właściwości model, context_object_name, template_name i success_url wyjaśniliśmy wcześniej. Jak widać, do edycji wiadomości wykorzystamy ten sam szablon, którego użyliśmy podczas dodawania.

Formularz jednak dostosujemy. Wykorzystamy właściwość form_class, której przypisujemy utworzoną w nowym pliku czat/forms.py klasę zmieniającą domyślne ustawienia:

Plik forms.pyKod nr

from django.forms import ModelForm, TextInput
from .models import Wiadomosc


class EdytujWiadomoscForm(ModelForm):
    class Meta:
        model = Wiadomosc
        fields = ['tekst', 'data_pub']
        exclude = ['autor']
        widgets = {'tekst': TextInput(attrs={'size': 60})}

Klasa EdytujWiadomoscForm oparta jest na wbudowanej klasie ModelForm. Właściwości formularza określamy w podklasie Meta:

model – oznacza to samo co w widokach, czyli model, dla którego tworzony jest formularz;
fields – to samo co w widokach, lista pól do wyświetlenia;
exclude – opcjonalnie lista pól do pominięcia;
widgets – słownik, którego klucze oznaczają pola danych, a ich wartości odpowiadające im w formularzach HTML typy pól i ich właściwości, np. rozmiar.

Teraz w szablonie wiadomosc_list.html musimy dodać link, aby zalogowany użytkownik mógł edytować swoje wiadomości. Kod wypisujący wiadomości w znaczniku <li> przyjmie następującą postać:

Plik wiadomosc_lista.html Kod nr

      <li>
        <strong>{{ wiadomosc.autor.username }}</strong> ({{ wiadomosc.data_pub }}):
        <br> {{ wiadomosc.tekst }}
        {% if wiadomosc.autor.username == user.username %}
          &bull; <a href="{% url 'czat:edytuj' wiadomosc.id %}">Edytuj</a>
        {% endif %}
      </li>

7.2.9.1. Ćwiczenie

Wejdź na stronę „Lista wiadomości” i kliknij link Edytuj:

Zmień treść wiadomości i kliknij przycisk Zapisz:

7.2.10. Usuwanie wiadomości 

Do usuwania wiadomości wykorzystamy – podobnie jak w przypadku edycji – adres zawierający jej identyfikator: /edytuj/<pk>. Uzupełniamy więc plik urls.py:

Plik urls.pyKod nr

    path('usun/<pk>', login_required(views.UsunWiadomosc.as_view()), name='usun'),

Na końcu pliku views.py umieszczamy kod klasy UsunWiadomosc, która wykorzystuje wbudowany widok DeleteView:

Plik views.pyKod nr

class UsunWiadomosc(DeleteView):
    model = Wiadomosc
    template_name = 'czat/wiadomosc_usun.html'
    success_url = '/lista'

Domyślny szablon dla tego widoku przyjmuje nazwę <nazwa-modelu>_confirm_delete.html, dlatego uprościliśmy jego nazwę we właściwości template_name. Tworzymy więc plik wiadomosc_usun.html:

Plik wiadomosc_usun.htmlKod nr

<!-- templates/czat/wiadomosc_usun.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Usuwanie wiadomości</title>
</head>
<body>
    <h1>Usuń wiadomość</h1>
    <form method="POST">
      {% csrf_token %}
      <p>Czy na pewno chcesz usunąć wiadomość:<br /><i>{{ object }}</i>?</p>
      <button type="submit">Usuń</button>
    </form>

    <p><a href="{% url 'czat:lista' %}">Lista wiadomości</a></p>
  </body>
</html>

Tag {{ object }} zostanie zastąpiony treścią wiadomości zwróconą przez funkcję __str__() modelu.

7.2.10.1. Ćwiczenie

W szablonie wiadomosc_list.html za linkiem Edytuj wstaw podobny link Usuń: • <a href="{% url 'czat:usun' wiadomosc.id %}">Usuń</a>, aby zalogowany użytkownik mógł usunąć wiadomość.
Wejdź na stronę „Lista wiadomości” i kliknij link Usuń:

Potwierdź usunięcie wiadomości:

7.2.11. Materiały 

Built-in class-based generic views
Strona projektu Django https://www.djangoproject.com/
Co to jest framework? http://pl.wikipedia.org/wiki/Framework
Co nieco o HTTP i żądaniach GET i POST http://pl.wikipedia.org/wiki/Http

Materiały Python 101 udostępniane przez Centrum Edukacji Obywatelskiej na licencji Creative Commons Uznanie autorstwa-Na tych samych warunkach 4.0 Międzynarodowa.

Utworzony:: 2026-05-30 o 19:12 w Sphinx 7.3.7
Autorzy:: Robert Bednarz