Pelajari cara membuat aplikasi pengelola tugas menggunakan prinsip CRUD dan tampilan berbasis kelas di Django.

Salah satu fitur utama Django adalah dukungan bawaannya untuk membuat proyek di atas operasi CRUD (Buat, Baca, Perbarui, Hapus). Sementara tampilan berbasis kelas Django menyediakan cara yang cepat, mudah, dan fleksibel untuk membuat aplikasi web, banyak pengembang masih menggunakan tampilan berbasis fungsi.

Tampilan berbasis kelas menawarkan beberapa keuntungan dibandingkan tampilan berbasis fungsi, termasuk pewarisan, penataan kode, penggunaan kembali kode, dan banyak lagi. Meskipun mengimplementasikan tampilan berbasis kelas mungkin tampak sedikit rumit, panduan ini akan membantu Anda memahami konsep dengan membuat aplikasi pengelola tugas dan memberikan petunjuk langkah demi langkah.

Apakah Tampilan Berbasis Kelas di Django?

Di Django, tampilan adalah Fungsi Python yang mengambil permintaan web dan mengembalikan respons web. Tampilan berbasis kelas (CBV) adalah cara alternatif untuk mendefinisikan tampilan di Django menggunakan kelas Python alih-alih fungsi.

instagram viewer

CBV memiliki beberapa keunggulan, seperti pengorganisasian kode yang lebih baik, penggunaan kembali kode yang lebih mudah, dan kemampuan menggunakan pewarisan untuk membuat variasi tampilan yang ada. CBV juga menyediakan metode bawaan seperti mendapatkan() Dan pos() metode yang dapat Anda timpa untuk perilaku khusus.

Kode yang digunakan dalam artikel ini tersedia di sini repositori GitHub.

Tampilan Berbasis Kelas Tersedia di Django

Django menyediakan beberapa CBV bawaan untuk kasus penggunaan populer, seperti menampilkan daftar objek atau membuat yang baru. Beberapa CBV bawaan ini adalah:

  1. Tampilan Daftar: Tampilan ini merender daftar objek yang diambil dari model. Misalnya, halaman yang mencantumkan semua posting yang tersedia di blog akan menggunakan a Tampilan Daftar.
  2. DetailView: Tampilan ini merender tampilan mendetail dari satu objek yang diambil dari model. Anda dapat menggunakan a DetailView untuk menampilkan detail postingan tertentu di aplikasi blog.
  3. BuatTampilan: Tampilan ini merender formulir untuk membuat objek baru dan menangani pengiriman formulir. Misalnya, di aplikasi pengelola tugas, Anda akan menggunakan tampilan ini untuk membuat tugas baru.
  4. Hapus Lihat: Tampilan ini merender halaman konfirmasi untuk menghapus objek dan menangani penghapusan halaman.
  5. Tampilan Pembaruan: Tampilan ini merender formulir untuk memperbarui objek yang sudah ada dan menangani pengiriman formulir.

Django juga menyediakan tampilan lain, termasuk Tampilan Templat, RedirectView, Dan Tampilan Formulir. Anda bisa merujuk ke dokumentasi Django untuk informasi mendetail tentang tampilan berbasis kelas.

Bangun Aplikasi Pengelola Tugas Dengan Tampilan Berbasis Kelas Django

Membuat aplikasi seperti aplikasi pengelola tugas akan membuat Anda memahami cara mengimplementasikan operasi CRUD dengan CBV. Pengelola tugas memiliki fitur yang memungkinkan pengguna membuat, memperbarui, menghapus, dan membaca tugas. Fitur-fitur ini sejalan dengan operasi CRUD. Langkah-langkah berikut akan membantu Anda membuat aplikasi pengelola tugas dengan Django CBVs.

Siapkan Proyek Django

