Tindakan admin

Alir kerja dasar dari admin Django adalah, dalam kulit kacang, "pilih sebuah obyek, kemudian rubah itu." Ini bekerja baik untuk kebanyakan penggunaan kasus. Bagaimanapun, jika anda butuh perubahan sama ke banyak obyek sekali waktu, alir kerja ini bisa sangat membosankan.

In these cases, Django's admin lets you write and register "actions" -- functions that get called with a list of objects selected on the change list page.

Jika anda mencari daftar perubahan apapun di admin, anda akan melihat fitur ini di tindakan; Django dikirim dengan tindakan "menghapus obyek terpilih" tersedia untuk semua model. Sebagai contoh, ini adalah modul pengguna dari aplikasi django.contrib.auth pasang-tetap Django :

../../../_images/admin-actions.png

Peringatan

Tindakan "hapus obyek-obyek terpilih" menggunakan QuerySet.delete() untuk alasan efesiensi, yang mempunyai surat keberatan yang penting: metode delete() model anda tidak akan dipanggil.

Jika anda berharap menimpa perilaku ini, anda dapat menimpa ModelAdmin.delete_queryset() atau menulis penyesuaian tindakan yang melakukan penghapusan dalam perilaku anda pilih -- sebagai contoh, dengan memanggil Model.delete() untuk setiap dari barang terpilih.

Untuk latar belakang lebih pada penghapusan jumlah besar, lihat dokumentasi pada object deletion.

Baca untuk menemukan bagaimana menambah tindakan anda sendiri ke daftar ini.

Menulis tindakan

Cara mudah untukmenjelaskan tindakan adalah dengan contoh, jadi mari kita selami.

A common use case for admin actions is the bulk updating of a model. Imagine a news application with an Article model:

from django.db import models

STATUS_CHOICES = [
    ('d', 'Draft'),
    ('p', 'Published'),
    ('w', 'Withdrawn'),
]

class Article(models.Model):
    title = models.CharField(max_length=100)
    body = models.TextField()
    status = models.CharField(max_length=1, choices=STATUS_CHOICES)

    def __str__(self):
        return self.title

Tugas utama kami mungkin lakukan dengan sebuah model seperti ini adalah memperbaharui sebuah keadaan article dari "draft" menjadi "published". Kami dapat dengan mudah melakukan ini di admin satu artikel pada sekali waktu, tetapi jika kami ingin menerbitkan-jumlah besar kelompok dari artikel, itu akan membosankan. Jadi, mari kita menulis sebuah tindakan yang membuat kita merubah sebuah keadaan artikel menjadi "published."

Menulis fungsi tindakan

First, we'll need to write a function that gets called when the action is triggered from the admin. Action functions are regular functions that take three arguments:

  • ModelAdmin saat ini
  • Sebuah HttpRequest mewakili permintaan saat ini,
  • Sebuah QuerySet mengandung sekumpulan dari obyek-obyek terpilih oleh pengguna.

Fungsi terbitan-artikel-ini kami tidak butuh ModelAdmin atau obyek permintaan, tetapi kami akan menggunakan queryset:

def make_published(modeladmin, request, queryset):
    queryset.update(status='p')

Catatan

For the best performance, we're using the queryset's update method. Other types of actions might need to deal with each object individually; in these cases we'd iterate over the queryset:

for obj in queryset:
    do_something_with(obj)

Itu benar-benar semuanya ada adalah menulis sebuah tindakan! Bagaimanapun, kami akan mengambil satu atau lebih langkah pilihan-tetapi-berguna dan memberikan tindakan sebuah judul "nice" dalam admin. Secara awalan, tindakan ini akan muncul dalam daftar tindakan sebagai "Make published" -- nama fungsi, dengan garis bawah diganti oleh ruang. Tidak apa-apa, tetai kami dapat menyediakan lebih baik, nama lebih ramah-manusia dengan memberikan fungsi make_published sebuah atribut short_description:

def make_published(modeladmin, request, queryset):
    queryset.update(status='p')
make_published.short_description = "Mark selected stories as published"

Catatan

Ini mungkin terlihat akrab; pilihan list_display admin menggunakan teknik sama untuk menyediakan gambaran dapat dibaca-manusia untuk fungsi callback terdaftar disana, juga.

Menambahkan tindakan pada ModelAdmin

Selanjutnya, kami akan butuh menginformasikan ModelAdmin kami dari tindakan. Ini bekerja seperti piliha konfigurasi lain apapun. Jadi, admin.py lengkap dengan tindakan dan pendaftarannya akan terlihat seperti:

