‫All right, in this lecture,
‫we're going to talk about something called
‫nested routes, what they are,
‫why we need them, and how we can
‫actually implement them in Express.
‫Let's think for a second how in practice,
‫we actually want to create a new review.
‫Up until this point, when creating new reviews,
‫we always manually passed the tour ID
‫and the user ID into the request body,
‫and then created the review from there, right.
‫That's okay during development, but of course,
‫that's not how a review will
‫be created in the real world.
‫So, in the real world, the user ID
‫should ideally come from the currently logged in user
‫and a tour ID should come from the current tour.
‫That should ideally be encoded
‫right in the route, so in the URL.
‫When submitting a post request for a new review,
‫we will want to submit that to a URL like this.
‫Let's write that down here just as a comment.
‫Ideally, we will want to do a request
‫for post, for tour, and the ID of the tour,
‫it doesn't really matter here, and then reviews.
‫Okay, so now, just like this,
‫we have the tour ID right in the URL
‫and the user ID will then also come
‫from the currently logged in user.
‫What we see here is now a so-called nested route.
‫They make a lot of sense when there is
‫a clear parent-child relationship between resources.
‫That is clearly the case here, right.
‫Reviews is clearly a child of tour.
‫This nested route basically means
‫to access the reviews resource
‫on the tour's resource, all right.
‫In the same way, we will actually also want to
‫access reviews from a certain tour in the same way.
‫Let's say then a get request,
‫and again for tour slash tour ID and slash reviews.
‫This would then ideally get us
‫all the reviews for this tour.
‫We could go even further
‫and also specify the ID of the review.
‫So again, just a random string here,
‫but you get the point.
‫In this case, we would get review
‫with the ID of this here
‫on the tour with this ID.
‫This is what nested routes are all about.
‫This is a way more easier way of reading
‫and understanding how the API works for our API users.
‫It's way easier then messing around with
‫query strings and all that stuff like that.
‫Also, it really shows how there is
‫this clear relationship between these resources,
‫again, reviews and tours.
‫All right, but enough talk.
‫Let's now actually implement this
‫starting with the post route.
‫Now, since the route actually starts with tours,
‫it will be of course redirected to our tour router.
‫We're going to have to implement this functionality
‫at least for now, in the tour router,
‫even though that seems a bit counter-intuitive
‫since we're in fact, dealing with reviews.
‫But again, for now, let's implement it like this.
‫We come to our user router
‫and first, since we're actually
‫going to use reviews here,
‫we need to import the review controller.
‫Controller require.
‫Maybe I should have just copied the line from before.
‫Controllers, and review controller.
‫All right, now here at the very bottom,
‫and let's actually get our code
‫for this example from here
‫just as a reference.
‫So that we can now actually implement it.
‫The route that we're going to implement here is
‫slash ID and then reviews.
‫This tour part here, as you already know,
‫is where we mounted this router
‫and so therefore, we do not have to repeat it here.
‫But then, we have the tour ID and then slash reviews.
‫In order to make this really clear,
‫let's actually call it tour ID
‫since we're now dealing with
‫different resources here.
‫So it's a bit clearer to really call it what it is.
‫We now want to implement the create review.
‫Authcontroller dot protect.
‫We also want to restrict access only to users,
‫and then of course, our review controller dot create
‫review, all right.
‫Again, it is a bit weird and counter-intuitive
‫to actually call the review controller
‫here in the user route.
‫Well actually, it should not be in the user route.
‫For some reason, I opened the user routes
‫and not the tour routes, so sorry for that one.
‫Let's cut it from here, come to our tour routes,
‫and actually do it here at the bottom.
‫Of course we also need to get the review controller.
‫So now we should be good to go.
‫That was a stupid bug.
‫But anyway, what I was saying is that
‫it doesn't make much sense to actually call
‫the review controller in the tour route,
‫but again, for now, we need to do it like this
‫because the route starts with tour.
‫It's this router that will get activated.
‫In the next video, we're going to fix that,
‫but for now, we just want to make it work
‫and to become familiar with
‫this whole concept of nested routes.
‫Anyway, we now got our tour ID right in the route,
‫but of course, we need to let
‫the controller know that it should now use this tour ID
‫and also the currently logged in user's ID.
‫We now need to go ahead
‫and update our review controller
‫right here at create review.
‫What we're going to do is this.
‫We will say, if there is no request dot body
‫dot tour, so basically if we didn't specify
‫the tour ID and the body,
‫then we want to define that
‫as the one coming from the URL.
‫Req dot body dot tour equals request,
‫and now remember how that URL parameter
‫is on request dot params and then of course,
‫the name of the parameter itself, so tour ID.
‫This is the first part and second,
‫we also need to do the same with the user.
‫If there is no request dot user,
‫or actually, request dot body dot user,
‫well then the request dot body dot user
‫should be request dot user dot ID.
‫And again, we get request dot user from
‫the protect middleware, and that's actually it.
‫Let's just put a comment here, nested routes.
‫With this, we actually make it so
‫that the user can still specify manually
‫the tour and the user ID.
‫What we're doing here is simply
‫to define them when they are not there
‫or when they are not specified in the request body.
‫This should be enough for us to test this now.
‫All right, so let's take a look
‫at the users that we got at this point.
‫We have these two regular users,
‫we have the test user and we have Jonas here,
‫but we forgot his password.
‫Let's go ahead and delete this user
‫and create a new one.
‫All right, so in Compass, the users,
‫and it's this one.
‫Let's recreate this user basically.
‫All we really need is these two pieces of data.
‫Actually that's sign up.
‫The same name, the same email
‫and the same password as well.
‫At this point, we are already logged in as this user,
‫so-called Jonas, let's keep that in mind.
‫Next up, we need to choose which tour
‫we actually want to create the review on.
‫Let's again do it here at The Forest Hiker
‫so that then we get multiple reviews on the same tour.
‫What we're going to now
‫is to basically access that nested route
‫that we just created.
‫We have the tours.
‫Now we need to get the tour ID,
‫and again, we're going to use this one
‫for The Forest Hiker,
‫and then slash reviews,
‫and then remember a post.
‫Then we also need to specify the authorization,
‫so bearer token, and then now in the body,
‫all we really need is to
‫specify the rating and the review.
‫The rating is five
‫and then some text here.
‫So this should actually already be enough to try this out.
‫Let's send it.
‫Now we don't have permission to perform this action,
‫for some reason, so that's weird.
‫We signed up as this Jonas,
‫and it's actually just a normal user
‫like it's supposed to be.
‫Let's take a look at our router.
‫Here, oh okay, it's user, not users.
‫A small bug like that can, as you see,
‫crash this entire route, so let's try it again now.
‫And now we actually get the final review
‫with both the tour and the user correctly defined.
‫At least I hope so.
‫The tour ID, you see, ends here in 951,
‫and so it's exactly the same here.
‫The user is this 1f3, and so indeed,
‫it is this exact same one.
‫All right, and so now we should actually be able
‫to confirm that, and so this get tour here
‫is actually already the one that we were
‫creating the new review on.
‫Let's take a look, and indeed,
‫we now get two reviews.
‫This one is the one that we just created.
‫It is on the correct tour and of course,
‫also the correct user with the name of Jonas.
‫Awesome, that's really cool.
‫Let's go ahead and save this.
‫I'm going to create a new folder here again.
‫I'm going to call it tours slash reviews.
‫Now in here, let's create,
‫create new review on tour.
‫That should actually be outside and just like this.
‫Let's actually put that one here.
‫It doesn't really work as it should for some reason.
‫And here we go.
‫All right, that worked just fine,
‫but as I mentioned before, the implementation
‫is a bit confusing at this point.
‫And again, that is because we technically defined
‫a review route in the tour router.
‫That's a bit confusing, and so in the next video,
‫we are going to fix that.