Administrativa åtgärderLink to this heading#

Skriva handlingsfunktionerLink to this heading#

Först måste vi skriva en funktion som anropas när åtgärden utlöses från administratören. Åtgärdsfunktioner är vanliga funktioner som tar tre argument:

• Den aktuella ModelAdmin

• En HttpRequest som representerar den aktuella begäran,

• En QuerySet som innehåller den uppsättning objekt som användaren har valt.

Vår funktion publish-these-articles kommer inte att behöva ModelAdmin eller request-objektet, men vi kommer att använda queryset:

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

Det är faktiskt allt som krävs för att skriva en åtgärd! Vi ska dock ta ytterligare ett valfritt men användbart steg och ge åtgärden en ”fin” titel i admin. Som standard visas den här åtgärden i åtgärdslistan som ”Gör publicerad” - funktionsnamnet, med understreck ersatta av mellanslag. Det är bra, men vi kan ge ett bättre, mer människovänligt namn genom att använda action()-dekoratorn på make_published-funktionen:

from django.contrib import admin

...


@admin.action(description="Mark selected stories as published")
def make_published(modeladmin, request, queryset):
    queryset.update(status="p")

Lägga till åtgärder till ModelAdminLink to this heading#

Därefter måste vi informera vår ModelAdmin om åtgärden. Detta fungerar precis som alla andra konfigurationsalternativ. Så, den kompletta admin.py med åtgärden och dess registrering skulle se ut så här:

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


@admin.action(description="Mark selected stories as published")
def make_published(modeladmin, request, queryset):
    queryset.update(status="p")


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


admin.site.register(Article, ArticleAdmin)

Den koden kommer att ge oss en ändringslista för administratörer som ser ut ungefär så här:

Det är verkligen allt som behövs! Om du är sugen på att skriva dina egna åtgärder vet du nu tillräckligt för att komma igång. Resten av det här dokumentet handlar om mer avancerade tekniker.

Hantering av fel i åtgärderLink to this heading#

Om det finns förutsebara felförhållanden som kan uppstå när du kör din åtgärd, bör du på ett elegant sätt informera användaren om problemet. Detta innebär att hantera undantag och använda django.contrib.admin.ModelAdmin.message_user() för att visa en användarvänlig beskrivning av problemet i svaret.

Åtgärder som ModelAdmin-metoderLink to this heading#

I exemplet ovan är åtgärden make_published definierad som en funktion. Det är helt okej, men det är inte perfekt ur en koddesignsynpunkt: eftersom åtgärden är tätt kopplad till objektet Article är det vettigt att koppla åtgärden till själva objektet ArticleAdmin.

Du kan göra det så här:

class ArticleAdmin(admin.ModelAdmin):
    ...

    actions = ["make_published"]

    @admin.action(description="Mark selected stories as published")
    def make_published(self, request, queryset):
        queryset.update(status="p")

Lägg först märke till att vi har flyttat make_published till en metod och bytt namn på parametern modeladmin till self, och sedan att vi nu har lagt strängen 'make_published i actions istället för en direkt funktionsreferens. Detta säger till ModelAdmin att leta upp åtgärden som en metod.

Genom att definiera åtgärder som metoder får åtgärden en mer idiomatisk tillgång till själva ModelAdmin, vilket gör att åtgärden kan anropa vilken som helst av de metoder som tillhandahålls av administratören.

Vi kan t.ex. använda self för att skicka ett meddelande till användaren om att åtgärden var lyckad:

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,
        )

Detta gör att åtgärden motsvarar vad admin själv gör efter att en åtgärd har utförts framgångsrikt:

Åtgärder som ger mellanliggande sidorLink to this heading#

Som standard omdirigeras användaren tillbaka till den ursprungliga sidan i ändringslistan efter att en åtgärd har utförts. Vissa åtgärder, särskilt mer komplexa sådana, måste dock returnera mellanliggande sidor. Till exempel: ber den inbyggda åtgärden delete om bekräftelse innan de valda objekten raderas.

För att tillhandahålla en mellanliggande sida, returnera en HttpResponse (eller underklass) från din åtgärd. Du kan till exempel skriva en exportfunktion som använder Djangos serialiseringsfunktioner för att dumpa några utvalda objekt som 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

Generellt sett anses något som ovanstående inte vara en bra idé. För det mesta är den bästa metoden att returnera en HttpResponseRedirect och omdirigera användaren till en vy som du har skrivit och skicka listan över valda objekt i GET-frågesträngen. Detta gör att du kan tillhandahålla komplex interaktionslogik på de mellanliggande sidorna. Om du till exempel vill tillhandahålla en mer komplett exportfunktion skulle du vilja låta användaren välja ett format och eventuellt en lista över fält som ska ingå i exporten. Det bästa du kan göra är att skriva en liten åtgärd som omdirigerar till din anpassade exportvy:

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),
        )
    )

