We've seen two different ways to validate a single field.

We can do it with clean field or

with a validator, either one that Jango provides, or one that we write ourselves.

All of these methods, though, only let us handle a single field at a time.

What if we need to check two or

more fields together to know if the one was valid?

This is where the form's clean method comes into play.

Let's go to workspaces.

All right, so our suggestion form is good.

One thing we probably wanna add, just to make this a more complete form

is we want somebody to verify their email address.

Let's go over here, let's get rid of this inspector.

We don't need that anymore.

So we want them to verify their e-mail address, and

let's do that by adding in another field.

So we'll say verify_email = forms.EmailField, and for

the help_text, let's put in, "Please verify your email address".

And now let's see what this does to our view, or form.

So we have our name like normal, we have email, and we have verify email, and

below that it says, Please verify your email address.

We can do that as a label instead of as the help text if we wanted.

We could be wanting to change this right here over to label,

and then Refresh, there we go,

and that's maybe a little more clean, and what you'd expect either way it works,

the help text is really handy when you're making forms for the admin.

And now though, we need to make sure that if put in my name here,

and I put in kenneth.example.com here, but I put in kennethlove@example.com here,

it should throw an error, and go, hey, you didn't give me the same email address.

So how do we do that?

We do that by specifying a clean method for the entire form.

So notice this clean method is just called clean.

There's no field name after it.

So this will clean the entire form.

So everybody go through every field and

make sure the field satisfies its own requirements.

Then we can go through the entire form as a whole and

make sure the form satisfies its requirements.

So, we need to get a couple of things in here.

So first of all let's get all of the data.

And we're gonna call super.clean.

That calls the clean method on our forms.form, or on our suggestion form.

So, that gets all of our cleaned data, it give us all of our data back.

So then we'll do email = cleaned_data.

And you can either do email or you could do, .get( 'email'

) it acts like a dictionary, so, you can do either one of these.

And and then we'll do verify, cleaned_data.get( 'verify_email' ).

And so now, what we wanna do is we wanna make sure that the two of

those have the same data and are both filled in.

We already know they're both gonna be filled in, because it's gonna come back.

So we can just do, if email does not equal verify.

So if they don't have the same data in them,

then we want to raise forms.ValidationError.

And our error, we're gonna put in here, we'll just say,

"You need to enter the same email in both fields".

All right, so that's it.

Now we don't have to return anything from clean.

Unlike clean field,

like clean honeypot, you don't have to return anything back from clean.

It's cool with just running through and if there's no errors then it's happy.

So, this is bad.

Let's go ahead and suggest that and we'll say, Data security!

Oops, there we go.

That's the thing I want somebody to cover.

And if we hit that we get you need to enter the same email in both fields.

So great we got an error message about our two fields.

The fields are both, one of them is wrong.

We don't know which one.

So they both need to match.

Between cleaning fields, validators, and cleaning whole forms,

we're definitely able to make sure that our data is exactly what we want and need.

Okay, let's leave forms alone for a little bit and

go make some more interesting models for our next feature.