Python for Entrepreneurs Transcripts
Chapter: Build web apps with Pyramid: Applied web development
Lecture: View models demo (reading data section)
Login or
purchase this course
to watch this video and the rest of the course contents.
0:02
Ok so let's move this over into the view model as well.
0:04
This part here we will point in in this data and I am going to call it like this,
0:07
I'm going to add a function called from_dict and we need to give it a dictionary,
0:14
so we go like this, let me just cut that out of here
0:20
we'll add that method, let PyCharm do it
0:22
and POST is not a good idea, let's just call it data_dict or something like that,
0:26
and here we are going to do basically the same code
0:28
but instead of self.request, we are just going to say "get that from the data_dict", like so
0:33
this lets us get it from the query string, from other places as you'll see later
0:36
we'll unify this into one piece, and this will be self.email
0:43
and our error, we don't get that from the form, that's generated in the handler,
0:48
so that might come out later.
0:50
Now let's go over here and we'll say vm.from_dict and then see all this stuff,
0:54
let's just write this in terms of the model,
0:57
the data the model the view models gathered and then we'll fix this
1:01
so we'll say vm.password, if those aren't equal, we'll move this somewhere else in a moment.
1:06
vm.confirm_password. If that doesn't match
1:09
we want to turn all this data back but we also want to set an error
1:12
so we'll say vm.error, it's going to be whatever the error was.
1:18
And then all of this goes away we just say "return vm.to_dict()",
1:22
remember, it can't give it itself.
1:24
So look how this what we need to get from the form is gone,
1:29
we are going to remove this in a moment,
1:31
the concept of doing the testing here is well and let's try it one more time.
1:36
Go over here and try to register, this will be "jeff", hit Enter, oh oops,
1:43
my little print statement is killing us here,
1:46
I forgot to move that over, and let's just delete this, alright,
1:50
that was just telling us that was being called, right,
1:51
this is not actually part of the form or anything,
1:53
this is just me trying to print this out and from the previous one.
1:56
Let's do it again.
1:58
We repost it, ta-da, error, the password and confirmation don't match
2:02
because I entered two values, let me just put the word "the" into both of them
2:06
and now it should run through that comparison and it should be all good.
2:11
Boom, your account is valid.
2:13
Last step, let's move this validation into the view model,
2:15
so I am just going to take this and we'll say vm.validate, this is a thing I am making up,
2:22
we can call it whatever we want.
2:24
So down here it's going to just run whatever test we had, well how about this,
2:28
of course vm doesn't make sense here but "self" does, and let's start by saying this,
2:35
the beginning of this validate we are going to just in case null out the errors,
2:40
and then we are going to do this, if there is some kind of failure,
2:46
we are going to set the error, maybe this error should be a list of errors, who knows,
2:49
but for this sample case, we are just going to make it a single string,
2:52
not a set of errors that could possibly occur.
2:55
OK, and then up here we are going to say "validate"
2:57
and then we are just going to say "if there is an error,
3:01
we don't really care or know what it is, we just don't want to display the page", OK,
3:06
so we are going to create the view model, we are stored from the POST data,
3:11
we'll do a validation and we'll just see if it failed the validation
3:15
we'll go and just show the form again, we don't have to worry in this area what happens,
3:19
but what we do care about is up here, we'll start working with vm.email and things like that
3:24
to create the account assuming everything was setup OK.
3:28
Alright, last bit, let's try, one more time.
3:32
So over here, we'll put in an email address,
3:34
the password is going to be, I'll make them mismatch for a minute,
3:39
we'll try this, error, it doesn't match,
3:41
alright, this should be identical behavior as we had before.
3:44
Now they do match, boom, look at that, how nice is that,
3:47
we could also add additional validation here,
3:49
we could say things like "if self"... "if not self.password",
3:55
like if the password is empty, you could say something like this,
3:58
like maybe we want to bail out of here
4:01
as soon as we can so we could change this to return right,
4:04
we are not collecting a set of errors, and we'll say "if not self.email"
4:12
OK, great, now we are really validating for all the things that we probably care about,
4:15
we could also check for valid email using regular expression or whatever,
4:18
but you can get the idea, right, so if I just hit "register", you must specify a password,
4:22
the password doesn't match, I better remember what I typed,
4:26
make the match, you must specify an email address,
4:30
see how it carries the data back around, beautiful, let's pick that one,
4:34
let's say go, and boom, we are registered.
4:38
So you can see we've created this thing I called the view model,
4:40
based on our ViewModelBase, which really is just to give us this to_dict as a common feature
4:46
and it stores various fields that the template is going to need,
4:52
initially it's empty it could allocate these from a database or somewhere
4:55
but this one, there is no data to start with, so it starts like this,
4:58
and we have a from_dict, which will read the form POST basically,
5:02
and then a validation, and look how much simpler this becomes.
5:06
So let's go over here, I'll show you cool trick on the accounts control,
5:10
I can go to local history, show history, I haven't checked this into GitHub
5:13
but let's have a look anyway, so we can compare this against yesterday,
5:20
oops, that's not good enough, there we go,
5:22
so we can compare this against this, so you can see that the GET call is much simpler,
5:27
this register here is just the to_dict
5:29
and no longer does the controller really care about the data that's being exchanged,
5:33
it only has to work with the data that it cares about,
5:35
so we've pushed that off to the view model and look how much simpler this has gotten,
5:40
all this stuff about getting this thing or that,
5:42
you know, getting the password, "what was it called in the form again?", forget it,
5:47
that's the view model's problem, it goes to the from_dict,
5:49
this I took away because I just didn't want to edit it, and this validation,
5:53
here we only had one but you saw we really needed
5:55
three or four different validations at least,
5:58
and so those were all moved and expanded down into this "validate",
6:02
and we just look at the error.
6:06
So this view model idea is a bit of a new concept that layers
6:09
on top of what we are doing here, but once you start working with it,
6:12
you really want to keep working on it because it makes the separation so much simpler
6:17
and these controller actions become ridiculously simple
6:21
so I encourage you to adopt it in your own app as well.