from django.contrib import admin
from myapp.models import Article

def make_published(modeladmin, request, queryset):
    queryset.update(status='p')
make_published.short_description = "Mark selected stories as published"

class ArticleAdmin(admin.ModelAdmin):
    list_display = ['title', 'status']
    ordering = ['title']
    actions = [make_published]

admin.site.register(Article, ArticleAdmin)

Kode akan memberikan kami sebuah daftar rubah admin yang terlihat sesuatu seperti ini:

../../../_images/adding-actions-to-the-modeladmin.png

That's really all there is to it! If you're itching to write your own actions, you now know enough to get started. The rest of this document covers more advanced techniques.

Penanganan kesalahan di tindakan

Jika ada kondisi kesalahan mendatang yang mungkin muncul selagi menjalankan tindakan anda, anda harus anggun menginformasikan pengguna dari masalah. Ini berarti menangani pengecualian dan menggunakan django.contrib.admin.ModelAdmin.message_user() untuk memperlihatkan gambaran yang ramah pengguna dari masalah di tanggapan.

Teknik-teknik tindakan lanjutan

Ada sepasang pilihan tambahan dan kemungkinan anda dapat menggunakan lebih pilihan lanjutan

Tindakan sebagai metode ModelAdmin

The example above shows the make_published action defined as a function. That's perfectly fine, but it's not perfect from a code design point of view: since the action is tightly coupled to the Article object, it makes sense to hook the action to the ArticleAdmin object itself.

Anda dapat melakukan itu seperti ini:

class ArticleAdmin(admin.ModelAdmin):
    ...

    actions = ['make_published']

    def make_published(self, request, queryset):
        queryset.update(status='p')
    make_published.short_description = "Mark selected stories as published"

Perhatikan pertama yang kami telah pindahkan make_published kedalam metode dan dinamai kembali parameter modeladmin pada self, dan kedua kami telah sekarang menaruh string 'make_published' dalam actions daripada acuan fungsi langsung. Ini mengatakan ModelAdmin untuk mencari tindakan sebagai sebuah metode.

Defining actions as methods gives the action more idiomatic access to the ModelAdmin itself, allowing the action to call any of the methods provided by the admin.

For example, we can use self to flash a message to the user informing them that the action was successful:

from django.contrib import messages
from django.utils.translation import ngettext

class ArticleAdmin(admin.ModelAdmin):
    ...

    def make_published(self, request, queryset):
        updated = queryset.update(status='p')
        self.message_user(request, ngettext(
            '%d story was successfully marked as published.',
            '%d stories were successfully marked as published.',
            updated,
        ) % updated, messages.SUCCESS)

Ini membuat tindakan cocok apa yang admin itu sendiri lakukan setelah berhasil melakukan sebuah tindakan:

../../../_images/actions-as-modeladmin-methods.png

Tindakan yang menyediakan halaman menengah

By default, after an action is performed the user is redirected back to the original change list page. However, some actions, especially more complex ones, will need to return intermediate pages. For example, the built-in delete action asks for confirmation before deleting the selected objects.

To provide an intermediary page, return an HttpResponse (or subclass) from your action. For example, you might write an export function that uses Django's serialization functions to dump some selected objects as JSON:

from django.core import serializers
from django.http import HttpResponse

def export_as_json(modeladmin, request, queryset):
    response = HttpResponse(content_type="application/json")
    serializers.serialize("json", queryset, stream=response)
    return response

Generally, something like the above isn't considered a great idea. Most of the time, the best practice will be to return an HttpResponseRedirect and redirect the user to a view you've written, passing the list of selected objects in the GET query string. This allows you to provide complex interaction logic on the intermediary pages. For example, if you wanted to provide a more complete export function, you'd want to let the user choose a format, and possibly a list of fields to include in the export. The best thing to do would be to write a small action that redirects to your custom export view:

from django.contrib.contenttypes.models import ContentType
from django.http import HttpResponseRedirect

def export_selected_objects(modeladmin, request, queryset):
    selected = queryset.values_list('pk', flat=True)
    ct = ContentType.objects.get_for_model(queryset.model)
    return HttpResponseRedirect('/export/?ct=%s&ids=%s' % (
        ct.pk,
        ','.join(str(pk) for pk in selected),
    ))

As you can see, the action is rather short; all the complex logic would belong in your export view. This would need to deal with objects of any type, hence the business with the ContentType.

Meunlis tampilan ini adalah sisa dari sebuah latihan ke pembaca.

Membuat tindakan tersedia lebar-situs

AdminSite.add_action(action, name=None)

