Added passport auth

.gitignore

@@ -1 +1,2 @@
-node_modules
+node_modules
+.env

controllers/orderController.js

@@ -0,0 +1,60 @@
+const Order = require('../models/orderModel')
+
+exports.create_order =  async (req, res) => {
+        const body = req.body;
+
+        const total_price = body.items.reduce((prev, curr) => {
+            prev += curr.price
+            return prev
+        }, 0);
+
+        const order = await Order.create({ 
+            items: body.items,
+            created_at: moment().toDate(),
+            total_price
+        })
+
+        return res.json({ status: true, order })
+}
+
+exports.get_order = async(req, res) => {
+        const { orderId } = req.params;
+        const order = await Order.findById(orderId)
+
+        if (!order) {
+            return res.status(404).json({ status: false, order: null })
+        }
+
+        return res.json({ status: true, order })
+    }
+
+exports.get_orders = async(req, res) => {
+        const orders = await Order.find()
+
+        return res.json({ status: true, orders })
+    }
+
+exports.update_order = async(req, res) => {
+    const { id } = req.params;
+    const { state } = req.body;
+
+    const order = await Order.findById(id)
+
+    if (!order) {
+        return res.status(404).json({ status: false, order: null })
+    }
+
+    if (state < order.state) {
+        return res.status(422).json({ status: false, order: null, message: 'Invalid operation' })
+    }
+
+    order.state = state;
+
+    await order.save()
+
+    return res.json({ status: true, order })
+}
+
+exports.delete_order = async(req, res) => {
+
+}

controllers/user_controllers.js

@@ -0,0 +1,108 @@
+const User = require('../models/user_models')
+const passport = require('passport')
+const bcrypt = require('bcryptjs')
+const jwt = require('jsonwebtoken')
+const LocalStrategy = require('passport-local')
+const JWTStrategy = require('passport-jwt').Strategy
+const ExtractJWT = require('passport-jwt').ExtractJwt
+
+require('dotenv').config()
+
+passport.use(
+    new JWTStrategy(
+        {
+          secretOrKey: process.env.JWT_SECRET,
+          jwtFromRequest: ExtractJWT.fromAuthHeaderAsBearerToken()
+        },
+        async (token, done) => {
+          try {
+            return done(null, token.user)
+          }catch (err){
+            done(err)
+          }
+        }
+    )
+)
+//register method
+passport.use(
+    'signup',
+    new LocalStrategy(
+        {
+          usernameField: 'email',
+          passwordField: 'password',
+          usertypeField: 'user_type'
+        },
+        async (email, password, user_type) => {
+          try {
+            const user = await User.create({ email, password, user_type})
+
+            return done(null, user)
+          }catch (err){
+            done(err)
+          }
+        }
+    )
+)
+
+passport.use(
+    'login',
+    new LocalStrategy(
+        {
+          usernameField: 'email',
+          passwordField: 'password',
+          usertypeField: 'user_type'
+        },
+        async (email, password, done) => {
+          try {
+            const user = await User.findOne({ email })
+
+            if (!user){
+              return done(null, false, { message: 'User does not exist' })
+            }
+            const validate = await User.isValidPassword(password)
+
+            if (!validate){
+              return done(null, false, { message: 'Invalid username or password'})
+            }
+            return done(null, user, { message: 'Logged in successfully' })
+          }catch (err){
+            return done(err)
+          }
+        }
+    )
+)
+
+// exports.registerUser = async(req, res) => {
+//     try {
+//         // hash the password
+//         req.body.password = await bcrypt.hash(req.body.password, 10);
+//         // create a new user
+//         const user = await User.create(req.body);
+//         // send new user as response
+//         res.json(user);
+//       } catch (error) {
+//         res.status(400).json({ error });
+//       }
+// }
+
+exports.loginUser = async(req, res) => {
+    try {
+        // check if the user exists
+        const user = await User.findOne({ username: req.body.username });
+        if (user) {
+          //check if password matches
+          const result = await bcrypt.compare(req.body.password, user.password);
+          if (result) {
+            // sign token and send it in response body
+            const token = await jwt.sign({ username: user.username }, process.env.JWT_SECRET);
+            res.json({ token });
+          } else {
+            res.status(400).json({ error: "password doesn't match" });
+          }
+        } else {
+          res.status(400).json({ error: "User doesn't exist" });
+        }
+      } catch (error) {
+        res.status(400).json({ error });
+      }
+}

