Python for Entrepreneurs Transcripts
Chapter: Build web apps with Pyramid: Applied web development
Lecture: Concept: View models

Login or purchase this course to watch this video and the rest of the course contents.
0:03 Now that you've seen view models in action, let's review them in a picture.
0:07 So we've seen that we can have these view models, classes really,
0:11 in this case we have a RegistrationViewModel that we've created
0:14 and what we want to do is use this type to help alleviate some of the challenges
0:18 of sharing and passing data back to the views
0:22 as well as validation and getting it from forms.
0:25 So we are going to have two methods here, two actions,
0:28 one is a register, which is handling the GET request
0:31 and one, which is going to handle the POST or the form submission.
0:34 Here what we need to do in this register_get is
0:36 we need to return the data that will be displayed in the Chameleon template,
0:41 so we probably have to have an email and a password and things like that.
0:45 Our RegistrationViewModel is a class that has those properties or fields
0:50 and we write a to_dict method that will turn that to a dictionary, basically
0:54 a model as far as Pyramid is concerned, to be passed back.
0:58 So, this is really nice and simple and this might even be doing data access
1:02 in the constructor for the registration view model, right,
1:05 it could be doing lots of interesting stuff to get that data, that model prepared.
1:09 Next, we want to handle the form POST,
1:12 now we have the register_post and how do we do this?
1:14 Again we are going ot create our view model, and now we have a from_dict,
1:18 so given a dictionary which in this case is coming from the form POST,
1:22 let's parse that data back into our variables,
1:25 in our registration view model and then we'll be able to work with all those values
1:29 as if they were just present in the view model.
1:32 We also kind of add validation, so here we can call a validate method
1:35 once we've restored it from the dictionary, we can check
1:39 and even use this error field that we've added,
1:42 so if it happens to be there is something wrong,
1:44 we don't want to accept their form POST,
1:47 in this case we don't want to let them register for the site,
1:49 we can just return the view model to the same template and this will round trip
1:53 all of their data they have entered as well, so this is really nice and simple.
1:58 If we do validate, then we'll work with the various fields on that view model,
2:03 so view model email address, view model password and so on,
2:06 once we actually create the account and do the login and so on,
2:09 then we might raise an HTTP found exception
2:12 to redirect the user to wherever they need to go.
2:15 Remember, the GET/POST/redirect pattern.
2:19 Here it is, with view models.
2:21 Let's look into this to/from dictionary concept a little more deeply.
2:25 So what we've done is we've realized
2:28 that basically any view model needs to be able to convert itself to a dictionary
2:31 so it can be passed to the templates,
2:34 so we've created a ViewModelBase so that it has
2:36 the simplest possible implementation of "to dictionary".
2:38 it just returns all the fields, if for some reason your particular view model can't work this way,
2:44 just overwrite this method and create a dictionary and return it.
2:47 Now we have our various page-specific view models like a registration view model
2:51 and it derives from this ViewModelBase and it has a __init__
2:54 where it creates this fields, so above when we say "to dictionary", we get
2:58 an email address, a password, and an error passed to the view.
3:01 Optionally, if it's supposed to support a processing of form post,
3:06 we can add it from_dict as well, not all of view models need this,
3:10 but this particular one did.
3:13 And so here you can see we are passing in a dictionary
3:16 we don't really care where it came from,
3:18 and the case we just saw it from the form POST but it could come from the variety of locations
3:21 and we are going to use the GET sort of the safe dictionary key access
3:25 or dictionary value access to get the email address and password and store those.