Updating A Course's Difficulty, Status, or Access Level

In This Lesson

We'll add a specific endpoint with the ability to patch a course's difficulty, status, or access level with a new value so our users have a way to update these without needing to send the entire course payload.

Created by: @tomgobich
Published: 1 year ago

Join the Discussion 0 comments

Be the first to comment!

Transcript

- Now at present, in order for us to update a course's status, difficulty, or access level,
within our API, we need to update the entire course, which contains the name, access level, status, and difficulty as all required properties within that.
So we would need to provide the entire payload of our course to update any one of those. But in our UI here, we have the ability
to toggle them one by one via these little dropdowns here. So what would be great is if we also had a way to do that within our API, so that we didn't need
to post up the entire body payload of our course to update any one of them. So within our courses controller, what we wanna do is add a new method
that will be relatively similar to the method that we're doing this with on our courses controller outside of our API. So if we scroll down to that, we have this tag method right here,
and we'll be doing mostly the exact same thing, just returning back differently. We'll be returning back an API response rather than redirecting back to our UI. Great, so within our courses controller,
let's go ahead and add in that tag method. So async tag, let's grab our params so that we know what course it is that we're dealing with, the request so that we can validate our data,
and the organization from our HTTP context. And as always, the first thing that we need to do is authorize our token. And this is gonna be an update because we're updating the tag,
which is a combined name that we've chosen for our difficulty statuses and access levels for the course itself. The course needs to pre-exist in order for us to update any one of those.
So we'll pass into the authorized tokens update method, our organization, to verify that the interfacing application has permission to update this. Then we'll go ahead and await
our update course tag action, importing that, and we'll call the handle method passing in the ID from our params ID,
the data, and then the organization. Oh, right, we skipped a step. We have to validate our data as well.
So const data equals await request validate using, and we should have a course patch tag validator, if I can spell it right, patch tag validator.
There we go. And that too is going to need our with organization metadata so that the validator, if we take a look at it here, can go ahead and make sure that the status or difficulty
or access level actually exists within the organization. Additionally, these are all optional, but they all are required if the other two are missing. So for our status ID,
if the difficulty ID and access level are missing, then it is going to be required, despite it being optional, thanks to this required if missing.
The other two look the exact same as the status ID here. So from our validator, we're going to get back our data that has either an access level difficulty or status ID populated. If we did not provide it in the payload,
then it will be undefined, and our update operation will ignore it and leave it be. Within our update course tag action, we're querying the course that we're updating
off of our organization via the ID that we're passing in, and then just merging that data, which is what's going to omit or ignore
those undefined properties that we've passed in, allowing us to update any one of those three. So perfect. Let's go ahead and close that out and finish this off
by returning back the response from our course tag, which is our actual courses updated information. So we can go ahead and just simply return directly back from there.
Now, this new method's not going to be handled within our route definitions for our resource on our courses. Instead, what we need to do is add a specific route definition for it.
So underneath our resource here, let's do router. And since we're updating partial data, I'm going to go ahead and set this as a patch request. Since we're not updating the entire course, we're just updating specific properties
or a single property within it. And for the routes pattern, let's do /courses/id, mimicking the route definition structure
that will be set by our resource here. And then tag is what we're calling these. And then tag is the universal term that we're using to reference the access level status or difficulty
within our courses, modules, and lessons. So we'll do /tag there, so that we know with this patch request, we're updating the specific course for the ID that we're passing in
and specifically updating one of its tags. Then to handle this route, we'll use our courses controller and its tag method for that.
Then we'll go ahead and give it a name of as courses.tag. All right, so we can give that a save and let's jump on over to Hopscotch and get a new request set up for this.
So we'll call this patch course tag, save it. And with this, we want to switch the HTTP method from post to patch.
Then let's jump back over to our get courses here and take a look at what exactly the tag IDs are. Okay, so my first course is all ones
for our access level difficulty and status IDs there. So let's hone in on our first course and then note that we want to patch the tag.
Within our body, we only need to specify one of the three that we want to update. So if we wanted to update our access level ID,
we'd specify that and we could set it to something like two since it's currently one. If we send this off, we're going to get back our 200 OK response with our updated courses details
now set to the access level of an ID of two. Thanks to our validation, if we set this to an ID that does not exist within this organization, send this off,
we're going to get back a validation error noting that the selected access level ID is invalid. And this tag update operation should work for our difficulty ID.
We set that to two, send that off, as well as our status ID. If we send that off, that's going to now update all three to the ID of two
where they were all previously one.

Adding an API to an AdonisJS Web App

43 Lessons

5h 31m

Introduction

API Authentication

Getting Started with APIs

Organization Resources

Courses

Searching

Rate Limiting

Rate Limiting an Organization's HTTP Requests

13m 59s

Stop losing your best ideas!

Use our integrated note feature to capture and organize your key insights. Take a note at any timestamp and jump instantly back to that moment in the video with a single click.