Bailíochtú foirm agus réimseLink to this heading#

Tarlaíonn bailíochtú foirme nuair a ghlantar na sonraí. Más mian leat an próiseas seo a shaincheapadh, tá áiteanna éagsúla ann chun athruithe a dhéanamh, agus gach ceann acu ag freastal ar chuspóir difriúil. Reáchtáiltear trí chineál modhanna glantacháin le linn próiseála foirme. De ghnáth déantar iad seo a fhorghníomhú nuair a ghlaonn tú ar an modh is_valid () ``ar fhoirm. Tá rudaí eile ann a d'fhéadfadh glanadh agus bailíochtú a spreagadh freisin (rochtain a fháil ar an tréith ``earráidí ``nó glaoch ar `full_clean () go díreach), ach de ghnáth ní bheidh siad ag teastáil.

Go ginearálta, is féidir le haon mhodh glantacháin ValidationError` a ardú má tá fadhb ann leis na sonraí atá á phróiseáil aige, ag cur an fhaisnéis ábhartha chuig an tógálaí ``ValidationError`. :ref: `Féach thíos <raising-validation-error>`le haghaidh an dea-chleachtas maidir le ``ValidationError a ardú. Mura n-ardaítear aon ValidationError, ba cheart don modh na sonraí glanta (normalaithe) a thabhairt ar ais mar réad Python.

Is féidir an chuid is mó de bhailíochtú a dhéanamh ag baint úsáide as bailíodóirí `_ - cúntóirí is féidir a athúsáid. Is feidhmeanna (nó glaonna) iad bailíochtóirí a thógann argóint amháin agus a ardaíonn ``ValidationError` ar ionchur neamhbhailí. Déantar bailíochtóirí a reáchtáil tar éis modhanna to_python agus validate an réimse a ghlaoch.

Roinntear bailíochtú foirme ina roinnt céimeanna, ar féidir iad a shaincheapadh nó a shárú:

• Is é an modh to_python () ``ar `Réimse an chéad chéim i ngach bailíochtú. Cuireann sé an luach ar chineál sonraí ceart agus ardaíonn sé ValidationError mura féidir é sin a dhéanamh. Glacann an modh seo leis an luach amh ón ngiuirléid agus filleann sé an luach tiontaithe ar ais. Mar shampla, iompróidh Floatfield na sonraí ina float` Python nó ardóidh ValidationError.

• Láimhseálann an modh validate () ``ar `Réimse bailíochtú réamh-shonrach nach bhfuil oiriúnach do bhailíochtóir. Tógann sé luach a cuireadh iallach ar chineál sonraí ceart agus ardaíonn sé ValidationError ar aon earráid. Ní thugann an modh seo aon rud ar ais agus níor cheart dó an luach a athrú. Ba chóir duit é a shárú chun loighic bhailíochtaithe nach féidir leat nó nach dteastaíonn uait bailíochtóir a chur isteach.

• Ritheann an modh run_validators () ``ar `Réimse bailíochtóirí uile an réimse agus comhiomlánann sé na hearráidí go léir ina ValidationError amháin. Níor chóir go gcaithfidh tú an modh seo a shárú.

• Tá an modh clean () ``ar fho-aicme ``Field freagrach as to_python (), validate () `, agus run_validators () a reáchtáil san ord ceart agus a n-earráidí a iomadú. Má ardaíonn aon cheann de na modhanna, ag am ar bith, ValidationError, stopann an bailíochtú agus ardaítear an earráid sin. Tugann an modh seo na sonraí glan ar ais, a chuirtear isteach ansin isteach i bhfoclóir cleaned_data na foirme.

• <fieldname>Glaítear ar an modh clean_ () `ar fho-aicme foirme -- ina gcuirtear ainm tréith réim <fieldname>se na foirme in ionad ``. Déanann an modh seo aon ghlanadh atá sonrach don tréith áirithe sin, nach mbaineann leis an gcineál réimse atá ann. Ní chuirtear an modh seo ar bith paraiméadair. Beidh ort luach an réimse a fheiceáil suas i self.cleaned_data ``agus cuimhnigh gur réad Python é ag an bpointe seo, ní an teaghrán bunaidh a chuirtear isteach san fhoirm (beidh sé i ``cleaned_data` toisc gur ghlanadh an modh réimse ginearálta ``clean () ``thuas, na sonraí cheana féin).

  Mar shampla, dá dteastaíonn uait a bhailíochtú go raibh ábhar charfield ar a dtugtar serialnumber uathúil, bheadh clean_serialnumber () ``an áit cheart chun é seo a dhéanamh. Ní theastaíonn réimse ar leith uait (is `Charfield é), ach teastaíonn píosa bailíochtaithe atá sonrach le réimse foirme uait agus, b'fhéidir, na sonraí a ghlananach/normalú.

  Cuireann luach tuairisceáin an mhodha seo in ionad an luach atá ann cheana i cleaned_data `, mar sin caithfidh sé a bheith luach an réimse ó cleaned_data` (fiú mura n-athraigh an modh seo é) nó luach nua glantaithe.

