DetailView: bekerja dengan obyek tunggal Django¶

Untuk menunjukkan rincian dari sebuah obyek, kami dasarnya butuh melakukan dua hal: kami butuh mencari obyek dan kemudian kami butuh membuat TemplateResponse dengan cetakan yang cocok, dan obyek itu sebagai konteks.

Untuk mendapatkan obyek, DetailView bergantung pada SingleObjectMixin, yang menyediakan sebuah metode get_object() yang mencari tahu berdasarkan obyek pada URL dari permintaan (itu sepertinya untuk argumen kata kunci pk dan slug seperti dinyatakan di URLConf, dan mencari obyek antara dari atribut model pada tampilan, atau atribut queryset jika itu disediakan). SingleObjectMixin juga menimpa get_context_data(), yang digunakan terhadap semua tampilan siap-pakai Django untuk memasok data konteks untuk membangun cetakan.

Untuk kemudian sebuah TemplateResponse, DetailView menggunakan SingleObjectTemplateResponseMixin, yang memperpanjang TemplateResponseMixin, menimpa get_template_names() seperti diobrolkan diatas. Itu sebenarnya menyediakan kumpulan cukup canggih pilihan, tetapi satu utama yang paling orang akan gunakan adalah <app_label>/<model_name>_detail.html. Bagian _detail dapat dirubah dengan mengatur template_name_suffix pada subkelas atau sesuatu lain. (Sebagai contoh, generic edit views menggunakan _form untuk membuat dan memperbaharui tampilan, dan _confirm_delete untuk tampilan menghapus.)

ListView: bekerja dengan banyak obyek Django¶

Daftar dari obyek mengikuti kurang lebih pola sama: kami butuh sebuah (kemungkinan diberikan nomor) daftar obyek, khususnya sebuah QuerySet, dan kemudian kami butuh membuat sebuah TemplateResponse dengan cetakan cocok menggunakan daftar itu dari obyek.

Untuk mendapatkan obyek, ListView menggunakan MultipleObjectMixin, yang menyediakan kedua get_queryset() dan paginate_queryset(). Tidak seperti dengan SingleObjectMixin, tidak perlu key off bagian dari URL untuk mencari tahu queryset bekerja, jadi awalan hanya menggunakan atribut queryset atau model pada kelas tampilan. Sebuah alasan umum untun menimpa get_queryset() disini akan menjadi secara dinamis beragam obyek, seperti bergantung pada pengguna saat ini atau mengeluarkan penempatan di masa depan untuk sebuah blog.

MultipleObjectMixin juga menimpa get_context_data() untuk menyertakan variabel konteks sesuai untuk penomoran halaman (menyediakan contoh jika penomoran halaman ditiadakan). Itu bergantung pada 11object_list“ dilewatkan di sebuah argumen kata kunci, yang ListView mengatur untuk itu.

Untuk membuat sebuah TemplateResponse, ListView kemudian menggunakan MultipleObjectTemplateResponseMixin; seperti SingleObjectTemplateResponseMixin diatas, ini menimpa get_template_names() untuk menyediakan a range of options, yang paling digunakan-umum berwujud <app_label>/<model_name>_list.html, dengan bagian _list kembali diambil dari atribut template_name_suffix. (Tampilan umum berdasarkan tanggal menggunakan akhiran seperti _archive, _archive_year dan sebagainya untuk menggunakan cetakan berbeda untuk beragam tampilan daftar berdasarkan-tanggal khusus.)

Menggunakan SingleObjectMixin dengan View¶

Jika kami ingin menulis tampilan berdasarkan-kelas sederhana yang menanggapi hanya pada POST, kami akan mensubkelaskan View dan menulis sebuah metode post() di subkelas. Bagaimanapun jika kami ingin pengolahan kami bekerja pada obyek tertentu, cirikan dari URL, kami akan ingin fungsionalitas disediakan oleh SingleObjectMixin.

Kami akan mempertunjukkan ini dengan model Author kami gunakan di generic class-based views introduction.

from django.http import HttpResponseForbidden, HttpResponseRedirect
from django.urls import reverse
from django.views import View
from django.views.generic.detail import SingleObjectMixin
from books.models import Author

class RecordInterest(SingleObjectMixin, View):
    """Records the current user's interest in an author."""
    model = Author

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return HttpResponseForbidden()

        # Look up the author we're interested in.
        self.object = self.get_object()
        # Actually record interest somehow here!

        return HttpResponseRedirect(reverse('author-detail', kwargs={'pk': self.object.pk}))

Dalam praktiknya anda mungkin ingin merekam ketertarikan dalam penyimpanan kunci-nilai daripada ddi basisdata hubungan, jadi kami telah meninggalkan sedikit. Hanya sedikit dari tampilan yang butuh dikhawatirkan tentang menggunakan SingleObjectMixin adalah dimana kami ingin mencari penulis kami tertarik, yang itu hanya dilakukan dengan panggulan sederhana pada self.get_object(). Yang lainnya diurus untuk kami oleh mixin.

