---
title: "gníomhartha riaracháin"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/contrib/admin/actions/
canonical: https://djangodocs.dev/ga/6.1/ref/contrib/admin/actions/
---
# gníomhartha riaracháin

Is é sreabhadh oibre bunúsach riaracháin Django, go hachomair, “roghnaigh réad, ansin athraigh é.” Oibríonn sé seo go maith le haghaidh formhór na gcásanna úsáide. Mar sin féin, más gá duit an t-athrú céanna a dhéanamh ar go leor rudaí ag an am céanna, is féidir leis an sreabhadh oibre seo a bheith an-teannach.

Sna cásanna seo, ligeann riarachán Django duit “gníomhartha” a scríobh agus a chlárú - feidhmeanna a ghlaofar le liosta rudaí a roghnaítear ar leathanach an liosta athraithe.

Má fhéachann tú ar aon liosta athraithe sa riarachán, feicfidh tú an ghné seo i ngníomh; Seolann Django le gníomh “scrios rudaí roghnaithe” atá ar fáil do gach samhail. Mar shampla, seo an modúl úsáideora ó aip ionsuite Django: mod: django.contrib.auth:

![](ref/contrib/admin/_images/admin-actions.png)

> **Warning**
>
> Úsáideann \<django.db.models.query.QuerySet.delete\>an gníomh “scrios rudaí roghnaithe”: meth: QuerySet.delete () ar chúiseanna éifeachtúlachta, a bhfuil rabhadh tábhachtach aige: ní ghlaofar modh delete () do mhúnla.
>
> Más mian leat an t-iompar seo a shárú, is féidir leat: meth: .modelAdmin.delete\_querySet a shárú nó gníomh saincheaptha a scríobh a scriosann ar an mbealach is fearr leat - mar shampla, trí ghlaoch ar Model.delete () do gach ceann de na míreanna roghnaithe.
>
> \<topics-db-queries-delete\>Le haghaidh tuilleadh cúlra maidir le mór-scriosadh, féach an doiciméadú ar:ref: scriosadh réad .

Léigh ar aghaidh chun a fháil amach conas do ghníomhartha féin a chur leis an liosta seo.

## Gníomhartha scrí

Is é an bealach is éasca le gníomhartha a mhíniú trí shampla, mar sin déanaimis tumadh isteach.

Cás úsáide coitianta do ghníomhartha riaracháin is ea an mórchnuashonrú ar mhúnla. Samhlaigh feidhmchlár nuachta le samhail `Airteagal`:

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

Tasc coitianta a d'fhéadfaimis a dhéanamh le samhail mar seo ná stádas alt a nuashonrú ó “dréacht” go “foilsithe”. D'fhéadfaimis é seo a dhéanamh go héasca san riarachán alt amháin ag an am, ach dá dteastaíonn uainn grúpa alt a fhoilsiú go mór, bheadh sé deacair. Mar sin, déanaimis gníomh a scríobh a ligeann dúinn stádas alt a athrú go “foilsithe.”

### Feidhmeanna gníomhaíochta

Ar dtús, beidh orainn feidhm a scríobh a ghlaofar nuair a spreagtar an gníomh ón riarachán. Is feidhmeanna rialta iad feidhmeanna gníomhaíochta a thógann trí argóint:

- An reatha: aicme: ModelAdmin
- An:class: ~django.http.httpRequest a léiríonn an t-iarratas reatha,
- A: Class: ~django.db.models.query.querySet ina bhfuil an tacar rudaí a roghnaigh an t-úsáideoir.

Ní bheidh an: class: ModelAdmin nó an réad iarratais ag teastáil ó ár bhfeidhm foilsithe seo, ach úsáidfimid an tacar ceisteanna:

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

> **Note**
>
> \<topics-db-queries-update\>Le haghaidh an fheidhmíocht is fearr, táimid ag úsáid an Queryset 's:ref: modh nuashonraithe . B'fhéidir go mbeadh gá le cineálacha eile gníomhartha déileáil le gach réad ina n-aonar; sna cásanna seo déanfaimis athrá thar an tacar ceisteanna:
>
> ```
> for obj in queryset:
>     do_something_with(obj)
> ```