Untuk membuat aplikasi pengelola tugas dengan Django, Anda harus memulai dengan mengikuti langkah-langkah berikut:

  1. Instal Django ke dalam Lingkungan virtual Python dengan perintah ini:
    pip instal django
  2. Buat proyek Django. Perintah berikut akan membuat proyek bernama project_core.
    django-admin startproject project_core .
  3. Buat aplikasi bernama Pengelola tugas.
    python manage.py startapp task_manager
  4. Di Anda pengaturan.py tambahkan nama aplikasi Anda ke INSTALLED_APPS daftar.
    INSTALLED_APPS = [
    'Pengelola tugas',
    ]
  5. Buka urls.py file di direktori proyek Anda dan konfigurasikan URL untuk Anda Pengelola tugas aplikasi:
    dari django.urls impor jalan, termasuk
    pola url = [
     jalur('', termasuk('task_manager.url')),
    ]

Buat Model untuk Aplikasi Pengelola Tugas Anda

Di direktori aplikasi Anda (atau Pengelola tugas folder), buka file Anda model.py file dan buat model untuk aplikasi pengelola tugas Anda. Berikut ini contoh model yang dapat Anda gunakan:

dari django.db impor model
kelasTugas(model. Model):
 judul = model. CharField (max_length=200)
 deskripsi = model. Bidang Teks()
 selesai = model. BooleanField (default=PALSU)
 dibuat_at = model. DateTimeField (auto_now_add=BENAR)

Migrasikan model Anda dengan perintah ini:

python manage.py makemigrations && python manage.py migrasi

Buat Formulir Django untuk Aplikasi Anda

Anda harus memiliki formulir untuk penanganan Membuat Dan Memperbarui operasi. Di direktori aplikasi Anda, buat file bernama forms.py. Berikut contohnya:

dari django impor formulir
dari .model impor Tugas
kelasFormulir Tugas(formulir. Bentuk Model):
kelasMeta:
 model = Tugas
 bidang = ['judul', 'keterangan', 'lengkap']
 widget = {
'judul': formulir. Input Teks (attrs={'kelas': 'bentuk-kontrol',}),
'keterangan': formulir. Textarea (attrs={'kelas': 'bentuk-kontrol',}),
'lengkap': formulir. Kotak centangMasukan (attrs={'kelas': 'form-check-input'}),
 }

Kode di atas memiliki kelas yang disebut Formulir Tugas yang mendefinisikan bidang dan widget formulir. Ini juga menentukan model yang akan digunakan.

Buat Tampilan Django untuk Setiap Operasi CRUD

Aplikasi CRUD dasar dengan CBV memerlukan setidaknya empat tampilan untuk menangani semua operasi secara efektif. Beberapa langkah selanjutnya akan menunjukkan cara membuatnya.

Impor Modul dan Paket yang Diperlukan

Bukalah views.py file dan buat impor berikut:

dari django.views.generic impor ListView, DetailView, CreateView, UpdateView, HapusView
dari django.urls impor membalikkan_malas
dari .model impor Tugas
dari .formulir impor Formulir Tugas

Kode di atas mengimpor lima CBV. Itu juga impor membalikkan_malas untuk mengarahkan pengguna ke URL tertentu setelah pengiriman formulir. Akhirnya, itu mengimpor file Tugas model, dan Formulir Tugas dibuat sebelumnya.

Buat Tampilan ke Daftar Objek Model

Aplikasi pengelola tugas harus memiliki halaman yang mencantumkan semua tugas yang dibuat oleh pengguna. Untuk membuat tampilan untuk ini, Anda harus menggunakan Tampilan Daftar. Ini contohnya:

kelasTampilan Daftar Tugas(Tampilan Daftar):
 model = Tugas
 nama_template = 'task_manager/task_list.html'
 konteks_objek_nama = 'tugas'

