Building data-driven web apps with Pyramid and SQLAlchemy Transcripts
Chapter: Client and server-side validation
Lecture: Server-side validation
Login or
purchase this course
to watch this video and the rest of the course contents.
0:01
We're also going to use this over here.
0:04
And this is going to show you another aspect
0:06
of these view models that is beautiful.
0:09
So notice over here that we're saying
0:11
all right, some form data has been submitted to us.
0:15
Right here it's, look at this email
0:17
look at this name, look at this password.
0:20
Well instead of remembering to do this
0:22
and on complicated forms with ten pieces
0:24
like this gets really tiresome really quick.
0:27
We could actually just do like this.
0:29
Even on the Get because state is going to come in
0:33
but it'll just be missing so we could come over
0:34
and say self.requestdict.get('email')
0:39
Or we could just say .email, whichever you feel like.
0:44
That solves those three lines.
0:46
And then this validation, remember I said really
0:49
really there should be three lines.
0:50
You're email is required. You didn't enter it?
0:53
Oh, wait, you entered your email but your name is required.
0:55
You didn't enter it, and so on. Well let's go do that.
0:58
We only want to compute those sorts
1:01
of things on the form POST.
1:04
So let's add another validate function here.
1:07
And when that happens we're going to basically say
1:10
if not self.email self.error equals?
1:15
You must specify an email address.
1:17
And you can imagine, same for name, same for password.
1:23
So over here that is this sort of stuff and remember
1:27
all of these things are already being tracked
1:29
so watch how much simpler this becomes.
1:32
vm.validate, and remember this is totally scalable.
1:35
Like this could become way more involved.
1:38
And it, it means you're more likely
1:40
to write that extra validation code.
1:43
Because it's not making this method even worse
1:45
even harder to understand, right?
1:47
There's, it never gets more complicated than just validate.
1:50
So then you just ask if vm.error
1:52
if there is some kind of error
1:54
were just going to return vm.to_dic().
1:57
Which includes the error.
1:59
Otherwise, we say vm.email
2:02
vm.name, vm.password.
2:05
Done, how sweet is that?
2:07
So, look how clean this method becomes.
2:11
We create our view model and we ask for validation.
2:13
And if there's a problem we just let it exchange
2:15
other data back with potential
2:17
error messages, all sorts of stuff.
2:19
And, otherwise, we carry on.
2:20
Now let's do one more thing, let's go to this part here.
2:24
And let's add, say if self.email.
2:28
Remember we stored this in a simplified form.
2:30
We'll say email == self.email.strip().lower().
2:34
Just to make sure.
2:35
I think we're doing that in the data layer as well
2:37
but let's make sure the data is
2:38
already prepared when it comes in.
2:42
And we can come over here and say things like
2:44
if it's not there we'll just say strip on this as well.
2:49
We're not going to mess with the password.
2:50
They owant their password to be space, they can have it.
2:54
Alright, let's make sure we can still register.
2:56
So over here, we register get, register post.
3:00
Let's see if things are still working.
3:01
Come over here. Right now we're logged in so let's logout.
3:06
And let's register as user, user2.
3:12
At u2.com, get my password.
3:16
Actually, let's first leave some stuff out here.
3:19
Let's leave out the name and the password.
3:21
You must spec, specify your name.
3:23
User2 is my name.
3:25
You must specify password.
3:28
Alright, that's our password.
3:29
Now this should work and we should be logged in as user2.
3:33
Ready, bam, there we go.
3:38
So let's review, we've taken and created
3:40
this RegisterViewModel that has both the ability
3:44
to load the data and then validate it.
3:46
We saw our error handling checking
3:48
to make sure the user name was there
3:49
the actual name was there, the password was there.
3:52
We didn't check email but it's there.
3:55
And then, once all that stuff happens correctly
3:58
we just use the values from it.
4:00
So, what's really beautiful about this is it doesn't
4:03
no matter how much data you exchange, it doesn't
4:06
get more complicated than this.
4:08
The view model is in charge of validating the data
4:10
and exchanging the data with the form.
4:13
You just work with the, the data that's gotten.
4:16
It's real, real nice.
4:18
On this one, they can interact with
4:20
the database as it needs to, all sorts of stuff like that.
4:23
So here, it's going and getting the cookie from the request
4:26
and then it's actually hitting
4:27
the database to populate the user.
4:29
If it doesn't find it, we do some hard
4:31
error handling, we just send them to login.
4:33
Otherwise it passes that onto the view
4:35
which is why we saw that right there, user2.
4:39
So these view models are super, super valuable.
4:42
And we'll be using them for the rest of this course.
4:44
I'm going to go ahead and put view models in place for
4:47
the remaining methods that you don't see.
4:50
Like on packages and so on, but I'm not not going to
4:52
walk you through it because, guess what?
4:54
It's exactly the same as what we've
4:55
been doing in the last two.