Sin i ndáiríre gach rud atá ann chun gníomh a scríobh! Mar sin féin, glacfaimid céim roghnach ach úsáideach amháin eile agus tabharfaimid teideal “deas” don ghníomh sa riarachán. De réir réamhshocraithe, bheadh an gníomh seo le feiceáil ar an liosta gníomhaíochta mar “Déan foilsithe” - ainm na feidhme, le spásanna ina ionad béim. Tá sé sin go breá, ach is féidir linn ainm níos fearr, níos cairdiúla don duine a sholáthar tríd an maisitheoir: func: ~django.contrib.admin.action a úsáid ar an bhfeidhm make\_published :

```
from django.contrib import admin

...

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

> **Note**
>
> D'fhéadfadh cuma eolach air seo; úsáideann an rogha admin's:attr: ~django.contrib.admin.modeladmin.list\_display teicníc den chineál céanna leis an maisitheoir: func: ~django.contrib.admin.display chun tuairiscí inléite don duine a sholáthar d'fheidhmeanna aisghlaonna atá cláraithe ansin freisin.

### Gníomhartha a chur leis an:class: ModelAdmin

Ansin, beidh orainn ár n:class: ModelAdmin a chur ar an eolas faoin ngníomh. Oibríonn sé seo díreach cosúil le haon rogha cumraíochta eile. Mar sin, bheadh cuma ar an admin.py\` iomlán leis an ngníomh agus a chlá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)
```

Tabharfaidh an cód sin liosta athraithe riaracháin dúinn a bhfuil cuma mar seo air:

![](ref/contrib/admin/_images/adding-actions-to-the-modeladmin.png)

Sin go léir atá ann i ndáiríre! Má tá tú ag iarraidh do ghníomhartha féin a scríobh, tá a fhios agat anois go leor chun tosú. Clúdaíonn an chuid eile den doiciméad seo teicnící níos airde.

### Earráidí láimhseála i ngn

Má tá coinníollacha earráide intuartha ann a d'fhéadfadh tarlú agus do ghníomh á reáchtáil, ba cheart duit an t-úsáideoir a chur ar an eolas go grásta faoin bhfadhb. Ciallaíonn sé seo eisceachtaí a láimhseáil agus úsáid: meth: django.contrib.admin.modeladmin.message\_user chun cur síos atá cairdiúil don úsáideoir ar an bhfadhb sa fhreagra a thaispeáint.

## Teicnící gníomhaíochta chun

Tá cúpla rogha agus féidearthachtaí breise ann is féidir leat leas a bhaint as le haghaidh roghanna níos airde.

### Gníomhartha cosúil:class: ModelAdmin modhanna

Taispeánann an sampla thuas an gníomh `make_published` a shainmhínítear mar fheidhm. Tá sé sin go breá, ach níl sé foirfe ó thaobh dearaidh cód: ós rud é go bhfuil an gníomh ceangailte go docht leis an réad `Airteagal`, tá sé ciallmhar an gníomh a cheangal leis an réad ArticleAdMin\` féin.

Is féidir leat é a dhéanamh mar seo:

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

Tabhair faoi deara ar dtús gur bhogamar `make_published` isteach i modh agus athainmníomar an paraiméadar ```modeladmin ``go `self```, agus sa dara háit gur chuireamar an teaghrán ``` `make_published'` anois i ``actions ``` in ionad tagairt feidhme díreach. Insíonn sé seo la:class: ModelAdmin breathnú suas ar an ngníomh mar mhodh.

Tugann gníomhartha a shainmhíniú mar mhodhanna rochtain níos idiomatiúla don ghníomhaíocht ar an: class: ModelAdmin féin, rud a ligeann don ghníomh aon cheann de na modhanna a sholáthraíonn an riarachán a ghlaoch.

