Building data-driven web apps with Pyramid and SQLAlchemy Transcripts
Chapter: Client and server-side validation
Lecture: The viewmodel design pattern
0:00 You've seen view models in action
0:01 let's review them as a concept.
0:04 When you look at a web application
0:06 at a very high level
0:07 we have the browser and our job
0:09 is to send html to it.
0:11 In this case, the html defined a form
0:13 that's going to be submitted back.
0:15 So you see we're doing HTTP POST to register.
0:18 And there's some data being passed along.
0:20 Now in a naive sense
0:22 we might write a really complicated
0:25 long method to process this register request.
0:29 So here is a big action method.
0:31 Why is it big?
0:32 It has to get all the data out of the form.
0:34 Let's imagine, there's six or seven
0:35 fields it's got to pull out of there.
0:38 It has to validate them.
0:39 If they don't validate
0:40 it has to send back an error message.
0:41 And then, and only then does it actually
0:44 do what it's supposed to do
0:45 register the user.
0:47 So that's a lot of work.
0:48 And it makes these methods hard to test
0:50 it makes them hard to read
0:52 hard to maintain, error prone and so on.
0:55 If we could separate that
0:56 if we could put the place where we get
0:59 the data from the form and validate it
1:00 and make that the sole purpose of the entire file
1:04 is to validate the register form
1:05 well then, that's way easier.
1:07 Way easier to test and we can separate
1:09 the validation and getting of the data
1:11 from the other things.
1:12 We move that validation and that data acquisition
1:15 apart and put it somewhere else
1:16 into this thing we call a view model.
1:18 So we still have out action method
1:19 but now the view model knows about
1:22 the data exchange, it does that.
1:23 It knows about the validation.
1:25 And we just have the action method work with this.
1:28 The action method now becomes sort of orchestration
1:30 for the high level steps that need to happen here.
1:33 So at a high level
1:34 this is what the view model pattern looks like.
1:37 Let's see how it makes things
1:38 simpler when we use it.
1:40 So over here, we're going to look inside
1:43 that register method, and like I said
1:44 in theory, it could be really complicated.
1:47 But in practice because we're using view models
1:49 it's quite simple.
1:50 We have the get post redirect pattern still
1:52 so the top register under score get, this shows the form
1:56 and it doesn't matter how many
1:58 fields there are, what default data has to be there
2:00 it's basically just going to look like this.
2:03 Register view model and pass off the to_dict stuff.
2:07 It's up to the view model
2:08 to make sure the default data is there.
2:10 Things like, data that drives dropdowns are there and so on.
2:13 So this is pretty much it.
2:15 And then when we go and do our post
2:17 again, we're going to go to our view model
2:20 we're going to pass it the request
2:22 it's going to now validate that, right?
2:25 We don't need to validate it in the GET
2:26 because it's empty, it's always going to have errors like
2:28 "Your name's missing"
2:29 Yeah, I know 'cause we're showing the form.
2:31 But here we need to validate it.
2:33 And then we just check.
2:34 Anything go wrong?
2:35 Well, show them the error message
2:37 and give them back their data.
2:39 That's super easy.
2:40 Doesn't matter how many thesis' there are
2:42 how much validation there is
2:43 this is what we do.
2:45 And then we actually do the thing we're trying to do
2:47 in this case, register the user
2:49 based on the data we already have.
2:50 We know we have it because
2:52 it passed the validation on the line above
2:54 that if statement above.
2:55 But if it failed, we'll just set
2:57 another error message and pass that back.
2:59 If it succeeds, here's the redirect part
3:01 of the get post redirect pattern.
3:03 We've now registered them as a user
3:05 and we just send them back to /
3:07 or /account or welcome
3:09 or where ever we send them to.
3:11 This code is super easy to test
3:13 and it's very maintainable.
3:15 Moreover, you know exactly where to go
3:17 to look at the validation and data exchange
3:19 for registering.
3:21 It's in viewmodels/account/registration/viewmodel.
3:25 Boom, really nice design pattern
3:27 and here it is in action.