• Is féidir le modh clean () ``an fho-aicme foirme bailíochtú a dhéanamh a éilíonn rochtain ar réimsí iolracha foirme. Seo an áit a bhféadfá seiceálacha a chur isteach mar “má sholáthraítear réimse ``A, caithfidh seoladh ríomhphoist bailí a bheith i réimse B”. Is féidir leis an modh seo foclóir go hiomlán difriúil a thabhairt ar ais más mian leis, a úsáidfear mar an cleaned_data.

  Ós rud é go bhfuil na modhanna bailíochtaithe réimse á reáchtáil faoin am a dtugtar clean () ``, tá rochtain agat freisin ar thréith ``earráidí na foirme ina bhfuil na hearráidí go léir a ardaítear trí ghlanadh réimsí aonair.

  Tabhair faoi deara nach mbeidh baint ag aon earráidí a ardóidh sé:meth: Form.clean () `le haon réimse go háirithe. Téann siad isteach i “réimse” speisialta (ar a dtugtar ``__all__`), ar féidir leat rochtain a fháil tríd an modh:meth: ~django.forms.form.NON_FIELD_ERRORS más gá duit. Más mian leat earráidí a cheangal le réimse ar leith san fhoirm, ní mór duit glaoch ar: meth: `~django.forms.form.add_error () `.

  Tabhair faoi deara freisin go bhfuil breithnithe speisialta ann agus an modh `clean () `de fho-aicme ``ModelForm ``a shárú. (féach an:ref: `Doiciméadú ModelForm <overriding-modelform-clean-method>`le haghaidh tuilleadh eolais)

Reáchtáiltear na modhanna seo san ord a thugtar thuas, réimse amháin ag an am. <fieldname>Is é sin, i gcás gach réimse san fhoirm (san ord a dhearbhaítear iad sa mhíniú foirme), reáchtáiltear an modh Field.clean () (nó a shárú), ansin ``clean_ () ``. Faoi dheireadh, nuair a bheidh an dá mhodh sin á reáchtáil do gach réimse, déantar an modh:meth: `Form.clean () `, nó a shárú, a fhorghníomhú cibé acu tá earráidí ardaithe ag na modhanna roimhe seo nó nach bhfuil.

Tá samplaí de gach ceann de na modhanna seo ar fáil thíos.

Mar a luadh, is féidir le haon cheann de na modhanna seo Error Validationer a ardú. Maidir le haon réimse, má ardaíonn an modh Field.clean () ```Error validation, ní ghlaofar aon mhodh glantacháin réimsiú-shonrach. Mar sin féin, déantar na modhanna glantacháin do gach réimse atá fágtha i bhfeidhm fós.

raise ValidationError(
    _("Invalid value: %(value)s"),
    code="invalid",
    params={"value": "42"},
)

ValidationError(_("Invalid value: %s") % value)

# Good
raise ValidationError(
    [
        ValidationError(_("Error 1"), code="error1"),
        ValidationError(_("Error 2"), code="error2"),
    ]
)

# Bad
raise ValidationError(
    [
        _("Error 1"),
        _("Error 2"),
    ]
)

from django.core import validators
from django.forms import CharField


class SlugField(CharField):
    default_validators = [validators.validate_slug]

slug = forms.SlugField()

slug = forms.CharField(validators=[validators.validate_slug])

from django import forms
from django.core.validators import validate_email


class MultiEmailField(forms.Field):
    def to_python(self, value):
        """Normalize data to a list of strings."""
        # Return an empty list if no input was given.
        if not value:
            return []
        return value.split(",")

    def validate(self, value):
        """Check if value consists only of valid emails."""
        # Use the parent's handling of required fields, etc.
        super().validate(value)
        for email in value:
            validate_email(email)

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    sender = forms.EmailField()
    recipients = MultiEmailField()
    cc_myself = forms.BooleanField(required=False)

from django import forms
from django.core.exceptions import ValidationError


class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean_recipients(self):
        data = self.cleaned_data["recipients"]
        if "fred@example.com" not in data:
            raise ValidationError("You have forgotten about Fred!")

        # Always return a value to use as the new cleaned data, even if
        # this method didn't change it.
        return data

from django import forms
from django.core.exceptions import ValidationError


class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean(self):
        cleaned_data = super().clean()
        cc_myself = cleaned_data.get("cc_myself")
        subject = cleaned_data.get("subject")

        if cc_myself and subject:
            # Only do something if both fields are valid so far.
            if "help" not in subject:
                raise ValidationError(
                    "Did not send for 'help' in the subject despite CC'ing yourself."
                )

def clean(self):
    super().clean()
    cc_myself = self.cleaned_data.get("cc_myself")
    ...

from django import forms


class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean(self):
        cleaned_data = super().clean()
        cc_myself = cleaned_data.get("cc_myself")
        subject = cleaned_data.get("subject")

        if cc_myself and subject and "help" not in subject:
            msg = "Must put 'help' in subject when cc'ing yourself."
            self.add_error("cc_myself", msg)
            self.add_error("subject", msg)