Suíomh riaracháin DjangoLink to this heading#

Ábhair eileLink to this heading#

An maisitheoir clárLink to this heading#

register(*models, site=django.contrib.admin.sites.site)Link to this definition#

Tá maisitheoir ann freisin chun do ranganna ``ModelAdmin` a chlárú:

Code

from django.contrib import admin
from .models import Author


@admin.register(Author)
class AuthorAdmin(admin.ModelAdmin):
    pass

Tugtar rang samhail amháin nó níos mó dó chun clárú leis an ModelAdmin. Má tá saincheap:class: AdminSite á úsáid agat, pas é ag baint úsáide as an argóint eochairfhocal ``láithreach`:

Code

from django.contrib import admin
from .models import Author, Editor, Reader
from myproject.admin_site import custom_admin_site


@admin.register(Author, Reader, Editor, site=custom_admin_site)
class PersonAdmin(admin.ModelAdmin):
    pass

Ní féidir leat an maisitheoir seo a úsáid má chaithfidh tú tagairt a dhéanamh do rang riaracháin samhail ina mhodh ``__init__ () , m.sh. `super (PersonAdmin, self). __init__ (*args, **kwargs) `. Is féidir leat ``super () a úsáid. __init__ (*args, **kwargs) ``.

Faighneadh comhaid riaracháinLink to this heading#

Nuair a chuireann tú django.contrib.admin i do shuíomh: INSTALLED_APPS, lorgaíonn Django modúl ``admin ``go huathoibríoch i ngach feidhmchlár agus déanann Django é a allmhairiú.

class apps.AdminConfigLink to this definition#

This is the default AppConfig class for the admin. It calls autodiscover() when Django starts.

class apps.SimpleAdminConfigLink to this definition#

This class works like AdminConfig, except it doesn't call autodiscover().

default_siteLink to this definition#

Conair allmhairithe poncanach chuig rang an láithreáin riaracháin réamhshocraithe nó chuig glaoch a thugann sampla láithreáin ar ais. Réamhshocraithe go ``django.contrib.admin.sites.adminsite'. Féach: ref: `overriding-default-admin-site le húsáid.

autodiscover()Link to this definition#

Déanann an fheidhm seo iarracht modúl ``admin ``a allmhairiú i ngach feidhmchlár suiteáilte. Táthar ag súil go gclárfaidh modúil den sórt sin samhlacha leis an riarach

De ghnáth ní bheidh ort an fheidhm seo a ghlaoch go díreach mar: class: ~django.contrib.admin.apps.adminConfig glaonn sé nuair a thosaíonn Django.

Má tá tú ag úsáid saincheaptha AdminSite, is coitianta na fo-aicmí ModelAdmin go léir a iompórtáil isteach i do chód agus iad a chlárú chuig an saincheaptha AdminSite. Sa chás sin, d'fhonn uathoibríoch a dhíchumasú, ba chóir duit ``django.contrib.admin.apps.simpleAdminConfig'` a chur in ionad ``django.contrib.admin' i do shuíomh: INSTALLED_APPS.

Roghanna ModelAdminLink to this heading#

Tá an ModelAdmin an-solúbtha. Tá roinnt roghanna aige chun déileáil leis an gcomhéadan a shaincheapadh. Sainmhínítear gach rogha ar an bhfo-aicme ModelAdmin:

from django.contrib import admin


class AuthorAdmin(admin.ModelAdmin):
    date_hierarchy = "pub_date"

ModelAdmin.actionsLink to this definition#

Liosta de na gníomhartha atá le cur ar fáil ar an leathanach liosta athraithe. Féach: doc: /ref/contrib/admin/actions le haghaidh sonraí.

ModelAdmin.actions_on_topLink to this definition#

ModelAdmin.actions_on_bottomLink to this definition#

Rialuithe áit a bhfuil an barra gníomhartha le feiceáil ar an leathanach. De réir réamhshocraithe, taispeánann an liosta athraithe riaracháin gníomhartha ag barr an leathanaigh (actions_on_top = True; actions_on_bottom = False`).

ModelAdmin.actions_selection_counterLink to this definition#

Rialaíonn sé an bhfuil cuntar roghnúcháin ar taispeáint in aice leis an anuas gníomhaíochta. De réir réamhshocraithe, taispeánfaidh an liosta athraithe riaracháin é (actions_selection_counter = True).

ModelAdmin.date_hierarchyLink to this definition#

Socraigh date_hierarchy ar ainm DateField nó DateTimeField i do mhúnla, agus beidh nascleanúint drilldown bunaithe ar dáta-bhunaithe ag an réimse sin san leathanach liosta athraithe.

Sampla:

Code

date_hierarchy = "pub_date"

Is féidir leat réimse a shonrú freisin ar mhúnla gaolmhar ag baint úsáide as an lorg __, mar shampla:

Code

date_hierarchy = "author__pub_date"

Déanfaidh sé seo é féin a dhaonrú go cliste bunaithe ar na sonraí atá ar fáil, m.sh. má tá na dátaí go léir i mí amháin, taispeánfaidh sé an druileáil síos ar leibhéal lae amháin.

ModelAdmin.empty_value_displayLink to this definition#

Sáraíonn an tréith seo an luach taispeána réamhshocraithe do réimsí an taifead atá folamh (None ``, teaghrán folamh, srl.). Is é an luach réamhshocraithe ``- (sraigh). Mar shampla:

Code

from django.contrib import admin


class AuthorAdmin(admin.ModelAdmin):
    empty_value_display = "-empty-"

Is féidir leat empty_value_display a shárú freisin do gach leathanach riaracháin le:attr: adminsite.empty_value_display, nó le haghaidh réimsí ar leith mar seo:

Code

from django.contrib import admin


class AuthorAdmin(admin.ModelAdmin):
    list_display = ["name", "title", "view_birth_date"]

    @admin.display(empty_value="???")
    def view_birth_date(self, obj):
        return obj.birth_date

ModelAdmin.excludeLink to this definition#

Ba chóir go mbeadh an tréith seo, má thugtar, ina liosta d'ainmneacha réimse le eisiamh ón bhfoirm.

Mar shampla, déanaimis machnamh ar an tsamhail seo a leanas:

Code

from django.db import models


class Author(models.Model):
    name = models.CharField(max_length=100)
    title = models.CharField(max_length=3)
    birth_date = models.DateField(blank=True, null=True)

Más mian leat foirm don tsamhail Údar nach n-áirítear ach na réimsí ainm agus teideal ``, sonrófaí ``réimsí réimsí nó ``eisiam mar seo:

Code

from django.contrib import admin


class AuthorAdmin(admin.ModelAdmin):
    fields = ["name", "title"]


class AuthorAdmin(admin.ModelAdmin):
    exclude = ["birth_date"]

Ós rud é nach bhfuil ach trí réimse ag an tsamhail Údair, ainm ``, `teideal, agus dáta_bhreith`, beidh na réimsí céanna go díreach sna foirmeacha a eascraíonn as na dearbhuithe thuas.

ModelAdmin.fieldsLink to this definition#

Úsáid an rogha ``réimsí ``chun athruithe leagan amach simplí a dhéanamh sna foirmeacha ar na leathanaigh “cuir” agus “athraigh” amhail fo-thacar de réimsí atá ar fáil a thaispeáint, a n-ord a mhodhnú, nó iad a ghrúpáil i sraitheanna. Mar shampla, d'fhéadfá leagan níos simplí den fhoirm riaracháin a shainiú don tsamhail:class: django.contrib.flatpages.models.flatpage mar seo a leanas:

Code

class FlatPageAdmin(admin.ModelAdmin):
    fields = ["url", "title", "content"]

Sa sampla thuas, ní thaispeánfar ach na réimsí url ``, `teideal agus ábh`, sa fhoirm, go seicheamhach. Is féidir luachanna a shainmhínítear in:attr: `ModelAdmin.ReadOnly_Fields` a bheith i `fields le taispeáint mar léite amháin.

Le haghaidh riachtanais leagan amach níos casta, féach an rogha: attr: ~ModelAdmin.FieldSets.

Glacann an rogha fields leis na cineálacha céanna luachanna amha:attr: ~ModelAdmin.list_display, ach amháin nach nglactar le glaonna agus __ cuardaigh do réimsí gaolmhara. Ní úsáidfear ainmneacha modhanna riaracháin samhail agus samhail ach amháin má tá siad liostaithe in:attr: ~ModelAdmin.ReadOnly_Fields.

Chun réimsí iolracha a thaispeáint ar an líne chéanna, fillte na réimsí sin ina dtuple féin. Sa sampla seo, taispeánfar na réimsí url agus teideal ``ar an líne chéanna agus taispeánfar an réimse ``content faoina bhun ar a líne féin:

Code

class FlatPageAdmin(admin.ModelAdmin):
    fields = [("url", "title"), "content"]

If neither fields nor fieldsets options are present, Django will default to displaying each field that isn't an AutoField and has editable=True, in a single fieldset, in the same order as the fields are defined in the model, followed by any fields defined in readonly_fields.

ModelAdmin.fieldsetsLink to this definition#

Socraigh fieldsets chun leagan amach na leathanaigh riaracháin “cuir” agus “athraigh” a rialú.

<fieldset>Is liosta de 2-tuples é fieldsets, ina léiríonn gach 2-tuple ```` ar an leathanach foirm riaracháin. (Is “cuid<fieldset>” den fhoirm é a ```.)

Tá na 2-tuples i bhformáid (ainm, roghanna réimse), ina bhfuil ainm ``teaghrán a léiríonn teideal an tacar réimse agus is foclóir faisnéise faoin tacar réimse é `field_options, lena n-áirítear liosta réimsí atá le taispeáint ann.

Sampla iomlán, tógtha ón múnla:class: django.contrib.flatpages.models.flatpage:

Code

from django.contrib import admin


class FlatPageAdmin(admin.ModelAdmin):
    fieldsets = [
        (
            None,
            {
                "fields": ["url", "title", "content", "sites"],
            },
        ),
        (
            "Advanced options",
            {
                "classes": ["collapse"],
                "fields": ["registration_required", "template_name"],
            },
        ),
    ]

Mar thoradh air seo tá leathanach riaracháin a bhfuil cuma air:

Mura bhfuil roghanna fieldsets nor:attr: ~ModelAdmin.fields i láthair, réamhshocróidh Django gach réimse nach autofield a thaispeáint agus a bhfuil Editable=True, i tacar réimse amháin, san ord céanna agus atá na réimsí sainmhínithe sa tsamhail.

Is féidir leis na heochracha seo a leanas a bheith ag an bhfoclóir field_options`:

• ``réimsí ``

  Liosta nó tiúpla d'ainmneacha réimse le taispeáint sa tacar réimse seo. Tá an eochair seo ag teastáil.

  Sampla:

  Code

  {
      "fields": ["first_name", "last_name", "address", "city", "state"],
  }
  

  Mar is amhlaidh leis an rogha: attr: ~ModelAdmin.Fields, chun réimsí iolracha a thaispeáint ar an líne chéanna, timpail na réimsí sin ina dtuple féin. Sa sampla seo, taispeánfar na réimsí first_name agus last_name ar an líne chéanna:

  Code

  {
      "fields": [("first_name", "last_name"), "address", "city", "state"],
  }
  

  Is féidir luachanna a shainmhínítear in:attr: ~ModelAdmin.ReadOnly_Fields a bheith i fields` le taispeáint mar léite amháin.

  Má chuireann tú ainm inghlaonta le fields`, tá feidhm ag an riail chéanna leis an roghna:attr: ~ModelAdmin.Fields: ní mór an glaoch a liostáil in:attr: ~ModelAdmin.Readonly_Fields.

