Create endpoint for user-registration

What does this MR do?

1. Installing libraries and setting up the npm environment

Libraries:

• mongodb
• express
• mongoose
• nodemon
• bcrypt
• jsonwebtoken
• cors
• multer
• mongodb-memory-server

2. Connect with 'mongodb-memory-server' initially (Will change it to MongoDB Atlas later)

3. Create endpoints for POST requests - /register, /login, /updateUser, /user/:username

4. Create User.model.js which contains the properties of the schema using mongoose

5. Create Controllers for /register, /login, /updateUser, /user/:username

6. Validate authentication

Starting Project

Start server by npm start in the daily-thought-user-service/server directory

Testing endpoints

a. Register Route [/register]

Valid registration -

Username Exists -

Email Exists -

b. Login Route [/login]

You have to register first, and then log in. You can only log in with your username and password.

Valid Login -

User Not Found (Invalid User) -

Invalid Credentials (Password Does not Match)

c. GetUser Route [/user/:username]

You have to register first, and then can use this route. It is a GET request.

Valid User

Invalid User

d. Update User [/updateuser]

This is a PUT Request. After you register and login, you have to get the 'token' from the login route. You have to paste this token in the Auth>Bearer of the /updateuser.

Then you click send, and you will get the following response:

If you go to the GetUser [/user/:username] route again, you will see the email and profile got updated.

Relevant issues

Please ensure the 'Mongoose' is of version "mongoose": "^6.8.0",, as some methods do not work in the newer version.

daily-thought-user-service/server/controllers/appController.js

+import UserModel from '../model/User.model.js';
+import bcrypt from 'bcrypt';
+import jwt from 'jsonwebtoken';
+import ENV from '../config.js'
+
+// Middleware
+export async function verifyUser(req,res, next){
+
+    try{
+
+        const { username } = req.method == 'GET' ? req.query : req.body;
+
+        // Check if user exists
+        let exist = await UserModel.findOne( {username } );
+        if(!exist) return res.status(404).send({ error: "Can't find User"});
+        next();
+
+    } catch (error) {
+    
+        return res.status(404).send({ error: "Authentication Error"})
+    }
+}
+
 /** POST: http://localhost:8080/api/register
  * @param : {
   "username" : "example123",
@@ -7,7 +30,61 @@
 }
 */
 export async function register(req,res){
-    res.json('register route')
+
+  try {
+      const { username, password, profile, email } = req.body;        
+
+      // Checking existing Username
+      const existUsername = new Promise((resolve, reject) => {
+          UserModel.findOne({ username }, function(err, user){
+              if(err) reject(new Error(err))
+              if(user) reject({ error : "Please use unique username"});
+
+              resolve();
+          })
+      });
+
+      // Checking existing Email
+      const existEmail = new Promise((resolve, reject) => {
+          UserModel.findOne({ email }, function(err, email){
+              if(err) reject(new Error(err))
+              if(email) reject({ error : "Please use unique Email"});
+
+              resolve();
+          })
+      });
+
+
+      Promise.all([existUsername, existEmail])
+          .then(() => {
+              if(password){
+                  bcrypt.hash(password, 10)
+                      .then( hashedPassword => {
+                          
+                          const user = new UserModel({
+                              username,
+                              password: hashedPassword,
+                              profile: profile || '',
+                              email
+                          });
+
+                          // return save result as a response
+                          user.save()
+                              .then(result => res.status(201).send({ msg: "User Registered Successfully"}))
+                              .catch(error => res.status(500).send({error}))
+
+                      }).catch(error => {
+                          return res.status(500).send({
+                              error : "Enable to hashed password"
+                          })
+                      })
+              }
+          }).catch(error => {
+              return res.status(500).send({ error })
+          })
+  } catch (error) {
+      return res.status(500).send(error);
+  }
 }
 
 /** POST: http://localhost:8080/api/login 
@@ -17,5 +94,100 @@ export async function register(req,res){
 }
 */
 export async function login(req,res){
-    res.json('register route')
-}
\ No newline at end of file
+   
+    const { username, password } = req.body;
+
+    try {
+        
+        UserModel.findOne({ username })
+            .then(user => {
+                bcrypt.compare(password, user.password)
+                    .then(passwordCheck => {
+
+                        if(!passwordCheck) return res.status(400).send({ error: "Don't have Password"});
+
+                        // create jwt token
+                        const token = jwt.sign({
+                                        userId: user._id,
+                                        username : user.username
+                                    }, ENV.JWT_SECRET , { expiresIn : "24h"});
+
+
+                        return res.status(200).send({
+                            msg: "Login Successful...!",
+                            username: user.username,
+                            token
+                        });                                    
+
+                    })
+                    .catch(error =>{
+                        return res.status(400).send({ error: "Password does not Match"})
+                    })
+            })
+            .catch( error => {
+                return res.status(404).send({ error : "Username not Found"});
+            })
+
+    } catch (error) {
+        return res.status(500).send({ error});
+    }
+}
+
+
+export async function getUser(req,res){
+
+    const { username } = req.params;
+
+    try {
+
+        if(!username) return res.status(501).send({error: "Invalid Username"});
+
+        UserModel.findOne({username}, function(err, user){
+            if(err) return res.status(500).send({err});
+            if(!user) return res.status(501).send({ error: "Couldn't find the User"});
+            
+            const { password, ...rest } = Object.assign({}, user.toJSON());
+
+            return res.status(201).send(rest)
+        })
+
+    }catch(err) {
+        return res.status(404).send({ error: "Cannot find User Data"});
+    }
+}
+
+/** PUT: http://localhost:8080/api/updateuser
+ * 
+. * @param: {
+  "header" : "<token>"
+}
+body: {
+    firstName: '',
+    address : '',
+    profile : ''
+}
+*/
+export async function updateUser(req,res){
+    try {
+        
+        const {userId} = req.user;
+
+        if(userId){
+            const body = req.body;
+
+            // update the data
+            UserModel.updateOne({ _id : userId }, body, function(err, data){
+                if(err) throw err;
+
+                return res.status(201).send({ msg : "Record Updated...!"});
+            })
+
+        }else{
+            return res.status(401).send({ error : "User Not Found...!"});
+        }
+
+    } catch (error) {
+        return res.status(401).send({ error });
+    }
+}
+