RESTful and HTTP APIs in Pyramid Transcripts
Chapter: A nearly RESTful service
Lecture: Creating cars, RESTfully
Login or
purchase this course
to watch this video and the rest of the course contents.
0:01
Before we add the modification features to our api let me just talk really quickly about a little bit of reorganization that I've done for you.
0:08
So, the previous service that we created together I put that into its own folder, and I have given it various safe points
0:16
and now I've created a new service called restful auto service, so you'll be able to distinguish the two first service, restful auto service.
0:23
Also, I made a snapshot of exactly what we're starting with and called it like starter or something like that in that folder
0:29
so if you want to follow along, you can grab that and work from there, it should be exactly what I've started from myself.
0:35
Okay, so let' s just run it and remind ourselves where we are; okay, so we have our auto service, basic restful auto service
0:42
and we we're working with two url structures here so one we can get all of the autos, all the cars here, like so
0:50
and we are going to do a get against that or, if we have an individual car, we could get its details by saying api /auto/ whatever its id there is.
1:00
Now, if we're going to create a new car do we need a new url, do we want to use the same url? The way this typically works is, if you know the location
1:10
of the thing that you're trying to modify, we'll use this; so like if we're going to do a put and update it, we'd probably use that url,
1:16
if we're going to do a delete, we'll definitely use that url but with post, usually the server is the thing that ultimately decides where it is,
1:23
this is often the primary key or something like that that gets generated on the server side, so we don't know where it would live,
1:29
so we can't do like a post to its not yet existing location. So what we're going to do, is we are going to do a post against that url
1:36
and we're going to submit the details of the car, like its price and whatnot, and then, the server will return back the finally created one
1:45
with its location and things like that. Ok, so let's go over here, as you can see if we're starting from this one
1:51
probably the all cars is a good thing to model off of so let's go over here to the api, and here's the all cars
1:58
and let's put this modification stuff down below here for a minute, okay so this is going to be all autos, but we're not going to use get
2:07
that was the one that displayed them, we're going to use post and we're going to keep the same renderer for here
2:13
and instead of doing this, we're going to do a couple of different things. The first thing that we need to do is get the submitted body,
2:21
like what car was delivered to us, so let's go over here and we'll just say for now return nothing, so how do we do that?
2:29
Well, here notice there was this request and I gave the underscore to say I don't care about it,
2:34
but you know what, I do care about it now, so let's put it back and let's even use the type hints, type annotation stuff
2:39
so that we could get a little help if you're not familiar with this. Alright, so we'll come over here and we'll say request.
2:45
now, there's lots of places data gets submitted to us there is the matchdict, there's the get, the post, dictionaries,
2:51
but what's coming in here is a body, and it doesn't come in as a form body
2:55
it comes in as json, and the way we get that is there's a json body property;
3:00
basically what it does is it looks to json text or it looks at the text in the body
3:04
and then it uses the json library to pars it into a Python dictionary. So, this is going to give us our data,
3:11
now, that's all well and good, but it just blissfully passes this along to the json serialization, deserialization bit
3:19
and if there's something like there is no body or there is something wrong with it,
3:24
this is going to crash, so we're going to need to be a little bit careful there. So let's go ahead and put this into a try except block here,
3:32
and in case there is an error, we need to, we could just let it crash right, or return something,
3:38
but we want to be very restful here, so we're going to return a response and the status is going to be 400, number 400 stands for bad request
3:47
something broke and it's your fault, not the server's fault that it broke. And for the body, we could put some kind of message like
3:54
could not parse your response as json, something like that, and we're going to of course return this, all right.
4:02
Now, PyCharm has given us a little bit of a warning let me just tell it to leave us alone for now.
4:08
Okay great, so we've either told them that what they have given us didn't work or we've now parsed it into a proper object.
4:16
The next thing to do, we should probably add some validation here but for the time being, let's just put the validation on hold
4:23
and let's just try to convert this and save this as a car. So we have our repository and it has an add,
4:31
it does not yet have an add car, we're going to write an add car and we are going to have the data, and just add that, okay.
4:37
Now, we're going to do something a little bit funny here, so let's rename this to make it a little more obvious— car data,
4:45
now, this thing where we're adding this value here what we're going to do is we're actually going to take
4:52
whatever is created by the repository the data access layer, and use that and then we want to return this back as well.
5:00
Now, there's another possibility here that something goes wrong maybe we can't talk to the database or something like that,
5:06
so we're going to do something like this. Now, whether this should be 400, because some validation at the data layer failed
5:14
or it should be 500, because we can't talk to the server, we probably should be a little more careful,
5:19
but for now let's just say could not save car, all right, great, so one of the reasons we might not be to save the car
5:26
is there's no add car method, let's add that. All right, so for now, remember we are just using this fake data things
5:32
we're going to stash it in here, so we'll say cls.car_data of well, we're going to need some kind of key
5:43
up here notice, we're doing this little trick as we read it from the file to generate one of these fake ids and so it's a key = row
5:50
the row is what we're after, car data is what we're calling it right now. And then, let's return that, okay
5:58
so whether this is the same object we're passing back or we're actually generating a new object which might be the case in the database
6:05
we're going to go and save this, the most important thing is this now is going to have an id we're going to need that in a little bit.
6:13
Okay, so let's go and test it. If I click here, you'll find it's not the easiest thing so what do I click, even if I put a thing
6:22
I guess I could put a little form that submits something to test it but that seems a little hooky,
6:27
so when we get into things that are not get it's a little bit easier to use something outside the browser,
6:32
I know you can get plug in for the browser, but they're not as nice so let's go over here and look at postman.
6:39
So first, we have our get request and let's just run that and make sure it's working,
6:43
oh it is not— this is very interesting, let's go back and see why this is not working.
6:48
All right, so it's not the problem here, the problem is down here; remember the way Python works is when you execute that bit of code
6:56
when you literally parse this file, it executes this which defines an object like name this, all autos and down here, we are executing this bit of code
7:06
and it's defining the thing called all autos as well and replacing the value of the previous one, but this time it only listening here,
7:13
so we need to change the name of this to something like this, create auto or something like that, so it no longer is listening to get
7:22
it is only listening to post, all right. So now we got this back, and let's just take the body of one of these
7:28
because that's going to tell us what we need and we can come over here and duplicate this,
7:33
alright, so we're not going to do a get, we're going to do a post against that url and we're going to need to supply a body, alright.
7:39
We don't want this form data we want to just do raw, do this, make sure it has no id, it doesn't really matter but it's not going to,
7:46
and this is going to be the opel concept or whatever and 29 thousand euros and I guess this is fine, we'll start out with no damage.
7:59
So what we are going to do, so we are going to post this here, it's going to look at the request method as well as the url,
8:07
together it's going to say okay this function create auto is the one we should run well, convert this to a Python dictionary by calling json body,
8:15
come back to validation, we're going to assume that we're entering it, right, that's a big assumption and then we're going to go to the repository
8:23
and we're going to store this into our little temporary in memory database give it a primary key and return it back
8:28
and because of the renderer is json it's going to convert it back to json. All right, try this one more time. So here we got a post, here is our body
8:37
we'll see the response down here, go. And look at that, we got 200 ok that's pretty awesome
8:44
we can look at the brand, the opel concept, it's pretty much the same except if you scroll down, notice it now also has an id
8:52
so we could go back and just verify this now is a thing that exists in our database, so let's duplicate this again;
8:59
I want to do /autos/get/ this id here, and look there's our opel concept
9:04
and the price is 29 thousand, and the year, and all the stuff that we just set is there.
9:09
All right, so we've now added this ability to create new things, new automobiles for sale at our dealership.
9:17
So, that's great, now obviously we're skipping some validation and we're going to come back and do that but let's work on the other ones as well,
9:24
throughout this section we'll work on the updating this thing we just created and if we want to take it off we could even delete it.