Kami dapat menghubungkan kedalam URL kami dengan cukup mudah:

from django.urls import path
from books.views import RecordInterest

urlpatterns = [
    #...
    path('author/<int:pk>/interest/', RecordInterest.as_view(), name='author-interest'),
]

Catat kelompok bernama pk, yang get_object() menggunakan untuk mencari instance Author. Anda dapat juga menggunakan sebuah keong, atau apapun dari fitur-fitur lain dari SingleObjectMixin.

Menggunakan SingleObjectMixin dengan ListView¶

ListView menyediakan penomoran siap-pakai, tetapi anda mungkin ingin memberi nomor daftar dari obyek yang semua terkait (oleh foreign key) ke obyek lain. Di contoh penerbitan kami, anda mungkin ingin memberi nomor melalui semua buku-buku oleh penerbit tertentu.

Satu cara melakukan ini adalah memadukan ListView dengan SingleObjectMixin, sehingga queryset untuk memberi nomor halaman dari buku dapat menggantung penerbit ditemukan sebagai obyek tunggal. Untuk melakukan ini, kami butuh memiliki dua queryset berbeda:

Queryset Book untuk digunakan oleh ListView

Karena kami mempunyai akses ke Publisher yang bukunya kami ingin daftar, kami cukup menimpa get_queryset() dan menggunakan reverse foreign key manager Publisher.

Queryset Publisher untuk digunakan di get_object()

Kami akan bergantung pada penerapan awalan dari get_object() untuk mengambil obyek Publisher benar. Bagaimanapun, kami butuh jelas melewatkan sebuah argumen queryset karena jika tidak penerapan awalan dari get_object() akan memanggil get_queryset() yang kami telah timpa untuk mengembalikan obyek Book daripada Publisher.

Sekarang kami dapat menulis PublisherDetail baru:

from django.views.generic import ListView
from django.views.generic.detail import SingleObjectMixin
from books.models import Publisher

class PublisherDetail(SingleObjectMixin, ListView):
    paginate_by = 2
    template_name = "books/publisher_detail.html"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=Publisher.objects.all())
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['publisher'] = self.object
        return context

    def get_queryset(self):
        return self.object.book_set.all()

Perhatikan bagaimana kami menyetel self.object dalam get() jadi kami dapat menggunakan itu kembali kemudian dalam get_context_data() dan get_queryset(). Jika anda tidak menyetel template_name, cetakan akan awalan menjadi pilihan ListView biasa, yang dalam kasus ini akan menjadi "books/book_list.html" karena itu adalah daftar dari buku-buku; ListView tidak mengetahui apapun tentang SingleObjectMixin, jadi itu tidak mempunyai petunjuk tampilan ini adalah hubungannya dengan Publisher.

paginate_by sengaja kecil dalam contoh sehingga anda tidak perlu membuat banyak buku untuk melihat penomoran halaman bekerja! Ini adalah cetakan anda ingin gunakan:

{% extends "base.html" %}

{% block content %}
    <h2>Publisher {{ publisher.name }}</h2>

    <ol>
      {% for book in page_obj %}
        <li>{{ book.title }}</li>
      {% endfor %}
    </ol>

    <div class="pagination">
        <span class="step-links">
            {% if page_obj.has_previous %}
                <a href="?page={{ page_obj.previous_page_number }}">previous</a>
            {% endif %}

            <span class="current">
                Page {{ page_obj.number }} of {{ paginator.num_pages }}.
            </span>

            {% if page_obj.has_next %}
                <a href="?page={{ page_obj.next_page_number }}">next</a>
            {% endif %}
        </span>
    </div>
{% endblock %}

Menggunakan FormMixin dengan DetailView¶

Berpikir kembali ke contoh paling awal dari menggunakan View dan SingleObjectMixin bersama-sama. Kami sedang merekam sebuah minat pengguna dalam penulis tertentu; katakan sekarang yang kami ingin membiarkan mereka meninggalkan pesan mengatakan mengapa mereka menyukainya. Kembali, mari kita anggap tidak menyimpan ini dalam basisdata hubungan tetapi sebagai gantinya di lebih esoterik yang kami tidak akan khawatir disini.

Pada titik ini itu adalah alamiah mencapai untuk Form untuk mengenkapsulasi informasi dikirim dari peramban pengguna pada Django. Katakan juga bahwa kami melakukan investasi di REST, jadi kami ingin menggunakan URL sama untuk memperlihatkan penulis sebagai untuk menangkap pesan dar pengguna. Mari kita menulis kembali AuthorDetailView kami untuk melakukan itu.

Kami akan menjaga penanganan GET dari DetailView, meskipun kami akan harus menambah Form kedalam data konteks jadi kami dapat mengirim itu dalam cetakan. Kami akan juga ingin menarik dalam pengolahan formulir FormMixin, dan menulis sedikit kode sehingga pada POST formulir mendapatkan panggilan yang sesuai.