Mar shampla, is féidir linn `féin` a úsáid chun teachtaireacht a splancadh chuig an úsáideoir in iúl dóibh gur éirigh leis an ngníomh:

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

This makes the action match what the admin itself does after successfully
performing an action:

![](ref/contrib/admin/_images/actions-as-modeladmin-methods.png)

### Gníomhartha a sholáthraíonn leathanaigh

De réir réamhshocraithe, tar éis gníomh a dhéanamh atreoraítear an t-úsáideoir ar ais chuig an leathanach liosta athraithe bunaidh. Mar sin féin, beidh ar roinnt gníomhartha, go háirithe cinn níos casta, leathanaigh idirmheánacha a thabhairt ar ais. Mar shampla, iarrann an gníomh scriosta ionsuite deimhniú sula ndéanann siad na rudaí roghnaithe a scriosadh.

Chun leathanach idirghabhála a sholáthar, cuir ar ais an:class: ~django.http.httpResponse (nó fo-aicme) ó do ghníomhaíocht. Mar shampla, d'fhéadfá feidhm onnmhairiúcháin a scríobh a úsáideann django's:doc: feidhmeanna sraitheach chun roinnt rudaí roghnaithe a dhumpáil mar \</topics/serialization\> 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
```

Go ginearálta, ní mheastar gur smaoineamh iontach é rud éigin mar an méid thuas. An chuid is mó den am, is é an cleachtas is fearr ná filleadh an:class: ~django.http.http.HttpResponsereDirect agus an t-úsáideoir a atreorú chuig radharc a scríobh tú, ag dul ar liosta na rudaí roghnaithe sa teaghrán ceisteanna GET. Ligeann sé seo duit loighic idirghníomhú casta a sholáthar ar na leathanaigh idir Mar shampla, más mian leat feidhm easpórtála níos iomláine a sholáthar, ba mhaith leat ligean don úsáideoir formáid a roghnú, agus b'fhéidir liosta réimsí le cur san onnmhairiú. Is é an rud is fearr le déanamh ná gníomh beag a scríobh a atreoraíonn chuig do radharc saincheaptha onnmhairithe:

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

Mar a fheiceann tú, tá an gníomh sách gearr; bheadh an loighic chasta go léir i do dhearcadh onnmhairithe. Bheadh sé seo déileáil le rudaí de chineál ar bith, dá bhrí sin an gnó leis an “ContentType”.

Fágtar an dearcadh seo a scríobh mar chleachtadh don léitheoir.

### Gníomhartha a chur ar fáil ar fud an suíomh

#### `AdminSite.add_action(action, name=None)`

Some actions are best if they're made available to *any* object in the
admin site -- the export action defined above would be a good candidate.
You can make an action globally available using
[`AdminSite.add_action()`](#django.contrib.admin.AdminSite.add_action). For example:

```
from django.contrib import admin

admin.site.add_action(export_selected_objects)
```

This makes the `export_selected_objects` action globally available as an
action named "export\_selected\_objects". You can explicitly give the action
a name -- good if you later want to programmatically [remove the
action](#disabling-admin-actions) -- by passing a second argument to
[`AdminSite.add_action()`](#django.contrib.admin.AdminSite.add_action):

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

### Gníomhartha díchumasaithe

Uaireanta ní mór duit gníomhartha áirithe a dhíchumasú - go háirithe iad siú:ref: cláraithe ar fud an láithreáin \<adminsite-actions\>\- le haghaidh rudaí áirithe. Tá cúpla bealach ann is féidir leat gníomhartha a dhíchumasú:

#### Gníomh ar fud an láithreáin a dhíchumasú

#### `AdminSite.disable_action(name)`

If you need to disable a [site-wide action](#adminsite-actions) you
can call [`AdminSite.disable_action()`](#django.contrib.admin.AdminSite.disable_action).

Mar shampla, is féidir leat an modh seo a úsáid chun an gníomh ionsuite “scrios rudaí roghnaithe” a bhaint:

```
admin.site.disable_action("delete_selected")
```

Nuair a bheidh an méid thuas déanta agat, ní bheidh an gníomh sin ar fáil ar fud an láithreáin a thuilleadh.

Más gá duit, áfach, gníomh faoi mhíchumas domhanda a athchumasú do mhúnla áirithe amháin, liostaigh é go sainráite i do liosta ModelAdmin.Actions\`:

```
# 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"]
    ...
