Exercise (Video): Mongoose ODM Part 2

Loading...

Do curso por The Hong Kong University of Science and Technology

Server-side Development with NodeJS, Express and MongoDB

240 ratings

The Hong Kong University of Science and Technology

Server-side Development with NodeJS, Express and MongoDB

240 ratings

Curso 5 de 5 em Specialization Full Stack Web and Multiplatform Mobile App Development

This course deals with all things server-side. We base the entire course around the NodeJS platform. We start with a brief overview of the Web protocols: HTTP and HTTPS. We examine NodeJS and NodeJS modules: Express for building web servers. On the database side, we review basic CRUD operations, NoSQL databases, in particular MongoDB and Mongoose for accessing MongoDB from NodeJS. We examine the REST concepts and building a RESTful API. We touch upon authentication and security. Finally we review backend as a service (BaaS) approaches, including mobile BaaS, both open-source and commercial BaaS services. At the end of this course, you will be able to: - Demonstrate an understanding of server-side concepts, CRUD and REST - Build and configure a backend server using NodeJS framework - Build a RESTful API for the front-end to access backend services

Na lição

Data, Data, Where art Thou Data?

This module looks in detail at data storage with MongoDB, the popular NoSQL database. You will learn first about Express generator for scaffolding an Express application. Then you will learn about MongoDB. You will learn how to interact with MongoDB from a Node application. Then you will learn the Mongoose ODM to create schemas and models, and interact with MongoDB server.

Mongoose ODM21:58

Exercise (Video): Mongoose ODM Part 118:15

Exercise (Video): Mongoose ODM Part 214:18

Conheça os instrutores

Jogesh K. Muppala
Associate Professor
Department of Computer Science and Engineering

In this exercise, we're going to continue working on

the Node Mongoose server that we developed in the previous exercise.

We'll do another variation of that.

In addition, we will also look at how Mongoose supports

subdocuments and this enables us to store a document inside a document,

for storing additional information.

Let's look at that in the exercise next.

Continuing with the example that we have been working on.

Now, in the index.js file,

now we'll see a new way of creating a Dish and adding into our application.

So earlier, we had done var newDish and Dishes and defined the Dish.

Now in this case,

we will use a new method called Dishes.create,

which takes as a parameter the newDish to create and then,

saves it in our application.

So, instead of doing this newDish.save,

we can simply remove that and directly deal with the Dishes.create method here.

And so, the Dishes clear method will take as a parameter,

a new document that needs to be stored in

our database and then creates and adds the document to the database.

Thereafter, we can continue with the rest of the exercise.

This minor modification will show

that the same application runs exactly the same way as before.

So with this change,

let me just change the indentation here,

so that the chaining of the.then method is very clear.

So, we first do a Dishes.create,

which will return a promise and then change to.then and then we will carry out

the remaining steps on the created dish.

Let's save the changes,

and then go and take a look at this version of our server going to the terminal.

Once again, running the application,

we see that it will create exactly the same as the previous variation of the server.

So we are creating a new dish here and then insert it into the database.

And thereafter, we are retrieving that dish and then printing out on the screen.

With this change, this is a good time for us to do

a git commit with the message Mongoose part two.

So, let's check the git status and then add the files to

the repository and then do a git commit with the message Mongoose part two.

Continuing with the exercise,

in the next step,

we are going to add in a subdocument to

the document and see how subdocuments can be stored in our database.

So going to dishes.js file,

I'm going to add in another schema into my dishes.js file called

as commentSchema and then

define this as new Schema.

And in this commentSchema as you would have already expected,

we're going to use this to store comments about the dish.

So the comments will contain a rating field which is of the type: Number,

And it's minimum value is one.

Maximum value is five.

And required is true.

So you can see that when you use a feel with the type: Number,

you can specify the boundaries for it if you choose to.

Then, that next field is a comment field,

which would be of the type: String.

So this stores a message and then required is true.

And then, we'll also add another field called author,

which is of the type: String and required is true.

And, they will also add that timestamps field

for this and set it to true.

So for every comment that is added,

we will also store the corresponding time stamp.