Tampilan di atas mendefinisikan tiga atribut yaitu:

  1. model: Atribut ini menentukan model mana yang akan digunakan untuk tampilan spesifik tersebut.
  2. template_name: Atribut ini memberi tahu Django cetakan mana yang akan dirender ke peramban.
  3. konteks_objek_nama: Atribut ini menentukan nama yang memungkinkan templat mengakses daftar objek dalam model.

Sebagian besar CBV akan berisi ketiga atribut ini.

Buat Tampilan untuk Menangani Detail Tugas

Setiap tugas yang dibuat pengguna harus memiliki halaman yang menunjukkan detailnya. CBV yang ideal untuk menangani ini adalah DetailVew. Berikut contoh sederhananya:

kelasTampilanDetail Tugas(Tampilan Detail):
 model = Tugas
 nama_template = 'task_manager/task_detail.html'

Buat Tampilan untuk Pembuatan Tugas

Buat tampilan untuk menangani pembuatan atau penambahan tugas baru. Ini adalah Membuat bagian dari operasi CRUD, dan pandangan yang tepat untuk ini adalah BuatTampilan. Berikut cara menggunakannya:

kelasTaskCreateView(BuatTampilan):
 model = Tugas
 form_class = Formulir Tugas
 nama_template = 'task_manager/task_form.html'
 success_url = mundur_malas('Daftar tugas')

Kode di atas memperkenalkan dua atribut baru: form_class Dan success_url.

Itu form_class atribut memberi tahu tampilan kelas formulir mana yang akan dirender dan digunakan untuk operasinya.

Itu success_url menentukan cara mengarahkan ulang pengguna setelah mengirimkan formulir. Ini menggunakan membalikkan_malas fungsi yang mengambil nama jalur URL.

Buat Tampilan untuk Mengedit Tugas

Untuk mengizinkan pengguna Anda mengedit atau memperbarui tugas mereka, Anda harus membuat tampilan yang terlihat seperti ini:

kelasTaskUpdateView(Tampilan Pembaruan):
 model = Tugas
 form_class = Formulir Tugas
 nama_template = 'task_manager/task_form.html'
 success_url = mundur_malas('Daftar tugas')

Tampilan di atas mirip dengan TaskCreateView dibuat sebelumnya. Satu-satunya perbedaan adalah penggunaan Tampilan Pembaruan.

Buat Tampilan untuk Menangani Operasi Penghapusan

Untuk mengizinkan pengguna Anda menghapus tugas kapan pun mereka mau, Anda harus menggunakan Hapus Lihat CBV. Ini contohnya:

kelasTaskDeleteView(Hapus Tampilan):
 model = Tugas
 nama_template = 'task_manager/task_confirm_delete.html'
 success_url = mundur_malas('Daftar tugas')

Konfigurasikan URL Aplikasi Anda

Di direktori aplikasi Anda, buat file urls.py file dan konfigurasikan pola URL Anda seperti ini:

dari django.urls impor jalur
dari .view impor TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
pola url = 
 jalur('', TaskListView.as_view(), nama='Daftar tugas'),
 jalur('membuat/', TaskCreateView.as_view(), nama='tugas_buat'),
 jalur('tugas//', TaskDetailView.as_view(), nama='tugas_detail'),
 jalur('tugas//update/', TaskUpdateView.as_view(), nama='tugas_perbarui'),
 jalur('tugas//delete/', TaskDeleteView.as_view(), nama='tugas_hapus'),
]

Pola URL di atas serupa dengan URL yang dibuat dengan tampilan berbasis fungsi. Perbedaannya adalah as_view() fungsi ditambahkan ke akhir setiap nama tampilan.

Kamu bisa gunakan siput Django untuk membuat URL bukan kunci utama yang digunakan di atas.

Buat Template untuk Tampilan Anda

Mengizinkan pengguna Anda untuk melakukan tindakan yang ditentukan dalam tampilan di atas menunjukkan bahwa Anda menyediakan antarmuka untuk berinteraksi dengan mereka. Dari tampilan yang dibuat sebelumnya, aplikasi pengelola tugas seharusnya memiliki empat antarmuka pengguna.