Beberapa tindakan adalah terbaik jika mereka membuat tersedia pada setiap obyek di situs admin -- tindakan ekspor ditentukan diatas akan menjadi calon bagus. Anda dapat membuat sebuah tindakan secara global tersedia menggunakan AdminSite.add_action(). Sebagai contoh:

from django.contrib import admin

admin.site.add_action(export_selected_objects)

Ini membuat tindakan export_selected_objects secara global tersedia sebagai sebuah tindakan bernama "export_selected_objects". Anda dapat dengan jelas memberikan tindakan sebuah nama -- bagus jika anda kemudian ingin secara program remove the action -- dengan melewatkan argumen kedua ke AdminSite.add_action():

admin.site.add_action(export_selected_objects, 'export_selected')

Meniadakan tindakan

Terkadang anda butuh meniadakan beberapa tindakan -- khususnya itu registered site-wide -- untuk obyek-obyek tertentu. Ada sedikit cara anda dapat meniadakan tindakan:

Meniadakan tindakan lebar-situs

AdminSite.disable_action(name)

Jika anda butuh meniadakan sebuah site-wide action anda dapat memanggil AdminSite.disable_action().

Sebagai contoh, anda dapat menggunakan metode ini memindahkan tindakan "delete selected objects" siap-pakai:

admin.site.disable_action('delete_selected')

Sekali anda telah melakukan diatas, tindakan itu akan tidak lagi tersedia lebar-situs.

If, however, you need to re-enable a globally-disabled action for one particular model, list it explicitly in your ModelAdmin.actions list:

# Globally disable delete selected
admin.site.disable_action('delete_selected')

# This ModelAdmin will not have delete_selected available
class SomeModelAdmin(admin.ModelAdmin):
    actions = ['some_other_action']
    ...

# This one will
class AnotherModelAdmin(admin.ModelAdmin):
    actions = ['delete_selected', 'a_third_action']
    ...

Meniadakan semua tindakan untuk ModelAdmin tertentu

If you want no bulk actions available for a given ModelAdmin, set ModelAdmin.actions to None:

class MyModelAdmin(admin.ModelAdmin):
    actions = None

Ini memberitahu ModelAdmin untuk tidak memperlihatkan atau mengizinkan tindakan apapun, termasuk site-wide actions apapun.

Tindakan mengadakan dan meniadakan bersyarat

ModelAdmin.get_actions(request)

Akhirnya, anda dapat secara kondisional mengadakan atau meniadakan tindakan-tindakan pada sebuah per-permintaan (dan karenanya berdasarkan per-pengguna) dengan mengutamakan ModelAdmin.get_actions().

Ini mengembalikan sebuah kamus dari tindakan diizinkan. Kunci-kunci adalah nama-nama tindkan, dan nilai-nilai adalah tuple (function, name, short_description).

Sebagai contoh, jika anda hanya ingin pengguna yang namanya dimulai dengan 'J' untuk dapat menghapus obyek-pbyek dalam jumlah besar:

class MyModelAdmin(admin.ModelAdmin):
    ...

    def get_actions(self, request):
        actions = super().get_actions(request)
        if request.user.username[0].upper() != 'J':
            if 'delete_selected' in actions:
                del actions['delete_selected']
        return actions

Pengaturan perizinan untuk tindakan

Tindakan-tindakan mungkin membatasi ketersediaan pada pengguna dengan perizinan khusus dengan mengatur sebuah atribut allowed_permissions pada fungsi tindakan:

def make_published(modeladmin, request, queryset):
    queryset.update(status='p')
make_published.allowed_permissions = ('change',)

Tindakan make_published() hanya akan tersedia pada pengguna yang melewatkan pemeriksaan ModelAdmin.has_change_permission().

Jika allowed_permissions mempunyai lebih dari satu perizinan, tindakan akan tersedia selama pengguna melewatkan setidaknya satu pemeriksaan.

Nilai-nilai tersedia untuk allowed_permissions dan metode pemeriksaan terkait adalah:

Anda dapat menentukan nilai lain apapun selama anda menerapkan metode has__permission(self, request) sesuai pada ModelAdmin.

Sebagai contoh:

from django.contrib import admin
from django.contrib.auth import get_permission_codename

class ArticleAdmin(admin.ModelAdmin):
    actions = ['make_published']

    def make_published(self, request, queryset):
        queryset.update(status='p')
    make_published.allowed_permissions = ('publish',)

    def has_publish_permission(self, request):
        """Does the user have the publish permission?"""
        opts = self.opts
        codename = get_permission_codename('publish', opts)
        return request.user.has_perm('%s.%s' % (opts.app_label, codename))