Operasi CRUD Dalam Python & Django - Bahagian 2

Dalam artikel kami sebelum ini, kami membincangkan asas menyediakan projek Django dan mencipta model Latihan kami, yang kami paparkan di bahagian hadapan sebagai senarai. Dalam artikel ini, kita akan menyelami pelaksanaan operasi CRUD. Bagi mereka yang tidak dikenali, CRUD bermaksud Cipta, Baca, Kemas Kini dan Padam—pada asasnya empat tindakan asas yang boleh anda lakukan pada data anda.

Sekarang kami telah menyediakan API kami dalam folder apl, kami hanya akan melanjutkan paparan indeks untuk mengendalikan permintaan membuat, mengemas kini dan memadam.

Borang

Mari sediakan borang yang membolehkan pengguna membuat latihan. Kami akan menggunakan templat HTML untuk tujuan ini sekali lagi. Untuk bermula, buat templat baharu yang dipanggil add_exercise.html dalam folder app/templates.

<form method="POST" action="/">
    {% csrf_token %}
    <input type="text" name="title" placeholder="Enter the title" />
    <input type="date" name="date"  placeholder="Enter the date" />
    <button type="submit">Save</button>
</form>

Seterusnya, dalam templat index.html kami, kami akan memasukkan templat add_exercise.html menggunakan kaedah berikut:

{% extends "base.html" %} {% block content %}
    <h2>Exercises</h2>
    {% include 'add_exercise.html' %}
...
{% endblock %}

Kami menggunakan teg serta di sini, yang menggalakkan kebolehkomposisian merentas templat HTML, menjadikan kod kami lebih mudah untuk diselenggara dan difahami. Jika anda memuat semula halaman dalam penyemak imbas anda, anda sepatutnya melihat borang itu muncul pada skrin.

Dalam HTML kami, kami menggunakan  teg dengan atribut kaedah ditetapkan kepada POST dan atribut tindakan yang menunjuk /, yang merupakan titik akhir yang sama yang kami gunakan untuk mengambil senarai latihan.

Dalam konteks ini, csrf_token  ialah ciri keselamatan yang diwakili oleh nilai rahsia yang dijana secara rawak. Ini membantu melindungi penyerahan borang kami daripada serangan pemalsuan, iaitu maksud CSRF —Pemalsuan Permintaan Merentas Tapak. Token unik dijana untuk setiap sesi pengguna dan ia tidak boleh diakses oleh tapak pihak ketiga, dengan itu menghalang perubahan yang tidak dibenarkan daripada berlaku.

Borang kami termasuk dua medan input: satu untuk tajuk dan satu lagi untuk tarikh, mengikut skema model Senaman kami. Apabila borang diserahkan, nilai untuk tajuk dan tarikh akan dihantar melalui permintaan POST ke / titik akhir, yang kemudiannya akan diproses oleh paparan indeks kami dalam app/views.py.

Model

Dalam Django, kami boleh meningkatkan model Latihan kami—pada asasnya kelas Python—dengan menambahkan kaedah khusus yang sepadan dengan operasi CRUD. Dalam fail app/models.py , kami akan memasukkan perkara berikut:

class Exercise(models.Model):
    ...

    def create(request):
        title = request.POST.get('title')
        date = request.POST.get('date')

        exercise = Exercise.objects.create(title=title, date=date)

        return exercise

Kami boleh mengakses tajuk dan tarikh daripada permintaan POST, seperti yang ditunjukkan dalam kod di atas. Kemudian, kita boleh menggunakan ORM terbina dalam Django untuk mencipta latihan baharu dan mengembalikan tika yang dibuat.

Kami akan memanfaatkan paparan indeks yang sama yang kami gunakan untuk mendapatkan semula latihan, mengembangkannya untuk menyemak sama ada kaedah permintaan ialah POST. Jika ya, kami akan menyerahkan objek permintaan kepada kaedah kelas yang kami takrifkan sebelum ini. Setelah latihan dibuat, kami akan mengubah hala pengguna kembali ke halaman utama atau melakukan muat semula halaman, memastikan latihan yang baru ditambah muncul pada skrin.

from django.http import HttpResponseRedirect

from app import models

...

def index(request):
    if request.method == 'POST':
        models.Exercise.create(request)
        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

Cuba buat latihan baharu sekarang dan anda akan melihatnya muncul di bahagian bawah senarai.

Kemas kini Latihan

Mari kita memfaktorkan semula kod kita sebelum menambah fungsi kemas kini pada latihan. Kami akan mengalihkan latihan ke templat mereka sendiri yang dipanggil exercise.html.

<h2>Exercises</h2>
{% include 'add_exercise.html' %}
<ul style="margin: 0; list-style: none; padding: 0">
    {% for exercise in exercises %}
        <li style="margin-top: 4px">
            {% include 'exercise.html' %}
        </li>
    {% endfor %}
</ul>