So, now that we have declared a commentSchema,

we can then go ahead and modify the dishSchema to be able to store comments.

So within the dishSchema we can add in comments,

which is an array of the type commentSchema.

So which means that every dish object,

dish document can have multiple comments stored within an array inside the dish document.

So this is a that comment documents become subdocuments inside a dish document.

So we are storing all the comments about the dish

inside the dish itself as an array of comment documents.

So, this is the usage of the subdocument in Mongoose.

After this, let's go to the index.js file and then modify our index.js file.

In here, they create the dish just like before,

then after we create the dish,

then we console.log the dish.

Thereafter, we will update that dish.

So, it will say Dishes.findByIdAndUpdate.

So, we're going to modify the dish that we just inserted in that previous step.

So it will say findByIdAndUpdate,

and begin to supply it.

This takes two parameters.

The first parameter is the dish._id.

Now, this dish._id of course,

refers to this dish that we have just inserted,

and then we're going to modify that same dish in the next step.

So we'll say, dish._id and then within brackets, we specify, $set,

description, Updated test, and new: true.

So this, we are modifying the dish that we have

just inserted by updating its description there.

Now, this has to be enclosed inside.

This second flag that we are supplying here,

new: true, means that,

once the update of the dish is complete,

then this will return the updated dish back to us.

So that's the reason for using this flag here, say new: true.

So this dish will be returned in the next step,

and so we're going to take that dish and then print out that dish.

So in the next step,

we're going to modify this and say this,

then dish, and then we do a console.log(dish).

Then after this, we're going to insert a comment into the dish,

so we'll say, dish.comments.push.

Recall, that the comments is a field inside the dish.

So going back to the schema,

we see that this comments is in array of the commentSchema type.

So which means that we can push an item into this array.

So going back here, we'll say, dish.comments.push,

and then we'll push a comment document into a dish here.

So I will say, dish.comments.push,

and specify the fields here, so we'll say,

rating: five, comment, and author.

And so this will push this comment into that comment field of this specific dish.

So now that we have modified the dish,

the next step that we're going to do is to,

let me close off this and then put that into it,.then there.

I'm going to come back and fix that in a short while.

So now that we have modified the dish,

we need to save the dish,

so we'll say, return dish.save.

So in this step,

we are inserting a comment into the dish,

the dish that we just created and updated,

and then we are saving that comment,

and then this will return the dish and when

the dish is returned in the next callback,

I'm going to then say,

console.log(dish), and then after that,

we will say return db.collection('dishes').drop().

So we'll drop the collection,

and then close the database and of course catch and deal with the error here.

So with this, we have modified our index.js file.

Let's save the changes and look at this application running in the top.

So saving all the changes.

Going to the terminal.

Let's run NPM start,

and then see the resulting value here.

So going back, we see that in the first step,

we have created this dish here with the name and description as we have given earlier.

And then once the dish is created,

in the second step,

we updated the dish and then printed out the updated version of the dish.

So the updated version of the dish is printed out right there,

and you can see that the description has been updated from the previous case,

but the _id remains exactly the same as the dish that we created earlier.

And the comments field, as you can see here,

is an empty array of this locked.

In third step, we push a comment into our dish here,

and then so this particular comment that

we added has been added into this comments array,

so you can see that comment being enclosed here,

and this is the updated dish that has been now imprinted on to the screen here.

So you can see that we have done several steps.

One after another with our dish.

We first created the dish,

then we updated the dish,

then we inserted a comment into the dish,

which is a subdocument inside the dish document,

and then we print it out the result.

With this, we complete this exercise.

In this exercise, we have seen how we can first create a dish by using Dishes.create.

Then, we saw the use of subdocuments,

where we define a schema within the dishes.js file,

and then use that commentSchema that we define and then

define the field in the dishesSchema,

as an array of that commentSchema type.

And then, in the index.js file,

we were able to create a dish,

update the dish, and also push a comment document into the dish,

and then save the changes here.

With this, they complete this exercise.

This is a good time for you to do a git commit with the message, Mongoose part 3.

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2018 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play