--- title: "gníomhartha riaracháin" version: 6.0 locale: ga source: https://docs.djangoproject.com/ga/6.0/ref/contrib/admin/actions/ canonical: https://djangodocs.dev/ga/6.0/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 \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. > > \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** > > \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, ) ``` Déanann sé seo an gníomh a mheaitseáil leis an méid a dhéanann an riarachán féin tar éis gníomh a dhéanamh go rathúil: ![](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 \ 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 \\- 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 ``` \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)` 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. Tugann sé seo foclóir gníomhartha ceadaithe ar ais. Is ainmneacha gníomhaíochta iad na heochracha, agus is iad na luachanna `(feidhm, ainm, gearr_description)` tuples. 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): actions = super().get_actions(request) if request.user.username[0].upper() != "J": if "delete_selected" in actions: del actions["delete_selected"] return actions ``` ### 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_ _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)) ``` ## An maisitheoir `gníomha` #### `action(* (Keyword-only parameters separator (PEP 3102)), permissions=None, description=None)` 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. Tá tuairiscí gníomhaíochta %-formáidithe agus d'fhéadfadh go mbeadh `'% (verbose_name) s'` agus `` `% (verbose_name_plural) s' `` iontu, a chuirtear na samhlacha 's:attr: ~django.db.models.options.verbose\_name agus:attr: ~django.db.models.options.options.Verbose\_Ainm\_Plural.