All language subtitles for 003 Creating New Users_Downloadly.ir_en

All right, so let's now create

those new users, based on the model that

we just implemented in the last video.

So, we will do most of the user-related stuff

like creating new users, logging users in,

or updating passwords in the authentication controller.

So all of the stuff that's related to authentication really,

is not gonna be in the user controller

that we actually created before,

but instead we will create an authentication controller.

So all the functions that are related

to authentication will go here.

And this will make a bit more sense later on,

when we then start using all the functions

that I'm gonna put in here.

And now, the first thing that we need to do,

is to import our user,

so our user model of course,

and that is at one level up, then it should be in models,

and then userModel.

All right.

So, let's create and export our very first controller.

And I'm gonna call this one signup.

And so you see that I'm not calling it create user,

like I did in a tour controller,

but really I'm calling it signup because

that's the name that has a bit more meaning

in the context of authentication.

So it's gonna be an async function of course,

because we're gonna do some database operations.

Then request, respond, and next as always,

and then in here is where we create the new user.

And so that's very similar to what we did before.

So this time it's called newUser,

and then remember how we create

a new document based on a model.

So we use the model name of course,

which in this case is User, and then

on that we use the create method.

And then all we need to do is to

pass in an object with the data

from which the user should be created.

And so just like before, that data is actually in req.body.

And so all of this is gonna return a Promise,

and so we need to await that,

and so that's the reason why this is an async function.

And I see that up here, we need exports.

And now in the next step, we will then

actually send that newUser to the client.

So res.status, which is 201 for created,

and then our JSON object.

So that is success again,

and then our data property which is again

called an envelope here,

so a property that is gonna contain the data itself.

And the data is now called user,

when before it was called tour,

and so what we're gonna send in here is the newUser.

Give it a save, and before we try this out,

remember that this is an async function,

and so we need to think about error handling here.

So what do we need to do here?

Well, we need to wrap this entire function

that we just created into the catchAsync function

that we created in the last section.

So remember how we did that in the tourController,

where all of the functions that are asynchronous

are wrapped into this catchAsync function

so that we don't have to write

the try catch block in each and every function here.

Remember that from the last section?

So actually I'm gonna go ahead

and copy this require statement here.

So a bit lazy sometimes,

not feel like writing the same code over and over again,

so catchAsync, and then we need to

close that down right here in the end.

And now, all we need to do is to

actually implement the route so that

this signup handler here then can get called.

And so let's go to our userRoutes,

which we actually already created sometime before,

and we already have some routes in here.

But actually I'm gonna create a new one here now.

And as I mentioned right in the beginning of this video,

the user resource is a bit different

from all the other resources.

Again, because it really has to do with

all things authentication.

And so we have a different controller for that

so the authController, the function names

also have some different names,

and so we will actually also have a special route.

Let's say router.post,

and then we will create a route for signup, so /signup,

and then this is where we will use

that function that we just created before.

And of course before we can do that

we need to require that authentication controller.

So let's just duplicate this line here

and replace user in two places,

and so here we have our authController,

and so let's now use that.

.signup.

So as you see, the signup is really

kind of a special endpoint.

It doesn't fit the REST architecture

that we talked about before,

because in this case it doesn't make much sense.

And so remember how we said that

in some special cases, we of course can create

other endpoints that do not 100% fit that REST philosophy

that is basically implemented here.

So this here of course follows 100% the REST philosophy,

where the name of the URL has nothing to do

with the action that is actually performed.

While up here, of course, it has.

So the name of the route is signup

because we are signing up users.

And also down here we have implemented

all of these different HTTP warps

but in here for signup, we only really need POST.

So we cannot really get data from signup,

or we cannot patch patch a signup, so not update it.

Doesn't really make sense,

and so in this case all we want to do

is to have a route for signup,

where we can only POST data.

Because again, it makes only sense

to actually send data to this route,

so that the new user is then created.

And we will have different routes similar to this one,

like for login, or for reset password,

and all kinds of stuff like that.

And we will also keep these routes here

so the ones in a more REST format,

because there's also the possibility

of a system administrator updating or deleting

or getting all the users based on their ID.

But we will take care of that later,

for now we just want to implement

all the functions that are about authentication.

So basically functions that are

only relevant for the user itself.

So it's not an admin that is gonna sign up a user,

or it's not an admin that's gonna login a user,

but instead, it's the own user that's gonna

sign up himself, or log in himself.

Okay, does that make sense?

So we should have everything in place now,

so that it should now work when we create our new user.

So when we sign up basically, for our application.

So let's try that now.

Let's just copy this URL,

users, and then, signup.

Then we need to specify the Body,

we say raw, and then JSON.

Oh and also, don't forget of course,

to set this one to POST.

So, what data do we need here?

Remember, first one is the name,

then the email, and I'm putting my own here actually,

then the password, and so let's just

do something here, it doesn't really matter.

And again, we're gonna talk about

password management a bit later,

and actually right in the next video.

So now this one here should be the same.

So pass1234, just as a test.

And the photo remember is not required,

and so I'm not doing that.

And so let's see now.

And now we get this error here,

and that's because I misspelled password here.

Okay, so that would be the German way of writing it.

And now it's right.

Okay, and indeed, we get our new user here.

Perfect.

Now let's say that we tried to do this with a GET.

What would we get?

Well, "This route is not yet defined,"

which is because we actually already

kind of defined this route here,

so basically this part here of the route,

so let me quickly show you that,

so it's not in the tourController,

but in the userController.

So basically we have getUser here,

and then "This route is not yet defined."

So that's the one that we're getting,

but of course we're not not really interested in that.

And let's now go ahead and save this here,

to Postman so that we can then easily reuse it.

So Sign Up.

And now just to quickly confirm,

let's actually open it in Compass here as well,

and just see that at this point we only have tours,

and so let's go here to natours, try to reload this,

and that's probably up here,

and so indeed, now we get our users collection here.

So let's open that up, and indeed,

we now get our first document here.

So the user that we just created.

Now in here you can see the plain password,

and so of course that is not ideal.

And of course, that is not ideal,

so in a web application, passwords should never never ever

be stored as plain in a database.

So there's a lot of password management that needs to go on

behind the scenes, and so that is

exactly what we will do in the next video.