‫In this video, let's implement document updating.
‫And so, here, in our update tour handler, let's start by
‫making it an async function.
‫Then, or try catch block, and so I'm doing this
‫very quickly now, because we're already used to this
‫at this point.
‫Right?
‫So this goes into the try block and then
‫I simply get this one, here, from the catch block
‫of this other function.
‫All right, so.
‫Here we go.
‫And so now, what we need to do here
‫at the beginning of this try block
‫is to basically query for the document that
‫we want to update and then update it, all right?
‫And we can actually do that
‫all in one command with mongoose.
‫And, remember, again, that we're gonna update the tour
‫based on an ID, okay?
‫So, it's a similar situation like this one here,
‫where we find by ID.
‫And now, we can actually do something very similar,
‫which is find by ID and update.
‫So again, everything in one query.
‫So, let's do tour.findByID
‫and update.
‫Okay, so, what do we need to pass in here?
‫Well, of course, the ID, so that we can first find
‫the document that is to be updated.
‫So, just like before, that is req.params.ID,
‫and then the data that we actually want to change.
‫And that data will be in the body,
‫just like in the post request.
‫So req.body, okay?
‫And then, actually as a third argument,
‫we can also patch in some options, and we will do that.
‫And the first option that I want to specify is new
‫and set it to true.
‫Because this way, then the new updated document
‫is the one that will be returned.
‫And since we want to send back that updated document
‫to the client, we always want this method
‫to actually return that new document, okay?
‫So this way, it actually then makes sense to
‫await this query and then save it to a new variable.
‫So then simply call it tour here,
‫and then again, await the result of this query.
‫So all of these methods that we've been using on the tour
‫so far, so find by ID and update, or,
‫well, not really create, but find by ID or find,
‫all of these will return queries, so they are query methods
‫and let me actually show that to you
‫in the mongoose documentation.
‫So, up until this point, we didn't have a look at
‫the documentation so far.
‫And so, let's quickly do that.
‫So, on the model, which in our case is tour,
‫we have all these query methods, right?
‫So you see find, you see find one, you see find by ID,
‫which is just a shorthand for find one.
‫Then you see find by ID and update,
‫which is the one that we're currently using,
‫and which, in fact, is just a shorthand for
‫find one and update, where we're querying for an ID,
‫so similar to what we had in the last lecture, okay?
‫And actually we can click on any one of these,
‫so let's do the one that we're using currently,
‫and that will then really take us to the API documentation
‫which shows us how to really use a certain method.
‫So you see that we passed the ID, so the value,
‫off the ID to query by, we passed the object with
‫the data to be updated, and we passed an options object.
‫And down here we can actually see
‫the options that we can set, so remember,
‫we just set new to true, and so as it says here
‫that will then return the modified document
‫rather than the original.
‫Now, another one that we actually want to set to true
‫is this run validators, so that each time that we update
‫a certain document, then the validators that we specified
‫in the schema will run again, okay?
‫And we will talk a lot about validators and validation
‫a bit later in the section,
‫but I'm gonna leave it here for now so that we, basically,
‫don't forget it.
‫Okay?
‫Give it a save now, and actually I wanna go back here
‫just to show you how many methods
‫we actually have in mongoose.
‫So, on the model, we have all of these methods here
‫that you see in this list.
‫So for example we used create before,
‫we also used find.
‫Okay?
‫And so the ones that you see here in the top,
‫they are available right on the model,
‫and that, in our case, is the tour.
‫Now, down here you, for example also see
‫model.prototype.safe for example.
‫And this one, we actually also already used
‫right when we first started to work with mongoose.
‫So I'm not sure if you are familiar with this,
‫but in java script model.prototype always means
‫an object created from a class, or in this case,
‫created from a model.
‫And so, the save method here, refers to a save method
‫called on a document and not on a tour.
‫And remember that that's exactly what we did.
‫And I think I still have it here as a comment.
‫Yeah, right here.
‫So, we had a tour, this new tour variable here
‫which was created from the tour model,
‫and so this new tour here got access to the save method
‫because that is part of the prototype object of this class.
‫All right, now I don't want to bore you with the
‫fundamentals of java script, but it is important
‫in order to understand the documentation, okay?
‫Because at some point you will need to use documentation,
‫because mongoose is yute.
‫And I will actually teach you a lot of the stuff
‫that's important in there through all of this course,
‫but sometimes you will still need something that
‫I didn't show you in this course.
‫And so it's important that you really understand
‫the documentation as well, okay?
‫And so, again, when you see model.prototype here,
‫you know that the save method here
‫is going to be available on all of the instances
‫created through a model, okay?
‫And so, not the model itself.
‫So, for example, if you tried tour.save
‫you wouldn't be able to use it.
‫It would give you an error, but instead, if you tried save
‫on a document created through the tour,
‫then it would, of course, work, okay?
‫I hope that makes sense.
‫And, anyway, you see that we have a lot of other stuff,
‫so we have to query, which we already talked about,
‫because, for example, find by ID and update, or find,
‫or find by ID, all of these will return query objects.
‫And so, later on, when we're gonna implement stuff like
‫sorting or filtering we will then use this query object.
‫Okay?
‫So, let's go back, we kind of got off the track here
‫by looking at the documentation,
‫but, again, I think it's really important
‫to start looking at the documentation,
‫because a course like this can only take you so far,
‫and I hope you already know that at this point, okay?
‫It's really important that you're also able to
‫find information on your own, and I wanna show you how
‫to do that also in this course.
‫Anyways, let's now actually also send
‫this newly updated tour back to the client,
‫which, right now, we're not doing, because we have
‫simply this updated tour here string.
‫So let's get rid of that and simply send to tour.
‫And remember that this, in fact, is actually this.
‫So, the tour property is set to the tour object,
‫but, thanks to ES6, we no longer have to do that
‫when the property name has the same name of the value.
‫Okay, so let's get rid of that.
‫That makes our code look a bit better.
‫Okay, and let's now test it.
‫Back to postman, here we have the updated tour route.
‫And so, let's actually do it
‫on this same ID that we used before.
‫So, this one.
‫Then we come to the body, here, and let's change--
‫Well, what are we gonna change here?
‫Well, let's change the price to, like, 500.
‫So, price, 500,
‫send it, and indeed this gives us
‫the newly updated object with the price
‫already set to 500.
‫And if we now get all tours, then that, of course,
‫should be reflected here.
‫And here it is.
‫But now, let's say that we set it to a string.
‫Let's take a look at what happens, then.
‫Well, then we actually get an error.
‫And that's because we ran the validators again.
‫So, remember that we have--
‫Where is that?
‫Oh yeah, here.
‫So here we specify that the validators should be run again.
‫And so, right now the price is no longer a number
‫as it is expected, right?
‫So in a schema we say that the price should be a number,
‫but, of course, java script, or mongoose, actually,
‫cannot, basically, convert this string here to a number.
‫But that is what we expect.
‫So here it says kind should be number.
‫And so, therefor, it gives us an error,
‫simply because we're running the validators again.
‫So, let's put it back to 500 and then, of course,
‫it's gonna be back.
‫All right, now, keep in mind that we're actually
‫doing a patch request here.
‫Now, if we were doing a put request, remember,
‫then you would expect that the original object
‫would be completely replaced
‫with the new one that is sent in, okay?
‫So, in that case it would no longer work
‫the way we implemented here
‫because this one simply really updated the fields
‫that are different here in the body, okay?
‫But anyways, I think that the patch method
‫is actually way more useful, and so,
‫that's gonna be the only one that implementing here.
‫Cool, so we have three of our four correct operations
‫implemented, only one more left to go,
‫which is gonna be delete.