index.js

@@ -1,85 +1,24 @@
-const express = require('express');
-const moment = require('moment');
+const express = require('express')
+const passport = require('passport')
+require('dotenv').config()
 const mongoose = require('mongoose');
-const orderModel = require('./orderModel');
-
-const PORT = 3334
+const orderRoutes = require('./routes/orderRoutes')
+const userRoutes = require('./routes/user_routes')
+const port = process.env.PORT || 5000
 
 const app = express()
 
-app.use(express.json());
-
+app.use(express.json())
+app.use(express.urlencoded({ extended: false }))
 
 app.get('/', (req, res) => {
     return res.json({ status: true })
 })
 
+app.use('/orders', passport.authenticate('jwt', { session: false }), orderRoutes)
+app.use('/users', userRoutes)
 
-app.post('/order', async (req, res) => {
-    const body = req.body;
-
-    const total_price = body.items.reduce((prev, curr) => {
-        prev += curr.price
-        return prev
-    }, 0);
-
-    const order = await orderModel.create({ 
-        items: body.items,
-        created_at: moment().toDate(),
-        total_price
-    })
-
-    return res.json({ status: true, order })
-})
-
-app.get('/order/:orderId', async (req, res) => {
-    const { orderId } = req.params;
-    const order = await orderModel.findById(orderId)
-
-    if (!order) {
-        return res.status(404).json({ status: false, order: null })
-    }
-
-    return res.json({ status: true, order })
-})
-
-app.get('/orders', async (req, res) => {
-    const orders = await orderModel.find()
-
-    return res.json({ status: true, orders })
-})
-
-app.patch('/order/:id', async (req, res) => {
-    const { id } = req.params;
-    const { state } = req.body;
-
-    const order = await orderModel.findById(id)
-
-    if (!order) {
-        return res.status(404).json({ status: false, order: null })
-    }
-
-    if (state < order.state) {
-        return res.status(422).json({ status: false, order: null, message: 'Invalid operation' })
-    }
-
-    order.state = state;
-
-    await order.save()
-
-    return res.json({ status: true, order })
-})
-
-app.delete('/order/:id', async (req, res) => {
-    const { id } = req.params;
-
-    const order = await orderModel.deleteOne({ _id: id})
-
-    return res.json({ status: true, order })
-})
-
-
-mongoose.connect('mongodb://localhost:27017')
+mongoose.connect(process.env.MONGO_URI)
 
 mongoose.connection.on("connected", () => {
 	console.log("Connected to MongoDB Successfully");
@@ -90,6 +29,6 @@ mongoose.connection.on("error", (err) => {
 	console.log(err);
 });
 
-app.listen(PORT, () => {
-    console.log('Listening on port, ', PORT)
+app.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`)
 })

middleware/auth_middleware.js

@@ -0,0 +1,29 @@
+require("dotenv").config(); // loading env variables
+const jwt = require("jsonwebtoken");
+
+// MIDDLEWARE FOR AUTHORIZATION (MAKING SURE THEY ARE LOGGED IN)
+exports.protect = async (req, res, next) => {
+  try {
+    // check if auth header exists
+    if (req.headers.authorization) {
+      // parse token from header
+      const token = req.headers.authorization.split(" ")[1]; //split the header and get the token
+      if (token) {
+        const payload = await jwt.verify(token, process.env.SECRET);
+        if (payload) {
+          // store user data in request object
+          req.user = payload;
+          next();
+        } else {
+          res.status(400).json({ error: "token verification failed" });
+        }
+      } else {
+        res.status(400).json({ error: "malformed auth header" });
+      }
+    } else {
+      res.status(400).json({ error: "No authorization header" });
+    }
+  } catch (error) {
+    res.status(400).json({ error });
+  }
+};

orderModel.js → models/orderModel.js

@@ -3,7 +3,7 @@ const mongoose = require('mongoose');
 const Schema = mongoose.Schema;
 const ObjectId = Schema.ObjectId;
 
-const OrderSchema = new Schema({
+const orderSchema = new Schema({
   id: ObjectId,
   created_at: Date,
   state: { type: Number, default: 1 },
@@ -16,6 +16,6 @@ const OrderSchema = new Schema({
   }]
 });
 
-const Order = mongoose.model('Order', OrderSchema);
+const Order = mongoose.model('Order', orderSchema);
 
 module.exports = Order;