• ranga

  Liosta nó tuple ina bhfuil ranganna breise CSS le cur i bhfeidhm ar an tacar réimse. Féadfaidh sé seo aon rang CSS saincheaptha a shainmhínítear sa tionscadal a áireamh, chomh maith le haon cheann de na ranganna CSS a sholáthraíonn Django. Laistigh de bhileog stíl CSS an láithreáin riaracháin réamhshocraithe, sainmhínítear dhá rang an-úsáideach: tiomp agus wieh.

  Sampla:

  Code

  {
      "classes": ["wide", "collapse"],
  }
  

  Tabharfar spás cothrománach breise sa chomhéadan riaracháin do thacair réimse leis an stíl ``leathan ``. Titeofar tacair réimsí le hainm agus an stíl ``clise' i dtosach, ag baint úsáide as giuirléid leathnaithe le toggle chun a n-infheictheacht a athrú.

• `Tuairisc

  Sraith téacs breise roghnach le taispeáint ag barr gach tacar réimse, faoi cheannteideal an tacar réimse.

  Tabhair faoi deara go bhfuil an luach seo* éalaithe ag HTML nuair a thaispeántar é sa chomhéadan riaracháin. Ligeann sé seo duit HTML a áireamh más mian leat. Nó is féidir leat gnáthtéacs agus:func: django.utils.html.escape a úsáid chun éalú aon charachtair speisialta HTML.

ModelAdmin.filter_horizontalLink to this definition#

<select multiple>De réir réamhshocraithe, taispeántar a:class: ~django.db.models.manyTomanyField ar an suíomh riaracháin le ````. Mar sin féin, is féidir go mbeadh sé deacair boscaí ilroghnaithe a úsáid agus go leor míreanna á roghnú. Ag cur a:class: ~django.db.models.manyToManyField leis an liosta seo úsáidfear comhéadan “scagaire” JavaScript neamh-neamhbhraith ina ionad sin a cheadaíonn cuardach laistigh de na roghanna. Tá na roghanna neamhroghnaithe agus roghnaithe le feiceáil i dhá bhosca taobh le taobh. Féach: attr: ~ModelAdmin.filter_vertical chun comhéadan ingearach a úsáid.

ModelAdmin.filter_verticalLink to this definition#

Mar an gcéanna len:attr: ~ModelAdmin.filter_Horizontal, ach úsáideann sé taispeáint ingearach den chomhéadan scagaire leis an mbosca roghanna neamhroghnaithe atá le feiceáil os cionn an bhosca na roghanna roghnaithe.

ModelAdmin.formLink to this definition#

De réir réamhshocraithe cruthaítear ModelForm go dinimiciúil do do mhúnla. Úsáidtear é chun an fhoirm a chuirtear i láthair ar na leathanaigh cuirte/athraigh a chruthú. Is féidir leat do ModelForm ``féin a sholáthar go héasca chun aon iompar foirme réamhshocraithe ar na leathanaigh cuirte/athraithe a shárú. De rogha air sin, is féidir leat an fhoirm réamhshocraithe a shaincheapadh seachas ceann iomlán nua a shonrú tríd an modh: meth: `ModelAdmin.get_form a úsáid.

Mar shampla féach an rannáit:ref: admin-custom-validation.

ModelAdmin.formfield_overridesLink to this definition#

Soláthraíonn sé seo bealach tapa agus salach chun cuid de na roghanna: class: ~django.forms.field a shárú le húsáid sa riarachán. Is foclóir é formfield_overrides` ag mapáil rang réimse go dtí argóintí le dul chuig an réimse ag am tógála.

Ós rud é go bhfuil sé sin beagán teibí, féachaimis ar shampla nithiontach. Is é an úsáid is coitianta de formfield_overrides giuirléid saincheaptha a chur le haghaidh cineál áirithe réimse. <textarea>Mar sin, samhlaigh go bhfuil RichTextEditorWidget` scríofa againn ar mhaith linn a úsáid le haghaidh réimsí móra téacs in ionad an réamhshocraithe ```. Seo mar a dhéanfaimis é sin:

Code

from django.contrib import admin
from django.db import models

# Import our custom widget and our model from where they're defined
from myapp.models import MyModel
from myapp.widgets import RichTextEditorWidget


class MyModelAdmin(admin.ModelAdmin):
    formfield_overrides = {
        models.TextField: {"widget": RichTextEditorWidget},
    }

Tabhair faoi deara gurb é an eochair sa fhoclóir an rang réimse iarbhír, * ní* teaghrán. Is foclóir eile é an luach; cuirfear na hargóintí seo ar aghaidh chuig modh ``__init__ () ``réimse na foirme. Féach: doc: /ref/forms/api le haghaidh sonraí.

ModelAdmin.inlinesLink to this definition#

Féach: aicme: rudaí inlineModelAdmin thíos chomh maith leis: meth: ModelAdmin.get_formSets_with_inlines.

ModelAdmin.list_displayLink to this definition#

Socraigh list_display chun na réimsí a thaispeántar ar leathanach liosta athraithe an riaracháin a rialú.

Sampla:

Code

list_display = ["first_name", "last_name"]

Mura socraíonn tú list_display, taispeánfaidh an suíomh riaracháin colún amháin a thaispeánann léiriú ``__str__ () `de gach rud.

Tá cúig chineál luachanna ann is féidir a úsáid i list_display. Féadfaidh gach duine ach an ceann is simplí an maisitheoir: func: ~django.contrib.admin.display a úsáid, a úsáidtear chun an chaoi a gcuirtear an réimse i láthair a shaincheapadh:

• Ainm réimse samhail. Mar shampla:

  Code

  class PersonAdmin(admin.ModelAdmin):
      list_display = ["first_name", "last_name"]
  

• Ainm réimse gaolmhar, ag baint úsáide as an nótaí __. Mar shampla:

  Code

  class PersonAdmin(admin.ModelAdmin):
      list_display = ["city__name"]
  

• Inghlaonta a ghlacann le argóint amháin, an tsamhail samhail. Mar shampla:

  Code

  @admin.display(description="Name")
  def upper_case_name(obj):
      return f"{obj.first_name} {obj.last_name}".upper()
  
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = [upper_case_name]
  

• Sreang a léiríonn modh ModelAdmin a ghlacann le argóint amháin, an tsamhail samhail. Mar shampla:

  Code

  class PersonAdmin(admin.ModelAdmin):
      list_display = ["upper_case_name"]
  
      @admin.display(description="Name")
      def upper_case_name(self, obj):
          return f"{obj.first_name} {obj.last_name}".upper()
  

• Sreang a léiríonn tréith nó modh samhail (gan aon argóintí riachtanacha). Mar shampla:

  Code

  from django.contrib import admin
  from django.db import models
  
  
  class Person(models.Model):
      name = models.CharField(max_length=50)
      birthday = models.DateField()
  
      @admin.display(description="Birth decade")
      def decade_born_in(self):
          decade = self.birthday.year // 10 * 10
          return f"{decade}’s"
  
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ["name", "decade_born_in"]
  

Cúpla cás speisialta le tabhairt faoi deara faoi list_display:

• Más ForeignKey an réimse, taispeánfaidh Django ``__str__ () ``den réad gaolmhar.

• Ní thacaítear le réimsí ManyTomanyField`, toisc go mbeadh sé sin i gceist leis sin ráiteas SQL ar leithligh a fhorghníomhú do gach sraith sa tábla. Más mian leat é seo a dhéanamh mar sin féin, tabhair modh saincheaptha do do mhúnla, agus cuir ainm an mhodha sin le `list_display`. (Féach thíos le haghaidh tuilleadh faoi mhodhanna saincheaptha i `list_display.)

• Más Booleanfield é an réimse, taispeánfaidh Django deilbhín deas “tá”, “níl”, nó “anaithnid” in ionad True, False`, nó None.

• Más modh den mhúnla é an teaghrán a thugtar, ModelAdmin nó inghlaoithe, éalóidh Django an t-aschur HTML de réir réamhshocraithe. Chun ionchur úsáideora a éalú agus do chlibeanna gan éalú féin a cheadú, bain úsáid as: func: ~django.utils.html.format_html.

  Seo samhail iomlán sampla:

  Code

  from django.contrib import admin
  from django.db import models
  from django.utils.html import format_html
  
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
      color_code = models.CharField(max_length=6)
  
      @admin.display
      def colored_name(self):
          return format_html(
              '<span style="color: #{};">{} {}</span>',
              self.color_code,
              self.first_name,
              self.last_name,
          )
  
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ["first_name", "last_name", "colored_name"]
  

• Mar a léirigh roinnt samplaí cheana féin, agus modh inghlaonta, modh samhail, nó modh ModelAdmin á úsáid agat, is féidir leat teideal an cholúin a shaincheapadh tríd an glaoch a fhilleadh leis an maisitheoir: :func: ~django.contrib.admin.display agus an argóint Description a rith.

• Más é luach réimse None, teaghrán folamh, nó athraitheach gan eilimintí, taispeánfaidh Django - (doic). Is féidir leat é seo a shárú le:attr: adminsite.empty_value_display:

  Code

  from django.contrib import admin
  
  admin.site.empty_value_display = "(None)"
  

  Is féidir leat úsáid freisin: attr: ModelAdmin.empty_value_display:

  Code

  class PersonAdmin(admin.ModelAdmin):
      empty_value_display = "unknown"
  

  Nó ar leibhéal réimse:

  Code

  class PersonAdmin(admin.ModelAdmin):
      list_display = ["name", "birth_date_view"]
  
      @admin.display(empty_value="unknown")
      def birth_date_view(self, obj):
          return obj.birth_date
  

• Más modh den tsamhail é an teaghrán a thugtar, ModelAdmin nó glaoch a thugann ar ais True`, False`, nó None, taispeánfaidh Django deilbhín deas “yes”, “níl”, nó “anaithnid” má fhilleann tú an modh leis an: func: ~django.contrib.admin. argóint olean`` leis an luach socraithe go True:

  Code

  from django.contrib import admin
  from django.db import models
  
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      birthday = models.DateField()
  
      @admin.display(boolean=True)
      def born_in_fifties(self):
          return 1950 <= self.birthday.year < 1960
  
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ["name", "born_in_fifties"]
  

• Tá an modh __str__ () ``chomh bailí i ``list_display agus aon mhodh samhail eile, mar sin tá sé go foirfe ceart go leor é seo a dhéanamh:

  Code

  list_display = ["__str__", "some_other_field"]
  

• De ghnáth, ní féidir eilimintí de list_display` nach réimsí bunachar sonraí iarbhír iad a úsáid i sórtáil (toisc go ndéanann Django an sórtáil go léir ag leibhéal an bhunachar sonraí).

  Mar sin féin, má léiríonn eilimint de list_display` réimse áirithe bunachar sonraí, is féidir leat an fíric seo a chur in iúl tríd an maisitheoir: func: ~django.contrib.admin.display a úsáid ar an modh, ag rith an argóint ``ordú ``:

  Code

  from django.contrib import admin
  from django.db import models
  from django.utils.html import format_html
  
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      color_code = models.CharField(max_length=6)
  
      @admin.display(ordering="first_name")
      def colored_first_name(self):
          return format_html(
              '<span style="color: #{};">{}</span>',
              self.color_code,
              self.first_name,
          )
  
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ["first_name", "colored_first_name"]
  

  Inseoidh an méid thuas do Django ordú ag an réimse first_name agus tú ag iarraidh a shórtáil de réir colorred_first_name` sa riarachán.

  Chun ordú íslitheach a chur in iúl leis an argóint ``ordú ``is féidir leat réimír bhreitheach a úsáid ar ainm an réimse. Ag baint úsáide as an sampla thuas, bheadh an chuma seo mar seo:

  Code

  @admin.display(ordering="-first_name")
  def colored_first_name(self): ...
  

  Tacaíonn an argóint ``ordú ``le cuardaigh fiosrúcháin chun sórtáil de réir luachanna ar mhúnlaí gaolmhara. Cuimsíonn an sampla seo colún “céadainm an údair” i dtaispeáint an liosta agus ceadaíonn sé é a shórtáil de réir chéad ainm:

  Code

  class Blog(models.Model):
      title = models.CharField(max_length=255)
      author = models.ForeignKey(Person, on_delete=models.CASCADE)
  
  
  class BlogAdmin(admin.ModelAdmin):
      list_display = ["title", "author", "author_first_name"]
  
      @admin.display(ordering="author__first_name")
      def author_first_name(self, obj):
          return obj.author.first_name
  

  Query expressions may be used with the ordering argument:

  Code

  from django.db.models import Value
  from django.db.models.functions import Concat
  
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
  
      @admin.display(ordering=Concat("first_name", Value(" "), "last_name"))
      def full_name(self):
          return self.first_name + " " + self.last_name
  

