SamhlfhoirmeLink to this heading#Má tá aip faoi thiomáint bunachar sonraí á thógáil agat, is dócha go mbeidh foirmeacha agat a léarscálann go dlúth do mhúnlaí Django. Mar shampla, b'fhéidir go mbeadh samhail ``BlogComment ``agat, agus ba mhaith leat foirm a chruthú a ligeann do dhaoine tuairimí a chur isteach. Sa chás seo, bheadh sé iomarcach na cineálacha réimse i d'fhoirm a shainiú, toisc go bhfuil na réimsí i do mhúnla sainmhínithe agat cheana féin.
\nAr an gcúis seo, soláthraíonn Django rang cúntóra a ligeann duit rang ``Form ``a chruthú ó mhúnla Django.
\nMar shampla:
\n>>> from django.forms import ModelForm\n>>> from myapp.models import Article\n\n# Create the form class.\n>>> class ArticleForm(ModelForm):\n... class Meta:\n... model = Article\n... fields = ["pub_date", "headline", "content", "reporter"]\n...\n\n# Creating a form to add an article.\n>>> form = ArticleForm()\n\n# Creating a form to change an existing article.\n>>> article = Article.objects.get(pk=1)\n>>> form = ArticleForm(instance=article)\nBeidh réimse foirme ag an rang Foirm a ghintear do gach réimse samhail a shonraítear, san ord a shonraítear sa tréith ``réimsí réimsí `réimsí `réimsí `.
Tá réimse foirme réamhshocraithe comhfhreagrach ag gach réimse samhail Mar shampla, léirítear charfield ar mhúnla mar charfield` ar fhoirm. Léirítear samhail `ManyTomanyField mar MultiplechoiceField. Seo an liosta iomlán na tiontaithe:
Réimse múnla | \nRéimse foirm | \n
|---|---|
| \n | Ní léirítear san fhoirm | \n
| \n | Ní léirítear san fhoirm | \n
| \n |
| \n
| \n |
| \n
| \n |
| \n
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n
| \n
| \n | \n |
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
| \n | \n |
| \n | Ní léirítear san fhoirm | \n
| \n | \n |
| \n |
| \n
| \n | \n |
| \n | \n |
| \n | \n |
Mar a d'fhéadfá a bheith ag súil leis, is cásanna speisialta iad na cineálacha réimse samhail ForeignKey agus ManyTomanyField:
Léirítear ForeignKey le Django.Forms.ModelChoiceField, ar ChoiceField` is samhail QuerySet iad a roghanna.
Léirítear ManyTomanyField le Django.Forms.ModelMultipleChoiceField, ar MultipleChoiceField` is samhail QuerySet iad a roghanna.
Ina theannta sin, tá tréithe socraithe mar seo a leanas ag gach réimse foirme a ghintear
\nMá tá Blank=True sa réimse samhail, ansin socraítear riachtan go False ar an réimse foirme. Seachas sin, Required=True.
Socraítear lip réimse an fhoirme go verbose_name an réimse samhail, agus an chéad charachtar a chaipitliú.
Socraítear help_text réimse an fhoirme go help_text sa réimse samhail.
Má tá roghanna ``socraithe sa réimse samhail, ansin socraítear ``giuirléid réimse an fhoirme go Roghnaigh ``, agus roghanna a thagann ó `roghanna réimse an mhúnla. De ghnáth beidh an rogha bán a roghnaítear de réir réamhshocraithe san áireamh sna roghanna. Má tá an réimse ag teastáil, cuireann sé seo iallach ar an úsáideoir rogha a dhéanamh. Ní chuirfear an rogha bán san áireamh má tá blank=false ``sa réimse samhail agus luach sainráite ``default (roghnófar an luach default i dtosach ina ionad).
Faoi dheireadh, tabhair faoi deara gur féidir leat an réimse foirme a úsáidtear do réimse samhail ar leith a shárú. Féach `Sárú ar na réimsí réamhshocraithe `_ thíos.
\nSmaoinigh ar an tacar samhlacha seo:
\nfrom django.db import models\nfrom django.forms import ModelForm\n\nTITLE_CHOICES = {\n "MR": "Mr.",\n "MRS": "Mrs.",\n "MS": "Ms.",\n}\n\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n title = models.CharField(max_length=3, choices=TITLE_CHOICES)\n birth_date = models.DateField(blank=True, null=True)\n\n def __str__(self):\n return self.name\n\n\nclass Book(models.Model):\n name = models.CharField(max_length=100)\n authors = models.ManyToManyField(Author)\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title", "birth_date"]\n\n\nclass BookForm(ModelForm):\n class Meta:\n model = Book\n fields = ["name", "authors"]\nLeis na samhlacha seo, bheadh na fo-aicmí `ModelForm ``thuas comhionann go garbh leis seo (is é an t-aon difríocht ná an modh `save () `, a phléifimid i nóiméad. ):
\nfrom django import forms\n\n\nclass AuthorForm(forms.Form):\n name = forms.CharField(max_length=100)\n title = forms.CharField(\n max_length=3,\n widget=forms.Select(choices=TITLE_CHOICES),\n )\n birth_date = forms.DateField(required=False)\n\n\nclass BookForm(forms.Form):\n name = forms.CharField(max_length=100)\n authors = forms.ModelMultipleChoiceField(queryset=Author.objects.all())\nSamhlfhoirmeLink to this heading#Tá dhá phríomhchéim i gceist le “Modelform” a bhailíochtú:
\n<validating-objects>:ref: `An samhail samhail a bhailíochtú `
Just like normal form validation, model form validation is triggered implicitly\nwhen calling is_valid() or accessing the\nerrors attribute and explicitly when calling\nfull_clean(), although you will typically not use the latter method in\npractice.
Model validation is triggered from within the form validation step right\nafter the form's clean() method is called. First, the model's\nfull_clean() is called with\nvalidate_unique=False and validate_constraints=False, then the model's\nvalidate_unique() and\nvalidate_constraints() methods are called in\norder.
Is féidir leat an modh ``clean () ``a shárú ar fhoirm mhúnla chun bailíochtú breise a sholáthar ar an mbealach céanna is féidir leat ar ghnáthfhoirm.
\nBeidh tréith instance i gcás foirme samhail atá ceangailte le réad samhail a thugann rochtain dá mhodhanna ar an samhail shonrach sin.
Mar chuid den phróiseas bailíochtaithe, glaóidh ModelForm ``modh `glan () gach réimse ar do mhúnla a bhfuil réimse comhfhreagrach aige ar d'fhoirm. Má tá aon réimsí samhlacha eisiata agat, ní reáchtálfar bailíochtú ar na réimsí sin. Féach an doiciméadach:doc: `bailíochtú foirme' le haghaidh tuilleadh eolais fa</ref/forms/validation> oin gcaoi a n-oibríonn glanadh agus bailíochtú
The model's clean() method will be called before any uniqueness or\nconstraint checks are made. See Validating objects\nfor more information on the model's clean() hook.
error_messages an tsamhailLink to this heading#<django.db.models.Field.error_messages>Bíonn teachtaireachtaí earráide a shainmhínítear ag leibhéal:attr: réimse foirme <django.forms.Field.error_messages>`nó ag leibhéal:ref: `form Meta<modelforms-overriding-default-fields> tosaíocht i gcónaí thar na teachtaireachtaí earráide a shainmhínítear ag leibhéal:attr: `réimse samhail `.
\n<validating-objects>Ní úsáidtear teachtaireachtaí earráide a shainmhínítear ar:attr: réimsí samhail <django.db.models.Field.error_messages>`ach nuair a ardaítear an ``ValidationError` le linn na céime:ref: bailíochtú samhail agus nach sainmhínítear aon teachtaireachtaí earráide comhfhreagracha ag leibhéal na foirme.
\nIs féidir leat na teachtaireachtaí earráide ó NON_FIELD_ERRORS` arna ardú trí bhailíochtú samhail a chur trí:data: ~django.core.exceptions.non_field_errors eochair leis an bhfoclóir error_messages` de rang Meta` istigh ModelForm:
from django.core.exceptions import NON_FIELD_ERRORS\nfrom django.forms import ModelForm\n\n\nclass ArticleForm(ModelForm):\n class Meta:\n error_messages = {\n NON_FIELD_ERRORS: {\n "unique_together": "%(model_name)s's %(field_labels)s are not unique.",\n }\n }\nTá modh save () ``ag gach `ModelForm freisin. Cruthaíonn agus sábhálann an modh seo réad bunachar sonraí ó na sonraí atá ceangailte leis an bhfoirm. Is féidir le fo-aicme de ModelForm` glacadh le samhail atá ann cheana mar an argóint eochairfhocal instance; má sholáthraítear é seo, déanfaidh ``save () ``an cás sin a nuashonrú. Mura soláthraítear é, cruthóidh ``save () ``sampla nua den tsamhail shonraithe:
>>> from myapp.models import Article\n>>> from myapp.forms import ArticleForm\n\n# Create a form instance from POST data.\n>>> f = ArticleForm(request.POST)\n\n# Save a new Article object from the form's data.\n>>> new_article = f.save()\n\n# Create a form to edit an existing Article, but use\n# POST data to populate the form.\n>>> a = Article.objects.get(pk=1)\n>>> f = ArticleForm(request.POST, instance=a)\n>>> f.save()\nTabhair faoi deara mura bhfuil an fhoirm:ref: bailíochtaithe `, déanfar glaoch ar <validation-on-modelform>save () amhlaidh trí ``form.errors a sheiceáil. Ardófar Error lua mura ndéanann na sonraí san fhoirm bailíochtú - ie, má mheasóidh form.errors go True`.
Mura bhfuil réimse roghnach le feiceáil i sonraí na foirme, úsáideann an samhail mar thoradh air an réimse samhail: attr: ~django.db.models.field.default, má tá ceann ann, don réimse sin. <select multiple>Ní bhaineann an t-iompar seo le réimsí a úsáide:class: ~django.forms.checkboxInput, :class: ~django.forms.checkboxSelectMultiple, no:class: ~django.forms.selectMultiple (nó aon ghuirléid saincheaptha ciú:meth: ~django.forms.widget.value_omitted_fromdat_dat_dat_Filleann modh ``False` i gcónaí) ós rud é nach bhfuil bosca seiceála neamhsheiceáilte agus ```` neamhroghnaithe le feiceáil i sonraí aighneachta foirme HTML. Úsáid réimse nó giuirléid fhoirme saincheaptha má tá API á dhearadh agat agus má theastaíonn uait an t-iompar titim réamhshocraithe do réimse a úsáideann ceann de na giuirléidí seo.
\nGlacann an modh save () ``seo le hargóint eochairfhocal roghnach ``commit, a ghlacann le True nó False. Má ghlaonn tú ar save () ``le `Commit=false, ansin cuirfidh sé rud ar ais nár shábháiltear go fóill chuig an mbunachar sonraí. Sa chás seo, is fútsa atá sé glaoch ar save () ``ar an gcás samhail mar thoradh air. <ref-models-force-insert>Tá sé seo úsáideach más mian leat próiseáil saincheaptha a dhéanamh ar an réad sula ndéanann tú é a shábháil, nó más mian leat ceann de na roghanna speisialaithe: ref: `samhail sábhála `a úsáid. Is é ``commit True de réir réamhshocraithe.
Feictear fo-éifeacht eile a bhaineann le `Commit=false ``a úsáid nuair a bhíonn gaol go leor ag do mhúnla le samhail eile. Má tá gaol go leor ag do mhúnla agus má shonraíonn tú ``Commit=false ``nuair a shábhálann tú foirm, ní féidir le Django sonraí na foirme a shábháil láithreach don ghaol go leor. Tá sé seo toisc nach féidir sonraí go leor a shábháil mar shampla go dtí go mbeidh an cás sa bhunachar sonraí.
\nChun oibriú timpeall ar an bhfadhb seo, gach uair a shábhálann tú foirm ag baint úsáide as Commit=false`, cuireann Django modh save_m2m () ``le do fho-aicme ``ModelForm. Tar éis duit an cás a tháirgeann an fhoirm a shábháil de láimh, is féidir leat `save_m2m () ``a ghairm chun na sonraí foirme go leor a shábháil. Mar shampla:
# Create a form instance with POST data.\n>>> f = AuthorForm(request.POST)\n\n# Create, but don't save the new author instance.\n>>> new_author = f.save(commit=False)\n\n# Modify the author in some way.\n>>> new_author.some_field = "some_value"\n\n# Save the new instance.\n>>> new_author.save()\n\n# Now, save the many-to-many data for the form.\n>>> f.save_m2m()\nCalling save_m2m() is only required if you use save(commit=False).\nWhen you use a save() on a form, all data -- including many-to-many data --\nis saved without the need for any additional method calls. For example:
# Create a form instance with POST data.\n>>> a = Author()\n>>> f = AuthorForm(request.POST, instance=a)\n\n# Create and save the new author instance. There's no need to do anything else.\n>>> new_author = f.save()\nSeachas na modhanna save () ``agus `save_m2m ()`, oibríonn Modelform díreach ar an mbealach céanna le haon fhoirm foirme eile. Mar shampla, úsáidtear an modh is_valid () ``chun bailíocht a sheiceáil, úsáidtear an modh ``is_multipart () chun a chinneadh an gá uaslódáil comhad ilpháirteach ó fhoirm (agus dá bhrí sin an gcaithfear request.files a chur chuig an bhfoirm), srl. Féach: binding-uploaded-files le haghaidh tuilleadh faisnéise.
Moltar go láidir duit gach réimse a shocrú go sainráite ar chóir a chur in eagar sa fhoirm ag baint úsáide as an tréith fields. D'fhéadfadh fadhbanna slándála a bheith mar thoradh air go héasca nuair a cheadaíonn foirm gan choinne d'úsáideoir réimsí áirithe a shocrú, go háirithe nuair a chuirtear réimsí nua le samhail. Ag brath ar an gcaoi a ndéantar an fhoirm a léiriú, b'fhéidir nach mbeadh an fhadhb le feiceáil fiú ar an leathanach
The alternative approach would be to include all fields automatically, or\nremove only some. This fundamental approach is known to be much less secure and\nhas led to serious exploits on major websites (e.g. GitHub\n).
\nTá dhá aicearra ar fáil, áfach, do chásanna inar féidir leat a ráthú nach mbaineann na hábhair imní slándála seo leat:
\nSocraigh an tréith fields don luach speisialta `__all__' chun a léiriú gur chóir gach réimse sa tsamhail a úsáid. Mar shampla:
from django.forms import ModelForm\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = "__all__"\nSocraigh tréith eisiam d'aicme Meta istigh an ModelForm` chuig liosta réimsí atá le eisiamh ón bhfoirm.
Mar shampla:
\nclass PartialAuthorForm(ModelForm):\n class Meta:\n model = Author\n exclude = ["title"]\nÓs rud é go bhfuil na 3 réimse ainm, teideal ``agus ``dáta_bhreith` sa tsamhail Údar, beidh na réimsí ainm agus dáta_bhreith` i láthair ar an bhfoirm.
Má úsáidtear ceachtar díobh seo, is é an t-ord a bheidh na réimsí le feiceáil san fhoirm an t-ord a shainmhínítear na réimsí sa tsamhail, agus cásanna ``ManyTomanyField` le feiceáil go deireanach.
\nIna theannta sin, cuireann Django an riail seo a leanas i bhfeidhm: má shocraíonn tú Editable=False ar an réimse samhail, ní chuimseoidh an réimse sin aon fhoirme a cruthaíodh ón tsamhail trí ModelForm `.
Is réamhshocruithe ciallmhar iad na cineálacha réimse réamhshocraithe, mar a thuairiscítear sa tábla Cineálacha réimse `_ thuas. Má tá ``Datefield` agat i do mhúnla, is dócha gur mhaith leat é sin a léiriú mar Datefield i do fhoirm. Ach tugann ``ModelForm ``an solúbthacht duit an réimse foirme a athrú do mhúnla ar leith.
Chun giuirléid saincheaptha do réimse a shonrú, bain úsáid as an tréith giuirléidí ``den aicme ``Meta istigh. Ba chóir go mbeadh sé seo ina fhoclóir a mhapáil ainmneacha réimse chuig ranganna nó cásanna
<textarea><input type="text">Mar shampla, más mian leat an Charfield don tréith ainm ``de ``Údar a léiriú le`` ```` ```` ```` in ionad a réamhshocraithe ```` `, is féidir leat giuirléid an réimse a shárú:
from django.forms import ModelForm, Textarea\nfrom myapp.models import Author\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title", "birth_date"]\n widgets = {\n "name": Textarea(attrs={"cols": 80, "rows": 20}),\n }\nGlacann an foclóir giuirléidí ``le ceachtar cásanna giuirléid (m.sh., ``Textarea (...)) nó ranganna (m.sh., Textarea). Tabhair faoi deara go ndéantar neamhaird ar an bhfoclóir ``giuirlisí ``do réimse samhail le tréith ``roghnaí` neamh-folamh. Sa chás seo, ní mór duit an réimse foirme a shárú chun giuirléid dhifriúil a úsáid.
Ar an gcaoi chéanna, is féidir leat tréithe labels, help_texts` agus error_messages sa rang Meta` istigh a shonrú más mian leat réimse a shaincheapadh tuilleadh.
Mar shampla más mian leat foclaíocht na teaghráin uile atá os comhair an úsáideora a shaincheapadh don réimse ``ainm ``:
\nfrom django.utils.translation import gettext_lazy as _\n\n\nclass AuthorForm(ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title", "birth_date"]\n labels = {\n "name": _("Writer"),\n }\n help_texts = {\n "name": _("Some useful help text."),\n }\n error_messages = {\n "name": {\n "max_length": _("This writer's name is too long."),\n },\n }\nIs féidir leat field_classes nó formfield_callback a shonrú freisin chun an cineál réimsí a shaincheapadh ag an bhfoirm.
Mar shampla, dá dteastaíonn uait MyslugFormField` a úsáid don réimse slug, d'fhéadfá an méid seo a leanas a dhéanamh:
from django.forms import ModelForm\nfrom myapp.models import Article\n\n\nclass ArticleForm(ModelForm):\n class Meta:\n model = Article\n fields = ["pub_date", "headline", "content", "reporter", "slug"]\n field_classes = {\n "slug": MySlugFormField,\n }\nnó:
\nfrom django.forms import ModelForm\nfrom myapp.models import Article\n\n\ndef formfield_for_dbfield(db_field, **kwargs):\n if db_field.name == "slug":\n return MySlugFormField()\n return db_field.formfield(**kwargs)\n\n\nclass ArticleForm(ModelForm):\n class Meta:\n model = Article\n fields = ["pub_date", "headline", "content", "reporter", "slug"]\n formfield_callback = formfield_for_dbfield\nFaoi dheireadh, más mian leat smacht iomlán ar réimse - lena n-áirítear a chineál, bailíochtóirí, riachtanacha, srl. - is féidir leat é seo a dhéanamh trí réimsí a shonrú go dearbhaithe mar a dhéanfá i ``Foirm 'rialta.
\nMás mian leat bailíochtóirí réimse a shonrú, is féidir leat é sin a dhéanamh tríd an réimse a shainiú go dearbhaithe agus a pharaiméadar ``bailíodóirí ``a shocrú:
\nfrom django.forms import CharField, ModelForm\nfrom myapp.models import Article\n\n\nclass ArticleForm(ModelForm):\n slug = CharField(validators=[validate_slug])\n\n class Meta:\n model = Article\n fields = ["pub_date", "headline", "content", "reporter", "slug"]\nDe réir réamhshocraithe, ní dhéanfaidh na réimsí i ModelForm ``a gcuid sonraí a logánú. Chun logánú do réimsí a chumasú, is féidir leat an tréith ``localized_fields` a úsáid ar an rang Meta.
>>> from django.forms import ModelForm\n>>> from myapp.models import Author\n>>> class AuthorForm(ModelForm):\n... class Meta:\n... model = Author\n... localized_fields = ['birth_date']\nMá shocraítear localized_fields go dtí an luach speisialta '__all__', beidh gach réimse logánaithe.
As with basic forms, you can extend and reuse ModelForm classes by\ninheriting them. This is useful if you need to declare extra fields or extra\nmethods on a parent class for use in a number of forms derived from models.\nFor example, using the previous ArticleForm class:
>>> class EnhancedArticleForm(ArticleForm):\n... def clean_pub_date(self): ...\n...\nCruthaíonn sé seo foirm a iompraíonn go cosúil le ArticleForm, ach amháin go bhfuil roinnt bailíochtaithe agus glantacháin bhreise ann don réimse pub_date.
Féadfaidh tú rang istigh Meta an tuismitheora a fho-aicmiú freisin más mian leat na liostaí Meta.Fields nó Meta.Exclude` a athrú:
>>> class RestrictedArticleForm(EnhancedArticleForm):\n... class Meta(ArticleForm.Meta):\n... exclude = ["body"]\n...\nCuireann sé seo an modh breise leis an EnhancedArticleForm agus athraíonn sé an ArticleForm.meta` bunaidh chun réimse amháin a bhaint.
Tá cúpla rud le tabhairt faoi deara, áfach.
\nTá feidhm ag gnáthrialacha um réiteach ainm Python. Má tá bunaicmí iolracha agat a dhearbhíonn rang istigh Meta`, ní úsáidfear ach an chéad cheann. Ciallaíonn sé seo ``Meta an linbh, má tá sé ann, ar shlí eile Meta an chéad thuismitheora, srl.
Is féidir oidhreacht a dhéanamh ó Form ``agus `ModelForm araon ag an am céanna, áfach, ní mór duit a chinntiú go bhfuil ``ModelForm ``le feiceáil ar dtús sa MRO. Tá sé seo toisc go mbraitheann na ranganna seo ar mhithaiclasanna éagsúla agus ní féidir ach meiteachlas amháin a bheith ag rang.
Is féidir Field a bhaint go dearbhaithe ó rang tuismitheoirí tríd an ainm a shocrú mar ``None ``ar an bhfo-aicme.
Ní féidir leat an teicníc seo a úsáid ach chun diúltú as réimse a shainmhíníonn go dearbhaithe ag rang tuismitheoirí; ní chuirfidh sé cosc ar an meiteachlas ModelForm réimse réimse réamhshocraithe a ghiniúint. Chun diúltú ó réimsí réamhshocraithe, féach:ref: modelforms-selecting-fields.
Mar is amhlaidh le foirmeacha rialta, is féidir sonraí tosaigh do fhoirmeacha a shonrú trí pharaiméadar tosaithe a shonrú agus an fhoirm á chur i bhfeidhm. Déanfaidh luachanna tosaigh a chuirtear ar fáil ar an mbealach seo athsháraíonn luachanna tosaigh ón réimse foirme agus luachanna ó shampla samhail Mar shampla:
>>> article = Article.objects.get(pk=1)\n>>> article.headline\n'My headline'\n>>> form = ArticleForm(initial={"headline": "Initial headline"}, instance=article)\n>>> form["headline"].value()\n'Initial headline'\nIs féidir leat foirmeacha a chruthú ó mhúnla ar leith ag baint úsáide as an bhfeidhm neamhspleách: func: ~django.forms.models.modelform_factory, in ionad sainmhíniú ranga a úsáid. D'fhéadfadh sé seo a bheith níos áisiúla mura bhfuil go leor saincheaptha agat le déanamh:
\n>>> from django.forms import modelform_factory\n>>> from myapp.models import Book\n>>> BookForm = modelform_factory(Book, fields=["author", "title"])\nIs féidir é seo a úsáid freisin chun modhnuithe a dhéanamh ar fhoirmeacha atá ann cheana, mar shampla trí na giuirléidí atá le húsáid le haghaidh réimse ar leith a shonrú:
\n>>> from django.forms import Textarea\n>>> Form = modelform_factory(Book, form=BookForm, widgets={"title": Textarea()})\nIs féidir na réimsí atá le cur san áireamh a shonrú ag baint úsáide as na hargóintí eochairfhocal réimsí ``agus ``eisiam, nó na tréithe comhfhreagracha ar an aicme Meta istigh Modelform. Féach an doiciméadú ModelForm:ref: modelforms-selecting-fields le do thoil.
... nó logánú a chumasú do réimsí ar leith:
\n>>> Form = modelform_factory(Author, form=AuthorForm, localized_fields=["birth_date"])\nCosúil le: doc: foirmeacha rialta, soláthraíonn D</topics/forms/formsets> jango cúpla rang foirm fheabhsaithe chun oibriú le samhlacha Django a dhéanamh níos áisiúla. Déanaimis an tsamhail ``Údar` a athúsáid as thuas:
\n>>> from django.forms import modelformset_factory\n>>> from myapp.models import Author\n>>> AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])\nAg baint úsáide as `réimsí ``cuirtear srian ar an bhfoirmshraith chun na réimsí a thugtar a úsáid amháin. De rogha air sin, is féidir leat cur chuige “diúltú amach” a ghlacadh, ag sonrú cé na réimsí atá le eisiamh:
\n>>> AuthorFormSet = modelformset_factory(Author, exclude=["birth_date"])\nCruthóidh sé seo tacar foirme atá in ann oibriú leis na sonraí a bhaineann leis an tsamhail ``Údar`. Oibríonn sé díreach cosúil le foirmshraith rialta:
\n>>> formset = AuthorFormSet()\n>>> print(formset)\n<input type="hidden" name="form-TOTAL_FORMS" value="1" id="id_form-TOTAL_FORMS"><input type="hidden" name="form-INITIAL_FORMS" value="0" id="id_form-INITIAL_FORMS"><input type="hidden" name="form-MIN_NUM_FORMS" value="0" id="id_form-MIN_NUM_FORMS"><input type="hidden" name="form-MAX_NUM_FORMS" value="1000" id="id_form-MAX_NUM_FORMS">\n<div><label for="id_form-0-name">Name:</label><input id="id_form-0-name" type="text" name="form-0-name" maxlength="100"></div>\n<div><label for="id_form-0-title">Title:</label><select name="form-0-title" id="id_form-0-title">\n<option value="" selected>---------</option>\n<option value="MR">Mr.</option>\n<option value="MRS">Mrs.</option>\n<option value="MS">Ms.</option>\n</select><input type="hidden" name="form-0-id" id="id_form-0-id"></div>\nDe réir réamhshocraithe, nuair a chruthaíonn tú tacar foirme ó mhúnla, úsáidfidh an tacar foirme tacar ceisteanna a chuimsíonn gach rud sa tsamhail (m.sh., Author.Objects.all () `). Is féidir leat an t-iompar seo a shárú tríd an argóint queryset a úsáid:
>>> formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith="O"))\nDe rogha air sin, is féidir leat fo-aicme a chruthú a leagann self.queryset i __init__:
from django.forms import BaseModelFormSet\nfrom myapp.models import Author\n\n\nclass BaseAuthorFormSet(BaseModelFormSet):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.queryset = Author.objects.filter(name__startswith="O")\nAnsin, cuir do rang ``BaseAuthorFormSet ``chuig feidhm an mhonarcha:
\n>>> AuthorFormSet = modelformset_factory(\n... Author, fields=["name", "title"], formset=BaseAuthorFormSet\n... )\nMás mian leat tacar foirme a thabhairt ar ais nach n-áirítear * aon chás den tsamhail atá ann cheana féin, is féidir leat QuerySet folamh a shonrú:
\n>>> AuthorFormSet(queryset=Author.objects.none())\nDe réir réamhshocraithe, nuair a úsáideann tú modelformset_factory, cruthófar foirm mhúnla ag baint úsáidea:func: ~django.forms.models.modelform_factory. Go minic, is féidir go mbeadh sé úsáideach foirm mhúnla saincheaptha a shonrú. Mar shampla, is féidir leat foirm mhúnla saincheaptha a chruthú a bhfuil bailíochtú saincheaptha aige:
class AuthorForm(forms.ModelForm):\n class Meta:\n model = Author\n fields = ["name", "title"]\n\n def clean_name(self):\n # custom validation for the name field\n ...\nAnsin, cuir d'fhoirm mhúnla chuig feidhm an mhonarcha:
\nAuthorFormSet = modelformset_factory(Author, form=AuthorForm)\nNí gá i gcónaí foirm mhúnla saincheaptha a shainiú. Tá roinnt argóintí ag an bhfeidhm modelformset_factory` a chuirtear tríd chuig modelform_factory`, a bhfuil cur síos orthu thíos.
\ngiuirléidíLink to this heading#Ag baint úsáide as an paraiméadar giuirlisí ``, is féidir leat foclóir luachanna a shonrú chun rang giuirléid ``ModelForm a shaincheapadh do réimse áirithe. Oibríonn sé seo ar an mbealach céanna agus a oibríonn an foclóir giuirléid' ar an aicme ``Meta istigh de ModelForm `:
>>> AuthorFormSet = modelformset_factory(\n... Author,\n... fields=["name", "title"],\n... widgets={"name": Textarea(attrs={"cols": 80, "rows": 20})},\n... )\nlocalized_fieldsLink to this heading#Ag baint úsáide as an paraiméadar localized_fields, is féidir leat logánú a chumasú do réimsí san fhoirm.
>>> AuthorFormSet = modelformset_factory(\n... Author, fields=['name', 'title', 'birth_date'],\n... localized_fields=['birth_date'])\nMá shocraítear localized_fields go dtí an luach speisialta '__all__', beidh gach réimse logánaithe.
Mar is amhlaidh le foirmeacha rialta, is féidir: ref: sonraí tosaigh a shonrú <formsets-initial-data>do fhoirmeacha sa tacar foirmeacha trí pharaiméadar ``initial` a shonrú agus an aicme foirmeacha samhail a chuirtear ar ais ag: func: ~django.forms.models.modelformset_factory. Mar sin féin, le foirmeacha samhlacha, ní bhaineann na luachanna tosaigh ach le foirmeacha breise, iad siúd nach bhfuil ceangailte le samhail shampla atá ann cheana. Má sháraíonn fad tosaithe líon na bhfoirmeacha breise, déantar neamhaird ar na sonraí tosaigh iomarcacha. Mura n-athraíonn an t-úsáideoir na foirmeacha breise le sonraí tosaigh, ní dhéanfar iad a bhailíochtú ná a shábháil.
Mar is amhlaidh le ModelForm`, is féidir leat na sonraí a shábháil mar réad samhail. Déantar é seo le modh ``save () ``an tsraith foirmeacha:
\n# Create a formset instance with POST data.\n>>> formset = AuthorFormSet(request.POST)\n\n# Assuming all is valid, save the data.\n>>> instances = formset.save()\nTugann an modh `save () ``ar ais na cásanna a shábháiltear chuig an mbunachar sonraí. Mura n-athraigh sonraí cás ar leith sna sonraí ceangailte, ní shábháilfear an cás sa bhunachar sonraí agus ní chuirfear san áireamh sa luach tuairisceáin (``instancs', sa sampla thuas).
\nWhen fields are missing from the form (for example because they have been\nexcluded), these fields will not be set by the save() method. You can find\nmore information about this restriction, which also holds for regular\nmodel forms, in Selecting the fields to use.
Pas Commit=False` chun na cásanna samhail neamhshábháilte a thabhairt ar ais:
\n# don't save to the database\n>>> instances = formset.save(commit=False)\n>>> for instance in instances:\n... # do something with instance\n... instance.save()\n...\nTugann sé seo an cumas duit sonraí a cheangal leis na cásanna sula ndéantar iad a shábháil leis an mbunachar sonraí. Má tá ManyTomanyField sa tacar foirme, beidh ort glaoch ar `formset.save_m2m () ``chun a chinntiú go sábhálfar na caidrimh go leor i gceart.
Tar éis glaoch ar ``save () ``,, beidh trí thréith nua ag do shraith foirmeacha samhail ina bhfuil athruithe an fhoirmshraith:
\nMar is amhlaidh le foirmeacha rialta, is féidir leat na paraiméadair max_num agus extra a úsáid to:func: ~django.forms.models.modelformset_factory chun líon na bhfoirmeacha breise a thaispeántar a theorannú.
Ní chuireann max_num cosc ar rudaí atá ann cheana a thaispeáint:
>>> Author.objects.order_by("name")\n<QuerySet [<Author: Charles Baudelaire>, <Author: Paul Verlaine>, <Author: Walt Whitman>]>\n\n>>> AuthorFormSet = modelformset_factory(Author, fields=["name"], max_num=1)\n>>> formset = AuthorFormSet(queryset=Author.objects.order_by("name"))\n>>> [x.name for x in formset.get_queryset()]\n['Charles Baudelaire', 'Paul Verlaine', 'Walt Whitman']\n<understanding-the-managementform>Chomh maith leis sin, ní choisceann extra=0 cásanna samhail nua a chruthú mar is féidir leat: ref: foirmeacha breise a chur le JavaScript `nó seol sonraí POST breise. Féach: ref: `model-formsets-edit-only maidir le conas é seo a dhéanamh.
Má tá luach max_num níos mó ná líon na rudaí gaolmhara atá ann cheana, cuirfear foirmeacha bán breise suas le extra leis an tacar foirmeacha, fad nach mbeidh líon iomlán na bhfoirmeacha níos mó ná max_num:
>>> AuthorFormSet = modelformset_factory(Author, fields=["name"], max_num=4, extra=2)\n>>> formset = AuthorFormSet(queryset=Author.objects.order_by("name"))\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-name">Name:</label><input id="id_form-0-name" type="text" name="form-0-name" value="Charles Baudelaire" maxlength="100"><input type="hidden" name="form-0-id" value="1" id="id_form-0-id"></div>\n<div><label for="id_form-1-name">Name:</label><input id="id_form-1-name" type="text" name="form-1-name" value="Paul Verlaine" maxlength="100"><input type="hidden" name="form-1-id" value="3" id="id_form-1-id"></div>\n<div><label for="id_form-2-name">Name:</label><input id="id_form-2-name" type="text" name="form-2-name" value="Walt Whitman" maxlength="100"><input type="hidden" name="form-2-id" value="2" id="id_form-2-id"></div>\n<div><label for="id_form-3-name">Name:</label><input id="id_form-3-name" type="text" name="form-3-name" maxlength="100"><input type="hidden" name="form-3-id" id="id_form-3-id"></div>\nCuireann luach max_num de None (an réamhshocrú) teorainn ard ar líon na bhfoirmeacha a thaispeántar (1000). Go praiticiúil tá sé seo coibhéiseach le haon teorainn.
Ag baint úsáide as an paraiméadar edit_only, is féidir leat cosc a chur ar chruthú aon rudaí nua:
\n>>> AuthorFormSet = modelformset_factory(\n... Author,\n... fields=["name", "title"],\n... edit_only=True,\n... )\nAnseo, ní dhéanfaidh an tacar foirme ach cásanna ``Údar` atá ann cheana a chur in eagar. Ní chruthófar nó a chur in eagar aon rudaí eile.
\nTá foirmeacha samhlacha an-chosúil le foirmeacha. Ligean le rá gur mhaith linn tacar foirme a chur i láthair chun cásanna samhail ``Údar` a chur in eagar:
\nfrom django.forms import modelformset_factory\nfrom django.shortcuts import render\nfrom myapp.models import Author\n\n\ndef manage_authors(request):\n AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])\n if request.method == "POST":\n formset = AuthorFormSet(request.POST, request.FILES)\n if formset.is_valid():\n formset.save()\n # do something.\n else:\n formset = AuthorFormSet()\n return render(request, "manage_authors.html", {"formset": formset})\nMar a fheiceann tú, níl loighic radharc tacar foirmeacha samhail difriúil go mór ná loighic thacar foirmeacha “gnáth”. Is é an t-aon difríocht ná go nglaoimid ar ``formset.save () ``chun na sonraí a shábháil sa bhunachar sonraí. (Rinneadh cur síos air seo thuas, in:ref: saving-objects-in-the-formset.)
\nclean () ``ar `ModelFormSetLink to this heading#Just like with a ModelForm, by default the clean() method of a\nModelFormSet will validate that none of the items in the formset violate\nthe unique constraints on your model (either unique, unique_together or\nunique_for_date|month|year). If you want to override the clean() method\non a ModelFormSet and maintain this validation, you must call the parent\nclass's clean method:
from django.forms import BaseModelFormSet\n\n\nclass MyModelFormSet(BaseModelFormSet):\n def clean(self):\n super().clean()\n # example custom validation across forms in the formset\n for form in self.forms:\n # your custom formset validation\n ...\nTabhair faoi deara freisin faoin am a shroicheann tú an chéim seo, go bhfuil cásanna samhail aonair cruthaithe cheana féin do gach Foirm ``. Ní leor luach a mhodhnú i `form.cleaned_data ``chun dul i bhfeidhm ar an luach sábháltha. Más mian leat luach a mhodhnú in `ModelFormSet.clean () ``ní mór duit ``form.instance a mhodhnú:
from django.forms import BaseModelFormSet\n\n\nclass MyModelFormSet(BaseModelFormSet):\n def clean(self):\n super().clean()\n\n for form in self.forms:\n name = form.cleaned_data["name"].upper()\n form.cleaned_data["name"] = name\n # update the instance value.\n form.instance.name = name\nMar a dúradh níos luaithe, is féidir leat an tacar ceisteanna réamhshocraithe a úsáideann an tacar foirmeacha samhail a shárú:
\nfrom django.forms import modelformset_factory\nfrom django.shortcuts import render\nfrom myapp.models import Author\n\n\ndef manage_authors(request):\n AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])\n queryset = Author.objects.filter(name__startswith="O")\n if request.method == "POST":\n formset = AuthorFormSet(\n request.POST,\n request.FILES,\n queryset=queryset,\n )\n if formset.is_valid():\n formset.save()\n # Do something.\n else:\n formset = AuthorFormSet(queryset=queryset)\n return render(request, "manage_authors.html", {"formset": formset})\nTabhair faoi deara go rachaimid an argóint queryset sna cásanna POST ``agus `GET sa sampla seo.
Tá trí bhealach ann chun tacar foirme a rinneadh i dteimpléad Django.
\nAr dtús, is féidir leat ligean don fhoirmset an chuid is mó den obair a dhéanamh:
\n<form method="post">\n {{ formset }}\n</form>\nAr an dara dul síos, is féidir leat an tacar foirme a rinneadh de láimh, ach lig don fhoirm déileáil leis féin:
\n<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {{ form }}\n {% endfor %}\n</form>\nNuair a dhéanann tú na foirmeacha a rinneadh de láimh tú féin, bí cinnte an fhoirm bhainistíochta a thabhairt mar a thaispeán <understanding-the-managementform>Féach an:ref: `doiciméadú foirm bhainistíochta `.
\nSa tríú háit, is féidir leat gach réimse a rinneadh de láimh
\n<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {% for field in form %}\n {{ field.label_tag }} {{ field }}\n {% endfor %}\n {% endfor %}\n</form>\nMá roghnaíonn tú an tríú modh seo a úsáid agus mura ndéanann tú athrá thar na réimsí le lúb {% for%}, beidh ort an príomhréimse eochair a rinneadh. Mar shampla, má bhí réimsí ainm ``agus ``aois á ndéanamh agat de mhúnla:
<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n {{ form.id }}\n <ul>\n <li>{{ form.name }}</li>\n <li>{{ form.age }}</li>\n </ul>\n {% endfor %}\n</form>\nTabhair faoi deara conas is gá dúinn {{form.id}} a rinneadh go sainráite. Cinntíonn sé seo go n-oibreoidh an tacar foirme samhail, sa chás POST `, i gceart. (Glacann an sampla seo le príomh-eochair darb ainm id`. Má tá d'eochair phríomhúil féin sainmhínithe go sainráite agat nach dtugtar id, déan cinnte go ndéantar é a léiriú.)
Is ciseal beag tearbhaithe é foirmeacha inlíne ar bharr foirmeacha samhlacha. Déanann siad seo an cás oibriú le rudaí gaolmhara trí eochair eachtrach a shimpliú. Cuir i gcás go bhfuil an dá mhúnla seo agat:
\nfrom django.db import models\n\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n\n\nclass Book(models.Model):\n author = models.ForeignKey(Author, on_delete=models.CASCADE)\n title = models.CharField(max_length=100)\nMás mian leat tacar foirme a chruthú a ligeann duit leabhair a bhaineann le húdar áirithe a chur in eagar, d'fhéadfá seo a dhéanamh:
\n>>> from django.forms import inlineformset_factory\n>>> BookFormSet = inlineformset_factory(Author, Book, fields=["title"])\n>>> author = Author.objects.get(name="Mike Royko")\n>>> formset = BookFormSet(instance=author)\n<formset-prefix><model name>``BookformSet```'s:ref: réimír `is é ```book_set'` (_set). Má tá a: attr: ~Django.db.Models.ForeignKey.Related_Name de Book go Author `,`` Book``, úsáidtear é sin ina ionad.
inlineFormSetLink to this heading#Agus modhanna a shárú ar InlineFormSet`, ba cheart duit fo-aicme: ~Models.BaseLineFormSet seachas: ~Models.BaseModelFormSet seachas: ~Models.BaseModelFormSet.
\nMar shampla, más mian leat ``clean () ``a shárú:
\nfrom django.forms import BaseInlineFormSet\n\n\nclass CustomInlineFormSet(BaseInlineFormSet):\n def clean(self):\n super().clean()\n # example custom validation across forms in the formset\n for form in self.forms:\n # your custom formset validation\n ...\nFéach freis:ref: model-formsets-overriding-clean.
\nAnsin nuair a chruthaíonn tú do shraith foirme inlíne, pas isteach san argóint roghnach formset:
>>> from django.forms import inlineformset_factory\n>>> BookFormSet = inlineformset_factory(\n... Author, Book, fields=["title"], formset=CustomInlineFormSet\n... )\n>>> author = Author.objects.get(name="Mike Royko")\n>>> formset = BookFormSet(instance=author)\nMá tá níos mó ná eochair eachtrach amháin don tsamhail chéanna i do mhúnla, beidh ort an débhríocht a réiteach de láimh ag baint úsáide as fk_name`. Mar shampla, smaoinigh ar an tsamhail seo a leanas:
\nclass Friendship(models.Model):\n from_friend = models.ForeignKey(\n Friend,\n on_delete=models.CASCADE,\n related_name="from_friends",\n )\n to_friend = models.ForeignKey(\n Friend,\n on_delete=models.CASCADE,\n related_name="friends",\n )\n length_in_months = models.IntegerField()\nChun é seo a réiteach, is féidir leat fk_name a úsáid to:func: ~django.forms.models.inlineformset_factory:
>>> FriendshipFormSet = inlineformset_factory(\n... Friend, Friendship, fk_name="from_friend", fields=["to_friend", "length_in_months"]\n... )\nB'fhéidir gur mhaith leat radharc a sholáthar a ligeann d'úsáideoir rudaí gaolmhara samhail a chur in eagar. Seo mar is féidir leat é sin a dhéanamh:
\ndef manage_books(request, author_id):\n author = Author.objects.get(pk=author_id)\n BookInlineFormSet = inlineformset_factory(Author, Book, fields=["title"])\n if request.method == "POST":\n formset = BookInlineFormSet(request.POST, request.FILES, instance=author)\n if formset.is_valid():\n formset.save()\n # Do something. Should generally end with a redirect. For example:\n return HttpResponseRedirect(author.get_absolute_url())\n else:\n formset = BookInlineFormSet(instance=author)\n return render(request, "manage_books.html", {"formset": formset})\nTabhair faoi deara conas a théann muid instance sna cásanna POST ``agus `GET araon.
Úsáideann `inlineformset_factory modelformset_factory agus cuireann an chuid is mó dá argóintí chuig modelformset_factory`. Ciallaíonn sé seo gur féidir leat an paraiméadar widgets a úsáid ar an mbealach céanna agus é a chur chuig modelformset_factory`. Féach `Giuirléidí a shonrú le húsáid san fhoirm le giuirléidí `_ thuas.