Membuat formulir dari model¶
ModelForm
¶
If you're building a database-driven app, chances are you'll have forms that
map closely to Django models. For instance, you might have a BlogComment
model, and you want to create a form that lets people submit comments. In this
case, it would be redundant to define the field types in your form, because
you've already defined the fields in your model.
For this reason, Django provides a helper class that lets you create a Form
class from a Django model.
Sebagai contoh:
>>> from django.forms import ModelForm
>>> from myapp.models import Article
# Create the form class.
>>> class ArticleForm(ModelForm):
... class Meta:
... model = Article
... fields = ['pub_date', 'headline', 'content', 'reporter']
# Creating a form to add an article.
>>> form = ArticleForm()
# Creating a form to change an existing article.
>>> article = Article.objects.get(pk=1)
>>> form = ArticleForm(instance=article)
Jenis bidang¶
The generated Form
class will have a form field for every model field
specified, in the order specified in the fields
attribute.
Setiap bidang model mempunyai biadng formulir awalan sesuai. Sebagai contoh, sebuah CharField
pada sebuah model adalah diwakili sebagai CharField
pada formulir. Sebuah model ManyToManyField
diwakilkan sebagai sebuah MultipleChoiceField
. Ini adalah daftar penuh dari perubahan:
Bidang Model | Bidang Formulir |
---|---|
AutoField |
Tidak muncul di formulir |
BigAutoField |
Tidak muncul di formulir |
BigIntegerField |
IntegerField dengan min_value disetel ke -9223372036854775808 dan max_value disetel ke 9223372036854775807. |
BooleanField |
BooleanField |
CharField |
CharField with
max_length set to the model field's
max_length and
empty_value
set to None if null=True . |
DateField |
DateField |
DateTimeField |
DateTimeField |
DecimalField |
DecimalField |
EmailField |
EmailField |
FileField |
FileField |
FilePathField |
FilePathField |
FloatField |
FloatField |
ForeignKey |
ModelChoiceField (lihat dibawah) |
ImageField |
ImageField |
IntegerField |
IntegerField |
IPAddressField |
IPAddressField |
GenericIPAddressField |
GenericIPAddressField |
ManyToManyField |
ModelMultipleChoiceField (lihat dibawah) |
NullBooleanField |
NullBooleanField |
PositiveIntegerField |
IntegerField |
PositiveSmallIntegerField |
IntegerField |
SlugField |
SlugField |
SmallIntegerField |
IntegerField |
TextField |
CharField dengan widget=forms.Textarea |
TimeField |
TimeField |
URLField |
URLField |
As you might expect, the ForeignKey
and ManyToManyField
model field
types are special cases:
ForeignKey
diwakili olehdjango.forms.ModelChoiceField
, yaitu sebuahChoiceField
yang pilihan-pilihan adalah sebuah modelQuerySet
.ManyToManyField
diwakili olehdjango.forms.ModelMultipleChoiceField
, dimanaMultipleChoiceField
yang pilihan-pilihannya adalah sebuah modelQuerySet
.
Sebagai tambahan, setiap bidang formulir dibangkitkan mempunyai atribut disetel sebagai berikut:
- Jika bidang model mempunyai
blank=True
, makarequired
disetel keFalse
pada bidang formulir. Sebaliknyarequired=True
. - The form field's
label
is set to theverbose_name
of the model field, with the first character capitalized. - The form field's
help_text
is set to thehelp_text
of the model field. - If the model field has
choices
set, then the form field'swidget
will be set toSelect
, with choices coming from the model field'schoices
. The choices will normally include the blank choice which is selected by default. If the field is required, this forces the user to make a selection. The blank choice will not be included if the model field hasblank=False
and an explicitdefault
value (thedefault
value will be initially selected instead).
Finally, note that you can override the form field used for a given model field. See Overriding the default fields below.
Sebuah contoh penuh¶
Pertimbangkan kumpulan model ini:
from django.db import models
from django.forms import ModelForm
TITLE_CHOICES = (
('MR', 'Mr.'),
('MRS', 'Mrs.'),
('MS', 'Ms.'),
)
class Author(models.Model):
name = models.CharField(max_length=100)
title = models.CharField(max_length=3, choices=TITLE_CHOICES)
birth_date = models.DateField(blank=True, null=True)
def __str__(self):
return self.name
class Book(models.Model):
name = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
class AuthorForm(ModelForm):
class Meta:
model = Author
fields = ['name', 'title', 'birth_date']
class BookForm(ModelForm):
class Meta:
model = Book
fields = ['name', 'authors']
With these models, the ModelForm
subclasses above would be roughly
equivalent to this (the only difference being the save()
method, which
we'll discuss in a moment.):
from django import forms
class AuthorForm(forms.Form):
name = forms.CharField(max_length=100)
title = forms.CharField(
max_length=3,
widget=forms.Select(choices=TITLE_CHOICES),
)
birth_date = forms.DateField(required=False)
class BookForm(forms.Form):
name = forms.CharField(max_length=100)
authors = forms.ModelMultipleChoiceField(queryset=Author.objects.all())
Pengesahan pada sebuah ModelForm
¶
Terdapat dua langkah utama dilibatkan dalam ModelForm
:
- Validating the form
- Validating the model instance 1
Just like normal form validation, model form validation is triggered implicitly
when calling is_valid()
or accessing the
errors
attribute and explicitly when calling
full_clean()
, although you will typically not use the latter method in
practice.
Model
validation (Model.full_clean()
) is triggered from within the form
validation step, right after the form's clean()
method is called.
Peringatan
The cleaning process modifies the model instance passed to the
ModelForm
constructor in various ways. For instance, any date fields on
the model are converted into actual date objects. Failed validation may
leave the underlying model instance in an inconsistent state and therefore
it's not recommended to reuse it.
Menimpa metode clean()¶
You can override the clean()
method on a model form to provide additional
validation in the same way you can on a normal form.
A model form instance attached to a model object will contain an instance
attribute that gives its methods access to that specific model instance.
Peringatan
The ModelForm.clean()
method sets a flag that makes the model
validation step validate the uniqueness of model
fields that are marked as unique
, unique_together
or
unique_for_date|month|year
.
If you would like to override the clean()
method and maintain this
validation, you must call the parent class's clean()
method.
Interaksi dengan pengecekan model¶
Sebagai bagian dari pengolahan pengesahan. ModelForm
akan memanggil metode clean()
untuk setiap bidang pada model anda yang mempunyai bidang sesuai pada formulir anda. Jika anda telah tidak menyertakan bidang model apapun, pengesahan tidak akan berjalan pada bidang-bidang tersebut. Lihat dokumentasi form validation 1 untuk lebih pada bagimana bidang membersihkan dan pengesahan bekerja.
Metode clean()
model akan dipanggil sebelum pemeriksanaan keunikan apapun dibuat. Lihat Validating objects untuk informasi lebih pada tautan clean()
model.
Pertimbangan mengenai error_messages
model¶
Error messages defined at the
form field
level or at the
form Meta level always take
precedence over the error messages defined at the
model field
level.
Pesan-pesan kesalahan ditentukan pada model fields
hanya digunakan ketika ValidationError
dimunculkan selama langkah model validation 1 dan tidak ada pesan kesalahan sesuai ditentukan pada tingkatan formulir.
You can override the error messages from NON_FIELD_ERRORS
raised by model
validation by adding the NON_FIELD_ERRORS
key
to the error_messages
dictionary of the ModelForm
’s inner Meta
class:
from django.core.exceptions import NON_FIELD_ERRORS
from django.forms import ModelForm
class ArticleForm(ModelForm):
class Meta:
error_messages = {
NON_FIELD_ERRORS: {
'unique_together': "%(model_name)s's %(field_labels)s are not unique.",
}
}
Cara save()
¶
Every ModelForm
also has a save()
method. This method creates and saves
a database object from the data bound to the form. A subclass of ModelForm
can accept an existing model instance as the keyword argument instance
; if
this is supplied, save()
will update that instance. If it's not supplied,
save()
will create a new instance of the specified model:
>>> from myapp.models import Article
>>> from myapp.forms import ArticleForm
# Create a form instance from POST data.
>>> f = ArticleForm(request.POST)
# Save a new Article object from the form's data.
>>> new_article = f.save()
# Create a form to edit an existing Article, but use
# POST data to populate the form.
>>> a = Article.objects.get(pk=1)
>>> f = ArticleForm(request.POST, instance=a)
>>> f.save()
Note that if the form hasn't been validated, calling save()
will do so by checking
form.errors
. A ValueError
will be raised if the data in the form
doesn't validate -- i.e., if form.errors
evaluates to True
.
If an optional field doesn't appear in the form's data, the resulting model
instance uses the model field default
, if
there is one, for that field. This behavior doesn't apply to fields that use
CheckboxInput
,
CheckboxSelectMultiple
, or
SelectMultiple
(or any custom widget whose
value_omitted_from_data()
method always returns
False
) since an unchecked checkbox and unselected <select multiple>
don't appear in the data of an HTML form submission. Use a custom form field or
widget if you're designing an API and want the default fallback behavior for a
field that uses one of these widgets.
This save()
method accepts an optional commit
keyword argument, which
accepts either True
or False
. If you call save()
with
commit=False
, then it will return an object that hasn't yet been saved to
the database. In this case, it's up to you to call save()
on the resulting
model instance. This is useful if you want to do custom processing on the
object before saving it, or if you want to use one of the specialized
model saving options. commit
is True
by default.
Another side effect of using commit=False
is seen when your model has
a many-to-many relation with another model. If your model has a many-to-many
relation and you specify commit=False
when you save a form, Django cannot
immediately save the form data for the many-to-many relation. This is because
it isn't possible to save many-to-many data for an instance until the instance
exists in the database.
Untuk memecahkan masalah ini, setiap kali anda menyimpan sebuah formulir menggunakan commit=False
, Django menambahkan sebuah metode save_m2m()
ke subkelas ModelForm
. Setelah anda telah secara manual menyimpan instance dihasilkan oleh formulir, anda dapat meminta save_m2m()
untuk menyimpan data formulir many-to-many. Sebagai contoh:
# Create a form instance with POST data.
>>> f = AuthorForm(request.POST)
# Create, but don't save the new author instance.
>>> new_author = f.save(commit=False)
# Modify the author in some way.
>>> new_author.some_field = 'some_value'
# Save the new instance.
>>> new_author.save()
# Now, save the many-to-many data for the form.
>>> f.save_m2m()
Calling save_m2m()
is only required if you use save(commit=False)
.
When you use a simple save()
on a form, all data -- including
many-to-many data -- is saved without the need for any additional method calls.
For example:
# Create a form instance with POST data.
>>> a = Author()
>>> f = AuthorForm(request.POST, instance=a)
# Create and save the new author instance. There's no need to do anything else.
>>> new_author = f.save()
Other than the save()
and save_m2m()
methods, a ModelForm
works
exactly the same way as any other forms
form. For example, the
is_valid()
method is used to check for validity, the is_multipart()
method is used to determine whether a form requires multipart file upload (and
hence whether request.FILES
must be passed to the form), etc. See
Mengikat berkas terunggah ke formulir for more information.
Memilih bidang untuk digunakan¶
It is strongly recommended that you explicitly set all fields that should be
edited in the form using the fields
attribute. Failure to do so can easily
lead to security problems when a form unexpectedly allows a user to set certain
fields, especially when new fields are added to a model. Depending on how the
form is rendered, the problem may not even be visible on the web page.
The alternative approach would be to include all fields automatically, or blacklist only some. This fundamental approach is known to be much less secure and has led to serious exploits on major websites (e.g. GitHub).
There are, however, two shortcuts available for cases where you can guarantee these security concerns do not apply to you:
Setel atribut
fields
ke nilai khusus'__all__'
untuk menunjukkan bahwa semua bidang-bidang dalam model harus digunakan. Sebagai contoh:from django.forms import ModelForm class AuthorForm(ModelForm): class Meta: model = Author fields = '__all__'
Setel atribut
exclude
dari kelasMeta
sebelah dalamModelForm
pada daftar dari bidang untuk tidak disertakan dari formulir.Sebagai contoh:
class PartialAuthorForm(ModelForm): class Meta: model = Author exclude = ['title']
Since the
Author
model has the 3 fieldsname
,title
andbirth_date
, this will result in the fieldsname
andbirth_date
being present on the form.
If either of these are used, the order the fields appear in the form will be the
order the fields are defined in the model, with ManyToManyField
instances
appearing last.
In addition, Django applies the following rule: if you set editable=False
on
the model field, any form created from the model via ModelForm
will not
include that field.
Catatan
Any fields not included in a form by the above logic
will not be set by the form's save()
method. Also, if you
manually add the excluded fields back to the form, they will not
be initialized from the model instance.
Django will prevent any attempt to save an incomplete model, so if
the model does not allow the missing fields to be empty, and does
not provide a default value for the missing fields, any attempt to
save()
a ModelForm
with missing fields will fail. To
avoid this failure, you must instantiate your model with initial
values for the missing, but required fields:
author = Author(title='Mr')
form = PartialAuthorForm(request.POST, instance=author)
form.save()
Cara lain, anda dapat menggunakan save(commit=False)
dan secara manul menyetel bidang lain yang dibutuhkan:
form = PartialAuthorForm(request.POST)
author = form.save(commit=False)
author.title = 'Mr'
author.save()
See the section on saving forms for more details on using
save(commit=False)
.
Mengesampingan nilai awal¶
The default field types, as described in the Field types table above, are
sensible defaults. If you have a DateField
in your model, chances are you'd
want that to be represented as a DateField
in your form. But ModelForm
gives you the flexibility of changing the form field for a given model.
Untuk menentukan widget penyesuaian untuk bidang, gunakan atribut widgets
dari kelas Meta
sebelah dalam. Ini harus berupa nama bidang pemetaan kamus pada kelas widget atau instance.
For example, if you want the CharField
for the name
attribute of
Author
to be represented by a <textarea>
instead of its default
<input type="text">
, you can override the field's widget:
from django.forms import ModelForm, Textarea
from myapp.models import Author
class AuthorForm(ModelForm):
class Meta:
model = Author
fields = ('name', 'title', 'birth_date')
widgets = {
'name': Textarea(attrs={'cols': 80, 'rows': 20}),
}
The widgets
dictionary accepts either widget instances (e.g.,
Textarea(...)
) or classes (e.g., Textarea
).
Demikian pula, anda dapat menentukan atribut labels
, help_texts
dan error_messages
dari kelas Meta
sebelah dalam jika anda ingin lebih lanjut menyesuaikan bidang.
For example if you wanted to customize the wording of all user facing strings for
the name
field:
from django.utils.translation import gettext_lazy as _
class AuthorForm(ModelForm):
class Meta:
model = Author
fields = ('name', 'title', 'birth_date')
labels = {
'name': _('Writer'),
}
help_texts = {
'name': _('Some useful help text.'),
}
error_messages = {
'name': {
'max_length': _("This writer's name is too long."),
},
}
You can also specify field_classes
to customize the type of fields
instantiated by the form.
For example, if you wanted to use MySlugFormField
for the slug
field, you could do the following:
from django.forms import ModelForm
from myapp.models import Article
class ArticleForm(ModelForm):
class Meta:
model = Article
fields = ['pub_date', 'headline', 'content', 'reporter', 'slug']
field_classes = {
'slug': MySlugFormField,
}
Finally, if you want complete control over of a field -- including its type,
validators, required, etc. -- you can do this by declaratively specifying
fields like you would in a regular Form
.
If you want to specify a field's validators, you can do so by defining
the field declaratively and setting its validators
parameter:
from django.forms import CharField, ModelForm
from myapp.models import Article
class ArticleForm(ModelForm):
slug = CharField(validators=[validate_slug])
class Meta:
model = Article
fields = ['pub_date', 'headline', 'content', 'reporter', 'slug']
Catatan
When you explicitly instantiate a form field like this, it is important to
understand how ModelForm
and regular Form
are related.
ModelForm
is a regular Form
which can automatically generate
certain fields. The fields that are automatically generated depend on
the content of the Meta
class and on which fields have already been
defined declaratively. Basically, ModelForm
will only generate fields
that are missing from the form, or in other words, fields that weren't
defined declaratively.
Fields defined declaratively are left as-is, therefore any customizations
made to Meta
attributes such as widgets
, labels
, help_texts
,
or error_messages
are ignored; these only apply to fields that are
generated automatically.
Mirip, bidang-bidang ditentukan menerangkan tidak menggambar atribut mereka seperti max_length
atau required
dari model sesuai Jika anda ingin merawat perilaku ditentukan dalam model, anda harus mensetel argumen terkait secara jelas ketika menyatakan bidang formulir.
Sebagai contoh, jika model Article
kelihatan seperti ini:
class Article(models.Model):
headline = models.CharField(
max_length=200,
null=True,
blank=True,
help_text='Use puns liberally',
)
content = models.TextField()
and you want to do some custom validation for headline
, while keeping
the blank
and help_text
values as specified, you might define
ArticleForm
like this:
class ArticleForm(ModelForm):
headline = MyFormField(
max_length=200,
required=False,
help_text='Use puns liberally',
)
class Meta:
model = Article
fields = ['headline', 'content']
Anda harus memastikan bahwa jenis dari biadng formulir dapat digunakan menyetel isi dari bidang model sesuai. Ketika mereka tidak sepadan, anda akan mendapatkan ValueError
sebagai peruahan bukan tersirat berlangsung.
Lihat dokumentasi bidang formulir untuk lebih informasi pada bidang dan argumen mereka.
Enabling localization of fields¶
By default, the fields in a ModelForm
will not localize their data. To
enable localization for fields, you can use the localized_fields
attribute on the Meta
class.
>>> from django.forms import ModelForm
>>> from myapp.models import Author
>>> class AuthorForm(ModelForm):
... class Meta:
... model = Author
... localized_fields = ('birth_date',)
If localized_fields
is set to the special value '__all__'
, all fields
will be localized.
Warisan formulir¶
As with basic forms, you can extend and reuse ModelForms
by inheriting
them. This is useful if you need to declare extra fields or extra methods on a
parent class for use in a number of forms derived from models. For example,
using the previous ArticleForm
class:
>>> class EnhancedArticleForm(ArticleForm):
... def clean_pub_date(self):
... ...
This creates a form that behaves identically to ArticleForm
, except there's
some extra validation and cleaning for the pub_date
field.
Anda dapat juga mensubkelaskan kelas sebelah dalam Meta
induk jika anda ingin merubah daftar Meta.fields
atau Meta.exclude
:
>>> class RestrictedArticleForm(EnhancedArticleForm):
... class Meta(ArticleForm.Meta):
... exclude = ('body',)
This adds the extra method from the EnhancedArticleForm
and modifies
the original ArticleForm.Meta
to remove one field.
Terdapat sepasang hal untuk dicatat, bagaimanapun.
Normal Python name resolution rules apply. If you have multiple base classes that declare a
Meta
inner class, only the first one will be used. This means the child'sMeta
, if it exists, otherwise theMeta
of the first parent, etc.It's possible to inherit from both
Form
andModelForm
simultaneously, however, you must ensure thatModelForm
appears first in the MRO. This is because these classes rely on different metaclasses and a class can only have one metaclass.It's possible to declaratively remove a
Field
inherited from a parent class by setting the name to beNone
on the subclass.You can only use this technique to opt out from a field defined declaratively by a parent class; it won't prevent the
ModelForm
metaclass from generating a default field. To opt-out from default fields, see Memilih bidang untuk digunakan.
Menyediakan nilai awal¶
As with regular forms, it's possible to specify initial data for forms by
specifying an initial
parameter when instantiating the form. Initial
values provided this way will override both initial values from the form field
and values from an attached model instance. For example:
>>> article = Article.objects.get(pk=1)
>>> article.headline
'My headline'
>>> form = ArticleForm(initial={'headline': 'Initial headline'}, instance=article)
>>> form['headline'].value()
'Initial headline'
Fungsi pabrik ModelForm¶
Anda dapat membuat formulir dari model yang diberikan menggunakan fungsi berdiri sendiri modelform_factory()
, daripada menggunakan pengertian kelas. Ini mungkin lebih nyaman jika anda tidak memiliki banyak penyesuaian untuk dibuat:
>>> from django.forms import modelform_factory
>>> from myapp.models import Book
>>> BookForm = modelform_factory(Book, fields=("author", "title"))
Ini juga dapat digunakan untuk membuat perubahan sederhana pada formulir yang ada, sebagai contoh dengan menentukan widget untuk digunakan untuk bidang yang diberikan:
>>> from django.forms import Textarea
>>> Form = modelform_factory(Book, form=BookForm,
... widgets={"title": Textarea()})
Bidang-bidang untuk disertakan dapat ditentukan menggunakan argumen katakunci fields
dan exclude
, atau atribut-atribut sesuai pada ModelForm
didalam kelas Meta
. Harap lihat dokumentasi Memilih bidang untuk digunakan ModelForm
.
... or enable localization for specific fields:
>>> Form = modelform_factory(Author, form=AuthorForm, localized_fields=("birth_date",))
Model formsets¶
-
class
models.
BaseModelFormSet
¶
Like regular formsets, Django provides a couple
of enhanced formset classes that make it easy to work with Django models. Let's
reuse the Author
model from above:
>>> from django.forms import modelformset_factory
>>> from myapp.models import Author
>>> AuthorFormSet = modelformset_factory(Author, fields=('name', 'title'))
Using fields
restricts the formset to use only the given fields.
Alternatively, you can take an "opt-out" approach, specifying which fields to
exclude:
>>> AuthorFormSet = modelformset_factory(Author, exclude=('birth_date',))
This will create a formset that is capable of working with the data associated
with the Author
model. It works just like a regular formset:
>>> formset = AuthorFormSet()
>>> print(formset)
<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-MAX_NUM_FORMS" id="id_form-MAX_NUM_FORMS" />
<tr><th><label for="id_form-0-name">Name:</label></th><td><input id="id_form-0-name" type="text" name="form-0-name" maxlength="100" /></td></tr>
<tr><th><label for="id_form-0-title">Title:</label></th><td><select name="form-0-title" id="id_form-0-title">
<option value="" selected>---------</option>
<option value="MR">Mr.</option>
<option value="MRS">Mrs.</option>
<option value="MS">Ms.</option>
</select><input type="hidden" name="form-0-id" id="id_form-0-id" /></td></tr>
Catatan
modelformset_factory()
uses
formset_factory()
to generate formsets. This
means that a model formset is just an extension of a basic formset that
knows how to interact with a particular model.
Changing the queryset¶
By default, when you create a formset from a model, the formset will use a
queryset that includes all objects in the model (e.g.,
Author.objects.all()
). You can override this behavior by using the
queryset
argument:
>>> formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith='O'))
Alternatively, you can create a subclass that sets self.queryset
in
__init__
:
from django.forms import BaseModelFormSet
from myapp.models import Author
class BaseAuthorFormSet(BaseModelFormSet):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = Author.objects.filter(name__startswith='O')
Then, pass your BaseAuthorFormSet
class to the factory function:
>>> AuthorFormSet = modelformset_factory(
... Author, fields=('name', 'title'), formset=BaseAuthorFormSet)
If you want to return a formset that doesn't include any pre-existing instances of the model, you can specify an empty QuerySet:
>>> AuthorFormSet(queryset=Author.objects.none())
Merubah formulir¶
By default, when you use modelformset_factory
, a model form will
be created using modelform_factory()
.
Often, it can be useful to specify a custom model form. For example,
you can create a custom model form that has custom validation:
class AuthorForm(forms.ModelForm):
class Meta:
model = Author
fields = ('name', 'title')
def clean_name(self):
# custom validation for the name field
...
Kemudian, lewati formulir model anda ke fungsi pabrik:
AuthorFormSet = modelformset_factory(Author, form=AuthorForm)
It is not always necessary to define a custom model form. The
modelformset_factory
function has several arguments which are
passed through to modelform_factory
, which are described below.
Specifying widgets to use in the form with widgets
¶
Using the widgets
parameter, you can specify a dictionary of values to
customize the ModelForm
’s widget class for a particular field. This
works the same way as the widgets
dictionary on the inner Meta
class of a ModelForm
works:
>>> AuthorFormSet = modelformset_factory(
... Author, fields=('name', 'title'),
... widgets={'name': Textarea(attrs={'cols': 80, 'rows': 20})})
Enabling localization for fields with localized_fields
¶
Using the localized_fields
parameter, you can enable localization for
fields in the form.
>>> AuthorFormSet = modelformset_factory(
... Author, fields=('name', 'title', 'birth_date'),
... localized_fields=('birth_date',))
If localized_fields
is set to the special value '__all__'
, all fields
will be localized.
Menyediakan nilai awal¶
As with regular formsets, it's possible to specify initial data for forms in the formset by specifying an initial
parameter when instantiating the model formset class returned by
modelformset_factory()
. However, with model
formsets, the initial values only apply to extra forms, those that aren't
attached to an existing model instance. If the extra forms with initial data
aren't changed by the user, they won't be validated or saved.
Saving objects in the formset¶
As with a ModelForm
, you can save the data as a model object. This is done
with the formset's save()
method:
# Create a formset instance with POST data.
>>> formset = AuthorFormSet(request.POST)
# Assuming all is valid, save the data.
>>> instances = formset.save()
The save()
method returns the instances that have been saved to the
database. If a given instance's data didn't change in the bound data, the
instance won't be saved to the database and won't be included in the return
value (instances
, in the above example).
When fields are missing from the form (for example because they have been
excluded), these fields will not be set by the save()
method. You can find
more information about this restriction, which also holds for regular
ModelForms
, in Selecting the fields to use.
Pass commit=False
to return the unsaved model instances:
# don't save to the database
>>> instances = formset.save(commit=False)
>>> for instance in instances:
... # do something with instance
... instance.save()
This gives you the ability to attach data to the instances before saving them
to the database. If your formset contains a ManyToManyField
, you'll also
need to call formset.save_m2m()
to ensure the many-to-many relationships
are saved properly.
After calling save()
, your model formset will have three new attributes
containing the formset's changes:
-
models.BaseModelFormSet.
changed_objects
¶
-
models.BaseModelFormSet.
deleted_objects
¶
-
models.BaseModelFormSet.
new_objects
¶
Membatasi angka dari obyek dapat di sunting¶
As with regular formsets, you can use the max_num
and extra
parameters
to modelformset_factory()
to limit the number of
extra forms displayed.
max_num
tidak mencegah obyek yang ada dari menjadi ditampilkan:
>>> Author.objects.order_by('name')
<QuerySet [<Author: Charles Baudelaire>, <Author: Paul Verlaine>, <Author: Walt Whitman>]>
>>> AuthorFormSet = modelformset_factory(Author, fields=('name',), max_num=1)
>>> formset = AuthorFormSet(queryset=Author.objects.order_by('name'))
>>> [x.name for x in formset.get_queryset()]
['Charles Baudelaire', 'Paul Verlaine', 'Walt Whitman']
Also, extra=0
doesn't prevent creation of new model instances as you can
add additional forms with JavaScript
or just send additional POST data. Formsets don't yet provide functionality for an "edit only" view that
prevents creation of new instances.
If the value of max_num
is greater than the number of existing related
objects, up to extra
additional blank forms will be added to the formset,
so long as the total number of forms does not exceed max_num
:
>>> AuthorFormSet = modelformset_factory(Author, fields=('name',), max_num=4, extra=2)
>>> formset = AuthorFormSet(queryset=Author.objects.order_by('name'))
>>> for form in formset:
... print(form.as_table())
<tr><th><label for="id_form-0-name">Name:</label></th><td><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" /></td></tr>
<tr><th><label for="id_form-1-name">Name:</label></th><td><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" /></td></tr>
<tr><th><label for="id_form-2-name">Name:</label></th><td><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" /></td></tr>
<tr><th><label for="id_form-3-name">Name:</label></th><td><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" /></td></tr>
Sebuah nilai max_num
dari None
(awalan) menaruh batasan tinggi pada sejumlah formulir-formulir ditampilkan (1000). Dalam praktiknya ini adalah setara pada tidak ada batasan.
Using a model formset in a view¶
Model formsets are very similar to formsets. Let's say we want to present a
formset to edit Author
model instances:
from django.forms import modelformset_factory
from django.shortcuts import render
from myapp.models import Author
def manage_authors(request):
AuthorFormSet = modelformset_factory(Author, fields=('name', 'title'))
if request.method == 'POST':
formset = AuthorFormSet(request.POST, request.FILES)
if formset.is_valid():
formset.save()
# do something.
else:
formset = AuthorFormSet()
return render(request, 'manage_authors.html', {'formset': formset})
As you can see, the view logic of a model formset isn't drastically different
than that of a "normal" formset. The only difference is that we call
formset.save()
to save the data into the database. (This was described
above, in Saving objects in the formset.)
Menimpa clean()
pada sebuah ModelFormSet
¶
Just like with ModelForms
, by default the clean()
method of a
ModelFormSet
will validate that none of the items in the formset violate
the unique constraints on your model (either unique
, unique_together
or
unique_for_date|month|year
). If you want to override the clean()
method
on a ModelFormSet
and maintain this validation, you must call the parent
class's clean
method:
from django.forms import BaseModelFormSet
class MyModelFormSet(BaseModelFormSet):
def clean(self):
super().clean()
# example custom validation across forms in the formset
for form in self.forms:
# your custom formset validation
...
Also note that by the time you reach this step, individual model instances
have already been created for each Form
. Modifying a value in
form.cleaned_data
is not sufficient to affect the saved value. If you wish
to modify a value in ModelFormSet.clean()
you must modify
form.instance
:
from django.forms import BaseModelFormSet
class MyModelFormSet(BaseModelFormSet):
def clean(self):
super().clean()
for form in self.forms:
name = form.cleaned_data['name'].upper()
form.cleaned_data['name'] = name
# update the instance value.
form.instance.name = name
Menggunakan queryset penyesuaian¶
Seperti dinyatakan sebelumnya, anda dapat menimpa queryset awalan digunakan oleh formset model:
from django.forms import modelformset_factory
from django.shortcuts import render
from myapp.models import Author
def manage_authors(request):
AuthorFormSet = modelformset_factory(Author, fields=('name', 'title'))
if request.method == "POST":
formset = AuthorFormSet(
request.POST, request.FILES,
queryset=Author.objects.filter(name__startswith='O'),
)
if formset.is_valid():
formset.save()
# Do something.
else:
formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith='O'))
return render(request, 'manage_authors.html', {'formset': formset})
Catat bahwa kami melewatkan argumen queryset
dalam kedua kasus POST
dan GET
dalam contoh ini.
Menggunakan formset dalam cetakan¶
Ada tiga cara untuk mengirim sebuah formset dalam sebuah cetakan Django.
Pertama, anda dapat membiarkan formset melakukan sebagian besar pekerjaan:
<form method="post">
{{ formset }}
</form>
Kedua, anda dapat secara manual membangun formset, tetapi membiarkan formulir berurusan dengan itu sendiri:
<form method="post">
{{ formset.management_form }}
{% for form in formset %}
{{ form }}
{% endfor %}
</form>
When you manually render the forms yourself, be sure to render the management form as shown above. See the management form documentation.
Ketiga, anda dapat secara manual membangun setiap bidang:
<form method="post">
{{ formset.management_form }}
{% for form in formset %}
{% for field in form %}
{{ field.label_tag }} {{ field }}
{% endfor %}
{% endfor %}
</form>
If you opt to use this third method and you don't iterate over the fields with
a {% for %}
loop, you'll need to render the primary key field. For example,
if you were rendering the name
and age
fields of a model:
<form method="post">
{{ formset.management_form }}
{% for form in formset %}
{{ form.id }}
<ul>
<li>{{ form.name }}</li>
<li>{{ form.age }}</li>
</ul>
{% endfor %}
</form>
Notice how we need to explicitly render {{ form.id }}
. This ensures that
the model formset, in the POST
case, will work correctly. (This example
assumes a primary key named id
. If you've explicitly defined your own
primary key that isn't called id
, make sure it gets rendered.)
Formset berderet¶
-
class
models.
BaseInlineFormSet
¶
Formset berderet adalah lapisan abstraksi kecil pada atas formset model. Ini menyederhanakan kasus dari bekerja dengan obyek-obyek terkait melalui sebuah foreign key. Seandainya anda mempunyai dua model ini:
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
class Book(models.Model):
author = models.ForeignKey(Author, on_delete=models.CASCADE)
title = models.CharField(max_length=100)
If you want to create a formset that allows you to edit books belonging to a particular author, you could do this:
>>> from django.forms import inlineformset_factory
>>> BookFormSet = inlineformset_factory(Author, Book, fields=('title',))
>>> author = Author.objects.get(name='Mike Royko')
>>> formset = BookFormSet(instance=author)
BookFormSet
's prefix is 'book_set'
(<model name>_set
). If Book
's ForeignKey
to Author
has a
related_name
, that's used instead.
Catatan
inlineformset_factory()
menggunakan modelformset_factory()
dan menandai can_delete=True
.
lihat juga
Metode menimpa pada InlineFormSet
¶
When overriding methods on InlineFormSet
, you should subclass
BaseInlineFormSet
rather than
BaseModelFormSet
.
Sebagai contoh, jika anda ingin menimpa clean()
:
from django.forms import BaseInlineFormSet
class CustomInlineFormSet(BaseInlineFormSet):
def clean(self):
super().clean()
# example custom validation across forms in the formset
for form in self.forms:
# your custom formset validation
...
Lihat juga Menimpa clean() pada sebuah ModelFormSet.
Kemudian ketika anda membuat formset berderet anda, lewatkan di argumen pilihan formset
:
>>> from django.forms import inlineformset_factory
>>> BookFormSet = inlineformset_factory(Author, Book, fields=('title',),
... formset=CustomInlineFormSet)
>>> author = Author.objects.get(name='Mike Royko')
>>> formset = BookFormSet(instance=author)
Lebih dari satu foreign key pada model sama¶
If your model contains more than one foreign key to the same model, you'll
need to resolve the ambiguity manually using fk_name
. For example, consider
the following model:
class Friendship(models.Model):
from_friend = models.ForeignKey(
Friend,
on_delete=models.CASCADE,
related_name='from_friends',
)
to_friend = models.ForeignKey(
Friend,
on_delete=models.CASCADE,
related_name='friends',
)
length_in_months = models.IntegerField()
Untuk mengatasi ini, anda dapat menggunakan fk_name
pada inlineformset_factory()
:
>>> FriendshipFormSet = inlineformset_factory(Friend, Friendship, fk_name='from_friend',
... fields=('to_friend', 'length_in_months'))
Menggunakan formset berderet di sebuah tampilan¶
You may want to provide a view that allows a user to edit the related objects of a model. Here's how you can do that:
def manage_books(request, author_id):
author = Author.objects.get(pk=author_id)
BookInlineFormSet = inlineformset_factory(Author, Book, fields=('title',))
if request.method == "POST":
formset = BookInlineFormSet(request.POST, request.FILES, instance=author)
if formset.is_valid():
formset.save()
# Do something. Should generally end with a redirect. For example:
return HttpResponseRedirect(author.get_absolute_url())
else:
formset = BookInlineFormSet(instance=author)
return render(request, 'manage_books.html', {'formset': formset})
Perhatikan bagaimana kami melewatkan instance
dalam kedua kasus POST
dan GET
.
Menentukan widget-widget untuk digunakan di formulir berderet¶
inlineformset_factory
menggunakan modelformset_factory
dan melewatkan kebanyakan argumennya ke modelformset_factory
. Ini berarti anda dapat menggunakan parameter widgets
dalam banyak cara yang sama ketika melewatkan itu ke modelformset_factory
. Lihat Specifying widgets to use in the form with widgets diatas.