Feature/google authentication

.gitignore

@@ -56,10 +56,10 @@ typings/
 
 # dotenv environment variables file
 .env
+*.env
+config/variables.env
 
 # next.js build output
 .next
 
 secretKey.js
-
-config

config/secretKey.js.example

@@ -0,0 +1,5 @@
+module.exports= {
+    token : {
+        key : 'keys'
+    },
+}

config/statusMsg.js

@@ -1,11 +1,32 @@
-module.exports= {
-    success : {
-        msg : "Success"
+module.exports = {
+    success: {
+        msg: "true"
     },
-    fail : {
-        msg : "Failure"
+    fail: {
+        msg: "false"
     },
-    email :{
-        msg: 'A verification email has been sent to '
+    email: {
+        msg: "A verification email has been sent to "
+    },
+    token_exp: {
+        msg: "Token Expired"
+    },
+    no_user: {
+        msg: "User not found"
+    },
+    not_verified: {
+        msg: "User is not verified"
+    },
+    password_not_match: {
+        msg: "Invalid Password"
+    },
+    error: {
+        msg: "Some error"
+    },
+    email_verfied: {
+        msg: "Email already verified"
+    },
+    database_error: {
+        msg: "Database Error"
     }
 }

controller/authTokenGenerator.js

@@ -0,0 +1,18 @@
+const jwt = require('jsonwebtoken');
+const secretKey = require('../config/secretKey');
+const dotenv = require('dotenv')
+dotenv.config({
+    path: './config/.env'
+})
+
+const access_token = async (email) => {
+    return await jwt.sign({ email }, secretKey.token.key, { expiresIn: process.env.access_token_exp });
+};
+
+const refresh_token = async (email) => {
+    return await jwt.sign({ email }, secretKey.token.key, { expiresIn: process.env.refresh_token_exp });
+};
+
+module.exports = {
+    access_token, refresh_token
+};

controller/emailVerify.js

@@ -1,7 +1,7 @@
 const nodemailer = require('nodemailer')
 const path = require('path');
 var EmailTemplate = require('email-templates');
-exports.verifyEmail = async (email, host, token) => {
+exports.verifyEmail = async (email, name, host, token) => {
     let transporter = nodemailer.createTransport({
         service: process.env.GMAIL_SERVICE,
         port: process.env.PORT,
@@ -19,9 +19,11 @@ exports.verifyEmail = async (email, host, token) => {
     emails.send({
         template: path.join(__dirname, '..', 'email', 'mentors'),
         message: {
-            to: email
+            to: email,
+            subject: "Account Verification"
         },
         locals: {
+            name: name,
             host: host,
             token: token
         }

controller/facebookContoller.js

@@ -0,0 +1,142 @@
+const dotenv = require('dotenv')
+const request = require('request')
+const User = require('../models/user')
+const http = require('http-status-codes')
+const statusMsg = require('../config/statusMsg')
+const tokenGenerator = require('./authTokenGenerator')
+const bcrypt = require('bcrypt')
+const email_verify = require('./emailVerify')
+const { validationResult } = require('express-validator/check')
+const SALTING = 10
+dotenv.config({
+    path: './config/.env'
+})
+
+exports.facebook = async (req, res, next) => {
+    try {
+        const fb_access_token = req.body.accessToken
+        await request(`https://graph.facebook.com/v3.3/me?fields=id,first_name,last_name,email&access_token=${fb_access_token}`,
+            async (err, response) => {
+                const userInfo = JSON.parse(response.body)
+                const access_token = await tokenGenerator.access_token(userInfo.email)
+                const refresh_token = await tokenGenerator.refresh_token(userInfo.email)
+                const payload = {
+                    "accessToken": access_token,
+                    "refreshToken": refresh_token,
+                    "data": userInfo
+                }
+                try {
+                    if (await dbQuery.idExists(userInfo, refresh_token)) {
+                        return res.status(http.OK).json({
+                            "success": statusMsg.success.msg,
+                            "payload": payload
+                        })
+                    }
+                    else if (await dbQuery.emailExists(userInfo)) {
+                        await dbQuery.updateWithId(userInfo, refresh_token)
+                        return res.status(http.OK).json({
+                            "success": statusMsg.success.msg,
+                            "payload": payload
+                        })
+                    }
+                    else if (!userInfo.email) {
+                        return res.status(http.CONFLICT).json({
+                            "success": statusMsg.fail.msg,
+                            "payload": userInfo
+                        })
+                    }
+                    else {
+                        await dbQuery.createAccount(userInfo, refresh_token)
+                        return res.status(http.CREATED).json({
+                            "success": statusMsg.success.msg,
+                            "payload": payload
+                        })
+                    }
+                }
+                catch (err) {
+                    err.status = http.INTERNAL_SERVER_ERROR
+                    next(err)
+                }
+            }
+        )
+    }
+    catch (err) {
+        err.status = http.CONFLICT
+        next(err)
+    }
+}
+
+exports.reauthorize = async (req, res, next) => {
+    const errors = validationResult(req)
+    if (!errors.isEmpty()) {
+        return res.status(http.UNPROCESSABLE_ENTITY).json({
+            "success": statusMsg.fail.msg,
+            "payload": "",
+            "error": {
+                "code": http.UNPROCESSABLE_ENTITY,
+                "message": errors.array()
+            }
+        })
+    }
+    try {
+        let role = null
+        if (req.body.user_role == 1) { role = "Mentor" }
+        else { role = "Student" }
+        let hash = await bcrypt.hash(req.body.password, SALTING)
+        const access_token = await tokenGenerator.access_token(req.body.email)
+        const refresh_token = await tokenGenerator.refresh_token(req.body.email)
+        const user = new User({
+            first_name: req.body.first_name,
+            last_name: req.body.last_name,
+            email: req.body.email,
+            user_role: role,
+            password: hash,
+            refresh_token: refresh_token
+        })
+        await user.save()
+        host = req.get('host')
+        await email_verify.verifyEmail(user.email, user.first_name, host, access_token)
+        const response = {
+            "accessToken": access_token,
+            "data": user,
+            "message": statusMsg.email.msg + user.email + '.'
+        }
+        res.status(http.CREATED).json({
+            "success": statusMsg.success.msg,
+            "payload": response
+        })
+    }
+    catch (err) {
+        err.status = http.CONFLICT
+        next(err)
+    }
+}
+
+const dbQuery = {
+    idExists: async (userInfo, refresh_token) => {
+        const facebookId = await User.findOne({ facebook_id: userInfo.id })
+        if (facebookId) {
+            await facebookId.refresh_token.push(refresh_token)
+            await facebookId.save()
+        }
+        return facebookId
+    },
+    emailExists: async (userInfo) => {
+        const facebookEmail = await User.findOne({ email: userInfo.email })
+        return facebookEmail
+    },
+    updateWithId: async (userInfo, refresh_token) => {
+        await User.findOneAndUpdate({ email: userInfo.email }, { facebook_id: userInfo.id, refresh_token: refresh_token })
+    },
+    createAccount: async (userInfo, refresh_token) => {
+        let user = {
+            first_name: userInfo.first_name,
+            last_name: userInfo.last_name,
+            email: userInfo.email,
+            facebook_id: userInfo.id,
+            verified_email: true,
+            refresh_token: refresh_token
+        }
+        await User.create(user)
+    }
+}

controller/googleController.js

@@ -0,0 +1,106 @@
+require('dotenv').config({
+    path: '../config/.env'
+});
+
+const httpStatus = require('http-status-codes');
+const googleOAuth = require('../middleware/googleOauthClient');
+const User = require('../models/user');
+const tokenGenerator = require('./authTokenGenerator');
+const statusMsg = require('../config/statusMsg')
+
+
+module.exports.oauthHandler = async (req, res) => {
+    let googleAuthToken = req.body.accessToken;
+    try {
+        const response = await googleOAuth.getUserInfo(googleAuthToken);
+        const userInfo = response.data;
+
+        const access_token = await tokenGenerator.access_token(userInfo.email);
+        const refresh_token = await tokenGenerator.refresh_token(userInfo.email);
+
+        const payload = {
+            access_token,
+            refresh_token,
+            data: userInfo
+        };
+
+        try {
+            //If the google id already exists in the db, update refresh token in the db
+            if (await dbQuery.idExists(userInfo.id)) {
+                return res.status(httpStatus.OK).json({
+                    "success": statusMsg.success.msg,
+                    "payload": payload
+                });
+            //if the google email exists in the db, link the accounts
+            } else if (await dbQuery.emailExists(userInfo.email)) {
+                await dbQuery.updateWithId(userInfo, refresh_token);
+                return res.status(httpStatus.OK).json({
+                    "success": statusMsg.success.msg,
+                    "payload": payload
+                });
+            //otherwise, create a new account
+            } else {
+                await dbQuery.createAccount(userInfo, refresh_token);
+                return res.status(httpStatus.CREATED).json({
+                    "success": statusMsg.success.msg,
+                    "payload": payload
+                });
+            }
+        } catch(error) {
+            console.log(error);
+            return res.status(httpStatus.INTERNAL_SERVER_ERROR).json({
+                "success": statusMsg.fail.msg,
+                "payload": {},
+                "error": {
+                    "code": httpStatus.INTERNAL_SERVER_ERROR,
+                    "message": statusMsg.database_error.msg
+                }
+            });
+        }
+    } catch(error) {
+        console.log(error);
+        return res.status(httpStatus.BAD_REQUEST).json({
+            "success": statusMsg.fail.msg,
+            "payload": {},
+            "error": {
+                "code": httpStatus.BAD_REQUEST,
+                "message": statusMsg.token_exp.msg
+            }
+        });
+    }
+};
+
+
+
+const dbQuery = {
+    idExists: async (id, refresh_token) => {
+        const googleId = await User.findOne({ google_id: id });
+        if (googleId) {
+            await googleId.refresh_token.push(refresh_token);
+            await googleId.save();
+        }
+        return googleId;
+    },
+    emailExists: async (email) => {
+        return await User.findOne({ email });
+    },
+    updateWithId: async (userInfo, refresh_token) => {
+        let google = await User.findOne({
+            email: userInfo.email
+        });
+        google.google_id = userInfo.id;
+        await google.refresh_token.push(refresh_token);
+        await google.save();
+    },
+    createAccount: async (userInfo, refresh_token) => {
+        let user = {
+            first_name: userInfo.given_name,
+            last_name : userInfo.family_name,
+            email: userInfo.email,
+            google_id: userInfo.id,
+            verified_email: true,
+            refresh_token
+        }
+        await User.create(user);
+    }
+};