Our routes are all written and

we've implemented all the HTTP verbs we plan to handle.

However, there is a problem.

There isn't much code to handle the actions outside of what we planned for.

In the next video, we'll see how to handle the common errors that might come up.

When a request is sent to our API,

it would be nice to get a little more information about it, and

the details about the response the server has to that request.

In other words,

we want an automated logger, something that logs out useful information.

Let's install another piece of middleware to help with that.

We can use a module called Morgan.

We can configure Morgan to log HTTP status codes as well as the routes for us.

In the terminal, run npm install

--save morgan@~1.7.

When that's done, we can move over to our app.js

file in our text editor and include it.

Let's put a required statement with our other required statements at the top

of the code to keep our code organized.

Let's call this logger, and require morgan.

Now we can connect it to our app with use, passing in dev to our logger function.

This will configure the middleware to give us colorful status codes for

our API's responses.

Feel free to check out the documentation from Morgan in the teacher's notes.

Let's build our answers routes now.

When we go to test them later, we'll see what Morgan does in action.

Going back to our routes.js file in the text editor,

let's enter our next route that we planned.

We planned a route to create an answer.

This route is POST

/questions/:id/answers.

We plan to use the post method for this route.

When implementing this route handler, remember to leave off /questions.

Our router is already mounted to questions.

Let's modify the response we say when we're reposting to /answers.

And return the questionId, too.

The next route we can handle is the PUT request to a specific answer.

As we build this route, You might notice a problem.

The problem is,

is that we have two parameters in the URL that have the same name.

This won't work.

One will override the other.

We need to give them different names.

Let's go back and

add updates to all the routes with the question ID with a new parameter of qID.

We can call the answers ID, aID

Let's copy the handler from the post route and

paste it into the put route and modify it with the appropriate response.

And have it respond with the answer ID too.

With the request params aID

We also need a delete handler for this route.

This will delete a specific answer.

Let's update the method we call from put to delete, then delete the req.body.

And finally update the response text.

Last of all, we'll create the routes for voting on answers.

Let's copy and paste this DELETE route.

And change delete to post.

Let's describe what URLs we want handled by this route.

The POST route,

Where we can upvote, And downvote.

These are to vote on a specific answer.

The URLs are identical except for the vote-up or the vote-down at the end.

We can capture these two possibilities with a parameter, and

we can use one route for both.

We can capture only part of the string we want.

So let's grab the up or down from the last part of the route.

We can call the parameter dir for direction.

Now let's modify the response

in the POST request, To

/vote-" and then

the req.params.dir.

Let's also include the vote down here at the bottom too.

Now let's test our routes out.

Switch over to the terminal, stop the server if it's running, and

clear the screen.

Now start up the server again.

In Postman,

let's send a POST request to

localhost:3000/questions/6/answers

with the body prop value.

We see that works.

In the Postman results window, we see the response that we constructed.

Now let's switch back to the terminal to see our new logging in action.

Our Morgan logging middleware has given us the HTTP verb,

the URL requested, the color coded status code 200, among other things.

Let's change our HTTP method to PUT.

Then change the URL

to localhost:3000/questions/9/answers/33,

with the same JSON body.

Hit Send, and let's see what happens.

We get the correct response.

Make sure the questionId is 9 and that the answerId is 33.

Now let's send a DELETE to the same URL.

Check the response is what you expect, that it's a DELETE

request with the questionId of 9 and the answerId of 33.

Finally, let's send a POST request too.

Localhost:3000/questions/5/answers/78/vot-

e-up.

See that the route was read correctly.

Let's check vote-down.

That works too.