• Is féidir le heilimintí de list_display` a bheith ina airíonna freisin:

  Code

  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
  
      @property
      @admin.display(
          ordering="last_name",
          description="Full name of the person",
          boolean=False,
      )
      def full_name(self):
          return self.first_name + " " + self.last_name
  
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ["full_name"]
  

  Tabhair faoi deara go gcaithfidh @property a bheith os cionn @display. Má tá an seanbhealach á úsáid agat - ag socrú na tréithe a bhaineann le taispeáint go díreach seachas an maisitheoir: func: ~django.contrib.admin.display a úsáid -- bí ar an eolas go gcaithfear an fheidhm property () ``agus **not** an maisitheoir @property ``a úsáid:

  Code

  def my_property(self):
      return self.first_name + " " + self.last_name
  
  
  my_property.short_description = "Full name of the person"
  my_property.admin_order_field = "last_name"
  my_property.boolean = False
  
  full_name = property(my_property)
  

• <field_name><th>Beidh na hainmneacha réimse i list_display` le feiceáil mar ranganna CSS san aschur HTML, i bhfoirm column- ``ar gach eilimint ``. Is féidir é seo a úsáid chun leithead colún a shocrú i gcomhad CSS mar shampla.

• Déanfaidh Django iarracht gach eilimint de list_display` a léirmhíniú san ord seo:

  • Réimse den tsamhail nó ó réimse gaolmhar.

  • Is féidir glaoch.

  • Sreang a léiríonn tréith ModelAdmin.

  • Sreang a léiríonn tréith samhail.

  Mar shampla má tá first_name agat mar réimse samhail agus mar thréith ModelAdmin, úsáidfear an réimse samhail.

ModelAdmin.list_display_linksLink to this definition#

Úsáid list_display_links chun rialú a dhéanamh ar chóir agus cé na réimsí in:attr: list_display a nascadh leis an leathanach “athraigh” le haghaidh réad.

De réir réamhshocraithe, nascfaidh an leathanach liosta athraithe an chéad cholún - an chéad réimse a shonraítear in list_display - leis an leathanach athraithe do gach mír. Ach ligeann list_display_links duit é seo a athrú:

• Socraigh é go ``None ```chun aon naisc a fháil ar chor ar bith.