Buat templat untuk exercise.html dalam folder app/templates dan kami akan menambahkan HTML berikut padanya:

<form method="POST" action="/">
    {% csrf_token %}
    <input hidden name="id" value="{{exercise.id}}" />
    <input
        type="text"
        name="title"
        value="{{exercise.title}}"
        placeholder="Enter the title"
    />
    <input
        type="date"
        name="date"
        placeholder="Enter the date"
        value="{{exercise.date | date:'Y-m-d'}}"
    />
    <button type="submit" name="update">Update</button>
</form>

Kami menggunakan  teg semula untuk setiap latihan dalam senarai dan menambah input tersembunyi untuk exercise.id, yang akan digunakan untuk mengemas kini latihan. Kembali ke penyemak imbas dan muat semula halaman; anda harus melihat borang untuk setiap latihan dalam senarai, dengan setiap input telah diisi terlebih dahulu dengan data latihan yang sepadan.

Perhatikan bahawa kami tidak menggunakan PUT sebagai kaedah borang; sebaliknya, kami menggunakan POST. Ini kerana pengendali paparan hanya boleh menghuraikan data yang dihantar melalui permintaan GET dan POST , tanpa sokongan terbina dalam untuk PUT dan DELETE. Apabila kami membuat kaedah kelas cipta dalam kelas Latihan, anda mungkin perasan kami menggunakan request.POST.get('title'). Walaupun ini berfungsi untuk POST permintaan, tiada kaedah PUT atau DELETE tersedia dalam objek permintaan.

Tetapi bagaimanakah kita membezakan antara POST dan permintaan PUT? Jika anda menyemak borang yang kami buat sebelum ini, anda akan dapati bahawa kami memberikan nama atribut kepada butang serah. Kami boleh mengakses atribut ini dengan cara yang sama kami mengakses tajuk dan tarikh, menggunakan request.POST.get('update').

Mari mengemas kini borang latihan cipta untuk memasukkan perubahan yang sama.

<form method="POST" action="/">
    ...
    <button type="submit" name="create">Save</button>
</form>

Dan dalam paparan senaman kami, kami akan membuat perubahan berikut untuk membezakan antara permintaan.

def index(request):
    if request.method == 'POST':
        create = 'create' in request.POST
        update = 'update' in request.POST

        if create == True:
            models.Exercise.create(request)
        elif update == True:
            models.Exercise.update(request)

        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

We check for the button name and forward the request to the appropriate Exercise method accordingly.

Let's add an update class method to the Exercise model in app/models.py.

def update(request):
    id = request.POST.get('id')
    title = request.POST.get('title')
    date = request.POST.get('date')

    exercise = Exercise.objects.filter(pk=id).update(title=title, date=date)

    return exercise

To update a row in the database, we can use the update method available on the Exercise model. However, before updating, we need to ensure that we are updating the correct exercise. To do this, we filter the exercises by the primary key, which is id, and update only that specific exercise.

Delete Exercise

Similarly, we’ll add a delete button next to each exercise in the exercise.html template.

<form method="POST" action="/">
    ...
    <button type="submit" name="update">Update</button>
    <button type="submit" name="delete">Delete</button>
</form>

We’ll set delete as the value of the name attribute, and in views.py, we’ll extend the if...elif statements to handle the delete operation.

def index(request):
    if request.method == 'POST':
        create = 'create' in request.POST
        update = 'update' in request.POST
        delete = 'delete' in request.POST

        if create == True:
            models.Exercise.create(request)
        elif update == True:
            models.Exercise.update(request)
        elif delete == True:
            models.Exercise.delete(request)

        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

And in the Exercise model, we'll add the class method delete.

def delete(request):
    id = request.POST.get('id')
    is_deleted = Exercise.objects.filter(pk=id).delete()

    if is_deleted == 1:
        return True

    return False

With this addition, we've successfully implemented CRUD operations in our Python and Django application.

Key Takeaways

1. Django view handlers do not support PUT and DELETE requests, as they do not parse the query parameters or request body for those HTTP methods. As a result, we must rely on POST requests and differentiate between them by passing an additional field in the request body.
2. Noticed that I'm making the POST request to the same route from which I'm fetching the exercises. This is important because if you were to create an endpoint like /api/exercises to handle requests, you would need to manage redirection manually. Otherwise, the behavior of the
   tag after the request is to redirect the user to the endpoint specified in the action attribute. Therefore, you will need to manually redirect the user back to the desired page, or in our case, keep the user on the same page.

from django.http import HttpResponseRedirect

def index(request):
    ...

    return redirect('/')
    # or
    return HttpResponseRedirect(request.META['HTTP_REFERER'])

In summary, by effectively managing our POST requests and ensuring proper redirection, we can create a seamless user experience while implementing CRUD operations in our Django application.

Atas ialah kandungan terperinci Operasi CRUD Dalam Python & Django - Bahagian 2. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!