# Node Jamatrix

```javascript
MONGO_URI= "mongodb://127.0.0.1:27017/JAMATRIX_CRUD"
JWT_SECRET= secret 
PORT=3000
const express = require("express");
const app = express();
require('dotenv').config();
const authRoute = require("./router/userRouter.route.js");
const connectDb = require("./utils/db.js")

app.use(express.json());

connectDb();
app.use("/api",authRoute);
app.listen(process.env.PORT,()=>{
    console.log(`server is running   https://localhost:${process.env.PORT}`)
})

MONGO_URI= "mongodb://127.0.0.1:27017/JAMATRIX_CRUD"
JWT_SECRET= secret 
PORT=3000

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

const connectDb = async (req,res)=>{
    try {
        mongoose.connect(process.env.MONGO_URI).then({message:"Mongodb Connected Successfully"})
        console.log("mongodb connected successfully")
    } catch(error){
         console.error("Error while connected");
         res.status(400).json({message:"error while connect"})
    }
}

module.exports = connectDb;



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

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

const authMiddleware = require("../middleware/authMiddleware.js")

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


router.post("/addSlot", authMiddleware, slotController.addSlot);
router.get("/getInterviewer", authMiddleware, slotController.getInterviewer);
router.get("/getSlot/:interviewerId",authMiddleware,slotController.getSlotInterviewer);
router.post("/bookSlot",authMiddleware,slotController.slotBooked);
module.exports = router;



const mongoose = require("mongoose");


const slotSchema =  new mongoose.Schema({
   interviewerId:{
        type:mongoose.Schema.Types.ObjectId,
        ref:"User"
    },
    startTime:{
        type:String,
        default:""
    },
    endTime:{
        type:String,
        default:""
    },
    date:{
        type:Date,
        default:""
    },
    isBooked: {
         type: Boolean, 
         default: false
     },
    bookedBy: {
         type: mongoose.Schema.Types.ObjectId, 
         ref: "User", 
         default: null 
    }
},
{
    timestamps:true
});

const Slot = mongoose.model("Slot",slotSchema);
module.exports = Slot;

const mongoose = require("mongoose");

const userSchema = new mongoose.Schema({
    userName:{
        type:String,
        default:""
    },
    email:{
        type:String,
        default:""
    },
    password:{
       type:String,
        default:""
    },
    role:{
         type:String,
         enum:['candidate',"interviewer"],
         default:"candidate"
    }   
},{
    timestamps:true
})

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

const jwt = require('jsonwebtoken');

const authMiddleware = async(req,res,next)=>{
    try {
      const token = req.headers.authorization?.split(" ")[1];
    if(!token){
        return res.status(401).json({message:"token is required"})
    }
     
   jwt.verify(token,process.env.JWT_SECRET,(error,user)=>{
    req.user = user;
    next();
   });
    }
   catch(error){
    console.error("error while middleware run",error)
   }
   
}

module.exports = authMiddleware;

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

const register = async(req,res)=>{
    try{
        const {username,email,password,role}= req.body;

        const isUser = await User.findOne({email});
        if(isUser){
            return res.status(400).json({message:"User Already exists"});
        }
        const hashedPassword = await bcrypt.hash(password , 10);
        const user = new User({username,email,password:hashedPassword, role});
        await user.save();
             return res.status(200).json({message:"User Register Successfully"});
    } catch(error){
        console.error("error while register",error);
         res.status(4000).json({message:"error while register",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){
        res.status(400).json({message:"password invalid",error})
      }
       const token = jwt.sign({userId: isUser._id}, process.env.JWT_SECRET, {expiresIn:"1d"})
       res.status(200).json({message:"Login successfully",token});
    } catch(error){
         console.error("error while login",error);
         res.status(400).json({message:"error while login",error});
    }
}

module.exports = {
    register,
    login
}

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

const addSlot = async(req,res)=>{
    try {
    const { date, startTime, endTime } = req.body;
    await Slot.create({ interviewerId: req.userId, date, startTime, endTime });
    res.json({ message: "Slot added" });
  } catch (err) {
    res.status(500).json({ message: "Failed to add slot" });
  }
}

const  getInterviewer = async(req,res)=>{
       const getInterviewer = await User.find({role:'interviewer'}).select('username email');
       res.status(200).json({message:"get all Interviewer",getInterviewer});
}

const  getSlotInterviewer = async(req,res)=>{
       const getSlotInterviewer = await Slot.find({interviewerId:req.params.interviewerId ,  isBooked: false})
       res.status(200).json({message:"get Slot all Interviewer",getSlotInterviewer});
}


const slotBooked = async(req,res) => {
        const {slotId} = req.body;
        const slot = await Slot.findById(slotId);
        if (slot.isBooked) return res.json({ message: "Slot already booked" });

        slot.isBooked = true;
        slot.bookedBy = req.user.userId;
        await slot.save();
        res.json({ message: "Slot booked" });
}


module.exports = {
    addSlot,
    getInterviewer,
    getSlotInterviewer,
    slotBooked
}
```