```

#### Gach gníomh a dhíchumasú le haghaidh áirithe: class: ModelAdmin

Más mian leat mórghníomhaíochtaí *no* ar fáil le haghaidh tugadh: class: ModelAdmin, socraí:attr: ModelAdmin.actions go `None`:

```
class MyModelAdmin(admin.ModelAdmin):
    actions = None
```

\<adminsite-actions\>Insíonn sé seo la:class: ModelAdmin gan aon ghníomhartha a thaispeáint ná a cheadú, lena n-áirítear aon ghníomhartha: ref: láithreáin ghníomhartha .

#### gníomhartha a chumasú nó a dhíchumasú

#### `ModelAdmin.get_actions(request, action_location=ActionLocation.CHANGE_LIST)`

Faoi dheireadh, is féidir leat gníomhartha a chumasú nó a dhíchumasú go coinníollach ar aghaidh iarratais (agus dá bhrí sin in aghaidh an úsáideora) trí:meth: ModelAdmin.get\_actions a ró-dhiaidh.

This returns a dictionary of actions allowed for the specific
`action_location`. The keys are action names, and the values are
[`Action`](#django.contrib.admin.Action) objects.

Mar shampla, mura dteastaíonn uait ach go mbeidh úsáideoirí a dtosaíonn a n-ainmneacha le 'J' in ann rudaí a scriosadh ar an mórchóir:

```
class MyModelAdmin(admin.ModelAdmin):
    ...

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