Di direktori aplikasi Anda, buat empat template HTML. Anda juga harus membuat basis.html mengajukan. Kamu bisa gaya templat Django Anda dengan Bootstrap untuk menghemat waktu.

Templat Daftar Tugas

Templat ini harus menyertakan kode yang mencantumkan semua tugas dalam model. Contoh kerangka kode adalah ini:

{% memperluas 'base.html' %}
{% blokir konten %}
<tengah>
<h1>Tugas Andah1>
<Ahref="{% url 'task_create' %}">Tambahkan TugasA>
 {% untuk tugas dalam tugas %}
<div>
<div>
<h5>{{tugas.judul}}h5>
<P>{{ task.description|truncatechars: 50 }}P>
<P>
<kuat>Lengkap:kuat>
 {% if task.completed %}Ya{% else %}Tidak{% endif %}
P>
<Ahref="{% url 'task_detail' tugas.pk %}">
 Baca selengkapnya
A>
<Ahref="{% url 'task_delete' tugas.pk %}">
 Hapus tugas
A>
div>
div>
 {% kosong %}
<h3>Belum ada tugas.h3>
<Ahref="{% url 'task_create' %}">Tambahkan TugasA>
 {% akhir untuk %}
tengah>
{% blok akhir %}

Dengan beberapa kelas Bootstrap, Anda dapat membuat halaman Anda terlihat seperti ini:

Templat Detail Tugas

Halaman ini harus menunjukkan detail lengkap dari setiap tugas yang dibuat. Berikut ini contoh template yang dapat Anda gunakan:

{% memperluas 'base.html' %}
{% blokir konten %}
<h1>{{tugas.judul}}h1>
<P>{{tugas.deskripsi}}P>
<P>Selesai: {% if task.completed %}Ya{% else %}Tidak{% endif %}P>
<Ahref="{% url 'task_update' tugas.pk %}">Mengedit tugasA>
<Ahref="{% url 'task_delete' tugas.pk %}">Hapus tugasA>
{% blok akhir %}

Bergantung pada pendekatan gaya Anda, halaman Anda akan terlihat seperti ini:

Templat Formulir Tugas

Templat ini harus berisi formulir yang memungkinkan pengguna membuat atau memperbarui tugas.

{% memperluas 'base.html' %}
{% blokir konten %}
<h1>Buat Tugash1>
<membentukmetode="pos">
 {% csrf_token %}
 {{ form.as_p }}
<tomboljenis="kirim">Menyimpantombol>
membentuk>
{% blok akhir %}

Templat akan terlihat seperti ini:

Hapus Templat Tugas

Template ini harus menjadi halaman konfirmasi untuk mencegah penghapusan tugas secara tidak sengaja.

{% memperluas 'base.html' %}
{% blokir konten %}
<h1>Konfirmasi Hapush1>
<P>Anda yakin ingin menghapus "{{ object.title }}"?P>
<membentukmetode="pos">
 {% csrf_token %}
<tomboljenis="kirim">Menghapustombol>
<Ahref="{% url 'task_list' %}">MembatalkanA>
membentuk>
{% blok akhir %}

Dengan beberapa Bootstrap, halaman Anda akan terlihat seperti ini:

Gunakan Tampilan Berbasis Kelas untuk Meningkatkan Produktivitas Anda

Tampilan berbasis kelas adalah cara yang bagus untuk menulis kode yang rapi dan teratur dalam waktu singkat, sehingga meningkatkan produktivitas Anda. Anda harus menggunakannya dalam proyek Anda sebanyak mungkin. Selain itu, Anda dapat lebih jauh mengintegrasikan fitur-fitur seperti fungsi pencarian, notifikasi, dan sebagainya untuk membuat aplikasi pengelola tugas Anda menjadi aplikasi fungsional yang lengkap.