Our resources are ready for action, but they don't yet

know how to take in input from our users.

We need some way of telling them what pieces of data they should expect,

like a title and URL for the courses, and also what those pieces of data should be.

Title should be strings, for example.

If we were doing this with models and

views, we'd use a form or some other sort of validation library.

Flask restful actually provides a validation library for

us that works really well, it's called reqparse, and it's for

parsing requests, let's go see how to use it.

So once I get reqparse set up,

I'm gonna be using Postman to test the API that I'm building.

This is a good time for you to go and get it installed though, there is both

a Chrome app and an OS X app, both are free and work more or less the same way.

I'll put a link to their site in the teachers notes.

I'm going to go ahead and put in the Chrome app though, because,

you know, I'm running Chrome.

And the cool thing is,

it pops up here in your little bar and then you hit Postman and there's Postman,

so cool, I'm going to skip that go straight to the app.

Reqparse tells the API how to parse incoming requests.

If you've used the Python module arg pars it's pretty similar so

what I wanna do this over here and courses.py, I need to import reqparse.

And then, I'm gonna add a parser to the course list thing here

first of the course list resource.

I don't know why I call it a thing, it's just a thing today.

All right, so, inside init, we're gonna do self.reqparse

= reqparse.RequestParser,

sometimes you just can't predict the variable names.

And so self.reqparse.add_argument, so we add arguments to

the parser for each of the things that we want to have come in each of the fields.

So for courses, I want to have one for title, I wanna have one for URL.

So let's add title first.

It is true, it is required, you have to have it.

If you don't give it to me, I'm going to say, no course title provided.

I could just say, no title provided, but either way.

And then location is actually going to be a list, it's going to be form and json.

So what this says is that, I need to tell reqparse where to look for this data.

So, I'm telling it to look in forming coded data or

to look in json data, which is in the body of the request.

Whichever one comes last is the one that's looked at first,

it's a little weird, but that's the way that one works.

All right so let's add the other argument here, self.reqparse.add_argument,

you can probably guess how most of this goes.

It's going to be url, required=true,

help=No course URL provided,

and location is gonna equal form, and json.

There are lots of other locations, I will link

to that documentation in the teacher's notes, so you can check that out.

Everything here is fairly straightforward, this is very similar to a forms library,

where you're kinda specifying what all this stuff is.

And by the way, if you're familiar with REST you might be thinking form here is

form data and it's not it's the X dash dab dab dash form URL link encoded

header which is like the standard one that HTML forms send.

So the basically the idea here is you can send a form to your API and

it'll work just like you were sending an XHR request or something like that.

And then at the end here, I do want to go ahead and

call super, and call init on that.

All right, so there we go.

This just makes sure that the standard set up goes ahead and it happens.

Let's look over here at Postman, now the cool thing is you can you see this

history thing you can save your post and stuff, which is kinda neat.

So, let's come over here and

get the URL, which is that one, all right.

If I do a get to courses and send, then I get back Json.

That's cool, that's exactly what we expected to get.

Okay, so let's try and do just a blank post to

it and I get back method is not allowed for this requested URL.

You know what I forgot all about that, I didn't add a post, did I?

All right let's go, we've got to get, let's add a post.

All right it's a def post(self), all right, and

then let's actually break apart these arguments.

So args=self.reqparse .parse_args,

I dare you to say that line like five times fast.

And we're gonna return jsonify, you know what, we're gonna return.

We're gonna return nothing.

Okay, so we get the same response back on get or post but

on post it parses these args.

All right, so now,

I should be able to post it because the method's allowed now, I should have it.

So let's hit send and no course title provided, that's right,

I didn't provide a course title.

And if you look here, you can see the status is a 400 bad request.

So good, that's what i should get because it is a bad request,

it doesn't have all of the right data.

All right so let's come over to body and let's say raw and

then we're going to put in title is Python Collections.

Okay, so we're just gonna send that, that's all we're gonna send.

Can I change, yeah.

So JSON application JSON, okay, so send.

And what did I get here, I got No course URL provided,

which is also true, I did not provide a URL.

All right, now, let's say URL and

i'm just gonna send python-collections because I'm just playing with this,

I don't know what I'm doing.

Let's send that, and I get back the data.

Wow, okay, so I got back a 200,

everything's okay, and I got back the data.

This isn't what I wanted to get though, because python-collections,

right here, that's not a valid URL.

So we need to make the parsers smarter.

Okay flask REST will come with a bunch of predefined inputs,

you can make your own but you often probably don't have to though.

The one that I need is included, so I'm going to use it.

So I'm gonna come up here to reqparse and I'm also import inputs,

going to have a lot of imports here from restful.

So, now title here by default these are always strings so

I don't need to add anything there.

So here on add argument, I'm going to add a new argument to the argument and I'm

gonna be type and I am going to put the type is a URL and it comes from inputs.

So now let's see what happens when I try to post a bad URL.

So I hit send, and now I've got the 400, and the no course URL provided.

Great, because that's true, I did not send a URL.

All right, so now what if I send an actual valid URL?

Let's come back over here https://teamtreehouse.com/library/python--

collections.

All right, so send that.

I have 200 and I got back my courses list.

So cool, that's the 200 that I expected.

I want to add one more part, I wanna actually save the model instance.

I'm not going to about changing the output though.

Because that's just a lot of trouble for right now and

we'll deal with that in a minute.

So I've got models imported already, so that's cool.

So then down here once I parse the args,

the args basically become a dictionary of all these items.

So I'm gonna do is I'm gonna do models.Course.create(**args).

And that will take the args dictionary and feed all of that data into Course.create.

So, cool, and now, if I go and submit my thing again,

still got a 200 and I don't have a way to look at this yet.

We'll check out the data that's in the database, in the next video.

For now though,

I'm gonna add the rest of these request parsers, while you do a code challenge.

You should try and do the requests parsers yourself too, to both course,

singular, and to review list and review.

And in the next video you can compare yours to mine.

Reqparse handles the request part of the request response cycle,

we still need to deal with the response half.

We'll do that in the next video.