# Node DCPL

```javascript
MONGO_URI= "mongodb://127.0.0.1:27017/DCPL_CRUD"
JWT_SECRET= secret 
PORT=3000

const express = require("express");
const app = express();
require('dotenv').config();
const connectDB = require("./utils/db.js");
const userRoute = require("./router/userRoutes.js")

app.use(express.json());

connectDB();
app.use("/api", userRoute);

app.listen(process.env.PORT,()=>{
    console.log(`server is running on https://localhost:${process.env.PORT}`)
})


require('dotenv').config();
const mongoose = require('mongoose');

const connectDB = async (req,res)=>{
     mongoose.connect(process.env.MONGO_URI)
     .then({message:"server is connected"});
     console.log("mongodb database is connected successfully")
}

module.exports = connectDB;


const mongoose = require("mongoose");

const userSchema = new mongoose.Schema({
    name:{
        type:String,
        default:"",
    },
    email:{
        type:String,
        default:"",
    },
    password:{
        type:String,
        default:"",
    },
    role:{
        type:String,
        enum:["user","admin"],
        default:"user"
    }
},
{
    timestamps:true
})

const User =  mongoose.model("User",userSchema);
module.exports = User;

const jwt = require("jsonwebtoken");


const authMiddleware = async(req,res,next)=>{
  const token =  req.headers.authorization?.split(" ")[1];
  if(!token){
    return res.status(401).json({message:"Invalid Token"});
  }
    
  jwt.verify(token,process.env.JWT_SECRET, (err,user )=>{
    req.user = user;
    next();
   })
}

const isAdmin = async(req,res,next) =>{
    if(req.user.role !== "admin"){
         return res.status(401).json({message:"Access Denied"});
    }
    next();
}

module.exports = {
   authMiddleware,
   isAdmin
} 



const express = require("express");
const router = express.Router();

const {isAdmin, authMiddleware} = require("../middleware/authMiddleware.js")

const authController = require("../controllers/authController.js");
const userController = require("../controllers/userController.js");

router.post("/signup",authController.signUp);
router.post("/login",authController.login);

router.get("/getAllUser", authMiddleware, isAdmin ,userController.getUsers);
router.get("/getUser/:id", authMiddleware, isAdmin ,userController.getUserById)
router.delete("/userDelete/:id", authMiddleware, isAdmin ,userController.deleteUserById)
router.put("/userUpdate/:id", authMiddleware, isAdmin ,userController.UpdatetUserById)

router.get('/me', authMiddleware, userController.getMyProfile);
router.put('/me', authMiddleware, userController.editMyProfile);
module.exports = router;


const bcrypt = require("bcrypt");
const User  = require("../models/user.model.js");
const jwt = require("jsonwebtoken");
require('dotenv').config();

const signUp = async (req,res) => {
    try {
    const {name,email,password,role} = req.body;
    
    const existingUser = await User.findOne({email});
    if(existingUser){
    return res.status(401).json({message:"User Already Exist"});    
    }
    
    const hashedPassword = await bcrypt.hash(password , 10);
    const user = new User({name,email,role,password:hashedPassword});
    user.save();
    res.status(200).json({message:"User Register Successfully"});
    console.log(req.body);
    } catch(error){
      res.status(401).json({message:"error while register",error});
      console.log("something went wrong",error)
    }   
};

const login = async (req,res) =>{
    try {
       const {email,password}  = req.body;
       const isUser = await User.findOne({email});
       const iscomparePassword = bcrypt.compare(password,isUser.password);
       if(!iscomparePassword){
        return res.status(401).json({message:"User not login successfully"});
       }
      const token = jwt.sign({id: isUser._id, role: isUser.role},process.env.JWT_SECRET,{expiresIn:'1d'} )
       res.status(200).json({message:"User login successfully", token});
    } catch(error){
         res.status(401).json({message:"error while login",error});
      console.log("something went wrong",error)
    }
}

module.exports = {
    signUp,
    login
}



const User = require("../models/user.model.js");

const getUsers = async (req,res)=>{
     const  getAllUser = await User.find();
     res.status(200).json({message:"get all user successfully" , getAllUser})
}

const getUserById = async (req,res)=>{
     const  getUser = await User.findById(req.params.id);
     res.status(200).json({message:"get user successfully" , getUser})
}

const UpdatetUserById = async (req,res)=>{
     const  updateUser = await User.findByIdAndUpdate(req.params.id , req.body , {new:true});
     res.status(200).json({message:"update user successfully" , updateUser})
}

const deleteUserById = async (req,res)=>{
     const deleteUser = await User.findByIdAndDelete(req.params.id);
     res.status(200).json({message:"user deleted successfully"})
}


const getMyProfile = async (req, res) => {
  const user = await User.findById(req.user.id);
  res.json(user);
};

const editMyProfile = async (req, res) => {
  const user = await User.findByIdAndUpdate(req.user.id, req.body, { new: true });
  res.json(user);
};
module.exports = {
    getUsers,
    deleteUserById,
    UpdatetUserById,
    getUserById,
    getMyProfile,
    editMyProfile
}
```