Som du kan se är åtgärden ganska kort; all komplex logik hör hemma i din exportvy. Denna skulle behöva hantera objekt av alla typer, därav verksamheten med ContentType.

Att skriva denna vy lämnas som en övning till läsaren.

Göra åtgärder tillgängliga för hela webbplatsenLink to this heading#

AdminSite.add_action(action, name=None)Link to this definition#

Vissa åtgärder är bäst när de är tillgängliga för alla objekt på adminwebbplatsen – exportåtgärden som definieras ovan är en bra kandidat. Du kan göra en åtgärd globalt tillgänglig med AdminSite.add_action(). Till exempel:

Code

from django.contrib import admin

admin.site.add_action(export_selected_objects)

Detta gör åtgärden export_selected_objects globalt tillgänglig med namnet ”export_selected_objects”. Du kan uttryckligen ge åtgärden ett namn – bra om du senare vill ta bort åtgärden programmässigt – genom att skicka ett andra argument till AdminSite.add_action():

Code

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

Inaktivera åtgärderLink to this heading#

Ibland behöver du inaktivera vissa åtgärder - särskilt de som registered site-wide - för vissa objekt. Det finns några olika sätt att inaktivera åtgärder:

class MyModelAdmin(admin.ModelAdmin):
    actions = None

Ange behörigheter för åtgärderLink to this heading#

Åtgärder kan begränsa sin tillgänglighet till användare med specifika behörigheter genom att omsluta åtgärdsfunktionen med action()-dekoratorn och skicka argumentet permissions:

@admin.action(permissions=["change"])
def make_published(modeladmin, request, queryset):
    queryset.update(status="p")

Åtgärden make_published() är endast tillgänglig för användare som passerar kontrollen ModelAdmin.has_change_permission() när den anropas med obj=None.

Om permissions har mer än en behörighet kommer åtgärden att vara tillgänglig så länge som användaren klarar minst en av kontrollerna.

Tillgängliga värden för permissions och motsvarande metodkontroller är:

• 'add': ModelAdmin.has_add_permission()

• 'change': ModelAdmin.has_change_permission()

• 'delete': ModelAdmin.has_delete_permission()

• 'view': ModelAdmin.has_view_permission()

Du kan ange vilket annat värde som helst så länge du implementerar en motsvarande has_<value>_permission(self, request)-metod på ModelAdmin.

Till exempel:

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


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

    @admin.action(permissions=["publish"])
    def make_published(self, request, queryset):
        queryset.update(status="p")

    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))

Administrationen kontrollerar inte automatiskt behörigheter på objektnivå för varje valt objekt när en åtgärd körs. Utför kontrollerna i själva åtgärden för att begränsa vilka objekt som en åtgärd får ändra utifrån behörigheter på objektnivå. Till exempel:

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

    @admin.action(permissions=["change"])
    def make_published(self, request, queryset):
        for obj in queryset:
            if self.has_change_permission(request, obj=obj):
                obj.status = "p"
                obj.save(update_fields=["status"])

Styra var åtgärder är tillgängligaLink to this heading#

Som standard är adminåtgärder endast tillgängliga på ändringslistsidan. Du kan styra var en åtgärd visas med argumentet location till dekoratorn @admin.action.

För att till exempel göra en åtgärd tillgänglig endast i ändringsformuläret anger du location till ActionLocation.CHANGE_FORM:

from django.contrib import admin
from django.contrib.admin import ActionLocation


@admin.action(location=ActionLocation.CHANGE_FORM)
def make_published(modeladmin, request, queryset): ...

För att göra en åtgärd tillgänglig både i ändringslistan och i ändringsformuläret:

@admin.action(
    location=[ActionLocation.CHANGE_FORM, ActionLocation.CHANGE_LIST],
    description="Publish",
    description_plural="Mark selected stories as published",
)
def make_published(modeladmin, request, queryset): ...

Observera att description och description_plural angavs. De är valfria, men adminåtgärden etiketteras med description i adminens ändringsformulär och description_plural i adminens ändringslista.

Du kan anpassa hur åtgärder återges genom att åsidosätta adminmallar. Ändringslistsidan använder admin/actions.html och ändringsformuläret använder admin/change_form_actions.html. Observera att ändringsformulärmallen ärver från mallen för ändringslistans åtgärder.