> **Changed in Django 6.1**
>
> The keyword argument `action_location` was added. The return type was
> changed to a dictionary where the keys are action names and the values
> are [`Action`](#django.contrib.admin.Action) objects, previously the values were
> `(function, name, description)` tuples.

### Ceadanna a shocrú le haghaidh gníomhar

Féadfaidh gníomhartha a n-infhaighteacht a theorannú d'úsáideoirí a bhfuil ceadanna sonracha acu tríd an bhfeidhm ghníomhaíochta a fhilleadh leis an maisitheoir: func: ~django.contrib.admin.action agus an argóint `ceadúna` a rith:

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

Ní bheidh an gníomh make\_published () ar fáil ach d'úsáideoirí a rachaidh an seice:meth: .modeladmin.has\_change\_permission.

Má tá níos mó ná cead amháin ag ceadúnaí, beidh an gníomh ar fáil chomh fada agus a rachaidh an t-úsáideoir ceann amháin de na seiceálacha ar a laghad.

Is iad na luachanna atá ar fáil le haghaidh ceadui' agus na seiceálacha modh comhfhreagracha:

- `'add'`: :meth: .ModelAdmin.has\_Add\_Permission
- `'athraithe`: :meth: .modelAdmin.has\_Change\_Ceadúnaí
- `'delete'`: :meth: .modeladmin.has\_delete\_ceadúnaí
- `'view'`: :meth: .modeladmin.has\_view\_permission

Is féidir leat aon luach eile a shonrú chomh fada agus a chuireann tú modh comhfhreagrach ```hais_ <value>_cead (féin, iarraidh) ``i bhfeidhm ar an `ModelAdmin```.

Mar shampla:

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

#### Controlling where actions are available

> **New in Django 6.1**

By default, admin actions are available on the change list page only. You can
control where an action appears using the `location` argument of the
`@admin.action` decorator.

For example, to make an action available only on the change form, set
`location` to [`ActionLocation.CHANGE_FORM`](#django.contrib.admin.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): ...
```

To make an action available on both the change list and the change form:

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

Notice that `description` and `description_plural` were provided. These are
optional but the admin action will be labeled by `description` in the admin
change form and `description_plural` in the admin change list.

You can customize how actions are rendered by overriding admin templates.
The change list page uses `admin/actions.html` and the change form page uses
`admin/change_form_actions.html`. Note that the change form template inherits
from the change list actions template.

## An maisitheoir `gníomha`

#### `action(* (Keyword-only parameters separator (PEP 3102)), permissions=None, description=None, description_plural=None, location=ActionLocation.CHANGE_LIST)`

Is féidir an maisitheoir seo a úsáid chun tréithe sonracha a shocrú ar fheidhmeanna gníomhaíochta saincheaptha is féidir a úsáid le:attr: ~django.contrib.admin.modelAdmin.actions:

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

Tá sé seo comhionann le roinnt tréithe (leis na hainmneacha bunaidh, níos faide) a shocrú go díreach ar an bhfeidhm:

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

make_published.allowed_permissions = ["publish"]
make_published.short_description = "Mark selected stories as published"
```

Níl sé éigeantach an maisitheoir seo a úsáid chun feidhm ghníomhaíochta a dhéanamh, ach d'fhéadfadh sé a bheith úsáideach é a úsáid gan argóintí mar mharcóir i do fhoinse chun cuspóir na feidhme a aithint:

```
@admin.action
def make_inactive(self, request, queryset):
    queryset.update(is_active=False)
```

Sa chás seo ní chuirfidh sé aon tréithe leis an bhfeidhm.

**Paraiméadair:** - `permissions` -- A list of permission codenames that restrict the action
  to users who have at least one of the defined permissions. This sets
  the `allowed_permissions` attribute on the function. See
  [Ceadanna a shocrú le haghaidh gníomhar](#admin-action-permissions) for details.
- `description` -- A human-readable description of the action to be
  rendered in the admin. If `description` is not provided, Django
  renders the function's name, converting underscores to spaces and
  capitalizing the first letter of the first word. This sets the
  `short_description` attribute on the function.
- `description_plural` -- A human-readable description of the action used
  in contexts where plural wording is required, such as on the admin
  change list. If `description_plural` is not provided, falls back to
  `description`. This sets the `plural_description` attribute on the
  function.
- `location` -- Specifies where the action is available. Accepts either a
  single [`ActionLocation`](#django.contrib.admin.ActionLocation) value or an iterable of values. If
  omitted, the action is only available on the admin change list. See
  [Controlling where actions are available](#admin-action-availability) for details.

> **Action description %-formatting support**
>
> Action descriptions support `%`-formatting and may include
> `'%(verbose_name)s'` and `'%(verbose_name_plural)s'` placeholders.
> These are replaced with the model’s
> [`verbose_name`](/ga/6.1/ref/models/options/#django.db.models.Options.verbose_name) and
> [`verbose_name_plural`](/ga/6.1/ref/models/options/#django.db.models.Options.verbose_name_plural).

> **Changed in Django 6.1**
>
> The keyword arguments `description_plural` and `location` were
> added.

## `ActionLocation`

> **New in Django 6.1**

#### `class ActionLocation`

Enum of allowed values for the `location` parameter of the
[`action()`](#django.contrib.admin.action) decorator.

#### `CHANGE_FORM`

The action is available on the admin change form. When an action is run,
any unsaved changes on the admin change form will be lost.

#### `CHANGE_LIST`

The action is available on the admin change list.

## `Action`

> **New in Django 6.1**

#### `class Action`

Represents an action. Actions should be defined using the [`action()`](#django.contrib.admin.action)
decorator.

#### `func`

The action function. See [Feidhmeanna gníomhaíochta](#action-function) for details.

#### `name`

The action function name.

#### `description`

A human-readable description of the action to be rendered in the admin.

#### `plural_description`

A human-readable description of the action used in contexts where
plural wording is required.

#### `locations`

A list of [`ActionLocation`](#django.contrib.admin.ActionLocation) values the admin action can be
rendered.