All language subtitles for 008 Modelling Reviews_ Parent Referencing_Downloadly.ir_en

In this video, let's continue to translate

the data model that we established right at the beginning

of the section into some actual code.

And so, this time we're gonna implement the reviews model.

So the first step is to create a new file

in the models folder and call it ReviewModel.js.

And to me, this looks like yet another great challenge

for you to practice some of the skills

that you already learned up to this point.

Okay so, in this challenge, I want you to create

the review model.

And what we need in there is actually very simple.

So let me put that here in a comment.

So we basically want a review,

so the text for the review.

We want a rating

so just like this.

Then we also want a createdAt

so with the current timestamp

and then we also want a reference to the tour

that this review belongs to

and also to the user who wrote this review.

Okay, so basically two parent references here, right.

And so with the stuff that you learned

in the last couple of lectures,

you should be able to actually complete this challenge

completely on your own.

So, pause the video now and good luck with that.

Now, okay, so I hope you didn't just skip this

and instead, you really implemented it by yourself

and anyway, this is how I created it.

So of course, we need to start by requiring mongoose

and then

the reviewSchema is equal to new mongoose.Schema.

And so let's start adding our fields.

So first the review is of course a string.

Now, right and of course, I'm doing this too fast,

so I also need to specify type

and then let's also set it to a required,

true,

review can not be empty.

Then we want a rating,

and this one is of the type number.

And the rating is ideally between one and five.

And so the minimum of one and the max is five.

So as you already know,

these are some simple validators.

That work only for numbers, right.

This is not correct here.

Okay.

Next up, the createdAt.

Into this is of type, date,

and by default we want

Date.now.

Okay.

So this was the easy part.

And lets actually also create a model

and export it before adding these references.

So const,

Review is equal too mongoose.model

with the name Review.

And then of course reviewSchema.

To finish of course module.export

equals the Review.

Alright, and now comes the reference part.

So a review of course needs to belong to a tour.

And it also needs an author.

Okay.

So that's again what we specified

in our data modeling lecture.

So basically that we were going to implement

parent referencing here in this case.

Because both the tour and the user

are in a sense the parents of this data set.

And we decided to do it this way

because we are going to potentially

huge erase any parent elements right?

So we should not design our application

thinking that there will only be a few reviews.

Only to then come back to it after some time

and find out that our assumptions were wrong.

And now we need to rebuild our entire data model.

So that would be terrible.

So in many situations, as you already know

what we do not really know, how much our erase will grow.

Then it's just best to opt for parent referencing.

So again, that's exactly what we're doing here

when we're referencing tour and user.

So lets actually now go ahead and implement that.

And starting with the tour.

Alright.

So here we need some space, and okay.

So the type is as we did before, mongoose,

and that's not correct.

So mongoose.Schema.ObjectId,

with a capital O and a capital I, but not the D.

And I'm just telling you that

because I once wrote ID like this,

and then spent half an hour trying to figure out

why my application wasn't working.

Okay, so this D needs to be lowercase.

Anyway.

The reference in this case is of course the tour.

And we also want to make this required.

So true and then Review must belong

to a tour.

Okay.

And just like this, each Review document now knows

exactly what tour it belongs too.

While the tour of course doesn't know initially

what Reviews and how many Reviews there are.

But that it a problem that

we will actually solve a bit later.

Okay.

Next up, when there is a Review, we not only

want to know what tour it belongs to,

but also who wrote this Review.

So user,

and again, the same type of

mongoose.Schema.ObjectId,

and this time

the reference, as you can imagine is gonna be user.

Okay, and again we make it required

because well, a review really cannot work

without an author basically.

And so review

must belong to a user.

Okay, that's actually it.

Alright.

Now just to finish lets actually also add these options

to the Schema where we make it so that virtual properties

also show up in Json and object outputs.

Okay.

So we did that before in the tours.

I'm not sure if we did it in the user model.

But anyway, here we are actually

gonna need it a bit later.

So we need to specify that.

Remember, basically what I mean

is this part.

So I'm actually going to go ahead and copy it.

Just to save us some time.

And so again, all this does is to really make sure

that when we have a virtual property,

basically a field that is not stored in the database

but calculated using some other value.

So we want this to also show up whenever there is an output.

Right, and so that's what we do here.

Okay.

And so I actually think that's actually it for now.

Very simple.

The only a bit tricky part is actually to create

these references here.

But we actually did that before

and so it really works in the exact same way.

So in the next video we will then use the Schema

in order to create some new reviews.

So see you then.