AuthorDetail baru kami seperti ini:

# CAUTION: you almost certainly do not want to do this.
# It is provided as part of a discussion of problems you can
# run into when combining different generic class-based view
# functionality that is not designed to be used together.

from django import forms
from django.http import HttpResponseForbidden
from django.urls import reverse
from django.views.generic import DetailView
from django.views.generic.edit import FormMixin
from books.models import Author

class AuthorInterestForm(forms.Form):
    message = forms.CharField()

class AuthorDetail(FormMixin, DetailView):
    model = Author
    form_class = AuthorInterestForm

    def get_success_url(self):
        return reverse('author-detail', kwargs={'pk': self.object.pk})

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return HttpResponseForbidden()
        self.object = self.get_object()
        form = self.get_form()
        if form.is_valid():
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def form_valid(self, form):
        # Here, we would record the user's interest using the message
        # passed in form.cleaned_data['message']
        return super().form_valid(form)

get_success_url() is just providing somewhere to redirect to, which gets used in the default implementation of form_valid(). We have to provide our own post() as noted earlier.

Pemecahan terbaik¶

Itu harus jelas bahwa nomor dari interaksi halus diantara FormMixin dan DetailView sudah mencoba kemampuan kami untuk mengelola hal-hal. Itu tidak sepertinya anda ingin menulis hal ini dari kelas anda sendiri.

Dalam kasus ini, itu akan sangat mudah hanya menulis metode post() anda sendiri, menjaga DetailView seperti fungsionalitas umum, meskipun menulis Form penanganan kode melibatkan banyak penggandaan.

Cara lain, itu akan masih lebih mudah daripada pendekatan diatas untuk memiliki tampilan terpisah untuk pengolahan formulir, yang dapat menggunakan FormView berbeda dari DetailView tanpa kepentingan.

Sebuah pilihan lain pemecahan terbaik¶

Apa kami sedang coba lakukan disini adalah menggunakan dua kelas bebeda berdasarkan tampilan dari URL sama. Jadi mengapa tidak lakukan hal itu? Kami mempunyai pembagian sangat jelas disini: permintaan GET harus mendapatkan DetailView (dengan Form ditambahkan ke data konteks), dan permintaan POST harus mendapatkan FormView. Mari kita menyetek tampilan tersebut dahulu.

Tampilan AuthorDisplay hampir sama seperti when we first introduced AuthorDetail; kami harus menulis get_context_data() kami sendiri untuk membuat AuthorInterestForm tersedia pada cetakan. Kami akan melewati get_object() menimpa dari sebelumnya untuk kejelasan:

from django import forms
from django.views.generic import DetailView
from books.models import Author

class AuthorInterestForm(forms.Form):
    message = forms.CharField()

class AuthorDisplay(DetailView):
    model = Author

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['form'] = AuthorInterestForm()
        return context

Kemudian AuthorInterest adalah FormView sederhana, tetapi kami harus membawa kedalam SingleObjectMixin sehingga kami dapat menemukan penulis kami sedang bicarakan, dan kami harus mengingat menyetel template_name memastikan bahwa kesalahan formulir akan membangun cetakan sama seperti AuthorDisplay sedang gunakan pada GET:

from django.http import HttpResponseForbidden
from django.urls import reverse
from django.views.generic import FormView
from django.views.generic.detail import SingleObjectMixin

class AuthorInterest(SingleObjectMixin, FormView):
    template_name = 'books/author_detail.html'
    form_class = AuthorInterestForm
    model = Author

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return HttpResponseForbidden()
        self.object = self.get_object()
        return super().post(request, *args, **kwargs)

    def get_success_url(self):
        return reverse('author-detail', kwargs={'pk': self.object.pk})

Akhirnya kami membawa ini bersama-sama dalam sebuah tampilan AuthorDetail baru. Kami sudah mengetahui bahwa memanggil as_view() pada sebuah tampilan berdasarkan-kelas memberikan kami sesuatu yang berperilaku persis seperti sebuah tampilan berdasarkan fungsi, jadi kami dapat melakukan itu pada titik kami pilih diantara dua sub tampilan.

Anda dapat melewatkan perjalanan melalui argumen kata kunci pada as_view() dalam cara sama anda akan dalam URLconf anda, seperti jika anda ingin perilaku AuthorInterest untuk juga muncul pada URL lain tetapi menggunakan cetakan berbeda:

from django.views import View

class AuthorDetail(View):

    def get(self, request, *args, **kwargs):
        view = AuthorDisplay.as_view()
        return view(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        view = AuthorInterest.as_view()
        return view(request, *args, **kwargs)

Pendekatan ini dapat juga digunakan dengan tampilan berdasarkan-kelas umum lainnya diwarisi langsung dari View or TemplateView, ketika itu menjaga tampilan berbeda sebagai terpisah mungkin.