Making a PR for the pizza app

.gitignore

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

authorization.js

@@ -0,0 +1,73 @@
+const passport = require('passport');
+const localStrategy = require('passport-local').Strategy;
+const UserModel = require('./model/userModel');
+
+
+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);
+            } catch (error) {
+                done(error);
+            }
+        }
+    )
+);
+
+passport.use(
+    'signup',
+    new localStrategy(
+        {
+            usernameField: 'username',
+            passwordField: 'password'
+        },
+        async (username, password, done) => {
+            try {
+                const user = await UserModel.create({ username, password });
+
+                return done(null, user);
+            } catch (error) {
+                done(error);
+            }
+        }
+    )
+);
+
+
+passport.use(
+    'login',
+    new localStrategy(
+        {
+            usernameField: 'username',
+            passwordField: 'password'
+        },
+        async (username, password, done) => {
+            try {
+                const user = await UserModel.findOne({ username });
+
+                if (!user) {
+                    return done(null, false, { message: 'no user found' });
+                }
+
+                const validate = await user.isValidPassword(password);
+
+                if (!validate) {
+                    return done(null, false, { message: 'Wrong Password' });
+                }
+
+                return done(null, user, { message: 'Logged in Successfully' });
+            } catch (error) {
+                return done(error);
+            }
+        }
+    )
+);

controller/orderController.js

@@ -0,0 +1,103 @@
+const orderModel = require('../model/orderModel');
+const moment = require('moment');
+
+exports.createOrders = async function (req, res, next){
+    try {
+        const body = req.body;
+        const total_price = body.items.reduce((prev, currItem) => {
+          prev += currItem.price * currItem.quantity;
+          return prev;
+        }, 0);
+        const order = await orderModel.create({
+          items: body.items,
+          created_at: moment().toDate(),
+          total_price,
+        });
+        return res.status(201).json({ status: true, order });
+      } catch (error) {
+        res.status(404).json({ message: "failed to post orders", error });
+      }
+
+}
+
+exports.getAllOrders = async function (req, res, next){
+    try {
+        const queryObj = { ...req.query };
+        const reservedkeys = ["sort", "page", "limit"];
+        reservedkeys.forEach((key) => delete queryObj[key]);
+        let orderQuery = orderModel.find(queryObj);
+        // SORTING
+        if (req.query.sort) {
+          const sortBy = req.query.sort.split(",").join(" ");
+          orderQuery = orderQuery.sort(sortBy);
+        } else {
+          orderQuery.sort({ state: -1 });
+        }
+        // PAGINATION
+        const page = +req.query.page || 1;
+        const limit = +req.query.limit || 5;
+        const skip = (page - 1) * limit;
+        orderQuery.skip(skip).limit(limit);
+        const orders = await orderQuery;
+        return res
+          .status(200)
+          .json({ status: true, results: orders.length, orders });
+      } catch (error) {
+        res.status(404).json({ message: "can't get orders now", error });
+      }
+}
+
+exports.getAllOrderById = async function (req, res, next){
+    try {
+        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 })
+    } catch (error) {
+        next(error);
+    }
+
+}
+
+exports.updateOrders = async function (req, res, next){
+    try {
+        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 })
+    } catch (error) {
+        next(error);
+    }
+
+}
+
+exports.deleteOrder = async function (req, res, next){
+    try {
+        const { id } = req.params;
+
+        const order = await orderModel.deleteOne({ _id: id})
+
+    return res.json({ status: true, order })
+    } catch (error) {
+        next(error);
+    }
+
+}

controller/userController.js

@@ -0,0 +1,45 @@
+const passport = require('passport');
+const jwt = require('jsonwebtoken');
+require('dotenv').config;
+
+
+exports.signup = async (req, res, next) => {
+    try {
+        res.json({
+            message: 'Signup successful',
+            user: req.user
+        });
+    } catch (error) {
+        next(error)
+    }
+}
+
+exports.login = async (req, res, next) => {
+    try {
+            passport.authenticate('login', async (err, user, info) => {
+                    if (err) {
+                        return next(err);
+                    }
+                    if (!user) {
+                        const error = new Error('Username or password is incorrect');
+                        return next(error);
+                    }
+
+                    req.login(user, { session: false },
+                        async (error) => {
+                            if (error) return next(error);
+
+                            const body = { _id: user._id, username: user.username };
+                            const token = jwt.sign({ user: body }, process.env.JWT_SECRET);
+
+                            return res.json({ token });
+                        }
+                    );
+
+                    }) (req, res, next);
+                }
+    catch (error) {
+     next(error);   
+    }
+}
+

index.js

@@ -1,16 +1,21 @@
 const express = require('express');
-const passport = require('passport');
-const OrderRouter = require('./routes/OrderRoutes');
-const AuthRouter = require('./routes/AuthRoutes');
-
+const connectToMongodb = require('./pizzadbapp');
+const orderRoute = require('./route/orderRoute');
+const userRoute = require('./route/userRoute');
+require('./authorization');
+const PORT = 3334
+connectToMongodb();
 const app = express()
 
 // register passport
 require("./passport") 
 
 // middleware
 app.use(express.json());
-// app.use(BasicAuth)
+app.use(express.urlencoded())
+
+app.use('/', userRoute)
+app.use('/', orderRoute)
 
 // routes
 app.use('/orders', passport.authenticate('jwt', { session: false  }), OrderRouter)
@@ -21,9 +26,8 @@ app.get('/', (req, res) => {
     return res.json({ status: true })
 })
 
-// 404 route
-app.use('*', (req, res) => {
-    return res.status(404).json({ message: 'route not found' })
-})
 
-module.exports = app;
+
+app.listen(PORT, () => {
+    console.log('Listening on port, ', PORT)
+})

model/orderModel.js

@@ -0,0 +1,22 @@
+const mongoose = require('mongoose');
+
+const Schema = mongoose.Schema;
+const ObjectId = Schema.ObjectId;
+
+const OrderSchema = new Schema({
+  id: ObjectId,
+  created_at: Date,
+  state: { type: Number, default: 1 },
+  total_price: Number,
+  items: [{
+    name: String,
+    price: Number,
+    size: { type: String, enum: ['m', 's', 'l']},
+    quantity: Number,
+
+  }]
+});
+
+const Order = mongoose.model('Order', OrderSchema);
+
+module.exports = Order;

model/userModel.js

@@ -0,0 +1,39 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcrypt')
+
+const Schema = mongoose.Schema;
+const ObjectId = Schema.ObjectId;
+
+const UserSchema = new Schema({
+username:{type:String, required:true, unique:true, trim:true},
+password:{type:String, required:true, unique:true, trim:true},
+user_type:{type:String, enum:["user", "admin"] },
+createdAt: {
+    type: Date,
+    default: Date.now(),
+  },
+});
+
+UserSchema.pre(
+    'save',
+    async function (next) {
+        const user = this;
+        const hash = await bcrypt.hash(this.password, 10);
+
+        this.password = hash;
+        next();
+    }
+);
+
+// To ensure that the user trying to log in has the correct details. Using the following new method:
+UserSchema.methods.isValidPassword = async function(password) {
+    const user = this;
+    const compare = await bcrypt.compare(password, user.password);
+
+    return compare;
+  }
+
+
+const user = mongoose.model('User', UserSchema);
+
+module.exports = user;

models/orderModel.js

@@ -13,6 +13,7 @@ const OrderSchema = new Schema({
     price: Number,
     size: { type: String, enum: ['m', 's', 'l']},
     quantity: Number,
+
   }]
 });