• Socraigh é go liosta nó tuipéar réimsí (san fhormáid chéanna le list_display`) ar mhaith leat a gcolúin a thiontú go naisc.

  Is féidir leat réimsí amháin nó go leor a shonrú. Chomh fada agus a bhíonn na réimsí le feiceáil in list_display`, ní cúram le Django cé mhéad (nó cé chomh beag) réimse atá nasctha. Is é an t-aon riachtanas ná más mian leat list_display_links a úsáid ar an mbealach seo, ní mór duit list_display a shainiú.

Sa sampla seo, beidh na réimsí first_name agus last_name nasctha ar an leathanach liosta athraithe:

Code

class PersonAdmin(admin.ModelAdmin):
    list_display = ["first_name", "last_name", "birthday"]
    list_display_links = ["first_name", "last_name"]

Sa sampla seo, ní bheidh aon naisc ag an eangach leathanaigh liosta athraithe:

Code

class AuditEntryAdmin(admin.ModelAdmin):
    list_display = ["timestamp", "message"]
    list_display_links = None

ModelAdmin.list_editableLink to this definition#

Socraigh list_editable go liosta d'ainmneacha réimse ar an tsamhail a cheadóidh eagarthóireacht ar leathanach an liosta athraithe. Is é sin, taispeánfar réimsí atá liostaithe i list_editable` mar ghuirléidí foirme ar leathanach an liosta athraithe, rud a ligeann d'úsáideoirí sraitheanna iolracha a chur in eagar agus a shábháil ag an am céanna.

ModelAdmin.list_filterLink to this definition#

Socraigh list_filter chun scagairí a ghníomhachtú i mbarra taobh na láimhe deise ar leathanach liosta athraithe an riaracháin.

Ag an rud is simplí glacann list_filter liosta nó tuple d'ainmneacha réimse chun scagadh a ghníomhachtú, ach roinnt roghanna níos airde mar atá ar fáil. Féach: ref: modeladmin-list-filters le haghaidh na sonraí.

ModelAdmin.list_max_show_allLink to this definition#

Socraigh list_max_show_all chun a rialú cé mhéad earra is féidir le feiceáil ar leathanach liosta athraithe riaracháin “Taispeáin go léir”. Taispeánfaidh an riarachán nasc “Taispeáin go léir” ar an liosta athraithe ach amháin má tá líon iomlán na dtorthaí níos lú ná nó cothrom leis an socrú seo. De réir réamhshocraithe, tá sé seo socraithe go 200.

ModelAdmin.list_per_pageLink to this definition#

Socraigh list_per_page chun a rialú cé mhéad míreanna atá le feiceáil ar gach leathanach liosta athraithe riaracháin leathanaigh. De réir réamhshocraithe, tá sé seo socraithe go 100.

ModelAdmin.list_select_relatedLink to this definition#

Socraigh list_select_related chun a rá le Django go n-úsáid:meth: ~django.db.models.query.queryset.select_related agus an liosta rudaí ar an leathanach liosta athraithe riaracháin a aisghabháil. Féadann sé seo dornán ceisteanna bunachar sonraí a shábháil duit.

Ba chóir go mbeadh an luach boolean, liosta nó tuple. Is é “False” réamhshocraithe.

Nuair a bhíonn luach True, glaofar ar select_related () ``i gcónaí. Nuair a shocraítear luach go `False, féachfaidh Django ar list_display` agus glaoidh sé ar select_related () ``má tá aon ``ForeignKey i láthair.

Má theastaíonn níos mó rialú mionghráin uait, bain úsáid as tuple (nó liosta) mar luach do list_select_related. Cuirfidh tuple folamh cosc ar Django glaoch ar select_related ar chor ar bith. Cuirfear aon tuple eile ar aghaidh go díreach chuig select_related mar pharaiméadair. Mar shampla:

Code

class ArticleAdmin(admin.ModelAdmin):
    list_select_related = ["author", "category"]

glaoifidh sé ar ``select_related ('author', 'category') ``.

Más gá duit luach dinimiciúil a shonrú bunaithe ar an iarratas, is féidir leat modh a: meth: ~ModelAdmin.get_List_Select_Related a chur i bhfeidhm.

ModelAdmin.orderingLink to this definition#

Socraigh ``ordú ``chun a shonrú conas ba chóir liostaí rudaí a ordú i dtuairimí riaracháin Django. Ba chóir go mbeadh sé seo ina liosta nó tuple san fhormáid chéanna le paraiméadar samhail's:attr: ~django.db.Models.Options.Ordering.

Mura gcuirtear é seo ar fáil, úsáidfidh riarachán Django ordú réamhshocraithe an tsamhail.

Más gá duit ordú dinimiciúil a shonrú (mar shampla ag brath ar úsáideoir nó ar theanga) is féidir leat modh a: meth: ~ModelAdmin.get_Ordering a chur i bhfeidhm.

ModelAdmin.paginatorLink to this definition#

An rang paginator le húsáid le haghaidh leathanaigh. De réir réamhshocraithe, úsáidtear: class: django.core.paginator.paginator. Mura bhfuil an comhéadan tógála céanna ag an rang paginator saincheaptha las:class: django.core.paginator.paginator, beidh ort cur i bhfeidhm a sholáthar freis:meth: ModelAdmin.get_Paginator.

ModelAdmin.prepopulated_fieldsLink to this definition#

Socraigh prepopulated_fields chuig foclóir ainmneacha réimse a mhapáil chuig na réimsí ba chóir dó a réamhphoiliú ó:

Code

class ArticleAdmin(admin.ModelAdmin):
    prepopulated_fields = {"slug": ["title"]}

Nuair a bheidh sé socraithe, úsáidfidh na réimsí ar leith beagán JavaScript chun líonadh ó na réimsí a shanntar. Is é an príomhúsáid don fheidhmiúlacht seo an luach do réimsí ``Slugfield` a ghiniúint go huathoibríoch ó réimse amháin nó níos mó eile. Déantar an luach a ghintear a tháirgeadh trí luachanna na réimsí foinse a chomhcheangal, agus ansin tríd an toradh sin a athrú ina slug bailí (m.sh. sraitheanna a chur in ionad spásanna agus litreacha ASCII níos ísle).

Ní dhéanann JavaScript réamhphoilte a mhodhnú tar éis luach a shábháil. De ghnáth ní theastaíonn sé go n-athraíonn slóga (rud a d'fhágfadh go n-athródh URL réada má úsáidtear an slug ann).

Ní ghlacann prepopulated_fields le réimsí DateTimeField, ForeignKey`, OneTooneField`, agus `ManyTomanyField.

ModelAdmin.preserve_filtersLink to this definition#

De réir réamhshocraithe, caomhnaítear scagairí feidhme ar amharc an liosta tar éis réad a chruthú, a chur in eagar nó a scriosadh Is féidir leat scagairí a ghlanadh tríd an tréith seo a shocrú go False.

ModelAdmin.show_facetsLink to this definition#

Rialaíonn cibé an dtaispeántar comhaireamh gnéithe do scagairí sa liosta athraithe riaracháin. Réamhshocraithe chuig: attr: .showFacets.allow.

Nuair a thaispeántar, nuashonraíonn comhaireamh gnéithe i gcomhréir leis na scagairí

class ShowFacetsLink to this definition#

Enum na luachanna ceadaithe le haghaidh: attr: .modeladmin.show_facets.

ALWAYSLink to this definition#

Taispeáin líon gnéithe i gcónaí.

ALLOWLink to this definition#

Taispeáin comhaireamh gnéithe nuair a chuirtear an paraiméadar teaghrán fiosrúcháin _facets ar fáil.

NEVERLink to this definition#

Ná taispeáin comhaireamh gnéithe riamh.

Socraigh show_facets go dtí an luach inmhianaithe: class: .showFacets. Mar shampla, chun comhaireamh gnéithe a thaispeáint i gcónaí gan gá duit an paraiméadar ceisteanna a sholáthar:

Code

from django.contrib import admin


class MyModelAdmin(admin.ModelAdmin):
    ...
    # Have facets always shown for this model admin.
    show_facets = admin.ShowFacets.ALWAYS

ModelAdmin.radio_fieldsLink to this definition#

De réir réamhshocraithe, úsáideann riarachán Django comhéadan bosca roghnaithe (<select>) do réimsí atá ForeignKey nó a bhfuil roghanna ``socraithe acu. Má tá réimse i láthair in `radio_fields, úsáidfidh Django comhéadan cnaipe raidió ina ionad. Ag glacadh leis gur Grúpa is Eochair Foreign ar an tsamhail Duine:

Code

class PersonAdmin(admin.ModelAdmin):
    radio_fields = {"group": admin.VERTICAL}

Tá an rogha agat HORIZONTAL nó VERTICAL a úsáid ón modúl django.contrib.admin.

Ná cuir réimse san áireamh i radio_fields` mura bhfuil ForeignKey ann nó má tá tacar ``roghanna ``ann.

ModelAdmin.autocomplete_fieldsLink to this definition#

Is é autocomplete_fields liosta de réimsí ForeignKey agus/nó ManyTomanyField ar mhaith leat a athrú go Select2 ionchuir uathchomhlánaithe. < https://select2.org/>

De réir réamhshocraithe, úsáideann an riarachán comhéadan bosca roghnaithe (<select>```) do na réimsí sin. Uaireanta níl tú ag iarraidh an lasbhreas a thabhairt faoi na cásanna gaolmhara go léir a roghnú le taispeáint sa anuas.

Breathnaíonn an t-ionchur Select2 cosúil leis an ionchur réamhshocraithe ach tagann sé le gné cuardaigh a luchtaíonn na roghanna go gascrónach. Tá sé seo níos tapúla agus níos éasca le húsáid má tá go leor cásanna ag an tsamhail ghaolmhar.

Ní mór duit: attr: ~ModelAdmin.search_fields a shainiú ar ModelAdmin` an réad gaolmhar toisc go n-úsáideann an cuardach uathchomhlánaithe é.

Chun nochtadh sonraí neamhúdaraithe a sheachaint, caithfidh an cead amharc nó athraithe a bheith ag úsáideoirí don réad gaolmhar chun uathchomhlánú a úsáid.

Rialaítear ordú agus leathanaigh na dtorthaí ag na modhanna gaolmhara ModelAdmin: Meth: ~ModelAdmin.get_Ordering agus:meth: ~ModelAdmin.get_Paginator.

Sa sampla seo a leanas, tá réimse uathchomhlánaithe ag ChoiceAdmin don ForeignKey` chuig an Cheiste`. Déantar na torthaí a scagadh ag an réimse question_text agus ordaítear leis an réimse date_created:

Code

class QuestionAdmin(admin.ModelAdmin):
    ordering = ["date_created"]
    search_fields = ["question_text"]


class ChoiceAdmin(admin.ModelAdmin):
    autocomplete_fields = ["question"]

ModelAdmin.raw_id_fieldsLink to this definition#

De réir réamhshocraithe, úsáideann riarachán Django comhéadan bosca roghnaithe (<select>) do réimsí atá ForeignKey`. Uaireanta níl tú ag iarraidh an lasbhreas a thabhairt faoi na cásanna gaolmhara go léir a roghnú le taispeáint sa anuas anuas.

Is liosta réimsí é raw_id_fields ar mhaith leat a athrú go giuirléid Input le haghaidh ForeignKey` nó ManyTomanyField:

Code

class ArticleAdmin(admin.ModelAdmin):
    raw_id_fields = ["newspaper"]

The raw_id_fields Input widget should contain a primary key if the field is a ForeignKey or a comma separated list of values if the field is a ManyToManyField. The raw_id_fields widget shows a magnifying glass button next to the field which allows users to search for and select a value:

ModelAdmin.readonly_fieldsLink to this definition#

De réir réamhshocraithe taispeánann an riarachán gach réimse mar ineagarthóir. Taispeánfaidh aon réimsí sa rogha seo (ar chóir a bheith ina liost nó tuple) a chuid sonraí mar atá agus neamh-eagarthaithe; tá siad eisiata freisin ó:class: ~django.forms.ModelForm a úsáidtear chun cruthú agus eagarthóireacht. Tabhair faoi deara go gcaithfidh na réimsí léite amháin a bheith i láthair nuair a shonraítear: attr: ModelAdmin.Fields nó: attr: ModelAdmin.FieldSets ní mór na réimsí léite amháin a bheith i láthair le taispeáint (déantar neamhaird orthu ar shlí eile).

Má úsáidtear readonly_fields gan ordú follasach a shainiú trí:attr: ModelAdmin.fields nó: attr: ModelAdmin.FieldSets cuirfear iad go deireanach tar éis gach réimse ineagarthóireachta.

Ní amháin gur féidir le réimse léite amháin sonraí ó réimse samhail a thaispeáint, féadann sé aschur modh samhail nó modh den rang ``ModelAdmin` féin a thaispeáint freisin. Tá sé seo an-chosúil leis an mbealach: attr: ModelAdmin.list_display iompraíonn. Soláthraíonn sé seo bealach chun an comhéadan riaracháin a úsáid chun aiseolas a sholáthar ar stádas na rudaí atá á chur in eagar, mar shampla:

Code

from django.contrib import admin
from django.utils.html import format_html_join
from django.utils.safestring import mark_safe


class PersonAdmin(admin.ModelAdmin):
    readonly_fields = ["address_report"]

    # description functions like a model field's verbose_name
    @admin.display(description="Address")
    def address_report(self, instance):
        # assuming get_full_address() returns a list of strings
        # for each line of the address and you want to separate each
        # line by a linebreak
        return format_html_join(
            mark_safe("<br>"),
            "{}",
            ((line,) for line in instance.get_full_address()),
        ) or mark_safe("<span class='errors'>I can't determine this address.</span>")

ModelAdmin.save_asLink to this definition#

Socraigh ``save_as ``chun gné “sábháil mar nua” a chumasú ar fhoirmeacha athraithe riaracháin.

De ghnáth, bíonn trí rogha sábhála ag rudaí: “Sábháil”, “Sábháil agus lean ar aghaidh ag eagarthóireacht”, agus “Sábháil agus cuir eile leis”. Más é save_as True`, cuirfear cnaipe “Sábháil mar nua” in ionad “Sábháil agus cuir eile leis” a chruthaíonn réad nua (le ID nua) seachas an réad atá ann cheana a nuashonrú.

De réir réamhshocraithe, socraítear save_as go False.

ModelAdmin.save_as_continueLink to this definition#

When: attr: save_as = True <save_as>, is é an t-atreorú réamhshocraithe tar éis an réad nua a shábháil chuig an radharc athraithe don réad sin. Má shocraíonn tú save_as_continue=False, beidh an t-atreorú chuig an radharc liosta athraithe.

De réir réamhshocraithe, socraítear save_as_continue go True.

ModelAdmin.save_on_topLink to this definition#

Socraigh save_on_top chun cnaipí sábhála a chur ar fud barr d'fhoirmeacha athraithe riaracháin.

De ghnáth, ní bhíonn na cnaipí sábhála le feiceáil ach ag bun na bhfoirmeacha. Má shocraíonn tú save_on_top, beidh na cnaipí le feiceáil ar an mbarr agus ar an mbun araon.

De réir réamhshocraithe, socraítear save_on_top go False.

ModelAdmin.search_fieldsLink to this definition#

Socraigh search_fields chun bosca cuardaigh a chumasú ar an leathanach liosta athraithe riaracháin. Ba chóir é seo a shocrú ar liosta d'ainmneacha réimse a chuardófar aon uair a chuireann duine fiosrúchán cuardaigh isteach sa bhosca téacs sin.

Ba chóir go mbeadh réimse téacs de chineál éigin sna réimsí seo, mar shampla Charfield nó TextField. Is féidir leat cuardach gaolmhar a dhéanamh freisin ar ForeignKey nó ManyTomanyField leis an notáil “lean” API cuardaigh:

Code

search_fields = ["foreign_key__related_fieldname"]

Mar shampla, má tá iontráil blag agat le húdar, chuirfeadh an sainmhíniú seo a leanas ar chumas iontrálacha blag a chuardach de réir seoladh ríomhphoist an údair:

Code

search_fields = ["user__email"]

Nuair a dhéanann duine cuardach sa bhosca cuardaigh riaracháin, scoilteann Django an fiosrúchán cuardaigh ina bhfocail agus filleann gach rud ina bhfuil gach ceann de na focail, neamh-íogair (ag baint úsáide as an lorga:lookup: icontains lookup), áit a gcaithfidh gach focal a bheith i gceann de search_fields` ar a laghad. Mar shampla, má shocraítear search_fields go ['first_name', 'last_name'] agus má chuardaíonn úsáideoir john lennon, déanfaidh Django an chomhionann leis an gclásal SQL WHERE:

SQL

WHERE (first_name ILIKE '%john%' OR last_name ILIKE '%john%')
AND (first_name ILIKE '%lennon%' OR last_name ILIKE '%lennon%')

Is féidir frásaí luaite le spásanna a bheith san fhiosrúchán cuardaigh. Mar shampla, má dhéanann úsáideoir cuardach ar "john winston" nó `john winston', déanfaidh Django an coibhéis leis an gclásal WHERE SQL seo:

SQL

WHERE (first_name ILIKE '%john winston%' OR last_name ILIKE '%john winston%')

Mura dteastaíonn uait icontains a úsáid mar an cuardach, is féidir leat aon chuardach a úsáid tríd an réimse a chur leis. Mar shampla, d'fhéadfá: lookup: exact a úsáid trí search_fields` a shocrú go ['first_name__correct'].

Tá roinnt aicearraí (níos sine) chun cuardach réimse a shonrú ar fáil freisin. <lookup>Is féidir leat réimse réimse a réamhrú in search_fields` leis na carachtair seo a leanas agus tá sé coibhéiseach le ``__ ``a chur leis an réimse:

Réimír	Cuardaigh
^	istartswith
=	iexact
@	search
Dada	icontains

Más gá duit cuardach a shaincheapadh is féidir leat: meth: ModelAdmin.get_search_results a úsáid chun iompar cuardaigh breise nó malartach a sholáthar.

ModelAdmin.search_help_textLink to this definition#

Socraigh search_help_text chun téacs tuairisciúil a shonrú don bhosca cuardaigh a thaispeánfar faoin mbosca cuardaigh.

ModelAdmin.show_full_result_countLink to this definition#

Socraigh show_full_result_count chun rialú a dhéanamh ar chóir líon iomlán na rudaí a thaispeáint ar leathanach riaracháin scagtha (m.sh. 99 torthaí (103 iomlán) ``). Má tá an rogha seo socraithe go ``False, taispeántar téacs mar ``99 thorthaí (Taispeáin go léir) ``ina ionad.

Gineann réamhshocrú show_full_result_count=True ceist chun comhaireamh iomlán a dhéanamh ar an tábla a d'fhéadfadh a bheith daor má tá líon mór sraitheanna sa tábla.

ModelAdmin.sortable_byLink to this definition#

De réir réamhshocraithe, ceadaíonn an leathanach liosta athraithe a shórtáil de réir gach réimse samhail (agus glaonna a úsáideann an argóint ording leis an maisitheoir: func: ~django.contrib.admin.display nó a bhfuil an tréith admin_order_field` acu) sonraithe in:attr: list_display.

Más mian leat sórtáil a dhíchumasú do roinnt colúin, socraigh sortable_by chuig bailiúchán (m.sh. list`, tuple`, nó set) den fho-thacar de:attr: list_display a theastaíonn uait a shórtáil. Díchumasaíonn bailiúchán folamh sórtáil do gach colún.

Más gá duit an liosta seo a shonrú go dinimiciúil, cuir modh a:meth: ~ModelAdmin.get_sortable_by i bhfeidhm ina ionad.

ModelAdmin.view_on_siteLink to this definition#

Socraigh view_on_site chun rialú a dhéanamh an bhfuil an nasc “Amharc ar an láithreán” a thaispeáint nó nach bhfuil. Ba chóir go dtabharfadh an nasc seo tú chuig URL áit ar féidir leat an réad sábháltha a thaispeáint.

Is féidir leis an luach seo a bheith ina bhratach boolean nó inghlaonta. Má tá True (an réamhshocraithe), úsáidfear an modh object's:meth: ~django.db.models.model.get_absolute_url chun an url a ghiniúint.

Má tá modh a:meth: ~django.db.models.model.get_absolute_url ag do mhúnla ach nach dteastaíonn uait go mbeadh an cnaipe “Amharc ar an láithreán” le feiceáil, ní gá duit ach view_on_site` a shocrú go False:

Code

from django.contrib import admin


class PersonAdmin(admin.ModelAdmin):
    view_on_site = False

Sa chás go bhfuil sé inghlaonta, glacann sé leis an gcás samhail mar pharaiméadar. Mar shampla:

Code

from django.contrib import admin
from django.urls import reverse


class PersonAdmin(admin.ModelAdmin):
    def view_on_site(self, obj):
        url = reverse("person-detail", kwargs={"slug": obj.slug})
        return "https://example.com" + url

Modhanna ModelAdminLink to this heading#

ModelAdmin.save_model(request, obj, form, change)Link to this definition#

Tugtar an HttpRequest` don modh save_model`, sampla samhail, sampla ModelForm, agus luach boolean bunaithe ar an bhfuil an réad á chur leis nó ag athrú. Ligeann an modh seo a shárú oibríochtaí réamhshábhála nó iar-shábháil a dhéanamh. Glaoigh ar ``super () .save_model () ``chun an réad a shábháil ag baint úsáid:meth: .model.save.

Mar shampla chun request.user a cheangal leis an réad sula ndéantar é a shábháil:

Code

from django.contrib import admin


class ArticleAdmin(admin.ModelAdmin):
    def save_model(self, request, obj, form, change):
        obj.user = request.user
        super().save_model(request, obj, form, change)

ModelAdmin.delete_model(request, obj)Link to this definition#

Tugtar an HttpRequest` agus sampla samhail don modh delete_model`. Ligeann an modh seo a shárú oibríochtaí réamh-scriosta nó iar-scriosta a dhéanamh. Glaoigh ar ``super () .delete_model () ``chun an réad a scriosadh ag baint úsáid:meth: .model.delete.

ModelAdmin.delete_queryset(request, queryset)Link to this definition#

The delete_queryset() method is given the HttpRequest and a QuerySet of objects to be deleted. Override this method to customize the deletion process for the "delete selected objects" action.

ModelAdmin.save_formset(request, form, formset, change)Link to this definition#

Tugtar an modh save_formset an HttpRequest`, sampla an tuismitheora ModelForm agus luach boolean bunaithe ar cibé an bhfuil sé ag cur nó ag athrú an tuismitheora réad.

Mar shampla, chun request.user` a cheangal le gach samhail foirmset athraithe:

Code

class ArticleAdmin(admin.ModelAdmin):
    def save_formset(self, request, form, formset, change):
        instances = formset.save(commit=False)
        for obj in formset.deleted_objects:
            obj.delete()
        for instance in instances:
            instance.user = request.user
            instance.save()
        formset.save_m2m()

Féach freis:ref: saving-objects-in-the-formset.

ModelAdmin.get_ordering(request)Link to this definition#

Glacann an modh get_ordering iarraidh mar pharaiméadar agus táthar ag súil go gcuirfidh sé liost` nó tuple` ar ais chun ordú cosúil leis an tréith: attr: ordúna. Mar shampla:

Code

class PersonAdmin(admin.ModelAdmin):
    def get_ordering(self, request):
        if request.user.is_superuser:
            return ["name", "rank"]
        else:
            return ["name"]

ModelAdmin.get_search_results(request, queryset, search_term)Link to this definition#

Athraíonn an modh get_search_results liosta na rudaí a thaispeántar isteach iad siúd a mheaitseálann an téarma cuardaigh a chuirtear ar fáil. Glacann sé leis an iarratas, tacar cheisteanna a chuireann na scagairí reatha i bhfeidhm, agus an téarma cuardaigh a sholáthraíonn an úsáideoir. Filleann sé tuple ina bhfuil tacar fiosrúcháin arna modhnú chun an cuardach a chur i bhfeidhm, agus boolean a thugann le fios an bhféadfadh dúbailtí a bheith sna torthaí.

Déanann an cur i bhfeidhm réamhshocraithe cuardach ar na réimsí a ainmnítear in:attr: ModelAdmin.search_fields.

Féadfar an modh seo a shárú le do mhodh cuardaigh saincheaptha féin. Mar shampla, b'fhéidir gur mhaith leat cuardach a dhéanamh de réir réimse sláimhir, nó uirlis sheachtrach mar Solr nó Haystack a úsáid. Ní mór duit a fháil amach an bhféadfadh na hathruithe tacar fiosrúcháin a chuirtear i bhfeidhm ag do mhodh cuardaigh dúbailtí a thabhairt isteach sna torthaí, agus True a thabhairt ar ais sa dara gné den luach tuairisceáin.

Mar shampla, chun cuardach a dhéanamh de réir ainm ``agus ``aois`, d'fhéadfá úsáid a bhaint as:

Code

class PersonAdmin(admin.ModelAdmin):
    list_display = ["name", "age"]
    search_fields = ["name"]

    def get_search_results(self, request, queryset, search_term):
        queryset, may_have_duplicates = super().get_search_results(
            request,
            queryset,
            search_term,
        )
        try:
            search_term_as_int = int(search_term)
        except ValueError:
            pass
        else:
            queryset |= self.model.objects.filter(age=search_term_as_int)
        return queryset, may_have_duplicates

Tá an cur i bhfeidhm seo níos éifeachtaí ná search_fields = ('name', '=age') ``a dtagann comparáid teaghráin don réimse uimhriúil mar thoradh air, mar shampla... NÓ UACHTARACH (“polls_choice”. vótaí” ::text) = UPPER ('4') ``ar PostgreSQL.

ModelAdmin.save_related(request, form, formsets, change)Link to this definition#

Tugtar an modh save_related an HttpRequest`, an tuismitheoir ``ModelForm ``, an liosta foirmeacha inlíne agus luach boolean bunaithe ar an bhfuil an tuismitheoir á chur leis nó á athrú. Anseo is féidir leat aon oibríochtaí réamhshábhála nó iar-shábháil a dhéanamh le haghaidh rudaí a bhaineann leis an tuismitheoir. Tabhair faoi deara go bhfuil an tuismitheoir réad agus a fhoirm sábháilte cheana féin ag an bpointe seo.

ModelAdmin.get_autocomplete_fields(request)Link to this definition#

Tugtar an HttpRequest` don modh get_autocomplete_fields () ``agus táthar ag súil go bhfaighidh sé ``list nó tuple d'ainmneacha réimse a thaispeánfar le giuirléid uathchomhlánaithe mar a thuairiscítear thuas sa ranna:attr: ModelAdmin.autocomplete_fields.

ModelAdmin.get_readonly_fields(request, obj=None)Link to this definition#

Tugtar an modh get_readonly_fields an HttpRequest` agus an obj` atá á chur in eagar (nó None ar fhoirm breise) agus táthar ag súil go bhfaighidh liost` nó tuple` d'ainmneacha réimse a thaispeánfar mar léamh amháin, mar a thuairiscítear thuas san: `Read.Model.rannán ly_fields'.

ModelAdmin.get_prepopulated_fields(request, obj=None)Link to this definition#

Tugtar an modh get_prepopulated_fields an HttpRequest` agus an obj` atá á chur in eagar (nó None ar fhoirm breise) agus táthar ag súil go bhfaighidh sé ``foclóir` ar ais, mar a thuairiscítear thuas sa ranna:attr: ModelAdmin.prePopulated_Fields.

ModelAdmin.get_list_display(request)Link to this definition#

Tugtar an HttpRequest` don modh get_list_display agus táthar ag súil go bhfaighidh sé list nó tuple` d'ainmneacha réimse a thaispeánfar ar an radharc an liosta athraithe mar a thuairiscítear thuas sa ranna:attr: ModelAdmin.list_display.

ModelAdmin.get_list_display_links(request, list_display)Link to this definition#

Tugtar an HttpRequest don modh get_list_display_links agus an list` nó tuple ar ais ar:meth: ModelAdmin.get_list_display. Táthar ag súil go bhfillfidh sé None nó liost nó tuple d'ainmneacha réimse ar an liosta athraithe a bheidh nasctha leis an radharc athraithe, mar a thuairiscítear sa ranna:attr: ModelAdmin.list_display_links.

ModelAdmin.get_exclude(request, obj=None)Link to this definition#

Tugtar an modh get_exclude an HttpRequest` agus an obj` atá á chur in eagar (nó None ar fhoirm breise) agus táthar ag súil go gcuirfidh sé liosta réimsí ar ais, mar a thuairiscítear in:attr: ModelAdmin.exclude.

ModelAdmin.get_fields(request, obj=None)Link to this definition#

Tugtar an modh get_fields an HttpRequest` agus an obj` atá á chur in eagar (nó None ar fhoirm bhreise) agus táthar ag súil go gcuirfidh sé liosta réimsí ar ais, mar a thuairiscítear thuas sa roinn:attr: ModelAdmin.fields.

ModelAdmin.get_fieldsets(request, obj=None)Link to this definition#

<fieldset>Tugtar an modh get_fieldsets an HttpRequest` agus an obj` atá á chur in eagar (nó None ar fhoirm bhreise) agus táthar ag súil go bhfaighidh sé liosta 2-tuples ar ais, ina léiríonn gach 2-tuple ``ar leathanach na foirme riaracháin, mar a thuairiscítear thuas in:attr: Adminmodel.fieldsets rannán.

ModelAdmin.get_list_filter(request)Link to this definition#

Tugtar an HttpRequest` don modh get_list_filter agus táthar ag súil go bhfaighidh sé an cineál céanna seicheamh ar ais leis an tréith: attr: ~ModelAdmin.list_filter.

ModelAdmin.get_list_select_related(request)Link to this definition#

Tugtar an HttpRequest` don modh get_list_select_related agus ba cheart boolean nó liosta a thabhairt ar ais mar: attr: ModelAdmin.list_Select_Related a dhéanann.

ModelAdmin.get_search_fields(request)Link to this definition#

Tugtar an HttpRequest` don modh get_search_fields agus táthar ag súil go bhfaighidh sé an cineál céanna seicheamh ar ais mar thréith: attr: ~ModelAdmin.search_fields.

ModelAdmin.get_sortable_by(request)Link to this definition#

Tá an modh get_sortable_by () ``rith an `HttpRequest agus táthar ag súil go bhfaighidh sé bailiúchán (m.sh. list`, tuple`, nó set) d'ainmneacha réimse a shórtálfar ar an leathanach liosta athraithe.

Filleann a chur i bhfeidhm réamhshocraithe:attr: sortable_by má tá sé socraithe, ar shlí eile cuirtear iarchur chuig: meth: get_list_display.

Mar shampla, chun colún amháin nó níos mó a chosc ó bheith inscartha:

Code

class PersonAdmin(admin.ModelAdmin):
    def get_sortable_by(self, request):
        return {*self.get_list_display(request)} - {"rank"}

ModelAdmin.get_inline_instances(request, obj=None)Link to this definition#

Tugtar an modh get_inline_instances an HttpRequest` agus an obj` atá á chur in eagar (nó None ar fhoirm breise) agus táthar ag súil go bhfaighidh sé rudaí list nó tuple` o:class: ~django.contrib.admin.inlineModelAdmin, mar a thuairiscítear thíos :class: ~django.contrib.admin.inlineModelAdmin rannán. Mar shampla, chuirfeadh an méid seo a leanas ar ais inlíne gan an scagadh réamhshocraithe bunaithe ar cheadanna a chur leis, a athrú, a scriosadh agus féachaint:

Code

class MyModelAdmin(admin.ModelAdmin):
    inlines = [MyInline]

    def get_inline_instances(self, request, obj=None):
        return [inline(self.model, self.admin_site) for inline in self.inlines]

Má sháraíonn tú an modh seo, déan cinnte gur cásanna iad na línte a thugtar ar ais de na ranganna atá sainmhínithe in:attr: inlines nó d'fhéadfadh go mbeadh earráid “Droch-iarratas” ort agus rudaí gaolmhara á chur leis.

ModelAdmin.get_inlines(request, obj)Link to this definition#

Tugtar an modh get_inlines an HttpRequest` agus an obj atá á chur in eagar (nó None ar fhoirm bhreise) agus táthar ag súil go bhfaighidh sé athrá inlíne ar ais. Is féidir leat an modh seo a shárú chun inlínte a chur go dinimiciúil bunaithe ar an iarratas nó an samhail samhail in ionad iad a shonrú in:attr: ModelAdmin.inlines.

ModelAdmin.get_urls()Link to this definition#

The get_urls method on a ModelAdmin returns the URLs to be used for that ModelAdmin in the same way as a URLconf. Therefore you can extend them as documented in URL dispatcher, using the AdminSite.admin_view() wrapper on your views:

Code

from django.contrib import admin
from django.template.response import TemplateResponse
from django.urls import path


class MyModelAdmin(admin.ModelAdmin):
    def get_urls(self):
        urls = super().get_urls()
        my_urls = [path("my_view/", self.admin_site.admin_view(self.my_view))]
        return my_urls + urls

    def my_view(self, request):
        # ...
        context = dict(
            # Include common variables for rendering the admin template.
            self.admin_site.each_context(request),
            # Anything else you want in the context...
            key=value,
        )
        return TemplateResponse(request, "sometemplate.html", context)

Más mian leat an leagan amach riaracháin a úsáid, síneadh ó admin/base_site.html:

Django template

{% extends "admin/base_site.html" %}
{% block content %}
...
{% endblock %}

Má tá an leathanach incháilithe, ach má theastaíonn uait fós go ndéanfaí an seiceáil ceada, is féidir leat argóint cacheable=True a chur ar aghaidh chuig adminsite.admin_view () `:

Code

path("my_view/", self.admin_site.admin_view(self.my_view, cacheable=True))

Tá tréithe model_admin ``ag tuairimí ``ModelAdmin. Tá tréithe admin_site ag tuairimí adminSite` eile.

ModelAdmin.get_form(request, obj=None, **kwargs)Link to this definition#

Tuairisceáin a:class: ~django.forms.ModelForm rang le húsáid sa riarachán tuairimí cuir agus athraigh, féach:meth: add_view agus:meth: change_view.

Úsáideann an cur i bhfeidhm bonn:func: ~django.forms.models.modelform_factory go fo-aicme: attr: ~form, modhnaithe ag tréithe mar: attr: ~fields agus:attr: ~fields agus:attr: `~ eisiúint `. Mar sin, mar shampla, dá dteastaíonn uait réimsí breise a thairiscint do sárúsáideoirí, d'fhéadfá malartú i bhfoirm bhonn difriúil mar sin:

Code

class MyModelAdmin(admin.ModelAdmin):
    def get_form(self, request, obj=None, **kwargs):
        if request.user.is_superuser:
            kwargs["form"] = MySuperuserForm
        return super().get_form(request, obj, **kwargs)

Féadfaidh tú rang saincheap:class: ~django.forms.ModelForm a thabhairt ar ais go díreach freisin.

ModelAdmin.get_formsets_with_inlines(request, obj=None)Link to this definition#

Péirí torthaí (FormSet, :class: InlineModelAdmin) le húsáid i riarachán tuairimí a chur leis agus a athrú.

Mar shampla más mian leat inlíne áirithe a thaispeáint sa radharc athraithe amháin, d'fhéadfá get_formsets_with_inlines a shárú mar seo a leanas:

Code

class MyModelAdmin(admin.ModelAdmin):
    inlines = [MyInline, SomeOtherInline]

    def get_formsets_with_inlines(self, request, obj=None):
        for inline in self.get_inline_instances(request, obj):
            # hide MyInline in the add view
            if not isinstance(inline, MyInline) or obj is not None:
                yield inline.get_formset(request, obj), inline

ModelAdmin.formfield_for_foreignkey(db_field, request, **kwargs)Link to this definition#

Ligeann an modh formfield_for_foreignkey ar ModelAdmin` duit an réimse foirme réamhshocraithe do réimse eochracha eachtracha eachtracha a shárú. Mar shampla, chun fo-thacar rudaí a thabhairt ar ais don phríomhréimse eachtrach seo bunaithe ar an úsáideoir:

Code

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == "car":
            kwargs["queryset"] = Car.objects.filter(owner=request.user)
        return super().formfield_for_foreignkey(db_field, request, **kwargs)

Úsáideann sé seo an tsampla HttpRequest` chun an réimse eochair eachtrach Car a scagadh chun na gluaisteáin atá faoi úinéireacht an ``Úsáideora ``a thaispeáint ach amháin.

Le haghaidh scagairí níos casta, is féidir leat ModelForm a úsáid. Modh __init__ () ``chun scagadh bunaithe ar `instance de do mhúnla (féach:ref: fields-what-handle-reachships). Mar shampla:

Code

class CountryAdminForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["capital"].queryset = self.instance.cities.all()


class CountryAdmin(admin.ModelAdmin):
    form = CountryAdminForm

ModelAdmin.formfield_for_manytomany(db_field, request, **kwargs)Link to this definition#

Cosúil leis an modh formfield_for_foreignkey, is féidir an modh formfield_for_manytomany a athrú chun an réimse foirme réamhshocraithe do réimse go leor réimse a athrú. Mar shampla, más féidir le húinéir ilghluaisteáin a bheith ag úinéir agus is féidir gluaisteáin a bheith bainteach le go leor úinéirí -- d'fhéadfá an réimse eochair eachtrach ``Carr` a scagadh chun na gluaisteáin atá faoi úinéireacht an ``Úsáideora ``a thaispeáint amháin:

Code

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_manytomany(self, db_field, request, **kwargs):
        if db_field.name == "cars":
            kwargs["queryset"] = Car.objects.filter(owner=request.user)
        return super().formfield_for_manytomany(db_field, request, **kwargs)

ModelAdmin.formfield_for_choice_field(db_field, request, **kwargs)Link to this definition#

Cosúil leis na modhanna formfield_for_foreignkey agus formfield_for_manytomany, is féidir an modh formfield_for_choice_field a athrú chun an réimse foirme réamhshocraithe a athrú do réimse a bhfuil roghanna dearbhaithe aige. Mar shampla, más chóir go mbeadh na roghanna atá ar fáil do sárúsáideoir difriúil ná na roghanna atá ar fáil d'fhoireann rialta, d'fhéadfá dul ar aghaidh mar seo a leanas:

Code

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_choice_field(self, db_field, request, **kwargs):
        if db_field.name == "status":
            kwargs["choices"] = [
                ("accepted", "Accepted"),
                ("denied", "Denied"),
            ]
            if request.user.is_superuser:
                kwargs["choices"].append(("ready", "Ready for deployment"))
        return super().formfield_for_choice_field(db_field, request, **kwargs)

ModelAdmin.get_changelist(request, **kwargs)Link to this definition#

Filleann sé an rang Changelist atá le húsáid le haghaidh liostú. De réir réamhshocraithe, úsáidtear django.contrib.admin.views.main.changeList. Trí an rang seo a oidhreacht is féidir leat iompar an liostaithe a athrú.

ModelAdmin.get_changelist_form(request, **kwargs)Link to this definition#

Tuairisceann a:class: ~django.forms.ModelForm rang le húsáid sa FormSet ar an leathanach liosta athraithe. Chun foirm saincheaptha a úsáid, mar shampla:

Code

from django import forms


class MyForm(forms.ModelForm):
    pass


class MyModelAdmin(admin.ModelAdmin):
    def get_changelist_form(self, request, **kwargs):
        return MyForm

ModelAdmin.get_changelist_formset(request, **kwargs)Link to this definition#

Tuairisceáin a:ref: ModelFormSet <model-formsets>`aicme le húsáid ar an leathanach liosta athraithe má úsáidtear: attr: `~ModelAdmin.list_editable. Chun tacar foirme saincheaptha a úsáid, mar shampla:

Code

from django.forms import BaseModelFormSet


class MyAdminFormSet(BaseModelFormSet):
    pass


class MyModelAdmin(admin.ModelAdmin):
    def get_changelist_formset(self, request, **kwargs):
        kwargs["formset"] = MyAdminFormSet
        return super().get_changelist_formset(request, **kwargs)

ModelAdmin.lookup_allowed(lookup, value, request)Link to this definition#

Is féidir na rudaí ar leathanach an liosta athraithe a scagadh le cuardaigh ó shreang fiosrúcháin an URL. Seo mar a oibríonn: attr: list_filter, mar shampla. Tá na cuardaigh cosúil leis an méid a úsáidtear in:meth: .querySet.filter (m.sh. ``user__email= user@example.com ``). Ós rud é gur féidir leis an úsáideoir na cuardaigh sa sreangán fiosrúcháin a ionramháil, caithfear iad a shláintiú chun nochtadh sonraí neamhúdaraithe a chosc.

Tugtar cosán cuardaigh don modh lookup_allow () ``ón sreang ceisteanna (m.sh. ```user__email'), an luach comhfhreagrach (m.sh. `user@example.com '), agus an t-iarratas, agus tugann sé boolean ag tabhairt le fios an bhfuil ceadaithe ag scagadh QuerySet ag baint úsáide as na paraiméadair. Má fhilleann lookup_allow () ```False,, DisallowedModelAdminlookup`` (fo-aicme de:exc: ~Django.Core.Exceptions.SuspiciousOperation) a ardaítear.

De réir réamhshocraithe, ceadaíonn ``lookup_allow () ``rochtain ar réimsí áitiúla samhail, cosáin réimse a úsáidtear in:attr: ~ModelAdmin.list_filter (ach ní cosáin ó:meth: ~ModelAdmin.get_list_filter), agus cuardaigh atá ag teastáil le haghaidh: attr: ~Django.db.models.foreignkey.limit_choices_to feidhmiú i gceart in:attr: ~django.contrib.admin.modeladmin.raw_id_fields.

Athraigh an modh seo chun na cuardaigh a cheadaítear do d'fho-aicme: ~django.contrib.admin.modelAdmin a shaincheapadh.

ModelAdmin.has_view_permission(request, obj=None)Link to this definition#

Ba chóir True a thabhairt ar ais má cheadaítear féachaint ar obj, False` ar shlí eile. Más é obj None, ba cheart True nó False` a thabhairt ar ais chun a léiriú an bhfuil ceadaithe féachaint ar rudaí den chineál seo go ginearálta (m.sh., léirmhínítear False mar a chiallaíonn nach ceadaítear don úsáideoir reatha aon rud den chineál seo a fheiceáil).

Tugann an cur i bhfeidhm réamhshocraithe True ar ais má tá an cead “athraigh” nó “féachaint” ag an úsáideoir.

ModelAdmin.has_add_permission(request)Link to this definition#

Ba chóir True a thabhairt ar ais má cheadaítear réad a chur leis, False ar shlí eile.

ModelAdmin.has_change_permission(request, obj=None)Link to this definition#

Ba chóir True a thabhairt ar ais má cheadaítear obj eagarthóireacht, False ar shlí eile. Má tá obj None, ba cheart True nó False` a thabhairt ar ais chun a léiriú an bhfuil ceadaithe eagarthóireacht rudaí den chineál seo i gcoitinne (m.sh., léirmhínítear False mar a chiallaíonn nach ceadaítear don úsáideoir reatha aon rud den chineál seo a chur in eagar).

ModelAdmin.has_delete_permission(request, obj=None)Link to this definition#

Ba chóir True a thabhairt ar ais má cheadaítear obj a scriosadh, False ar shlí eile. Má tá obj None, ba cheart True nó False` a thabhairt ar ais chun a léiriú an gceadaítear rudaí den chineál seo a scriosadh go ginearálta (m.sh., léirmhínítear False mar a chiallaíonn nach ceadaítear don úsáideoir reatha aon rud den chineál seo a scriosadh).

ModelAdmin.has_module_permission(request)Link to this definition#

Ba chóir go bhfilleadh True má cheadaítear an modúl a thaispeáint ar leathanach innéacs an riaracháin agus rochtain a fháil ar leathanach innéacs an mhodúil, False ar shlí eile. <django.contrib.auth.models.User.has_module_perms>Úsáid:Meth: User.has_module_perms () `de réir réamhshocraithe. Ní chuireann sé srian ar rochtain ar an radharc, cuir, athrú nó scriosadh radhairc, :meth: `~modeladmin.has_view_permission, :meth: ~modeladmin.has_add_permission, :meth: ~ModelAdmin.has_Change_Permission, agus:meth: ~ModelAdmin.has_delete_permission a úsáid chuige sin.

ModelAdmin.get_queryset(request)Link to this definition#

Tugann an modh get_queryset` ar ModelAdmin` a: class: ~django.db.models.queryset de gach cás samhail is féidir leis an suíomh riaracháin a chur in eagar. Cás úsáide amháin chun an modh seo a shárú is ea rudaí atá faoi úinéireacht an úsáideora logáilte isteach a thaispeáint:

Code

class MyModelAdmin(admin.ModelAdmin):
    def get_queryset(self, request):
        qs = super().get_queryset(request)
        if request.user.is_superuser:
            return qs
        return qs.filter(author=request.user)

ModelAdmin.message_user(request, message, level=messages.INFO, extra_tags='', fail_silently=False)Link to this definition#

Sends a message to the user using the django.contrib.messages backend. See the custom ModelAdmin example.

Ligeann argóintí eochairfhocal duit leibhéal na teachtaireachta a athrú, clibeanna CSS breise a chur leis, nó teip go ciúin mura bhfuil an creat contrib.messages suiteáilte. Meaitseálann na hargóintí eochairfhocal seo leo siúd le haghaidh: func: django.contrib.messages.add_message, féach doiciméadú na feidhme sin le haghaidh tuilleadh sonraí. Difríocht amháin is ea go bhféadfar an leibhéal a rith mar lipéad teaghrán i dteannta le sláin/tairiseach.

ModelAdmin.get_paginator(request, queryset, per_page, orphans=0, allow_empty_first_page=True)Link to this definition#

Tugann sé sampla den paginator ar ais le húsáid don radharc seo. De réir réamhshocraithe, cruthaíonn sé sampla de:attr: paginator.

ModelAdmin.response_add(request, obj, post_url_continue=None)Link to this definition#

Cinneann sé an:class: ~django.http.httpResponse don chéime:meth: add_view.

Glaofar response_add` tar éis an fhoirm riaracháin a chur isteach agus díreach tar éis an réad agus na cásanna gaolmhara go léir a chruthú agus a shábháil. Is féidir leat é a shárú chun an t-iompar réamhshocraithe a athrú tar éis an réad a chruthú.

ModelAdmin.response_change(request, obj)Link to this definition#

Cinneann sé an:class: ~django.http.httpResponse don chéime:meth: change_view.

Glaofar response_change` tar éis an fhoirm riaracháin a chur isteach agus díreach tar éis an réad agus na cásanna gaolmhara go léir a shábháil. Is féidir leat é a shárú chun an t-iompar réamhshocraithe a athrú tar éis an réad a athrú.

ModelAdmin.response_delete(request, obj_display, obj_id)Link to this definition#

Cinneann sé an:class: ~django.http.httpResponse don chéime:meth: delete_view.

Glaofar ar response_delete` tar éis an réad a scriosadh. Is féidir leat é a shárú chun an t-iompar réamhshocraithe a athrú tar éis an réad a scriosadh.

Is teaghrán é obj_display le hainm an réad scriosta.

Is é obj_id an t-aitheantóir sraitheach a úsáidtear chun an réad atá le scriosadh a aisghabháil.

ModelAdmin.get_formset_kwargs(request, obj, inline, prefix)Link to this definition#

Crúca chun na hargóintí eochairfhocal a shaincheapadh chuig tógálaí foirmshraith. Mar shampla, chun iarrat a chur chuig foirmeacha foirmeacha:

Code

class MyModelAdmin(admin.ModelAdmin):
    def get_formset_kwargs(self, request, obj, inline, prefix):
        return {
            **super().get_formset_kwargs(request, obj, inline, prefix),
            "form_kwargs": {"request": request},
        }

Is féidir leat é a úsáid freisin chun initial a shocrú d'fhoirmeacha foirmeacha.

ModelAdmin.get_changeform_initial_data(request)Link to this definition#

Croca do na sonraí tosaigh ar fhoirmeacha athraithe riaracháin. De réir réamhshocraithe, tugtar luachanna tosaigh do réimsí ó pharaiméadair GET`. Mar shampla, ? name=initial_value socróidh luach tosaigh an réimse ainm mar luach_inicial.

Ba chóir don modh seo foclóir a thabhairt ar ais sa fhoirm {'fieldname': 'fieldval'}:

Code

def get_changeform_initial_data(self, request):
    return {"name": "custom_initial_value"}

ModelAdmin.get_deleted_objects(objs, request)Link to this definition#

A hook for customizing the deletion process of the delete_view() and the "delete selected" action.

Is é an argóint objs ``is athraitheach aonchineálach de rudaí (``QuerySet nó liosta cásanna samhail) atá le scriosadh, agus is é request an:class: ~django.http.httpRequest.

Caithfidh an modh seo 4-tuple de (deleted_objects, model_count, perms_needed, protected) a thabhairt ar ais.

Is liosta de na teaghráin is ea deleted_objects` a léiríonn na rudaí go léir a scriosfar. Má tá aon rudaí gaolmhara le scriosadh, tá an liosta neadaithe agus tá na rudaí gaolmhara sin san áireamh. Déantar an liosta a fhormáidiú sa teimpléad ag baint úsáide as an scagair:tfilter: unordered_list.

Is foclóir é model_count mapáil gach samhail's:attr: ~django.db.models.options.verbose_name_plural ar líon na rudaí a scriosfar.

Is é perms_needed sraith de:attr: ~django.db.models.options.verbose_names de na samhlacha nach bhfuil cead ag an úsáideoir a scriosadh.

Is liosta de na teaghráin a léiríonn na rudaí gaolmhara cosanta go léir nach féidir iad a scriosadh. Taispeántar an liosta sa teimpléad.

class MyModelAdmin(admin.ModelAdmin):
    # A template for a very customized change view:
    change_form_template = "admin/myapp/extras/openstreetmap_change_form.html"

    def get_osm_info(self):
        # ...
        pass

    def change_view(self, request, object_id, form_url="", extra_context=None):
        extra_context = extra_context or {}
        extra_context["osm_data"] = self.get_osm_info()
        return super().change_view(
            request,
            object_id,
            form_url,
            extra_context=extra_context,
        )

Sainmhínithe sócmhainní ModelAdminLink to this heading#

Tá amanna ann nuair ba mhaith leat beagán CSS agus/nó JavaScript a chur leis na tuairimí a chur leis na tuairimí a chur leis /athraigh. Is féidir é seo a chur i gcrích trí rang istigh Meáin ``a úsáid ar do `ModelAdmin:

class ArticleAdmin(admin.ModelAdmin):
    class Media:
        css = {
            "all": ["my_styles.css"],
        }
        js = ["my_code.js"]

Tá an aip: doc: staticfiles `réasúnaí:socrú: `STATIC_URL (nó</ref/contrib/staticfiles> :socrú: MEDIA_URL más:socrú: STATIC_URL` ``None) le haon chosáin sócmhainní. <form-asset-paths>Tá na rialacha céanna i bhfeidhm as:ref: `sainmhínithe rialta sócmhainní ar fhoirmeacha `.

Roghanna InlineModelAdminLink to this heading#

Roinneann InlineModelAdmin go leor de na gnéithe céanna le ModelAdmin, agus cuireann sé cuid dá chuid féin leis (sainmhínítear na gnéithe roinnte i ndáiríre sa sáraicme BaseModelAdmin). Is iad na gnéithe roinnte:

• form

• fieldsets

• fields

• formfield_overrides

• exclude

• filter_horizontal

• filter_vertical

• ordering

• prepopulated_fields

• : meth: ~ModelAdmin.get_fieldsets

• get_queryset()

• radio_fields

• readonly_fields

• view_on_site

• empty_value_display

• autocomplete_fields

• raw_id_fields

• formfield_for_choice_field()

• formfield_for_foreignkey()

• formfield_for_manytomany()

• has_module_permission()

Cuireann an rang InlineModelAdmin leis nó a shaincheapadh:

InlineModelAdmin.modelLink to this definition#

An tsamhail atá ag baint úsáide as an inlíne. Tá sé seo ag teastáil.

InlineModelAdmin.fk_nameLink to this definition#

Ainm an eochair eachtrach ar an tsamhail. I bhformhór na gcásanna déileálfar leis seo go huathoibríoch, ach caithfear fk_name a shonrú go sainráite má tá níos mó ná eochair eachtrach amháin ann don tsamhail thuismitheora céanna.

InlineModelAdmin.formsetLink to this definition#

Tá sé seo réamhshocraithe chuig: aicme: ~django.forms.models.baseinlineFormSet. Is féidir go leor féidearthachtaí saincheaptha a thabhairt duit a úsáid do shraith foirme féin. <model-formsets>Tógtar inlínte timpeall: ref: `model formsets `.

InlineModelAdmin.formLink to this definition#

Tá an luach do foirm ``réamhshocraithe go ``ModelForm`. Seo an rud a chuirtear trí:func: ~django.forms.models.inlineformset_factory agus an foirmset á chruthú don inlíne seo.

Mar shampla féach an rannáit:ref: admin-custom-validation.

InlineModelAdmin.classesLink to this definition#

Liosta nó tuple ina bhfuil ranganna breise CSS le cur i bhfeidhm ar an tacar réimse a rinneadh do na línte inlíne. Réamhshocraithe go None. Mar is amhlaidh le ranganna atá cumraithe in:attr: ~ModelAdmin.FieldSets, titeofar inlínte le rang ``collise` i dtosach ag baint úsáide as giuirléid leathnaithe.

InlineModelAdmin.extraLink to this definition#

Rialaíonn sé seo líon na bhfoirmeacha breise a thaispeánfaidh an tacar foirme chomh maith leis na foirmeacha tosaigh. Réamhshocraithe go 3. Féach na:doc: formsets doiciméadach le haghaidh tuilleadh eolais. </topics/forms/formsets>

Maidir le húsáideoirí a bhfuil brabhsálaithe cumasaithe ag JavaScript acu, cuirtear nasc “Cuir eile leis” ar fáil chun aon líon inlíne breise a chur leis i dteannta leo siúd a chuirtear ar fáil mar thoradh ar an argóint breise.

Ní bheidh an nasc dinimiciúil le feiceáil má sháraíonn líon na bhfoirmeacha atá ar taispeáint faoi láthair max_num, nó mura bhfuil JavaScript cumasaithe ag an úsáideoir.

InlineModelAdmin.get_extra() also allows you to customize the number of extra forms.

InlineModelAdmin.max_numLink to this definition#

Rialaíonn sé seo an líon uasta na bhfoirmeacha atá le taispeáint san inlíne. Ní bhaineann sé seo go díreach le líon na rudaí, ach is féidir má tá an luach beag go leor. Féach: ref: model-formsets-max-num le haghaidh tuilleadh faisnéise.

InlineModelAdmin.get_max_num() also allows you to customize the maximum number of extra forms.

InlineModelAdmin.min_numLink to this definition#

Rialaíonn sé seo an líon íosta foirmeacha atá le taispeáint san inlíne. Féach: func: ~django.forms.models.modelformset_factory le haghaidh tuilleadh faisnéise.

InlineModelAdmin.get_min_num() also allows you to customize the minimum number of displayed forms.

InlineModelAdmin.raw_id_fieldsLink to this definition#

De réir réamhshocraithe, úsáideann riarachán Django comhéadan bosca roghnaithe (<select>) do réimsí atá ForeignKey`. Uaireanta níl tú ag iarraidh an lasbhreas a thabhairt faoi na cásanna gaolmhara go léir a roghnú le taispeáint sa anuas anuas.

Is liosta réimsí é raw_id_fields ar mhaith leat a athrú go giuirléid Input le haghaidh ForeignKey` nó ManyTomanyField:

Code

class BookInline(admin.TabularInline):
    model = Book
    raw_id_fields = ["pages"]

InlineModelAdmin.templateLink to this definition#

An teimpléad a úsáidtear chun an líne a léiriú ar an leathanach.

InlineModelAdmin.verbose_nameLink to this definition#

Athrú chuig an:attr: ~django.db.models.options.verbose_name ó rang Meta` istigh an tsamhail.

InlineModelAdmin.verbose_name_pluralLink to this definition#

Athrú chuig an: attr: ~django.db.models.options.verbose_name_plural ó rang Meta` istigh an tsamhail. Mura dtugtar é seo agus mura sainmhínítear an:attr: .inlineModelAdmin.verbose_name, úsáidfidh Django:attr: .inlineModelAdmin.verbose_name + 's'.

InlineModelAdmin.can_deleteLink to this definition#

Sonraíonn sé cibé an féidir rudaí inlíne a scriosadh sa líne nó nach bhfuil. Réamhshocraithe go True.

InlineModelAdmin.show_change_linkLink to this definition#

Sonraíonn sé an bhfuil nasc leis an bhfoirm athraithe ag rudaí inlíne is féidir a athrú sa riarachán nó nach bhfuil. Réamhshocraithe go False.

InlineModelAdmin.get_formset(request, obj=None, **kwargs)Link to this definition#

Tuairisceáin a:class: ~Django.Forms.Models.BaseinlineFormSet rang le húsáid i riarachán tuairimí a chur leis /athraigh. Is é obj an tuismitheoir réad atá á chur in eagar nó ``None ``nuair a chuirtear tuismitheoir nua leis. Féach an sampla le haghaidh: class: ModelAdmin.get_formSets_with_inlines.

InlineModelAdmin.get_extra(request, obj=None, **kwargs)Link to this definition#

Tugann sé líon na bhfoirmeacha inlíne breise atá le húsáid ar ais. De réir réamhshocraithe, filleann an tréith: attr: InlineModelAdmin.extra.

Athraigh an modh seo chun líon na bhfoirmeacha inlíne breise a chinneadh go cláraitheach. Mar shampla, d'fhéadfadh sé seo a bheith bunaithe ar an samhail samhail (a rith mar an argóint eochairfhocal ``obj ``):

Code

class BinaryTreeAdmin(admin.TabularInline):
    model = BinaryTree

    def get_extra(self, request, obj=None, **kwargs):
        extra = 2
        if obj:
            return extra - obj.binarytree_set.count()
        return extra

InlineModelAdmin.get_max_num(request, obj=None, **kwargs)Link to this definition#

Tugann sé an líon uasta na bhfoirmeacha inlíne breise le húsáid ar ais. De réir réamhshocraithe, filleann an tréith: attr: inlineModelAdmin.max_num.

Athraigh an modh seo chun líon uasta na bhfoirmeacha inlíne a chinneadh go cláraitheach. Mar shampla, d'fhéadfadh sé seo a bheith bunaithe ar an samhail samhail (a rith mar an argóint eochairfhocal ``obj ``):

Code

class BinaryTreeAdmin(admin.TabularInline):
    model = BinaryTree

    def get_max_num(self, request, obj=None, **kwargs):
        max_num = 10
        if obj and obj.parent:
            return max_num - 5
        return max_num

InlineModelAdmin.get_min_num(request, obj=None, **kwargs)Link to this definition#

Tugann sé an líon íosta foirmeacha inlíne atá le húsáid ar ais. De réir réamhshocraithe, filleann an tréith: attr: inlineModelAdmin.min_num.

Athraigh an modh seo chun líon íosta na bhfoirmeacha inlíne a chinneadh go cláraithe. Mar shampla, d'fhéadfadh sé seo a bheith bunaithe ar an samhail samhail (a rith mar an argóint eochairfhocal ``obj ``).

InlineModelAdmin.has_add_permission(request, obj)Link to this definition#

Ba chóir go bhfilleadh True má cheadaítear réad inlíne a chur leis, False ar shlí eile. Is é obj an tuismitheoir réad atá á chur in eagar nó ``None ``nuair a chuirtear tuismitheoir nua leis.

InlineModelAdmin.has_change_permission(request, obj=None)Link to this definition#

Ba chóir go bhfaighidh True a thabhairt ar ais má cheadaítear réad inlíne a chur in eagar, False ar shlí eile. Is é obj an tuismitheoir réad atá á chur in eagar.

InlineModelAdmin.has_delete_permission(request, obj=None)Link to this definition#

Ba chóir go bhfilleadh True má cheadaítear réad inlíne a scriosadh, False ar shlí eile. Is é obj an tuismitheoir réad atá á chur in eagar.

Ag obair le samhail le dhá eochracha eachtracha nó níos mó don tsamhail thuismitheora céannaLink to this heading#

Uaireanta is féidir níos mó ná eochair eachtrach amháin a bheith agat don tsamhail chéanna. Tóg an tsamhail seo mar shampla:

from django.db import models


class Person(models.Model):
    name = models.CharField(max_length=128)


class Friendship(models.Model):
    to_person = models.ForeignKey(
        Person, on_delete=models.CASCADE, related_name="friends"
    )
    from_person = models.ForeignKey(
        Person, on_delete=models.CASCADE, related_name="from_friends"
    )

Más mian leat inlíne a thaispeáint ar na leathanaigh riaracháin ``Duine ``a chur leis /athraigh ní mór duit an eochair eachtrach a shainiú go sainráite ós rud é nach féidir leis sin a dhéanamh go huathoibríoch:

from django.contrib import admin
from myapp.models import Friendship, Person


class FriendshipInline(admin.TabularInline):
    model = Friendship
    fk_name = "to_person"


class PersonAdmin(admin.ModelAdmin):
    inlines = [
        FriendshipInline,
    ]


admin.site.register(Person, PersonAdmin)

Ag obair le go leor samhlachaLink to this heading#

De réir réamhshocraithe, taispeánfar giuirléidí riaracháin le haghaidh caidrimh go leor ar cibé múnla ina bhfuil an tagairt iarbhír don: class: ~django.db.models.manyToManyField. Ag brath ar do shainmhíniú ModelAdmin`, beidh gach réimse go leor i do mhúnla ionadaíocht le HTML ``, caighdeánach, scagaire cothrománach nó ingearach, nó giuirléid raw_id_fields <select multiple>. Mar sin féin, is féidir inlíne a chur in ionad na giuirléidí seo.

Cuir i gcás go bhfuil na samhlacha seo a leanas againn:

from django.db import models


class Person(models.Model):
    name = models.CharField(max_length=128)


class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, related_name="groups")

Más mian leat caidreamh go leor a thaispeáint ag baint úsáide as inlíne, is féidir leat é sin a dhéanamh trí réad inlineModelAdmin a shainiú don chaidreamh:

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


class MembershipInline(admin.TabularInline):
    model = Group.members.through


class GroupAdmin(admin.ModelAdmin):
    inlines = [
        MembershipInline,
    ]
    exclude = ["members"]


admin.site.register(Group, GroupAdmin)

Tá dhá ghné is fiú a thabhairt faoi deara sa sampla seo.

Ar dtús - tagairtí aicme MembershipInline ``Group.Members.Through ``. Is tagairt é an tréith ``trí ``don tsamhail a bhainistíonn an gaol go leor. Cruthaíonn Django an tsamhail seo go huathoibríoch nuair a shainmhíníonn tú réimse go leor.

Ar an dara dul síos, ní mór don Groupadmin` an réimse ``baill ``a eisiamh de láimh. Taispeánann Django giuirléid riaracháin do réimse go leor ar an tsamhail a shainmhíníonn an gaol (sa chás seo, ``Grúpa ``). Más mian leat samhail inlíne a úsáid chun an caidreamh go leor a léiriú, ní mór duit a rá le riarachán Django ná* an giuirléid seo a thaispeáint - ar shlí eile beidh dhá ghuirléid agat ar do leathanach riaracháin chun an gaol a bhainistiú.

Tabhair faoi deara nach spreagtar na comharthaí: data: ~django.db.models.signals.m2m_changed nuair a úsáidtear an teicníc seo. Tá sé seo toisc nach bhfuil ach samhail le dhá phríomhréimse eachtracha eachtrach seachas caidreamh go leor le go leor.

Ar gach bealach eile, tá an InlineModelAdmin` díreach mar an gcéanna le haon cheann eile. Is féidir leat an cuma a shaincheapadh ag baint úsáide as aon cheann de na gnáthairíonna ``ModelAdmin`.

Ag obair le samhlacha idirghabhála go leorLink to this heading#

Nuair a shonraíonn tú samhail idirghabhála ag baint úsáide as an argóint ``through ``chuig a:class: ~django.db.models.manyToManyField, ní thaispeánfaidh an riarachán giuirléid de réir réamhshocraithe. Tá sé seo toisc go dteastaíonn níos mó faisnéise ó gach cás den tsamhail idirghabhálaí sin ná mar a d'fhéadfaí a thaispeáint i ngiuirléid amháin, agus beidh an leagan amach a theastaíonn le haghaidh giuirléidí iolracha

Mar sin féin, ba mhaith linn fós a bheith in ann an fhaisnéis sin a chur in eagar inlíne. Ar ámharaí an tsaoil, is féidir linn é seo a dhéanamh le samhlacha riaracháin inlíne. Cuir i gcás go bhfuil na samhlacha seo a leanas againn:

from django.db import models


class Person(models.Model):
    name = models.CharField(max_length=128)


class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through="Membership")


class Membership(models.Model):
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=["person", "group"], name="unique_person_group"
            )
        ]

Is é an chéad chéim chun an tsamhail idirmheánach seo a thaispeáint sa riarachán ná rang inlíne a shainiú don tsamhail ``Ballraíocht ``:

class MembershipInline(admin.TabularInline):
    model = Membership
    extra = 1

Úsáideann an sampla seo na luachanna réamhshocraithe InlineModelAdmin don tsamhail ``Ballraíocht ``, agus cuireann sé teorainn leis na foirmeacha breise le ceann amháin. D'fhéadfaí é seo a shaincheapadh ag baint úsáide as aon cheann de na roghanna atá ar fáil do ranganna ``InlineModelAdmin`.

Anois cruthaigh tuairimí riaracháin do na samhlacha Person agus Grúpa:

class PersonAdmin(admin.ModelAdmin):
    inlines = [MembershipInline]


class GroupAdmin(admin.ModelAdmin):
    inlines = [MembershipInline]

Faoi dheireadh, cláraigh do mhúnlaí Person` agus ``Grúpa leis an suíomh riaracháin:

admin.site.register(Person, PersonAdmin)
admin.site.register(Group, GroupAdmin)

Anois tá do shuíomh riaracháin bunaithe chun rudaí Ballraíocht ``a chur in eagar inlíne ó na leathanaigh sonraí ``Duine nó Grúpa`.

Ag baint úsáide as caidreamh cineálach mar inlíneLink to this heading#

Is féidir inlíne a úsáid le rudaí a bhaineann go ginearálta. Abair go bhfuil na samhlacha seo a leanas agat:

from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models


class Image(models.Model):
    image = models.ImageField(upload_to="images")
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")


class Product(models.Model):
    name = models.CharField(max_length=100)

Más mian leat eagarthóireacht agus cruthú sampla Image ar an Product` a cheadú, cuirte/athraigh tuairimí is féidir leat a úsáid:class: ~django.contrib.contentTypes.admin.GenericTabularInline nó:class: ~django.contrib.contentTypes.admin.GenericStackedInline (dá fho-aicme de:class: Django.Contrib.ContentTypes.Admin.GenericStackedInline Jango.Contrib.ContentTypes.Admin.GenericInlineModelAdmin`) arna sholáthar ar:mod: ~django.contrib.contenttypes.admin. Cuireann siad leagan amach amhairc táblaíocha agus cruachta i bhfeidhm do na foirmeacha a léiríonn na rudaí inlíne, faoi seach, díreach cosúil lena gcomhghleacaithe neamh Iompraíonn siad díreach cosúil le haon inlíne eile. I do admin.py` don aip sampla seo:

from django.contrib import admin
from django.contrib.contenttypes.admin import GenericTabularInline

from myapp.models import Image, Product


class ImageInline(GenericTabularInline):
    model = Image


class ProductAdmin(admin.ModelAdmin):
    inlines = [
        ImageInline,
    ]


admin.site.register(Product, ProductAdmin)

Féach na:doc: contenttypes doiciméadach le haghaidh faisnéise níos sainiúla. </ref/contrib/contenttypes>