Forem: swapnanilWebDeveloper

RESTful API CRUD Node, Express, MongoDB Atlas, Mongoose, #Hosting on Render #POSTMAN

swapnanilWebDeveloper — Tue, 27 Feb 2024 16:44:20 +0000

1) Hello guys I have created Another API by Node.js, Express.js, MongoDB Atlas, Mongoose and then finally hosted on both localhost-web-browser and Render.

Special notes : ==>

To get THE full code follow my github repository link given below => click here to get full code

Hosted this API on render and links are =>
a) get all students
b) get all students by name
c)get all students by gender and hobby
d)get all students by age and hobby
e)get all students by address
f)get students by marks in physics,chemistry,mathematics
g)get all students by total and grade

2) I have used postman to execute POST , GET, PATCH, DELETE requests.

3) Now I will be starting with folder and file structure.
4) Create a folder called MyStudentAPI and create folder src inside MyStudentAPI then create folders like => controllers , db , connect , routes , calculateGradeTotal inside src folder.

5) Then install some packages like =>
npm install express
npm install mongoose
npm install mongodb
npm install dotenv

6) Then create app.js file inside src folder

require("dotenv").config();
const express = require("express");
const app = express();
const connectDB = require("./db/connect");

const PORT = process.env.PORT || 7070 ;

const students_routes  = require("./routes/students");

app.use(express.json());

app.get("/", (req, res) => {
    res.send("Hello I am going to create a API on student data...!!!");
});

// middleware or to set router
app.use("/api/students", students_routes);

const startStudentInformation = async (req,res) => {
    try{
      const res = await connectDB(process.env.MONGODB_URL);
      if(res){
        console.log("Connection successfull !! ");
      }
      else{
        console.log("Something wrong with Connection to Database...");
      }
       app.listen(PORT, () => {
         console.log(`${PORT} Yes I am connected !!`);
       });
    }
    catch(err){
      console.log("Something went wrong !!! : "+err);
    }
 }

 startStudentInformation();

7) Then create students.js inside routes folder

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

const {
    getAllStudents, // pagination , limit
    getAllStudentsByName, // sort, select, name.first, name.last, regEx...
    getAllStudentsByHobbiesGender, // sort, select, hobby, gender 
    getAllStudentsByAgeRangeAndHobbies, // sort, select, age range
    getAllStudentsByAddress, // sort, select , address state/district/city , regEx..
    getAllStudentsByScienceMarksRange, // sort, select, science physics/chemistry/mathematacis ..... 
    getAllStudentsByTotalGrade, // sort, select, total range , grade...

} = require("../controllers/studentsA");

const {
    createNewStudent,
    updateStudentByName,
    updateStudentByAddress,
    deleteStudentByName,
    deleteStudentByAddress,

} = require("../controllers/studentsB");

router.route("/").get(getAllStudents);
router.route("/Name").get(getAllStudentsByName);
router.route("/HobbyGender").get(getAllStudentsByHobbiesGender);
router.route("/AgeHobby").get(getAllStudentsByAgeRangeAndHobbies);
router.route("/Address").get(getAllStudentsByAddress);
router.route("/Marks").get(getAllStudentsByScienceMarksRange);
router.route("/TotalGrade").get(getAllStudentsByTotalGrade);

router.route("/createStudent").post(createNewStudent);
router.route("/updateStudentbyName").patch(updateStudentByName);
router.route("/updateStudentbyAddress").patch(updateStudentByAddress);
router.route("/deletebyName").delete(deleteStudentByName);
router.route("/deletebyAddress").delete(deleteStudentByAddress);

module.exports = router;

8) Now come to models folder and create students.js file inside it then write code inside it like given below =>


const mongoose = require("mongoose");

const studentSchema = new  mongoose.Schema({
    name : {
        first : {
            type : String,
            required : true,
        },
        last : {
            type : String,
            required : true,
        }
    },
    age : {
        type : Number,
        required : [true, "Please fill the age field ...!!!"]
    },
    isAlive : {
        type : Boolean,
        default : true,
    },
    gender : {
        type : String,
        default : "Male",
        enum : {
            values : ["Male", "Female", "Others"],
            message : `${this.values} is not supported`,
        }
    },
    address : {
        state : { type : String, required : [true, "Please Provide state ...."]},
        district : { type : String, required : [true, "Please Provide district ...."]},
        city : { type : String, required : [true, "Please Provide city ...."]},
    },
    science : {
        physics : { type : Number, require : [true, "Please provide marks of physics..."]},
        chemistry : { type : Number, require : [true, "Please provide marks of chemistry..."]},
        mathematics : { type : Number, require : [true, "Please provide marks of mathematics..."]}
    },
    total : {
      type : Number,
      default : 90,
    },
    average : {
        type : Number,
        required : [true, "Average is not calculated..!!!"]
    },
    grade : { 
        type : String,
        default : "Good",
    },
    hobbies : [String],
});

const Student = mongoose.model('Student', studentSchema);

module.exports = Student;

9) Then go to Controllers folder and craete studentA.js and studentsB.js file inside it and

write code inside studentsA.js =>


const Student = require("../models/students");

const getAllStudents= async (req,res) => {
    try{
        const {sort, select} = req.query;

        let studentData = Student.find(); 

        if(sort){
            let sortFIx = sort.replaceAll(",", " ");
            console.log(sortFIx);
            studentData = studentData.sort(sortFIx);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            studentData = studentData.select(selectFIx);
        }

        let page = Number(req.query.page) || 1;
        let limit = Number(req.query.limit) || 5;

        let skip = (page - 1) * limit ;

        studentData = studentData.skip(skip).limit(limit);

        const resStudent = await studentData;
        console.log(resStudent);
        console.log(req.query);
        res.status(200).json({resStudent, lengthOfStudentList : resStudent.length});
    }
    catch(error){
        res.status(400).json("something went wrong while getting all the students : "+error);
    } 
}

const getAllStudentsByName = async (req,res) => {
        try{
            const {firstName, lastName, select, sort} = req.query;
            let queryObject = {};

            let studentData = Student.find();

            if(firstName){
                queryObject.firstName = { $regex : firstName , $options : 'i'},
                console.log(queryObject);
                console.log(queryObject.firstName);
                studentData = studentData.find({"name.first" : queryObject.firstName });
            }

            if(lastName){
                queryObject.lastName = { $regex : lastName , $options : 'i'} 
                console.log(queryObject);
                console.log(queryObject.lastName);
                studentData = studentData.find({"name.last" : queryObject.lastName});
            }

            if(select){
                let selectFIx = select.replaceAll(",", " ");
                console.log(selectFIx);
                studentData = studentData.select(selectFIx);
            }

            if(sort){
                let sortFIx = sort.replaceAll(",", " ");
                console.log(sortFIx);
                studentData = studentData.sort(sortFIx);
            }

            const resStudent = await studentData;
            console.log(resStudent);
            console.log(req.query);
            res.status(200).json({resStudent, lengthOfStudentList : resStudent.length})
        }
        catch(error){
            res.status(400).send("Something went wrong while getting all students by name : "+error);
        }
}

const getAllStudentsByHobbiesGender = async (req,res) => {
    try{
        const {hobbies , gender, sort, select} = req.query;
        const queryObject = {};

        let studentData = Student.find(); 

        if(sort){
            let sortFIx = sort.replaceAll(",", " ");
            console.log(sortFIx);
            studentData = studentData.sort(sortFIx);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            studentData = studentData.select(selectFIx);
        }

        if(gender){
            queryObject.gender = gender;
            console.log(queryObject);
            console.log(queryObject.gender);
            studentData = studentData.find(queryObject)
        }

        if(hobbies){
            queryObject.hobbies = hobbies.split(",");
            console.log(queryObject);
            console.log(queryObject.hobbies);
            studentData = studentData.find({hobbies : { $all : queryObject.hobbies } })
        }

        const resStudent = await studentData;
        console.log(resStudent);
        console.log(req.query);
        res.status(200).json({resStudent, lengthOfStudentList : resStudent.length});
    }
    catch(error){
        res.status(400).json("something went wrong while getting all the students by Gender and hobbies: "+error);
    }
}

const getAllStudentsByAgeRangeAndHobbies= async (req,res) => {
    try{
        const {ageMax, ageMin, hobbies, sort, select} = req.query;
        const queryObject = {};

        let studentData = Student.find(); 

        if(sort){
            let sortFIx = sort.replaceAll(",", " ");
            console.log(sortFIx);
            studentData = studentData.sort(sortFIx);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            studentData = studentData.select(selectFIx);
        }

        if(ageMax){
            queryObject.ageMax = ageMax;
            console.log(queryObject);
            console.log(queryObject.ageMax);
            studentData = studentData.find({ age : {$lte : queryObject.ageMax}});
        }

        if(ageMin){
            queryObject.ageMin = ageMin;
            console.log(queryObject);
            console.log(queryObject.ageMin);
            studentData = studentData.find({ age : { $gte : queryObject.ageMin}});
        }

        if(hobbies){
            queryObject.hobbies = hobbies.split(",");
            console.log(queryObject);
            console.log(queryObject.hobbies);
            studentData = studentData.find({hobbies : { $all : queryObject.hobbies } })
        }

        const resStudent = await studentData;
        console.log(resStudent);
        console.log(req.query);
        res.status(200).json({resStudent, lengthOfStudentList : resStudent.length});
    }
    catch(error){
        res.status(400).json("something went wrong while getting all the students by age range and hobbies: "+error);
    }
}

const getAllStudentsByAddress= async (req,res) => {
    try{
        const {state, district , city, sort, select} = req.query;
        const queryObject = {};

        let studentData = Student.find();

        if(sort){
            let sortFIx = sort.replaceAll(",", " ");
            console.log(sortFIx);
            studentData = studentData.sort(sortFIx);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            studentData = studentData.select(selectFIx);
        }

        if(state){
            queryObject.state ={ $regex : state , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.state);
            studentData = studentData.find({"address.state" : queryObject.state})
        }

        if(district){
            queryObject.district = { $regex : district , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.district);
            studentData = studentData.find({"address.district" : queryObject.district});
        }

        if(city){
            queryObject.city = { $regex : city, $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.city);
            studentData = studentData.find({"address.city" : queryObject.city});
        }

        const resStudent = await studentData;
        console.log(resStudent);
        console.log(req.query);
        res.status(200).send({resStudent, lengthOfStudentList : resStudent.length});
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all students by address : "+error);
    }
}

const getAllStudentsByScienceMarksRange = async (req,res) => {
    try{
        const {phyMin, phyMax, chemMin, chemMax, mathMin, mathMax, sort, select} = req.query;
        const queryObject = {};

        let studentData = Student.find();

        if(sort){
            let sortFIx = sort.replaceAll(",", " ");
            console.log(sortFIx);
            studentData = studentData.sort(sortFIx);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            studentData = studentData.select(selectFIx);
        }

        if(phyMin){
            queryObject.phyMin = phyMin;
            console.log(queryObject);
            console.log(queryObject.phyMin);
            studentData = studentData.find({"science.physics" : {$gte : phyMin} })
        }

        if(phyMax){
            queryObject.phyMax = phyMax;
            console.log(queryObject);
            console.log(queryObject.phyMax);
            studentData = studentData.find({"science.physics" : {$lte : phyMax} })
        }

        if(chemMin){
            queryObject.chemMin = chemMin;
            console.log(queryObject);
            console.log(queryObject.chemMin);
            studentData = studentData.find({"science.chemistry" : {$gte : chemMin} })
        }

        if(chemMax){
            queryObject.chemMax = chemMax;
            console.log(queryObject);
            console.log(queryObject.chemMax);
            studentData = studentData.find({"science.chemistry" : {$lte : chemMax} })
        }

        if(mathMin){
            queryObject.mathMin = mathMin;
            console.log(queryObject);
            console.log(queryObject.mathMin);
            studentData = studentData.find({"science.mathematics" : {$gte : mathMin} })
        }

        if(mathMax){
            queryObject.mathMax = mathMax;
            console.log(queryObject);
            console.log(queryObject.mathMax);
            studentData = studentData.find({"science.mathematics" : {$lte : mathMax} })
        }

        const resStudent = await studentData;
        console.log(resStudent);
        console.log(req.query);
        res.status(200).send({resStudent, lengthOfStudentList : resStudent.length});
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all science marks range  : "+error);
    }
}

const getAllStudentsByTotalGrade = async (req,res) => {
    try{
        const {totalMin, totalMax, grade, sort, select} = req.query;
        const queryObject = {};

        let studentData = Student.find(); 

        if(sort){
            let sortFIx = sort.replaceAll(",", " ");
            console.log(sortFIx);
            studentData = studentData.sort(sortFIx);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            studentData = studentData.select(selectFIx);
        }

        if(totalMax){
            queryObject.totalMax = totalMax;
            console.log(queryObject);
            console.log(queryObject.totalMax);
            studentData = studentData.find({ total : {$lte : queryObject.totalMax}});
        }

        if(totalMin){
            queryObject.totalMin = totalMin;
            console.log(queryObject);
            console.log(queryObject.totalMin);
            studentData = studentData.find({ total : { $gte : queryObject.totalMin}});
        }

        if(grade){
            queryObject.grade = { $regex : grade , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.grade);
            studentData = studentData.find({grade : queryObject.grade});
        }

        const resStudent = await studentData;
        console.log(resStudent);
        console.log(req.query);
        res.status(200).json({resStudent, lengthOfStudentList : resStudent.length});
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all students Total and Grade : "+error);
    }
}

module.exports = {
    getAllStudents,
    getAllStudentsByName,
    getAllStudentsByHobbiesGender,
    getAllStudentsByAgeRangeAndHobbies,
    getAllStudentsByAddress,
    getAllStudentsByScienceMarksRange,
    getAllStudentsByTotalGrade,
}

10) write code inside studentsB.js =>

const Student = require("../models/students");
const { calcGradeTotalStudent } = require("../CalculateTotalGrade/calcTotalGrade");

const createNewStudent= async (req,res) => {
        console.log(req.body);  
        try{
                 const studentData = new Student({
                    name : {
                        first : req.body.name.first,
                        last : req.body.name.last,
                    },
                    age : req.body.age,
                    isAlive : req.body.isAlive,
                    gender : req.body.gender,
                    address : {
                        state : req.body.address.state,
                        district : req.body.address.district,
                        city : req.body.address.city,
                    },
                    science : {
                        physics : req.body.science.physics,
                        chemistry : req.body.science.chemistry,
                        mathematics : req.body.science.mathematics,
                    },
                    hobbies : req.body.hobbies,
           });

           calcGradeTotalStudent([studentData]);
           const createStudentData = await studentData.save();
           res.status(201).send(createStudentData);

           console.log(createStudentData);
        }
    catch(error){
        res.status(400).json("something went wrong while getting all the students : "+error);
    } 
}

const updateStudentByName = async (req,res) => {
        try{
            console.log(req.body);
            const {firstName, lastName} = req.query;
            const queryObject = { firstName : "", lastName : ""};

            if(firstName){
                queryObject.firstName = { $regex : firstName , $options : 'i'},
                console.log(queryObject);
                console.log(queryObject.firstName);
            }

            if(lastName){
                queryObject.lastName = { $regex : lastName , $options : 'i'} 
                console.log(queryObject);
                console.log(queryObject.lastName);
            }
            const updateStudent = await Student.findOneAndUpdate({"name.first" : queryObject.firstName , "name.last" : queryObject.lastName}, 
                {$set : req.body },
                 {
                   returnDocument : "after"
                 }
                );
                calcGradeTotalStudent([updateStudent]);
                const resStudent = await updateStudent.save();

              console.log(resStudent);
              res.status(201).send(updateStudent);
        }
        catch(err){
            console.log("Something went wrong while updating the data : "+err);
        }
}

const updateStudentByAddress = async (req,res) => {
    try{
        console.log(req.body);
        const {state, district, city} = req.query;
        const queryObject = { state : "", district : "", city : ""};

        if(state){
            queryObject.state ={ $regex : state , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.state);
        }

        if(district){
            queryObject.district = { $regex : district , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.district);
        }

        if(city){
            queryObject.city = { $regex : city, $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.city);
        }
        const updateStudent = await Student.findOneAndUpdate({"address.state" : queryObject.state,
         "address.district" : queryObject.district, "address.city" : queryObject.city}, 
            {$set : req.body },
             {
               returnDocument : "after"
             }
            );
            calcGradeTotalStudent([updateStudent]);
            const resStudent = await updateStudent.save();

          console.log(resStudent);
          res.status(201).send(updateStudent);
    }
    catch(err){
        console.log("Something went wrong while updating the data : "+err);
    }
}

const deleteStudentByName = async (req,res) => {
    try{
        const {firstName, lastName} = req.query;
        const queryObject = { firstName : "", lastName : ""};

        if(firstName){
            queryObject.firstName = { $regex : firstName , $options : 'i'},
            console.log(queryObject);
            console.log(queryObject.firstName);
        }

        if(lastName){
            queryObject.lastName = { $regex : lastName , $options : 'i'} 
            console.log(queryObject);
            console.log(queryObject.lastName);
        }

        const studentResult = await Student.findOneAndDelete({"name.first" : queryObject.firstName, "name.last" : queryObject.lastName});

        if(!(firstName && lastName)){
           return res.status(404).send("No student is found with this first name and last name !!..");
        }
        console.log(studentResult);
        res.status(201).send(studentResult);   
    }
    catch(err){
      res.status(500).send("Somethething wrong happend in deleting : "+err);
    }
}

// deleteStudentByAddress
const deleteStudentByAddress = async (req,res) => {
    try{
        const {state, district , city} = req.query;
        const queryObject = {};

        if(state){
            queryObject.state ={ $regex : state , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.state);
        }

        if(district){
            queryObject.district = { $regex : district , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.district);
        }

        if(city){
            queryObject.city = { $regex : city, $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.city);
        }

        const studentResult = await Student.findOneAndDelete({"address.state" : queryObject.state, "address.district" : queryObject.district
                                                               , "address.city" : queryObject.city});

        if(!(state && district && city)){
           return res.status(404).send("No student is found with this address !!..");
        }
        console.log(studentResult);
        res.status(201).send(studentResult);  
    }
    catch(err){
      res.status(400).send("Something went Wrong while deleting student by address : !!! "+err);
    }
}

module.exports = {
    createNewStudent,
    updateStudentByName,
    updateStudentByAddress,
    deleteStudentByName,
    deleteStudentByAddress,
}

11) Now come to db folder and craete connect.js file and write code inside it =>


const mongoose = require("mongoose");
// const { options } = require("../routes/products");


const connectDB = (uri) => {
    console.log("Hello , I am inside connectDB function....!!!");
    return mongoose.connect(uri)
}

module.exports = connectDB;

12) Now create a .env file inside MyStudentAPI_1 folder
[ ***notes : go to mongoDB atlas set up your database ]


MONGODB_URL = mongodb+srv://{username}:{password}@{clustername}.jq9vjnd.mongodb.net/MyStudentDB[database name]?retryWrites=true&w=majority

13) The come to calculateGradeTotal folder and create calcTotalGrade.js file and write code inside it =>


const student = require("../models/students");

const calcGradeTotalStudent = (studentData) => {
    let total, avg, dataLength;
    dataLength = studentData.length;

    console.log("Hello , I am calculating Total and Grade ...!!!");
    console.log("Length of student data list = "+dataLength);

    for(var i = 0; i < dataLength ; i++){
        studentData[i].total = studentData[i].science.physics + studentData[i].science.chemistry + studentData[i].science.mathematics;
        total = studentData[i].total;
        avg = total / 3;
        studentData[i].average = avg.toFixed(2); 
        getGradeStudent(studentData,avg,i);
    } 
}

const getGradeStudent = (studentData,avg,ind) => {

     if(avg >= 90){
         studentData[ind].grade = "Excellent";
     }
     else if(avg >= 80 && avg < 90){
         studentData[ind].grade = "Very Good";
     }
     else if(avg >= 70 && avg < 80){
        studentData[ind].grade = "Good";
    }
    else if(avg >= 60 && avg < 70){
        studentData[ind].grade = "Satisfactory";
    }
    else if(avg >= 40 && avg < 60){
        studentData[ind].grade = "Not Good";
    }
    else{
        studentData[ind].grade = "Fail";
    }
}

module.exports = {
    calcGradeTotalStudent
}

14) Now create a file in main folder MyStudentAPI_1 called StudentDB.js =>

const connectDB = require("./src/db/connect");
require("dotenv").config();
const { 
    calcGradeTotalStudent
   }  = require("./src/CalculateTotalGrade/calcTotalGrade");

const Student = require("./src/models/students");
const StudentJson = require("./Students.json");

const startDataBase = async () => {
    try{
        await connectDB(process.env.MONGODB_URL);
       // await Product.deleteMany();
        calcGradeTotalStudent(StudentJson);
        await Student.create(StudentJson);
        console.log("Successfully Documents of students inserted...!!!");
    }
    catch(error){
        console.log("Something went wrong with Databse connection ....!!!"+error);
    }
}

startDataBase();

15) Now create a .json{} file inside MyStudentAPI_1 that is "Students.json{}" and write the code given below =>


[
   {
     "name" : {
        "first" : "Mayuk",
        "last" : "Mukherjee"
    },
    "age" : 24,
    "isAlive" : true,
    "gender" : "Male",
    "address" : {
        "state" : "California",
        "district" : "Denver",
        "city" : "Ohio"
    },
    "science" : {
        "physics" : 99,
        "chemistry" : 88,
        "mathematics" : 97
    },
    "hobbies" : ["Gymming", "Reading", "Travelling", "Painting"]
   },
   {
    "name" : {
        "first" : "Suryendu",
        "last" : "Sarkar"
    },
    "age" : 22,
    "isAlive" : true,
    "gender" : "Male",
    "address" : {
        "state" : "Colorado",
        "district" : "Colorado",
        "city" : "Georgia"
    },
    "science" : {
        "physics" : 86,
        "chemistry" : 81,
        "mathematics" : 92
    },
    "hobbies" : ["Gymming", "Reading", "Singing", "Dancing"]
   },
   {
    "name" : {
        "first" : "Aninda",
        "last" : "Mukherjee"
    },
    "age" : 27,
    "isAlive" : true,
    "gender" : "Male",
    "address" : {
        "state" : "Texas",
        "district" : "Ohio",
        "city" : "Colorado"
    },
    "science" : {
        "physics" : 81,
        "chemistry" : 71,
        "mathematics" : 86
    },
    "hobbies" : ["Gymming", "Travelling", "Singing", "Painting"]
   },
   {
    "name" : {
        "first" : "Snalap",
        "last" : "Gadai"
    },
    "age" : 22,
    "isAlive" : true,
    "gender" : "Male",
    "address" : {
        "state" : "California",
        "district" : "Georgia",
        "city" : "Denver"
    },
    "science" : {
        "physics" : 74,
        "chemistry" : 86,
        "mathematics" : 69
    },
    "hobbies" : ["Blogging", "Cricket", "Dancing", "Reading"]
   },
   {
    "name" : {
        "first" : "Souvik",
        "last" : "Chatterjee"
    },
    "age" : 29,
    "isAlive" : true,
    "gender" : "Male",
    "address" : {
        "state" : "Colorado",
        "district" : "Ohio",
        "city" : "Colorado"
    },
    "science" : {
        "physics" : 66,
        "chemistry" : 58,
        "mathematics" : 84
    },
    "hobbies" : ["Blogging", "Cricket", "Dancing", "Reading"]
   },
   {
    "name" : {
        "first" : "Shreyashi",
        "last" : "Biswas"
    },
    "age" : 19,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "California",
        "district" : "Georgia",
        "city" : "Ohio"
    },
    "science" : {
        "physics" : 86,
        "chemistry" : 74,
        "mathematics" : 64
    },
    "hobbies" : ["Blogging", "Cricket", "Football", "Coocking"]
   },
   {
    "name" : {
        "first" : "Sukalpa",
        "last" : "Das"
    },
    "age" : 38,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Texas",
        "district" : "California",
        "city" : "Denver"
    },
    "science" : {
        "physics" : 56,
        "chemistry" : 78,
        "mathematics" : 94
    },
    "hobbies" : ["Blogging", "Football", "Singing", "Tennis"]
   },
   {
    "name" : {
        "first" : "Sanjukta",
        "last" : "Chatterjee"
    },
    "age" : 32,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Denver",
        "district" : "Colorado",
        "city" : "Colorado"
    },
    "science" : {
        "physics" : 96,
        "chemistry" : 52,
        "mathematics" : 74
    },
    "hobbies" : ["Singing", "Baseball", "Coocking", "Football"]
   },
   {
    "name" : {
        "first" : "Soumi",
        "last" : "Chatterjee"
    },
    "age" : 36,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "California",
        "district" : "Texas",
        "city" : "Ohio"
    },
    "science" : {
        "physics" : 74,
        "chemistry" : 83,
        "mathematics" : 79
    },
    "hobbies" : ["Gymming", "Tennis", "Coocking", "Travelling"]
   },
   {
    "name" : {
        "first" : "Kakan",
        "last" : "Bag"
    },
    "age" : 49,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Denver",
        "district" : "California",
        "city" : "Georgia"
    },
    "science" : {
        "physics" : 88,
        "chemistry" : 72,
        "mathematics" : 69
    },
    "hobbies" : ["Tennis", "Cricket", "Singing", "Reading"]
   },
   {
    "name" : {
        "first" : "Tom",
        "last" : "Cruise"
    },
    "age" : 42,
    "isAlive" : true,
    "gender" : "Male",
    "address" : {
        "state" : "Colorado",
        "district" : "Texas",
        "city" : "Georgia"
    },
    "science" : {
        "physics" : 91,
        "chemistry" : 77,
        "mathematics" : 64
    },
    "hobbies" : ["Blogging", "Gymming", "Dancing", "Baseball"]
   },
   {
    "name" : {
        "first" : "Natlie",
        "last" : "Portman"
    },
    "age" : 46,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Ohio",
        "district" : "Colorado",
        "city" : "Ohio"
    },
    "science" : {
        "physics" : 88,
        "chemistry" : 66,
        "mathematics" : 92
    },
    "hobbies" : ["Reading", "Tennis", "Dancing", "Footbal"]
   },
   {
    "name" : {
        "first" : "Emma",
        "last" : "Stone"
    },
    "age" : 53,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Georgia",
        "district" : "Denver",
        "city" : "Georgia"
    },
    "science" : {
        "physics" : 94,
        "chemistry" : 67,
        "mathematics" : 84
    },
    "hobbies" : ["Blogging", "Gymming", "Coocking", "Singing"]
   },
   {
    "name" : {
        "first" : "Catherine",
        "last" : "Langford"
    },
    "age" : 44,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Ohio",
        "district" : "Colorado",
        "city" : "California"
    },
    "science" : {
        "physics" : 81,
        "chemistry" : 57,
        "mathematics" : 94
    },
    "hobbies" : ["Travelling", "Tennis", "Dancing", "Baseball"]
   },
   {
    "name" : {
        "first" : "Sylvester",
        "last" : "Stellone"
    },
    "age" : 46,
    "isAlive" : true,
    "gender" : "Female",
    "address" : {
        "state" : "Georgia",
        "district" : "Denver",
        "city" : "Ohio"
    },
    "science" : {
        "physics" : 68,
        "chemistry" : 97,
        "mathematics" : 82
    },
    "hobbies" : ["Reading", "Painting", "Coocking", "Footbal"]
   }
]

Now to start your Data base open your terminal and write command like =>

nodemon StudentDB.js
then type ctrl+c

then write command =>

nodemon src/app.js

then to host your api on your localhost at port number 7070
go to web browser and on the url section type links like=>

1) http://localhost:7070/api/students?sort=address.state,science.physics&select=name,address,science,-_id&page=1&limit=15

2) http://localhost:7070/api/students/Name?firstName=lvEsT&lastName=ElLO&sort=address.state&select=name,address,total,grade,-_id

3) http://localhost:7070/api/students/HobbyGender?gender=Female&hobbies=Singing,Football&sort=science.mathematics&select=name,total,-_id,grade,hobbies,gender

4) http://localhost:7070/api/students/AgeHobby?ageMax=35&ageMin=18&hobbies=Reading,Gymming&select=name,age,hobbies,-_id

5) http://localhost:7070/api/students/Address?state=CAliF&district=EOrG&city=ENv&sort=total&select=name,address,total,grade,-_id

6) http://localhost:7070/api/students/Marks?phyMin=75&phyMax=88&chemMin=70&chemMax=80&mathMin=65&mathMax=90&sort=science.mathematics&select=name,science,total,grade,-_id

7) http://localhost:7070/api/students/TotalGrade?totalMin=240&totalMax=290&grade=eRY&sort=science.chemistry&select=name,total,science,average,grade,-_id

Then after that you can also use POST, PATCH, DELTE Requests on POSTMAN =>

I am giving screen shots please follow that =>

REST APIs By Express,Node,MongoDB Atlas,Mongoose#CRUD operation in API

swapnanilWebDeveloper — Sat, 24 Feb 2024 09:45:12 +0000

1) It is very important to Build your own API. Building your own API can boost your Full stack project.

2)When ever you are creating a full stack project then you need an API to provide data to your front-end app.

3)If you are not able to create your own API then you will be dependent on the Mock APIs that are available on google .

4)Some times this APIs are not accurately relevant to the project You are building right now.

5)If you want to fulfill your project with proper API then you need to create your API by Express that will be perfectly suited to your project.

6)To build your own API you will need Express.js, Node.js, MongoDB Atlas or MongoDB compass and Mongoose.

7)Here in this article I will guide you step by step how to build your Own RestFul API.

8) To get the full code click on my git repository link

click to get full code

9) I have hosted this API on render also =>

click to get API

Step-1 : Folder structure
a) Create A folder called MyMoviesAPI_1

b) Create another folder inside it called src

c) Then install packages => inside main folder MyMoviesAPI_1
npm install express
npm install mongoose
npm install dotenv
npm install mongodb

d) create folder controllers,db,models,routes,VerdictPrediction
inside the folder src.

e) Then go to package.json file and write =>

     "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node src/app.js"
  },

step-2:
a) Create a file called app.js inside src
b) Now write code inside that app.js file like =>

require("dotenv").config();
const express = require("express");
const app = express();
const connectDB = require("./db/connect");

const PORT = process.env.PORT || 6060 ;

const movies_routes  = require("./routes/movies");

app.use(express.json());

app.get("/", (req, res) => {
    res.send("Hello programmer is live from the home page .....!!!");
});

// middleware or to set router
app.use("/api/movies", movies_routes);

const LiveStudentConnection = async (req,res) => {
    try{
        const res = await connectDB(process.env.MONGODB_URL);
          if(res){
            console.log("Connection successfull !! ");
           }
          else{
            console.log("Somwthing wrong with Connection to Database...");
          }
         app.listen(PORT, () => {
         console.log(`Port number : ${PORT} , Yes I am connected !!`);
       });
    }
    catch(err){
      console.log("Something went wrong at listening to port : "+PORT+" !!! : "+err);
    }
 }

 LiveStudentConnection();

step-3:
a)Inside db folder create file connect.js

b) Here you have to write the code as I give you below

const mongoose = require("mongoose");
const { options } = require("../routes/movies");


const connectDB = (uri) => {
    console.log("Hello , I am inside connectDB function....!!!");
    return mongoose.connect(uri)
}

module.exports = connectDB;

step-3 :
a) Now create a file MovieDB.js inside src folder
b) Then write the code given below =>

const connectDB = require("./src/db/connect");
require("dotenv").config();

const Movie = require("./src/models/movies");
const MovieJson = require("./Movies.json");

const CalculateVerdict = require("./src/VerdictPrediction/calcVerdict");

let len = MovieJson.length;
console.log("Number of movies are = "+len);

for(var i = 0; i < len; i++){
    CalculateVerdict(MovieJson[i]);
}

const start = async () => {
    try{
        await connectDB(process.env.MONGODB_URL);
       // await Product.deleteMany();
        await Movie.create(MovieJson);
        console.log("Documents of movies inserted, Successfully ...!!!");
    }
    catch(error){
        console.log("Something went wrong with Databse connection ....!!!"+error);
    }
}

start();

step-4 :
a)Then create another file Movies.json

b)Here in the .json{} file you will have to give data of multiple movies that will be inserted into your database in one go.

c) Then give the code as written below

[
    {
        "title" : "Beauty and the Beast",
        "releaseYear" : 2017,
        "rated" : "PG",
        "durationMinute" : 129,
        "genre" : ["Adventure", "Family", "Fantasy"],
        "ratings" : {
            "IMDB" :  7.1,
            "Metascore" : 65
        },
        "featured" : true,
        "director" :  "Bill Condon",
        "starCast" : ["Emma Watson", "Dan Stevens", "Luke Evans", "Josh Gad"],
        "votes" : 331952,
        "NumbersInCount" : {
            "grossCollection" : 504.01,
            "budget" : 254
        }
    },
    {
        "title" : "Logan",
        "releaseYear" : 2017,
        "rated" : "R",
        "durationMinute" : 137,
        "genre" : ["Action", "Drama", "ScienceFiction"],
        "ratings":{
            "IMDB" :  8.1,
            "Metascore" : 77
        },
        "featured" : true,
        "director" :  "James Mangold",
        "starCast" : ["Hugh Jackman", "Patrick Stewart", "Dafne Keen", "Boyd Holdbrook"],
        "votes" : 821852,
        "NumbersInCount" : {
            "grossCollection" : 226.28,
            "budget" : 97
        }
    },
    {
        "title" : "X-Men : Apocalypse",
        "releaseYear" : 2016,
        "rated" : "PG-13",
        "durationMinute" : 144,
        "genre" : ["Action", "Adventure", "ScienceFiction"],
        "ratings":{
            "IMDB" :  6.9,
            "Metascore" : 52
        },
        "featured" : true,
        "director" :  "Bryan Singer",
        "starCast" : ["James McAvoy", "Michael Fassbender", "Jennifer Lawrence", "Nicholas Hoult"],
        "votes" : 457705,
        "NumbersInCount" : {
            "grossCollection" : 543.9,
            "budget" : 178
        }
    },
    {
        "title" : "Deadpool",
        "releaseYear" : 2016,
        "rated" : "R",
        "durationMinute" : 108,
        "genre" : ["Action", "Comedy"],
        "ratings":{
            "IMDB" :  8.0,
            "Metascore" : 65
        },
        "featured" : true,
        "director" :  "Tim Miller",
        "starCast" : ["Ryan Reynolds", "Morena Baccarin", "T.J Miller", "ED Skrein"],
        "votes" : 1112702,
        "NumbersInCount" : {
            "grossCollection" : 363.07,
            "budget" : 58
        }
    },
    {
        "title" : "Man of Steel",
        "releaseYear" : 2013,
        "rated" : "PG-13",
        "durationMinute" : 143,
        "genre" : ["Action", "Adventure", "ScienceFiction"],
        "ratings":{
            "IMDB" :  7.1,
            "Metascore" : 55
        },
        "featured" : true,
        "director" :  "Zack Snyder",
        "starCast" : ["Henry Cavil", "Amy Adams", "Michael Shannon", "Diane Lane"],
        "votes" : 807519,
        "NumbersInCount" : {
            "grossCollection" : 668,
            "budget" : 225
        }
    },
    {
        "title" : "Batman v Superman : Dawn of Justice",
        "releaseYear" : 2016,
        "rated" : "PG-13",
        "durationMinute" : 151,
        "genre" : ["Action", "Adventure", "ScienceFiction"],
        "ratings":{
            "IMDB" :  6.5,
            "Metascore" : 44
        },
        "featured" : true,
        "director" :  "Zack Snyder",
        "starCast" : ["Ben Affleck", "Henry Cavil", "Amy Adams", "Jessy Einsberg"],
        "votes" : 748731,
        "NumbersInCount" : {
            "grossCollection" : 873.6,
            "budget" : 250
        }
    },
    {
        "title" : "Slumdog Milionaire",
        "releaseYear" : 2008,
        "rated" : "R",
        "durationMinute" : 120,
        "genre" : ["Crime", "Drama", "Romance"],
        "ratings":{
            "IMDB" :  8.0,
            "Metascore" : 84
        },
        "featured" : true,
        "director" :  "Danny Boyle",
        "starCast" : ["Dev Patel", "Freida Pinto", "Saurabh Sukla", "Anil Kapoor"],
        "votes" : 873576,
        "NumbersInCount" : {
            "grossCollection" : 377.9,
            "budget" : 15
        }
    },
    {
        "title" : "Titanic",
        "releaseYear" : 1997,
        "rated" : "PG-13",
        "durationMinute" : 194,
        "genre" : ["Drama", "Romance"],
        "ratings":{
            "IMDB" :  7.9,
            "Metascore" : 75
        },
        "featured" : true,
        "director" :  "James Cameron",
        "starCast" : ["Leonardo De Caprio", "Kate Winslet", "Billy Zane", "Kathy Bates"],
        "votes" : 1269409,
        "NumbersInCount" : {
            "grossCollection" : 600.78,
            "budget" : 200
        }
    },
    {
        "title" : "Avatar",
        "releaseYear" : 2009,
        "rated" : "PG-13",
        "durationMinute" : 162,
        "genre" : ["Action", "Adventure", "Fantasy"],
        "ratings":{
            "IMDB" :  7.9,
            "Metascore" : 83
        },
        "featured" : true,
        "director" :  "James Cameron",
        "starCast" : ["Sam Warthington", "Zoe Saldana", "Sigourney Weaver", "Michell Rodriguez"],
        "votes" : 1376466,
        "NumbersInCount" : {
            "grossCollection" : 2920,
            "budget" : 237
        }
    },
    {
        "title" : "Gravity",
        "releaseYear" : 2013,
        "rated" : "PG-13",
        "durationMinute" : 91,
        "genre" : ["Drama", "ScienceFiction", "Thriller"],
        "ratings":{
            "IMDB" :  7.7,
            "Metascore" : 96
        },
        "featured" : true,
        "director" :  "Alfonso Cuaron",
        "starCast" : ["Sandra Bullock", "George Clooney", "Ed Harris", "Orto Ignatiussen"],
        "votes" : 858587,
        "NumbersInCount" : {
            "grossCollection" : 723.19,
            "budget" : 100
        }
    },
    {
        "title" : "The Dark Knight",
        "releaseYear" : 2008,
        "rated" : "PG-13",
        "durationMinute" : 152,
        "genre" : ["Action", "Crime", "Drama"],
        "ratings":{
            "IMDB" :  9,
            "Metascore" : 84
        },
        "featured" : true,
        "director" :  "Chirstopher Nolan",
        "starCast" : ["Christian Bell", "Heath Ledger", "Aron Eckhart", "Michael Caine"],
        "votes" : 2841462,
        "NumbersInCount" : {
            "grossCollection" : 1006,
            "budget" : 185
        }
    },
    {
        "title" : "The Dark Knight Rises",
        "releaseYear" : 2012,
        "rated" : "PG-13",
        "durationMinute" : 164,
        "genre" : ["Action", "Drama", "erer"],
        "ratings":{
            "IMDB" :  8.4,
            "Metascore" : 78
        },
        "featured" : true,
        "director" :  "Chirstopher Nolan",
        "starCast" : ["Christian Bell", "Tom Hardy", "Anny Hataway", "Gary Oldman"],
        "votes" : 1810265,
        "NumbersInCount" : {
            "grossCollection" : 1085,
            "budget" : 250
        }
    },
    {  
        "title" : "Batman Begins",
        "releaseYear" : 2005,
        "rated" : "PG-13",
        "durationMinute" : 140,
        "genre" : ["Action", "Crime", "Drama"],
        "ratings":{
            "IMDB" :  8.2,
            "Metascore" : 70
        },
        "featured" : true,
        "director" :  "Chirstopher Nolan",
        "starCast" : ["Christian Bell", "Michael Caine", "Ken Watanabe", "Liam Neeson"],
        "votes" : 1564017,
        "NumbersInCount" : {
            "grossCollection" : 373.7,
            "budget" : 150
        }
    },
    {
        "title" : "Gurdians of the Galaxy",
        "releaseYear" : 2014,
        "rated" : "PG-13",
        "durationMinute" : 121,
        "genre" : ["Action", "Adventure", "Comedy"],
        "ratings":{
            "IMDB" :  8.0,
            "Metascore" : 76
        },
        "featured" : true, 
        "director" :  "James Gunn",
        "starCast" : ["Chris Patt", "Vin Diesel", "Bradley Cooper", "Zoe Saldana"],
        "votes" : 1263708,
        "NumbersInCount" : {
            "grossCollection" : 333.18,
            "budget" : 79.84
        }
    },
    {
        "title" : "Captain America: Civil War",
        "releaseYear" : 2016,
        "rated" : "PG-13",
        "durationMinute" : 147,
        "genre" : ["Action", "ScienceFiction"],
        "ratings":{
            "IMDB" :  7.8,
            "Metascore" : 75
        },
        "featured" : true,
        "director" :  "Anthony Russo",
        "starCast" : ["Chris Evans", "Robert Downey Jr.", "Scarlett Johansson", "Sebastian Stan"],
        "votes" : 842986,
        "NumbersInCount" : {
            "grossCollection" : 1153.3,
            "budget" : 250
        }
    }
]

step-5 :
a) Here we will discuss about the .env file and MongoDB Atlas

b) GO to mongoDB Atlas and create your own project , cluster, then go to DataBase and click on connect then click on drivers
then you will get a sample URL like =>

mongodb+srv://username:@clusterName.uiiembe.mongodb.net/DatabaseName{write your database name here}?retryWrites=true&w=majority

my Database name is MovieDB.

c)Now come to your Visual studio code and inside .env file write code like =>


MONGODB_URL = mongodb+srv://username:<password>@clusterName.uiiembe.mongodb.net/DatabaseName{write your database name here}?retryWrites=true&w=majority

d) Then inside terminal write command node MovieDb.js

step-6:
a) Inside the folder routes create files => movies.js

b) Write code like =>

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

const {
    getAllMoviesPaginationLimit,
    getAllMoviesBySortSelect,
    getAllMoviesByTitle, // regular expression // single request params
    getAllMoviesByDirector, // regular expression // single request params
    getAllMoviesByStarCast, // regular expression // single request params
    getAllMoviesByMultiStarCast, // array $all operator // single request params
    getAllMoviesByGenre, // array in element and regular expression // single request params

} = require("../controllers/moviesA");

const {
    getAllMoviesByReleaseYearRange, // and // double request params
    getAllMoviesByIMDBRatingRange, // and // double request params
    getAllMoviesByMetaScoreRatingRange, // and // double request params
    getAllMoviesByGrossCollection, //and // double request params
    getAllMoviesByBudget, // and // double request params
} = require("../controllers/moviesB");

const {
    getAllMoviesByRatedAndStarCast, // AND // multiple request params
    getAllMoviesByDirectorAndStarCast, // 1. reg Expression AND, 2.array in element // // multiple request params
    getAllMoviesByGenreAndStarCast, // 1. reg Expression AND, 2.array in element // // multiple request params  
} = require("../controllers/moviesC");

const {
    createNewMovie,
    updateMovieByTitle,
    deleteMovieByDirector,
} = require("../controllers/moviesD");

router.route("/").get(getAllMoviesPaginationLimit);
router.route("/sortProject").get(getAllMoviesBySortSelect);
router.route("/title").get(getAllMoviesByTitle);
router.route("/director").get(getAllMoviesByDirector);
router.route("/starCast").get(getAllMoviesByStarCast);
router.route("/multiStarCast").get(getAllMoviesByMultiStarCast);
router.route("/genre").get(getAllMoviesByGenre);

router.route("/releaseYear").get(getAllMoviesByReleaseYearRange);
router.route("/IMDBRating").get( getAllMoviesByIMDBRatingRange);
router.route("/MetaScoreRating").get(getAllMoviesByMetaScoreRatingRange);
router.route("/GrossCollection").get(getAllMoviesByGrossCollection);
router.route("/Budget").get(getAllMoviesByBudget);

router.route("/RatedAndStarCast").get(getAllMoviesByRatedAndStarCast);
router.route("/DirectorAndStarCast").get(getAllMoviesByDirectorAndStarCast);
router.route("/GenreAndStarCast").get(getAllMoviesByGenreAndStarCast);

router.route("/createMovie").post(createNewMovie);
router.route("/updatebytitle").patch(updateMovieByTitle);
router.route("/deletebydiredctor").delete(deleteMovieByDirector);

module.exports = router;

step-7:
a) Come to controllers create four Files moviesA.js, moviesB.js, moviesC.js, moviesD.js

 const Movie = require("../models/movies");

const getAllMoviesPaginationLimit = async (req,res) => {
    try{
        let page = Number(req.query.page) || 1;
        let limit = Number(req.query.limit) || 3;

        let MovieData = Movie.find();

        let skip = (page - 1) * limit ;

        MovieData = MovieData.skip(skip).limit(limit);

        const resMovie = await MovieData;
        console.log(resMovie);
        res.status(200).json({resMovie,ListMovieslength : resMovie.length});
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all products : "+error);
    }
}

const getAllMoviesBySortSelect = async (req,res) => {
    try{
        const {sort,select} = req.query;

        console.log(sort);
        let MovieData = Movie.find(); 

        if(sort){
            let sortFix = sort.replaceAll(",", " ");
            console.log(sortFix);
            MovieData = MovieData.sort(sortFix);
        }

        if(select){
            let selectFix = select.replaceAll(",", " ");
            console.log(select);
            console.log(selectFix);
            MovieData = MovieData.select(selectFix);
        }

        let page = Number(req.query.page) || 1;
        let limit = Number(req.query.limit) || 5;

        let skip = (page - 1) * limit ;

        MovieData = MovieData.skip(skip).limit(limit);

        const resMovie = await MovieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, lengthOfMyData : resMovie.length});
    }
    catch(error){
        res.status(400).json("something went wrong while testing the data : "+error);
    }
}

// get all movies by title
const getAllMoviesByTitle = async (req,res) => {
    try{
        const {title,select} = req.query;
        const queryObject = {};

        let MovieData = Movie.find();

        if(title){
            queryObject.title = { $regex : title , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.title);
            MovieData = MovieData.find(queryObject);
        }

        if(select){
            let selectFix = select.replaceAll(",", " ");
            console.log(select);
            console.log(selectFix);
            MovieData = MovieData.select(selectFix);
        }

        const resMovie = await MovieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by title : "+error);
    }
}

// get all movies by Director
const getAllMoviesByDirector = async (req,res) => {
    try{
        const {director,select} = req.query;
        const queryObject = {};

        let MovieData = Movie.find();

        if(director){
            queryObject.director = { $regex : director , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.director);
            MovieData = MovieData.find(queryObject);
        }

        if(select){
            let selectFix = select.replaceAll(",", " ");
            console.log(select);
            console.log(selectFix);
            MovieData = MovieData.select(selectFix);
        }

        const resMovie = await MovieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by director : "+error);
    }
}

// get all movies by StarCast
const getAllMoviesByStarCast = async (req,res) => {
    try{
        const {starCast,select} = req.query;
        const queryObject = {};

        let MovieData = Movie.find();

        if(starCast){
            queryObject.starCast = { $regex : starCast , $options : 'i'};
            console.log(queryObject);
            console.log(queryObject.starCast);
            MovieData = MovieData.find({starCast : { $elemMatch : queryObject.starCast } });
        }

        if(select){
            let selectFix = select.replaceAll(",", " ");
            console.log(select);
            console.log(selectFix);
            MovieData = MovieData.select(selectFix);
        }

        const resMovie = await MovieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by star cast : "+error);
    }
}

// get all movies by multi star cast
const getAllMoviesByMultiStarCast = async (req,res) => {
    try{
        const {starCast,select} = req.query;
        const queryObject = {};

        let MovieData = Movie.find();

        if(starCast){
            let starCastArr = starCast.split(",");
            console.log(starCastArr);
            queryObject.starCast = starCastArr;
            console.log(queryObject);
            console.log(queryObject.starCast);
            MovieData = MovieData.find({starCast : { $all : queryObject.starCast } });
        }

        if(select){
            let selectFix = select.replaceAll(",", " ");
            console.log(select);
            console.log(selectFix);
            MovieData = MovieData.select(selectFix);
        }

        const resMovie = await MovieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by genre : "+error);
    }
}

const getArrayMovieInformatrion = ( movie_info ) =>{
    const segmenter = new Intl.Segmenter([], { granularity: 'word' });
    const segmentedGenre = segmenter.segment(movie_info);
    const words = [...segmentedGenre].filter(s => s.isWordLike).map(s => s.segment);
    console.log(words)
    return words;
}

// get all movies by Genre
const getAllMoviesByGenre = async (req,res) => {
    try{
        const {genre,select} = req.query;
        const queryObject = {};

        let MovieData = Movie.find();

        if(genre){
            // console.log(genre);
            let genreArr = getArrayMovieInformatrion(genre);
            console.log(genreArr);
            queryObject.genre = genreArr;
            console.log(queryObject);
            console.log(queryObject.genre);
            MovieData = MovieData.find({genre : { $all : queryObject.genre } });
        }

        if(select){
            let selectFix = select.replaceAll(",", " ");
            console.log(select);
            console.log(selectFix);
            MovieData = MovieData.select(selectFix);
        }

        const resMovie = await MovieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by genre : "+error);
    }
}

module.exports = { 
    getAllMoviesPaginationLimit,
    getAllMoviesBySortSelect,
    getAllMoviesByTitle,
    getAllMoviesByDirector,
    getAllMoviesByStarCast,
    getAllMoviesByGenre,
    getAllMoviesByMultiStarCast,
}

step-8 :
a)Inside moviesB.js

const Movie = require("../models/movies");

const getAllMoviesByReleaseYearRange = async (req,res) => {
    try{
        const {max,min,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(max){
            queryObject.max = max;
            console.log(queryObject);
            console.log(queryObject.max);
            movieData = movieData.where("releaseYear").lte(max);
        }

        if(min){
            queryObject.min = min;
            console.log(queryObject);
            console.log(queryObject.min);
            movieData = movieData.where("releaseYear").gte(min);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all products : "+error);
    }
}

const getAllMoviesByIMDBRatingRange = async (req,res) => {
    try{
        const {max,min,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(max){
            queryObject.max = max;
            console.log(queryObject);
            console.log(queryObject.max);
            movieData = movieData.where("ratings.IMDB").lte(max);
        }

        if(min){
            queryObject.min = min;
            console.log(queryObject);
            console.log(queryObject.min);
            movieData = movieData.where("ratings.IMDB").gte(min);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by IMDB ratings : "+error);
    }
}

const getAllMoviesByMetaScoreRatingRange = async (req,res) => {
    try{
        const {max,min,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(max){
            queryObject.max = max;
            console.log(queryObject);
            console.log(queryObject.max);
            movieData = movieData.where("ratings.Metascore").lte(max);
        }

        if(min){
            queryObject.min = min;
            console.log(queryObject);
            console.log(queryObject.min);
            movieData = movieData.where("ratings.Metascore").gte(min);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by Metascore ratings : "+error);
    }
}

const getAllMoviesByGrossCollection = async (req,res) => {
    try{
        const {max,min,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(max){
            queryObject.max = max;
            console.log(queryObject);
            console.log(queryObject.max);
            movieData = movieData.where("NumbersInCount.grossCollection").lte(max);
        }

        if(min){
            queryObject.min = min;
            console.log(queryObject);
            console.log(queryObject.min);
            movieData = movieData.where("NumbersInCount.grossCollection").gte(min);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by Gross collection : "+error);
    }
}

const  getAllMoviesByBudget = async (req,res) => {
    try{
        const {max,min,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(max){
            queryObject.max = max;
            console.log(queryObject);
            console.log(queryObject.max);
            movieData = movieData.where("NumbersInCount.budget").lte(max);
        }

        if(min){
            queryObject.min = min;
            console.log(queryObject);
            console.log(queryObject.min);
            movieData = movieData.where("NumbersInCount.budget").gte(min);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all movies by budget : "+error);
    }
}

module.exports = {
    getAllMoviesByReleaseYearRange, 
    getAllMoviesByIMDBRatingRange, 
    getAllMoviesByMetaScoreRatingRange, 
    getAllMoviesByGrossCollection,
    getAllMoviesByBudget, 
}

step-9:
a)Now inside moviesC.js write code =>

const Movie = require("../models/movies");

const getAllMoviesByRatedAndStarCast = async (req,res) => {
    try{
        const {rated,starCast,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(rated){
            queryObject.rated = rated;
            console.log(queryObject);
            console.log(queryObject.rated);
            movieData = movieData.find(queryObject);
        }

        if(starCast){
            let starCastArr = starCast.split(",");
            console.log(starCastArr);
            queryObject.starCast = starCastArr;
            console.log(queryObject);
            console.log(queryObject.starCast);
            movieData = movieData.find({starCast : { $all : queryObject.starCast } });
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all products : "+error);
    }
}

const getAllMoviesByDirectorAndStarCast = async (req,res) => {
    try{
        const {director,starCast,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(director){
            queryObject.director = director;
            console.log(queryObject);
            console.log(queryObject.director);
            movieData = movieData.find(queryObject);
        }

        if(starCast){
            let starCastArr = starCast.split(",");
            console.log(starCastArr);
            queryObject.starCast = starCastArr;
            console.log(queryObject);
            console.log(queryObject.starCast);
            movieData = movieData.find({starCast : { $all : queryObject.starCast } });
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all products : "+error);
    }
}

const getAllMoviesByGenreAndStarCast = async (req,res) => {
    try{
        const {max,min,select} = req.query;
        const queryObject = {};

        let movieData = Movie.find();

        if(max){
            queryObject.max = max;
            console.log(queryObject);
            console.log(queryObject.max);
            movieData = movieData.where("releaseYear").lte(max);
        }

        if(min){
            queryObject.min = min;
            console.log(queryObject);
            console.log(queryObject.min);
            movieData = movieData.where("releaseYear").gte(min);
        }

        if(select){
            let selectFIx = select.replaceAll(",", " ");
            console.log(selectFIx);
            movieData = movieData.select(selectFIx);
        }

        const resMovie = await movieData;
        console.log(resMovie);
        console.log(req.query);
        res.status(200).json({resMovie, moviesLength : resMovie.length})
    }
    catch(error){
        res.status(400).send("Something went wrong while getting all products : "+error);
    }
} 

module.exports = {
    getAllMoviesByRatedAndStarCast,
    getAllMoviesByDirectorAndStarCast,
    getAllMoviesByGenreAndStarCast
}

ste-9 :
a) Now inside MovieD.js write =>

const Movie = require("../models/movies");

const CalculateVerdict = require("../VerdictPrediction/calcVerdict");

const createNewMovie = async (req,res) => {
    console.log(req.body);  
    try{
          console.log("creating a new movie...!!!");
            const movieData = new Movie({ 
                title : req.body.title,
                releaseYear :req.body.releaseYear,
                rated : req.body.rated,
                durationMinute : req.body.durationMinute,
                genre : req.body.genre,
                ratings :{
                    IMDB :  req.body.ratings.IMDB,
                    Metascore : req.body.ratings.Metascore,
                }, 
                featured : req.body.featured,
                director :  req.body.director,
                starCast : req.body.starCast,
                votes : req.body.votes,
                NumbersInCount : {
                    grossCollection : req.body.NumbersInCount.grossCollection,
                    budget : req.body.NumbersInCount.budget,
                } 
             });
             CalculateVerdict(movieData);
            const resMovie = await movieData.save();
            res.status(201).send(resMovie);

       console.log("title is = "+req.body.title+", releaseYear = "+movieData.releaseYear+
                "\n director is = "+req.body.director+", starCast = "+movieData.starCast+
                "\n genre is = "+movieData.genre+", budget = $ "+movieData.NumbersInCount.budget+" USD , gross collection = $ "
                 +movieData.NumbersInCount.grossCollection+" USD");
    }
    catch(err){
       res.status(404).send("Something went wrong : !! "+err);
    }
}


// UPDATE movies by StarCast
const updateMovieByTitle = async (req,res) => {
    try{
        const {title} = req.query;
        const queryObject = {};

        if(title){
            queryObject.title = title;
            console.log(queryObject);
            console.log(queryObject.title);
        }

        const updateMovie = await Movie.findOneAndUpdate(queryObject, 
            {$set : 
               { 
                title : req.body.title,
                releaseYear :req.body.releaseYear,
                rated : req.body.rated,
                durationMinute : req.body.durationMinute,
                genre : req.body.genre,
                ratings :{
                    IMDB :  req.body.ratings.IMDB,
                    Metascore : req.body.ratings.Metascore,
                }, 
                featured : req.body.featured,
                director :  req.body.director,
                starCast : req.body.starCast,
                votes : req.body.votes,
                NumbersInCount : {
                    grossCollection : req.body.NumbersInCount.grossCollection,
                    budget : req.body.NumbersInCount.budget,
                },
               } 
            },
             {
               returnDocument : "after"
             }
            );

        CalculateVerdict(updateMovie);
        const resMovie = await updateMovie.save();
        console.log(resMovie);
        res.status(200).send(resMovie);
    }
    catch(error){
        res.status(400).send("Something went wrong while updating movie by title : "+error);
    }
}

const deleteMovieByDirector =  async (req,res) => {
    try{
        const {director} = req.query;
        const queryObject = {};

        if(director){
            queryObject.director = director;
            console.log(queryObject);
            console.log(queryObject.director);
        }

     const movieResult = await Movie.findOneAndDelete(queryObject);
        if(!director){
           return res.status(404).send("No director is found with this name !!..");
        }
        res.status(201).send(movieResult);   
    }
    catch(err){
      res.status(500).send("Somethething wrong happend in deleting : "+err);
    }
}

module.exports = {
    createNewMovie,
    updateMovieByTitle,
    deleteMovieByDirector,
}

step-10 :
a) Then Go to models folder and create a file movies.js
b) Here we will create a Schema and Model =>


const mongoose = require("mongoose");

const movieSchema = new  mongoose.Schema({
    title : {
        type : String,
        required : true,
    },
    releaseYear : {
       type : Number,
       default : 2020,
    },
    rated : {
        type : String,
        required : true,
        enum : {
            values : ["R", "PG-13", "PG", "Not Rated", "TV-G"],
            message : `${this.values} is not supported`,
        }
    },
    durationMinute : {
        type : Number,
        required : [true, "PLease give the duration of movie ...!!!"],
    },
    genre : [String],
    ratings : {
        IMDB : {
            type : Number,
            required : [true, "IMDB rating must be provided ...!!!"],
        },
        Metascore : {
            type : Number,
            default : 55,
        },
    },
    featured : {
        type : Boolean,
        default : false,
    },
    director : {
        type : String,
        required : true,
    },
    starCast : [String],
    votes : {
        type : Number,
        required : true,
    },
    NumbersInCount : {
        grossCollection : {
            type : Number,
            required : true,
        }, 
        budget : {
            type : Number,
            required : true,
        },
    },
    verdict : {
        type : String,
        default : "flop",
        enum : {
            values : ["disaster", "flop", "semi-hit", "hit", "super-hit", "all time block buster"],
            message : `${this.values} is not appropiate`,
        }
    },
});

const Movie = mongoose.model('Movie', movieSchema);

module.exports = Movie;

step-11 :
a) Then goto Folder VerdictPrediction and then create a file
calcVerdict.js
b) Here you will create a function where you will define the value of the property "verdict".

c) Write the code as i Give here below =>


function CalculateVerdict(movie){
    let grsClt = movie.NumbersInCount.grossCollection;
    let bgt = movie.NumbersInCount.budget;
    let ratio = (grsClt / bgt).toFixed(1);

    if(ratio >= 4.5){
       movie.verdict = "all time block buster";
    }
    else if((ratio >= 3.5 && ratio < 4.5)){
      movie.verdict = "super-hit";
    }
    else if((ratio >= 2.5 && ratio < 3.5)){
     movie.verdict = "hit";
   }
   else if((ratio >= 1.5 && ratio < 2.5)){
     movie.verdict = "semi-hit";
   }
   else if((ratio >= 1.2 && ratio < 1.5)){
     movie.verdict = "flop";
   }
   else{
     movie.verdict = "disaster";
   }  
}

module.exports = CalculateVerdict;

Now finally you have to write two commands =>

1) nodemon MovieDb.js
2) ctrl+c
3) cls
{//Goto your Atlas and check your database that all the data inside json file has been inserted or not....}
2) nodemon src/app.js
5) Now you have a local host of port number 6060 and here is your API hosting on web-browser

links =>
1) http://localhost:6060/api/movies?page=1&limit=15

2) http://localhost:6060/api/movies/sortProject?sort=NumbersInCount.budget,-title&select=ratings,NumbersInCount,-_id,title,director,verdict,releaseYear&page=1&limit=15

3) http://localhost:6060/api/movies/title?title=Descendants&select=title,director,releaseYear,-_id,verdict,ratings&page=1&limit=15

4) http://localhost:6060/api/movies/director?director=Kenny%20Or&select=ratings,title,releaseYear,director,-_id,starCast,genre

5) http://localhost:6060/api/movies/multiStarCast?starCast=Booboo%20Stewart,Dove%20Cameron&select=title,director,starCast,-_id,releaseYear

6) http://localhost:6060/api/movies/genre?genre=Family,Fantasy,Comedy&select=title,releaseYear,ratings,genre,-_id

step-12 :
a) Now goto postman and do
POST , GET, PATCH, DELETE request

Mongoose Schema type required, lowercase, uppercase, trim, minLength,maxLength#challange 2

swapnanilWebDeveloper — Thu, 08 Feb 2024 19:43:53 +0000

I have already uploaded another challange1 . Go through that code briefly and then come to this example.
If you already have studied that previous challange1 now you are ready for this challange2.
follow my github account for more of these mongoose concepts

click to follow

const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
    await mongoose.connect('mongodb://127.0.0.1:27017/PersonData');

    const personSchema = new mongoose.Schema({
        name: {
            first: { type: String, required: true, lowercase: true, trim: true },
            last: { type: String, required: true, uppercase: true, trim: true }
        },

        username: {
            type: String,
            required: true,
            lowercase: true,
            trim: true,
            minLength: 6,
            maxLength: 25,
        },

        email: {
            type: String,
            required: true,
            uppercase: true,
            trim: true,
            minLength: 6,
            maxLength: 35,
        },

        living: Boolean,
        updated: {
            type: Date,
            default: Date.now,
        },

        age: {
            type: Number,
            min: [18, 'You are too young to be in profession'],
            max: [65, 'Now you can retire...'],
        },

        occupation: {
            type: String,
            required: true,
        }
    });

    // compile our model
    const Person = mongoose.model('Person', personSchema);

    // create a document
    await Person.insertMany([
        {
            name: {
                first: 'Mayuk',
                last: 'Mukherjee',
            },
            username: "Mayuk_ProgrammER_USER",
            email: "Mayuk@GMAIL.com",
            living : true,
            updated: new Date,
            age : 19,
            occupation: "Software Developer",
        },
        {
            name: {
                first: 'Suryendu',
                last: 'Sarkar',
            },
            username: "Suryendu_MediCAL_USER",
            email: "Suryendu@Gmail.com",
            living : true,
            updated: new Date,
            age : 54,
            occupation: "MBBS Doctor",
        },
        {
            name: {
                first: 'Aninda',
                last: 'Mukherjee',
            },
            username: "Aninda_Mathematician_USER",
            email: "Aninda@Gmail.com",
            living : false,
            updated: new Date,
            age : 55,
            occupation: "MBBS Doctor",
        },
        {
            name: {
                first: 'Snlap',
                last: 'Gadai',
            },
            username: "Sanlap_Physist_USER",
            email: "Sanlap@Gmail.com",
            living : false,
            updated: new Date,
            age : 48,
            occupation: "Physics Masters",
        },
        {
            name: {
                first: 'Souvik',
                last: 'Mondal',
            },
            username: "Souvik_UnEmployeed_USER",
            email: "Souvik@Gmail.com",
            living : true,
            updated: new Date,
            age : 48,
            occupation: "Tier 3 Engineer",
        },
    ]);

    const allPerson = await Person.find({});
    console.log(allPerson);

    for (var i = 0; i < allPerson.length; i++){
        console.log("first Name = " + allPerson[i].name.first + ", last Name = " + allPerson[i].name.last);
        console.log("userName = "+allPerson[i].username);
        console.log("email = "+allPerson[i].email);
        console.log("living = "+allPerson[i].updated);
        console.log("updated = "+allPerson[i].age);
        console.log("occupation = "+allPerson[i].occupation);
    }

}

Here is the output :


PS C:\Users\USER\Downloads\mongoExpress\SchemaModel_NestedData> node src/nested_3.js
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    _id: new ObjectId('65c52a310f778a59bff71c82'),
    email: 'Mayuk@gmail.com',
    address: { state: 'Alabama', district: 'Denver', city: 'Ohio' },
    facebook: { votes: 2045, favs: 42 },
    nested: { stuff: 'i am stuff number 1' },
    age: 34,
    living: true,
    hidden: false,
    sport_array: [
      'football',   16,
      'cricket',    22,
      'badminton',  25,
      'hockey',     29,
      'basketball'
    ],
    singer_arrayofString: [
      'Taylor Swift',
      'Justin Bieber',
      'Bruno Mars',
      'Zayn Mallik',
      'Ed Sheeran'
    ],
    phoneModel_ofNumber: [
      7, 11, 2, 4,
      6, 16, 9
    ],
    updated: 2024-02-08T19:23:29.403Z,
    comments: [ [Object], [Object], [Object] ],
    __v: 0
  },
  {
    name: { first: 'mayuk', last: 'MUKHERJEE' },
    _id: new ObjectId('65c52ee0051d28a32bc84195'),
    username: 'mayuk_programmer_user',
    email: 'MAYUK@GMAIL.COM',
    living: true,
    updated: 2024-02-08T19:43:28.871Z,
    age: 19,
    occupation: 'Software Developer',
    __v: 0
  },
  {
    name: { first: 'suryendu', last: 'SARKAR' },
    _id: new ObjectId('65c52ee0051d28a32bc84196'),
    username: 'suryendu_medical_user',
    email: 'SURYENDU@GMAIL.COM',
    living: true,
    updated: 2024-02-08T19:43:28.871Z,
    age: 54,
    occupation: 'MBBS Doctor',
    __v: 0
  },
  {
    name: { first: 'aninda', last: 'MUKHERJEE' },
    _id: new ObjectId('65c52ee0051d28a32bc84197'),
    username: 'aninda_mathematician_user',
    email: 'ANINDA@GMAIL.COM',
    living: false,
    updated: 2024-02-08T19:43:28.871Z,
    age: 55,
    occupation: 'MBBS Doctor',
    __v: 0
  },
  {
    name: { first: 'snlap', last: 'GADAI' },
    _id: new ObjectId('65c52ee0051d28a32bc84198'),
    username: 'sanlap_physist_user',
    email: 'SANLAP@GMAIL.COM',
    living: false,
    updated: 2024-02-08T19:43:28.871Z,
    age: 48,
    occupation: 'Physics Masters',
    __v: 0
  },
  {
    name: { first: 'souvik', last: 'MONDAL' },
    _id: new ObjectId('65c52ee0051d28a32bc84199'),
    username: 'souvik_unemployeed_user',
    email: 'SOUVIK@GMAIL.COM',
    living: true,
    updated: 2024-02-08T19:43:28.871Z,
    age: 48,
    occupation: 'Tier 3 Engineer',
    __v: 0
  }
]
first Name = Mayuk, last Name = Mukherjee
userName = undefined
email = Mayuk@gmail.com
living = Fri Feb 09 2024 00:53:29 GMT+0530 (India Standard Time)
updated = 34
occupation = undefined
first Name = mayuk, last Name = MUKHERJEE
userName = mayuk_programmer_user
email = MAYUK@GMAIL.COM
living = Fri Feb 09 2024 01:13:28 GMT+0530 (India Standard Time)
updated = 19
occupation = Software Developer
first Name = suryendu, last Name = SARKAR
userName = suryendu_medical_user
email = SURYENDU@GMAIL.COM
living = Fri Feb 09 2024 01:13:28 GMT+0530 (India Standard Time)
updated = 54
occupation = MBBS Doctor
first Name = aninda, last Name = MUKHERJEE
userName = aninda_mathematician_user
email = ANINDA@GMAIL.COM
living = Fri Feb 09 2024 01:13:28 GMT+0530 (India Standard Time)
updated = 55
occupation = MBBS Doctor
first Name = snlap, last Name = GADAI
userName = sanlap_physist_user
email = SANLAP@GMAIL.COM
living = Fri Feb 09 2024 01:13:28 GMT+0530 (India Standard Time)
updated = 48
occupation = Physics Masters
first Name = souvik, last Name = MONDAL
userName = souvik_unemployeed_user
email = SOUVIK@GMAIL.COM
living = Fri Feb 09 2024 01:13:28 GMT+0530 (India Standard Time)
updated = 48
occupation = Tier 3 Engineer

Mongoose Nested Data SchemaModel # Challange1 your skills # Difficulty Medium

swapnanilWebDeveloper — Thu, 08 Feb 2024 19:31:15 +0000

Here is the code for Nested data in mongoose . I hope you guys find it helpful. Go through it carefully and then checkout the out put also for better understanding....

check my github account for more of these mongoose codes . Follow the link below =>
click here to follow


const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/PersonData');

     const personSchema = new mongoose.Schema({
        name: {
          first: String,
          last: String
        },
        email : String,
        address : {
            state : String,
            district : String,
            city : String,
        },
        facebook: {
            votes: Number,
            favs: Number
        },

        nested: {
               stuff: { type: String, lowercase: true, trim: true }
        },

         age: { type: Number, min: 18, max: 65 },

         living: Boolean,
         hidden: Boolean,

         sport_array: [],
         singer_arrayofString: [String],
         phoneModel_ofNumber: [Number],
        // ofDates: [Date],

         updated: { type: Date, default: Date.now },
       //  date: { type: Date, default: Date.now },

         comments: [{ 
            body: String,
            date: Date,
            userName : String, 
            like : Boolean, 
            reply : String
        }],


      });

      // compile our model
      const Person = mongoose.model('Person', personSchema);

      // create a document
      await Person.insertMany([
        {
            name: { 
                    first: 'Mayuk',
                    last: 'Mukherjee',
                 },
            email : "Mayuk@gmail.com",
            address : {
                state : "Alabama",
                district : "Denver",
                city : "Ohio"
            },
            facebook : {
                votes : 2045,
                favs : 42,
            },
            nested : {
                stuff : "I am stuff number 1",
            },
            age : 34,

            living : true,
            hidden : false,

            sport_array : ["football",16, "cricket", 22, "badminton",25, "hockey", 29, "basketball"],

            singer_arrayofString : ["Taylor Swift", "Justin Bieber", "Bruno Mars", "Zayn Mallik", "Ed Sheeran"],

            phoneModel_ofNumber: [7, 11, 2, 4, 6, 16, 9],

            updated : new Date,

            comments: [
                { 
                   body: "This is comment number 1 from user 1",
                   date: new Date,
                   userName : "Kamilly Manoore", 
                   like : true, 
                   reply : "Thanks to you for feedback 1",
                },
                { 
                    body: "This is comment number 2 from user 2",
                    date: new Date,
                    userName : "Jemilly Rosaena", 
                    like : true, 
                    reply : "Thanks to you for feedback 2",
                 },
                 { 
                    body: "This is comment number 3 from user 3",
                    date: new Date,
                    userName : "Killey Jenner", 
                    like : false, 
                    reply : "Thanks to you for feedback 3",
                 },
            ],
        },

    ]);

    const allPerson = await Person.find({});
    console.log(allPerson);

    for(var i = 0; i < allPerson.length ; i++){
        console.log("first Name = "+allPerson[i].name.first+", last Name = "+allPerson[i].name.last);
        console.log("email = "+allPerson[i].email);
        console.log("state = "+allPerson[i].address.state+", district = "+allPerson[i].address.district+", city = "+allPerson[i].address.city);
        console.log("votes = "+allPerson[i].facebook.votes+", favourites = "+allPerson[i].facebook.favs);
        console.log("nested stuff = "+allPerson[i].nested.stuff+", age = "+allPerson[i].age+", living = "+allPerson[i].living+", hidden = "+allPerson[i].hidden);
        console.log("favourite sports = "+allPerson[i].sport_array+", favourite singers = "+allPerson[i].singer_arrayofString);
        console.log("Phone model number = "+allPerson[i].phoneModel_ofNumber);
        console.log("updated date = "+allPerson[i].updated);

        let allCom = allPerson[i].comments;
        console.log(allPerson[i].name.first+" "+allPerson[i].name.last+", has got : "+allCom.length+" comments....");

        for( var j = 0; j < allCom.length; j++){
             console.log("Person commented : "+allCom[j].userName);
             console.log("number "+(j+1)+" th comment is = "+allCom[j].body);
             console.log(allPerson[i].name.first+" "+allPerson[i].name.last+" replied with : "+allCom[j].reply);
             let res = allCom[j].like ? "Has liked your post" : "Has not liked your post";
             console.log(allCom[j].userName+" : "+res);
        }
    }

}

Now check out the output below :


PS C:\Users\USER\Downloads\mongoExpress\SchemaModel_NestedData> node src/nested_2.js
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    address: { state: 'Alabama', district: 'Denver', city: 'Ohio' },
    facebook: { votes: 2045, favs: 42 },
    nested: { stuff: 'i am stuff number 1' },
    _id: new ObjectId('65c52a310f778a59bff71c82'),
    email: 'Mayuk@gmail.com',
    age: 34,
    living: true,
    hidden: false,
    sport_array: [
      'football',   16,
      'cricket',    22,
      'badminton',  25,
      'hockey',     29,
      'basketball'
    ],
    singer_arrayofString: [
      'Taylor Swift',
      'Justin Bieber',
      'Bruno Mars',
      'Zayn Mallik',
      'Ed Sheeran'
    ],
    phoneModel_ofNumber: [
      7, 11, 2, 4,
      6, 16, 9
    ],
    updated: 2024-02-08T19:23:29.403Z,
    comments: [ [Object], [Object], [Object] ],
    __v: 0
  }
]
first Name = Mayuk, last Name = Mukherjee
email = Mayuk@gmail.com
state = Alabama, district = Denver, city = Ohio
votes = 2045, favourites = 42
nested stuff = i am stuff number 1, age = 34, living = true, hidden = false
favourite sports = football,16,cricket,22,badminton,25,hockey,29,basketball, favourite singers = Taylor Swift,Justin Bieber,Bruno Mars,Zayn Mallik,Ed Sheeran
Phone model number = 7,11,2,4,6,16,9
updated date = Fri Feb 09 2024 00:53:29 GMT+0530 (India Standard Time)
Mayuk Mukherjee, has got : 3 comments....
Person commented : Kamilly Manoore
number 1 th comment is = This is comment number 1 from user 1
Mayuk Mukherjee replied with : Thanks to you for feedback 1
Kamilly Manoore : Has liked your post
Person commented : Jemilly Rosaena
number 2 th comment is = This is comment number 2 from user 2
Mayuk Mukherjee replied with : Thanks to you for feedback 2
Jemilly Rosaena : Has liked your post
Person commented : Killey Jenner
number 3 th comment is = This is comment number 3 from user 3
Mayuk Mukherjee replied with : Thanks to you for feedback 3
Killey Jenner : Has not liked your post

Mongoose where() , equals(), gt, lt, gte, lte, in, all, nin Operators #projection select() #Difficulty Hard #Challange

swapnanilWebDeveloper — Thu, 08 Feb 2024 18:44:12 +0000

1) This is a Mongoose code where you can use where() with find(), equals(), gt(), lt(), gte(), lte() and for arrays in([]), all([]), nin([]) all the operators.

2)with the help of where() clause you can write a nested and complex query as per your need.

3) Follow my github account to get to learn about mongoose with various other concepts and also javascript, express.js ....

click here for my github account


const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/StudentData');

  const studentSchema = new mongoose.Schema({
    name: {
        first : String,
        last : String,
    },
    email : String,
    address : {
        state : String,
        district : String,
        city : String,
    },
    science : {
        physics : Number,
        chemistry : Number,
        mathematics : Number,
    },
    hobbies : [String],
  });

  const Student = mongoose.model('Student', studentSchema);

   await Student.insertMany([
    { 
        name : {
            first : "Mayuk",
            last : "Mukherjee",
        },
        email : "Mayuk@gmail.com",
        address : {
            state : "California",
            district : "Atlanta",
            city : "Georgia",
        },
        science : {
            physics : 99,
            chemistry : 88,
            mathematics : 97,
        },
        hobbies : ["sports", "singing", "dancing", "painting"],
    },
    { 
        name : {
            first : "Suryendu",
            last : "Sarkar",
        },
        email : "Suryendu@gmail.com",
        address : {
            state : "Texas",
            district : "Atlanta",
            city : "Denver",
        },
        science : {
            physics : 74,
            chemistry : 82,
            mathematics : 86,
        },
        hobbies : ["reading", "singing", "blogging", "sculpting"],
    },
    { 
        name : {
            first : "Aninda",
            last : "Mukherjee",
        },
        email : "Aninda@gmail.com",
        address : {
            state : "Massachuttes",
            district : "Atlanta",
            city : "Georgia",
        },
        science : {
            physics : 82,
            chemistry : 94,
            mathematics : 75,
        },
        hobbies : ["painting", "travelling", "sports", "judo"],
    },
    { 
        name : {
            first : "Sanlap",
            last : "Gadai",
        },
        email : "Sanlap@gmail.com",
        address : {
            state : "Alabama",
            district : "Oklohama",
            city : "Atlanta",
        },
        science : {
            physics : 85,
            chemistry : 66,
            mathematics : 79,
        },
        hobbies : ["coocking", "drawing", "sports", "gymming"],
    },
   ]);

   const allStudent = await Student.find({});
   console.log(allStudent);

    const result1 = await Student.find({ 'name.first' : "Mayuk", 'name.last' : "Mukherjee", 'address.state' : "California" }).
    where('address.district').equals('Atlanta').where('address.city').equals('Georgia').where('science.physics').gt(90).lte(100).
    select({ name: 1, "address.state" : 1, "address.district" : 1, "address.city" : 1, science : 1, hobbies : 1 });

    console.log(result1);

    const result2 = await Student.find({ 'address.state' : /Texas/i, 'address.district' : /Atlanta/i, 'science.chemistry' : {$gt : 75, $lte : 85},
    hobbies : {$in : ["travelling", "judo", "blogging", "reading"]}}).where('address.city').equals('Denver').
    where('name.last').equals('Sarkar').where('science.mathematics').gt(85).lte(90).
    select({ 'name.first' : 1, 'name.last' : 1, address : 1, 'science.physics' : 1, 'science.chemistry' : 1, 'science.mathematics' : 1, hobbies : 1})

    console.log(result2);

   const result3 = await Student.find({ "name.first" : /Aninda/i , "name.last" : /Mukherjee/i, email : 'Aninda@gmail.com'}).
                   where('address.state').equals('Massachuttes').
                   where('address.district').equals('Atlanta').
                   where('address.city').equals('Georgia').
                   where('science.physics').gte(80).lt(85).
                   where('science.chemistry').gt(85).lte(95).
                   where('science.mathematics').gte(70).lte(75).
                   where('hobbies').all([ 'painting', 'travelling', 'sports', 'judo' ]).
                   select({ name : 1, 'address.state' : 1, 'address.district' : 1, 'science.physics' : 1, 'science.mathematics' : 1, hobbies : 1})
    console.log(result3);

    const result4 = await Student.find({ 'address.state' : 'Alabama', 'address.district' : 'Oklohama', 'address.city' : 'Atlanta'}).
                    where('name.first').equals('Sanlap').
                    where('address.district').equals('Oklohama').
                    where('address.city').equals('Atlanta').
                    where('science.physics').gte(80).lt(90).
                    where('science.mathematics').gt(75).lte(80).
                    where('hobbies').nin(['painting','travelling','blogging','dancing']).
                    select({ 'name.first' : 1, address : 1, 'science.physics' : 1, 'science.chemistry' : 1, hobbies : 1})

     console.log(result4); 

    const result5 = await Student.find({ }).where('hobbies').in(['sculpting','gymming']).
                    select({ name : 1, 'address.state' : 1, 'address.city' : 1, 'science.chemistry' : 1, hobbies : 1 })

     console.log(result5);

    const result6 = await Student.find({ }).where('hobbies').all(['travelling','sports','judo']).
                    select({ 'name.last' : 1 , 'address.district' : 1, science : 1, hobbies : 1 });
     console.log(result6);

    const result7 = await Student.find({ }).where('hobbies').nin(['painting','travelling','reading','blogging']).
    select({ name : 1 , 'address.district' : 1, 'science.physics' : 1, 'science.mathematics' : 1, hobbies : 1 })

    console.log(result7);
}

Check the output here :

 PS C:\Users\USER\Downloads\mongoExpress\Queries_find_where> node src/find_where_1.js
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    address: { state: 'California', district: 'Atlanta', city: 'Georgia' },
    science: { physics: 99, chemistry: 88, mathematics: 97 },
    _id: new ObjectId('65c51a8df91b7f43aee89902'),
    email: 'Mayuk@gmail.com',
    hobbies: [ 'sports', 'singing', 'dancing', 'painting' ],
    __v: 0
  },
  {
    name: { first: 'Suryendu', last: 'Sarkar' },
    address: { state: 'Texas', district: 'Atlanta', city: 'Denver' },
    science: { physics: 74, chemistry: 82, mathematics: 86 },
    _id: new ObjectId('65c51a8df91b7f43aee89903'),
    email: 'Suryendu@gmail.com',
    hobbies: [ 'reading', 'singing', 'blogging', 'sculpting' ],
    __v: 0
  },
  {
    name: { first: 'Aninda', last: 'Mukherjee' },
    address: { state: 'Massachuttes', district: 'Atlanta', city: 'Georgia' },
    science: { physics: 82, chemistry: 94, mathematics: 75 },
    _id: new ObjectId('65c51a8df91b7f43aee89904'),
    email: 'Aninda@gmail.com',
    hobbies: [ 'painting', 'travelling', 'sports', 'judo' ],
    __v: 0
  },
  {
    name: { first: 'Sanlap', last: 'Gadai' },
    address: { state: 'Alabama', district: 'Oklohama', city: 'Atlanta' },
    science: { physics: 85, chemistry: 66, mathematics: 79 },
    _id: new ObjectId('65c51a8df91b7f43aee89905'),
    email: 'Sanlap@gmail.com',
    hobbies: [ 'coocking', 'drawing', 'sports', 'gymming' ],
    __v: 0
  }
]
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    address: { state: 'California', district: 'Atlanta', city: 'Georgia' },
    science: { physics: 99, chemistry: 88, mathematics: 97 },
    _id: new ObjectId('65c51a8df91b7f43aee89902'),
    hobbies: [ 'sports', 'singing', 'dancing', 'painting' ]
  }
]
[
  {
    name: { first: 'Suryendu', last: 'Sarkar' },
    address: { state: 'Texas', district: 'Atlanta', city: 'Denver' },
    science: { physics: 74, chemistry: 82, mathematics: 86 },
    _id: new ObjectId('65c51a8df91b7f43aee89903'),
    hobbies: [ 'reading', 'singing', 'blogging', 'sculpting' ]
  }
]
[
  {
    name: { first: 'Aninda', last: 'Mukherjee' },
    address: { state: 'Massachuttes', district: 'Atlanta' },
    science: { physics: 82, mathematics: 75 },
    _id: new ObjectId('65c51a8df91b7f43aee89904'),
    hobbies: [ 'painting', 'travelling', 'sports', 'judo' ]
  }
]
[
  {
    name: { first: 'Sanlap' },
    address: { state: 'Alabama', district: 'Oklohama', city: 'Atlanta' },
    science: { physics: 85, chemistry: 66 },
    _id: new ObjectId('65c51a8df91b7f43aee89905'),
    hobbies: [ 'coocking', 'drawing', 'sports', 'gymming' ]
  }
]
[
  {
    name: { first: 'Suryendu', last: 'Sarkar' },
    address: { state: 'Texas', city: 'Denver' },
    science: { chemistry: 82 },
    _id: new ObjectId('65c51a8df91b7f43aee89903'),
    hobbies: [ 'reading', 'singing', 'blogging', 'sculpting' ]
  },
  {
    name: { first: 'Sanlap', last: 'Gadai' },
    address: { state: 'Alabama', city: 'Atlanta' },
    science: { chemistry: 66 },
    _id: new ObjectId('65c51a8df91b7f43aee89905'),
    hobbies: [ 'coocking', 'drawing', 'sports', 'gymming' ]
  }
]
[
  {
    name: { last: 'Mukherjee' },
    address: { district: 'Atlanta' },
    science: { physics: 82, chemistry: 94, mathematics: 75 },
    _id: new ObjectId('65c51a8df91b7f43aee89904'),
    hobbies: [ 'painting', 'travelling', 'sports', 'judo' ]
  }
]
[
  {
    name: { first: 'Sanlap', last: 'Gadai' },
    address: { district: 'Oklohama' },
    science: { physics: 85, mathematics: 79 },
    _id: new ObjectId('65c51a8df91b7f43aee89905'),
    hobbies: [ 'coocking', 'drawing', 'sports', 'gymming' ]
  }
]

Mongoose find() Query : operators gt , lt ,gte, lte, in , all, nin # Challenge Your Skills

swapnanilWebDeveloper — Thu, 08 Feb 2024 18:11:34 +0000

1) Query in mongoose is very useful and you can perform multiple quires by find() method.
2) Here you can use many operators like -> $gt, $lt, $gte, $lte.
3) For arrays in mongoose you can use some operators like => $all, $in, $nin

Let's go through this code to understand the multiple combinations that you can make by find() method.

To know more about mongoose and enhance your knowledge you can go to my github account
click here to get the github aaccount


const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/StudentData');

  const studentSchema = new mongoose.Schema({
    name: {
        first : String,
        last : String,
    },
    email : String,
    address : {
        state : String,
        district : String,
        city : String,
    },
    science : {
        physics : Number,
        chemistry : Number,
        mathematics : Number,
    },
    hobbies : [String],
  });

  const Student = mongoose.model('Student', studentSchema);

   await Student.insertMany([
    { 
        name : {
            first : "Mayuk",
            last : "Mukherjee",
        },
        email : "Mayuk@gmail.com",
        address : {
            state : "California",
            district : "Atlanta",
            city : "Georgia",
        },
        science : {
            physics : 99,
            chemistry : 88,
            mathematics : 97,
        },
        hobbies : ["sports", "singing", "dancing", "painting"],
    },
    { 
        name : {
            first : "Suryendu",
            last : "Sarkar",
        },
        email : "Suryendu@gmail.com",
        address : {
            state : "Texas",
            district : "Atlanta",
            city : "Denver",
        },
        science : {
            physics : 74,
            chemistry : 82,
            mathematics : 86,
        },
        hobbies : ["reading", "singing", "blogging", "sculpting"],
    },
    { 
        name : {
            first : "Aninda",
            last : "Mukherjee",
        },
        email : "Aninda@gmail.com",
        address : {
            state : "Massachuttes",
            district : "Atlanta",
            city : "Georgia",
        },
        science : {
            physics : 82,
            chemistry : 94,
            mathematics : 75,
        },
        hobbies : ["painting", "travelling", "sports", "judo"],
    },
    { 
        name : {
            first : "Sanlap",
            last : "Gadai",
        },
        email : "Sanlap@gmail.com",
        address : {
            state : "Alabama",
            district : "Oklohama",
            city : "Atlanta",
        },
        science : {
            physics : 85,
            chemistry : 66,
            mathematics : 79,
        },
        hobbies : ["coocking", "drawing", "sports", "gymming"],
    },
   ]);

   const allStudent = await Student.find({});
  // console.log(allStudent);

  // name.first = "Mayuk", name.last = "Mukherjee"
   const result1 = await Student.find({ 'name.first' : 'Mayuk', 'name.last' : "Mukherjee",  'science.physics' : { $gte: 98 }, 
              'science.chemistry' : { $lte : 90, $gte : 85} }, 'name address.state address.district address.city hobbies');

   console.log(result1); 

   const result2 = await Student.find({ 'address.state' : /Texas/i, 'address.district' : /Atlanta/i, 'science.mathematics' : {$gt : 80, $lte : 90} }, 
                      'name.first name.last science.physics science.chemistry science.mathematics hobbies' );
   console.log(result2);

   const result3 = await Student.find({  'science.physics' : { $gte: 80, $lte : 85 }, 'science.chemistry' : { $gte : 90, $lte : 95},
                   'name.last' : "Mukherjee" }, 'name.first name.last address science.physics science.chemistry science.mathematics');
   console.log(result3);

   //likes: { $in: ['vaporizing', 'talking'] }
    const result4 = await Student.find({ 'name.first': /Sanlap/i, 'address.city' : /Atlanta/i , 'science.mathematics' : {$gt : 75, $lte : 85} }, 
                    'name address.state address.district address.city science hobbies');

   console.log(result4);

   const result5 = await Student.find({ hobbies : { $in : ['painting','sculpting'] }}, 'name.first name.last address science.chemistry hobbies');
   console.log(result5);

   const result6 = await Student.find({ hobbies : { $all : ["painting", "travelling", "sports", "judo"] }}, 'name address.state address.district address.city science hobbies');
   console.log(result6);

   const result7 = await Student.find({ hobbies : { $nin : ["gymming", "judo", "sculpting"] }}, 'name.first name.last address science.physics science.chemistry science.mathematics hobbies');
   console.log(result7);

}

Check this output here

PS C:\Users\USER\Downloads\mongoExpress\Queries_find> node src/find_1.js
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    address: { state: 'California', district: 'Atlanta', city: 'Georgia' },
    _id: new ObjectId('65c513f52ab43c3d210b1659'),
    hobbies: [ 'sports', 'singing', 'dancing', 'painting' ]
  }
]
[
  {
    name: { first: 'Suryendu', last: 'Sarkar' },
    science: { physics: 74, chemistry: 82, mathematics: 86 },
    _id: new ObjectId('65c513f52ab43c3d210b165a'),
    hobbies: [ 'reading', 'singing', 'blogging', 'sculpting' ]
  }
]
[
  {
    name: { first: 'Aninda', last: 'Mukherjee' },
    address: { state: 'Massachuttes', district: 'Atlanta', city: 'Georgia' },
    science: { physics: 82, chemistry: 94, mathematics: 75 },
    _id: new ObjectId('65c513f52ab43c3d210b165b')
  }
]
[
  {
    name: { first: 'Sanlap', last: 'Gadai' },
    address: { state: 'Alabama', district: 'Oklohama', city: 'Atlanta' },
    science: { physics: 85, chemistry: 66, mathematics: 79 },
    _id: new ObjectId('65c513f52ab43c3d210b165c'),
    hobbies: [ 'coocking', 'drawing', 'sports', 'gymming' ]
  }
]
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    address: { state: 'California', district: 'Atlanta', city: 'Georgia' },
    science: { chemistry: 88 },
    _id: new ObjectId('65c513f52ab43c3d210b1659'),
    hobbies: [ 'sports', 'singing', 'dancing', 'painting' ]
  },
  {
    name: { first: 'Suryendu', last: 'Sarkar' },
    address: { state: 'Texas', district: 'Atlanta', city: 'Denver' },
    science: { chemistry: 82 },
    _id: new ObjectId('65c513f52ab43c3d210b165a'),
    hobbies: [ 'reading', 'singing', 'blogging', 'sculpting' ]
  },
  {
    name: { first: 'Aninda', last: 'Mukherjee' },
    address: { state: 'Massachuttes', district: 'Atlanta', city: 'Georgia' },
    science: { chemistry: 94 },
    _id: new ObjectId('65c513f52ab43c3d210b165b'),
    hobbies: [ 'painting', 'travelling', 'sports', 'judo' ]
  }
]
[
  {
    name: { first: 'Aninda', last: 'Mukherjee' },
    address: { state: 'Massachuttes', district: 'Atlanta', city: 'Georgia' },
    science: { physics: 82, chemistry: 94, mathematics: 75 },
    _id: new ObjectId('65c513f52ab43c3d210b165b'),
    hobbies: [ 'painting', 'travelling', 'sports', 'judo' ]
  }
]
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    address: { state: 'California', district: 'Atlanta', city: 'Georgia' },
    science: { physics: 99, chemistry: 88, mathematics: 97 },
    _id: new ObjectId('65c513f52ab43c3d210b1659'),
    hobbies: [ 'sports', 'singing', 'dancing', 'painting' ]
  }
]

Mongoose Alias Schema with instance method# Diffuclty Exterme # Challange yourself

swapnanilWebDeveloper — Thu, 08 Feb 2024 17:25:11 +0000

1) Alias is a very important concept for those who want to master mongoose .
2) Alias provides you a shortcut path or a alternate path where you can get access to properties and values of documents.

To get more programs of mongoose and to boost your knowledge on mongoose you can follow this link of my GitHub account

click on this to get into github account

const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
    await mongoose.connect('mongodb://127.0.0.1:27017/StudentData');

    const studentSchema = new mongoose.Schema({
        studentName : {
            type: String,
            alias: 'name',
        },
        studentEmail : {
            type : String,
            alias : 'email',
        },
        studentAddress : {
            state : { type : String, alias : "st"},
            district : { type : String, alias : "dist"},
            city : { type : String, alias : "ct"},
        },
        scienceMarks : {
            theoryPaper : { 
                physics : { type : Number, alias : "phTheo"},
                chemistry : { type : Number, alias : "chTheo"},
                mathematics : { type : Number, alias : "mtTheo"},
            },
            practicalPaper : {
                physics : { type : Number, alias : "phPrt"},
                chemistry : { type : Number, alias : "chPrt"},
                mathematics : { type : Number, alias : "mtPrt"},
            }
        }
    },
    {
          methods: {
             getStudentBioData() {
                 const bioData =  "name is : "+this.name+", email is : "+this.email;
                 return bioData; 
            },
             getStudentLocationData() {
                const locationData =  "Student is currently living in state : "+this.st+", at district is : "+this.dist+
                                       ", at city is : "+this.ct;
                return locationData; 
           },
            getStudentScienceMarks(){
                let physicsTotal, chemistryTotal , mathematicsTotal;
                physicsTotal = this.phTheo + this.phPrt;
                chemistryTotal = this.chTheo + this.chPrt;
                mathematicsTotal = this.mtTheo + this.mtPrt;

                this.getHelloStudents(this.name, physicsTotal + chemistryTotal + mathematicsTotal);

                return "Marks in physics = "+physicsTotal+", chemistry = "+chemistryTotal+", mathematics = "+mathematicsTotal;
            },
            getHelloStudents(stuName, totalMarks){
                let grade, average;
                average = (totalMarks / 3).toFixed(2);

                if(average >= 90){
                     grade = "Excellent";
                }
                else if(average >= 70 && average < 90){
                     grade = "Very Good";
                }
                else if(average >= 50 && average < 70){
                    grade = "Good";
               }
               else if(average >= 30 && average < 50){
                grade = "Pass";
               }
               else{
                 grade = "Fail";
               }

               console.log(stuName+" , has got total marks of = "+totalMarks+", average = "+average
                  + ",\n with a grade of : "+grade);
            }
          }
    }
    );

    const Student = mongoose.model('Student', studentSchema);

    await Student.insertMany([
        {
            name : "Mayuk Mukherjee",
            email : "Mayuk@gmail.com",
            st : "California",
            dist : "Ohio",
            ct : "Colorado",
            phTheo : 79,
            chTheo : 68,
            mtTheo : 77,
            phPrt : 18,
            chPrt : 16,
            mtPrt : 19,
        },
        {
            name : "Suryendu Sarkar", 
            email : "Suryendu@gmail.com",
            st : "Alabama",
            dist : "Denver",
            ct : "California",
            phTheo : 49,
            chTheo : 58,
            mtTheo : 58,
            phPrt : 12,
            chPrt : 18,
            mtPrt : 12
        },
        {
            name : "Aninda Mukherjee",
            email : "Aninda@gmail.com",
            st : "Alaska",
            dist : "Texas",
            ct : "Huston",
            phTheo : 54,
            chTheo : 59,
            mtTheo : 42,
            phPrt : 15,
            chPrt : 20,
            mtPrt : 14,
        },
        {
            name : "Sanlap Gadai",
            email : "Sanlap@gmail.com",
            st : "MAssachuttes",
            dist : "Ohio",
            ct : "Atlanta",
            phTheo : 66,
            chTheo : 61,
            mtTheo : 59,
            phPrt : 18,
            chPrt : 12,
            mtPrt : 14,
        },
    ]);

    const allStudent = await Student.find({});
    console.log(allStudent);

    console.log("total students number = "+allStudent.length+"\n");

    for(var i = 0; i < allStudent.length; i++){
         console.log(allStudent[i].getStudentBioData());
         console.log(allStudent[i].getStudentLocationData());
         console.log(allStudent[i].getStudentScienceMarks());
         console.log("\n");
    }
}

Go through this code very carefully .
Check this output given below :


PS C:\Users\USER\Downloads\mongoExpress\Alias_Schema> node src/alias_2.js
[
  {
    studentAddress: { state: 'California', district: 'Ohio', city: 'Colorado' },
    scienceMarks: { theoryPaper: [Object], practicalPaper: [Object] },
    _id: new ObjectId('65c50e0667aa21025fa5f6dc'),
    studentName: 'Mayuk Mukherjee',
    studentEmail: 'Mayuk@gmail.com',
    __v: 0
  },
  {
    studentAddress: { state: 'Alabama', district: 'Denver', city: 'California' },
    scienceMarks: { theoryPaper: [Object], practicalPaper: [Object] },
    _id: new ObjectId('65c50e0667aa21025fa5f6dd'),
    studentName: 'Suryendu Sarkar',
    studentEmail: 'Suryendu@gmail.com',
    __v: 0
  },
  {
    studentAddress: { state: 'Alaska', district: 'Texas', city: 'Huston' },
    scienceMarks: { theoryPaper: [Object], practicalPaper: [Object] },
    _id: new ObjectId('65c50e0667aa21025fa5f6de'),
    studentName: 'Aninda Mukherjee',
    studentEmail: 'Aninda@gmail.com',
    __v: 0
  },
  {
    studentAddress: { state: 'MAssachuttes', district: 'Ohio', city: 'Atlanta' },
    scienceMarks: { theoryPaper: [Object], practicalPaper: [Object] },
    _id: new ObjectId('65c50e0667aa21025fa5f6df'),
    studentName: 'Sanlap Gadai',
    studentEmail: 'Sanlap@gmail.com',
    __v: 0
  }
]
total students number = 4

name is : Mayuk Mukherjee, email is : Mayuk@gmail.com
Student is currently living in state : California, at district is : Ohio, at city is : Colorado
Mayuk Mukherjee , has got total marks of = 277, average = 92.33,
 with a grade of : Excellent
Marks in physics = 97, chemistry = 84, mathematics = 96


name is : Suryendu Sarkar, email is : Suryendu@gmail.com
Student is currently living in state : Alabama, at district is : Denver, at city is : California
Suryendu Sarkar , has got total marks of = 207, average = 69.00,
 with a grade of : Good
Marks in physics = 61, chemistry = 76, mathematics = 70


name is : Aninda Mukherjee, email is : Aninda@gmail.com
Student is currently living in state : Alaska, at district is : Texas, at city is : Huston
Aninda Mukherjee , has got total marks of = 204, average = 68.00,
 with a grade of : Good
Marks in physics = 69, chemistry = 79, mathematics = 56


name is : Sanlap Gadai, email is : Sanlap@gmail.com
Student is currently living in state : MAssachuttes, at district is : Ohio, at city is : Atlanta
Sanlap Gadai , has got total marks of = 230, average = 76.67,
 with a grade of : Very Good
Marks in physics = 84, chemistry = 73, mathematics = 73

Mongoose QueryBuilder inside and outside schema with[ find, where, gt, lt, gte, lte, equals] different queries # Diffuclty Hard

swapnanilWebDeveloper — Thu, 08 Feb 2024 16:49:39 +0000

here is the code for query builder in mongoose .

QueryBuiders are very important in mongoose because you can build queries inside QueryBuilders and define any type of query as per your requirement.

You can call these querybuilders multiple times as much you need it . But if you do not create your own query builder then you have to write that query each time whenever you need that query.

QueryBuilder helps you to write efficient code and make your program better

const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
    await mongoose.connect('mongodb://127.0.0.1:27017/AnimalData');

      const animalSchema = new mongoose.Schema({ 
             name: String,
             breed: String,
             price : Number,
             discPerc : Number,
             discAvailable : Boolean,
             CountryOrigin : String,
        },
        {
          query: {
            // findByName query is here
            async byName(name) {
              console.log("Out of query builder function()....");

              const resAnimal = await this.where("name").equals(name);
              console.log("all the animals of name = "+name+" is found "+resAnimal.length);
              console.log(resAnimal);

              for(var i = 0; i < resAnimal.length; i++){
                    console.log("name of the animaal = "+resAnimal[i].name);
                    console.log("breed of the animaal = "+resAnimal[i].breed);
                    console.log("price of the animaal = "+resAnimal[i].price);
                    console.log("discPerc of the animaal = "+resAnimal[i].discPerc);
                    console.log("discAvailable of the animaal = "+resAnimal[i].discAvailable);
                    console.log("CountryOrigin of the animaal = "+resAnimal[i].CountryOrigin);
              }

              return resAnimal;
            },

           // findByPrice query is here

           async byPrice(min, max) {
            console.log("Out of query builder function()....");

            //await Tank.find({ size: 'small' }).where('createdDate').gt(oneYearAgo).exec();

            const resAnimal = await this.where("price").gte(min).lte(max);
            console.log("all the animals of price between = $"+min+" and $"+max+" is found "+resAnimal.length);
            console.log(resAnimal);

            for(var i = 0; i < resAnimal.length; i++){
                  console.log("name of the animal = "+resAnimal[i].name);
                  console.log("breed of the animal = "+resAnimal[i].breed);
                  console.log("price of the animal = "+resAnimal[i].price);
                  console.log("discPerc of the animal = "+resAnimal[i].discPerc);
                  console.log("discAvailable of the animal = "+resAnimal[i].discAvailable);
                  console.log("CountryOrigin of the animal = "+resAnimal[i].CountryOrigin);

                  if(resAnimal[i].discAvailable){
                    const netPrice = resAnimal[i].price -  resAnimal[i].price * (resAnimal[i].discPerc / 100);
                    console.log("\nprice after discount = $"+netPrice);
                  }
                  else{
                    console.log("\nDiscount is not available...for : "+resAnimal[i].name);
                  }
            }

            return resAnimal;
          }, 

          }
        });

        animalSchema.query.byBreed = async function(animal_breed) {
            console.log("byBreed function is executing...");

            const resAnimal = await this.where('breed').equals(animal_breed);
            console.log("all the breed of : "+animal_breed+", found = "+resAnimal.length+" times..");

            for(var i = 0; i < resAnimal.length; i++){
                console.log("\nname of the animal : "+resAnimal[i].name);
                console.log("breed of the animal : "+resAnimal[i].breed);
                console.log("price of the animal : $"+resAnimal[i].price);
                console.log("discPerc of the animal : "+resAnimal[i].discPerc+" '%' ");
                console.log("discAvailable of the animal : "+resAnimal[i].discAvailable);
                console.log("CountryOrigin of the animal : "+resAnimal[i].CountryOrigin);
            }

            return resAnimal;
          };

        const Animal = mongoose.model('Animal', animalSchema);

        await  Animal.insertMany([
            { 
               name: "Agean",
               breed: "Cat",
               price : 240,
               discPerc : 16,
               discAvailable : true,
               CountryOrigin : "Greece",
            },
            { 
                name: "American Bobtail",
                breed: "Cat",
                price : 355,
                discPerc : 23,
                discAvailable : true,
                CountryOrigin : "United States",
             },
             { 
                name: "Common KeelBack",
                breed: "Snake",
                price : 157,
                discPerc : 34,
                discAvailable : false,
                CountryOrigin : "New Guinea",
             },
             { 
                name: "Glosy Snake",
                breed: "Snake",
                price : 497,
                discPerc : 29,
                discAvailable : false,
                CountryOrigin : "Mexico",
             },
             { 
                name: "Philippine forest rat",
                breed: "Rat",
                price : 179,
                discPerc : 7,
                discAvailable : true,
                CountryOrigin : "Philippines",
             },
             { 
                name: "Rare UniBack",
                breed: "Rat",
                price : 88,
                discPerc : 13,
                discAvailable : false,
                CountryOrigin : "New Guinea",
             },
        ]);

        const animals = await Animal.find({});
        console.log(animals);

          const nameResult = await Animal.find().byName('Glosy Snake');
          console.log(nameResult);

         const breedResult = await Animal.find().byBreed("Rat");
         console.log(breedResult);  

         const priceResult = await Animal.find().byPrice(100, 200);
         console.log(priceResult);   
}

Here we have created byName(), byPrice(), byBreed() these three query builder . Among these three queryBuilders only one is outside the schema , i.e : byBreed() . byName() and byPrice() are built inside schema . Now checkout the output :


PS C:\Users\USER\Downloads\mongoExpress\SchemaModel_QueryBuilders> node src/queryBuilder_1.js
[
  {
    _id: new ObjectId('65c4fdcc73ad7f090cd8cd0d'),
    name: 'Siberian Husky',
    breed: 'Dog',
    countryOrigin: 'Siberia',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fdcc73ad7f090cd8cd0e'),
    name: 'British Smooth Hair',
    breed: 'Cat',
    countryOrigin: 'United Kingdom',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fdcc73ad7f090cd8cd0f'),
    name: 'American Short Hair',
    breed: 'Cat',
    countryOrigin: 'USA',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fdcc73ad7f090cd8cd10'),
    name: 'Bull Dog',
    breed: 'Dog',
    countryOrigin: 'Switzerland',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3dd9'),
    name: 'Agean',
    breed: 'Cat',
    price: 240,
    discPerc: 16,
    discAvailable: true,
    CountryOrigin: 'Greece',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3dda'),
    name: 'American Bobtail',
    breed: 'Cat',
    price: 355,
    discPerc: 23,
    discAvailable: true,
    CountryOrigin: 'United States',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddb'),
    name: 'Common KeelBack',
    breed: 'Snake',
    price: 157,
    discPerc: 34,
    discAvailable: false,
    CountryOrigin: 'New Guinea',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddc'),
    name: 'Glosy Snake',
    breed: 'Snake',
    price: 497,
    discPerc: 29,
    discAvailable: false,
    CountryOrigin: 'Mexico',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddd'),
    name: 'Philippine forest rat',
    breed: 'Rat',
    price: 179,
    discPerc: 7,
    discAvailable: true,
    CountryOrigin: 'Philippines',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3dde'),
    name: 'Rare UniBack',
    breed: 'Rat',
    price: 88,
    discPerc: 13,
    discAvailable: false,
    CountryOrigin: 'New Guinea',
    __v: 0
  }
]
Out of query builder function()....
all the animals of name = Glosy Snake is found 1
[
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddc'),
    name: 'Glosy Snake',
    breed: 'Snake',
    price: 497,
    discPerc: 29,
    discAvailable: false,
    CountryOrigin: 'Mexico',
    __v: 0
  }
]
name of the animaal = Glosy Snake
breed of the animaal = Snake
price of the animaal = 497
discPerc of the animaal = 29
discAvailable of the animaal = false
CountryOrigin of the animaal = Mexico
[
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddc'),
    name: 'Glosy Snake',
    breed: 'Snake',
    price: 497,
    discPerc: 29,
    discAvailable: false,
    CountryOrigin: 'Mexico',
    __v: 0
  }
]
byBreed function is executing...
all the breed of : Rat, found = 2 times..

name of the animal : Philippine forest rat
breed of the animal : Rat
price of the animal : $179
discPerc of the animal : 7 '%'
discAvailable of the animal : true
CountryOrigin of the animal : Philippines

name of the animal : Rare UniBack
breed of the animal : Rat
price of the animal : $88
discPerc of the animal : 13 '%'
discAvailable of the animal : false
CountryOrigin of the animal : New Guinea
[
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddd'),
    name: 'Philippine forest rat',
    breed: 'Rat',
    price: 179,
    discPerc: 7,
    discAvailable: true,
    CountryOrigin: 'Philippines',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3dde'),
    name: 'Rare UniBack',
    breed: 'Rat',
    price: 88,
    discPerc: 13,
    discAvailable: false,
    CountryOrigin: 'New Guinea',
    __v: 0
  }
]
Out of query builder function()....
all the animals of price between = $100 and $200 is found 2
[
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddb'),
    name: 'Common KeelBack',
    breed: 'Snake',
    price: 157,
    discPerc: 34,
    discAvailable: false,
    CountryOrigin: 'New Guinea',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddd'),
    name: 'Philippine forest rat',
    breed: 'Rat',
    price: 179,
    discPerc: 7,
    discAvailable: true,
    CountryOrigin: 'Philippines',
    __v: 0
  }
]
name of the animal = Common KeelBack
breed of the animal = Snake
price of the animal = 157
discPerc of the animal = 34
discAvailable of the animal = false
CountryOrigin of the animal = New Guinea

Discount is not available...for : Common KeelBack
name of the animal = Philippine forest rat
breed of the animal = Rat
price of the animal = 179
discPerc of the animal = 7
discAvailable of the animal = true
CountryOrigin of the animal = Philippines

price after discount = $166.47
[
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddb'),
    name: 'Common KeelBack',
    breed: 'Snake',
    price: 157,
    discPerc: 34,
    discAvailable: false,
    CountryOrigin: 'New Guinea',
    __v: 0
  },
  {
    _id: new ObjectId('65c500ee9a015a02983f3ddd'),
    name: 'Philippine forest rat',
    breed: 'Rat',
    price: 179,
    discPerc: 7,
    discAvailable: true,
    CountryOrigin: 'Philippines',
    __v: 0
  }
]

Mongoose Statics-Methods : Build statics-method inside and outside the Schema#Challange

swapnanilWebDeveloper — Thu, 08 Feb 2024 16:15:18 +0000

I am giving a code for how to build statics methods inside and outside the Schema.

Statics methods are kind of similar to instance methods .

Let's check out some new concepts of mongoose

// getting-started.js
const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/AnimalData');

  const animalSchema = new mongoose.Schema({ name: String, breed: String, countryOrigin : String },
    {
      statics: {
        async findByBreed(animal_breed) {

           const species = await this.find({ breed: new RegExp(animal_breed) });
           console.log("All animal species is = "+species);

           console.log("all the breed = "+animal_breed+", total found animal number = "+species.length);

           for(var i = 0; i < species.length; i++){
            console.log("name is = "+species[i].name);
            console.log("breed is = "+species[i].breed);
            console.log("countryOrigin is = "+species[i].countryOrigin+"\n");
           }

           return species;
        }
      }
    });

    animalSchema.statics.findByName =  async function(animal_name, modelName) {

        console.log("I am inside findByName() method...."+animal_name);
        const nameAnimal = await modelName.find({ name: new RegExp(animal_name) });

        console.log(nameAnimal);
        console.log("number of animals with name : "+animal_name+" : found = "+nameAnimal.length);

        for(var i = 0; i < nameAnimal.length; i++){
             console.log("name of the animal = "+nameAnimal[i].name);
             console.log("breed of the animal = "+nameAnimal[i].breed);
             console.log("country of origin of the animal = "+nameAnimal[i].countryOrigin);
        }

        return nameAnimal;
      };

    const Animal = mongoose.model('Animal', animalSchema);

    await Animal.insertMany([
        { 
          name: 'Siberian Husky',
          breed : "Dog",
          countryOrigin : "Siberia"
        },
        { 
            name: 'British Smooth Hair',
            breed : "Cat",
            countryOrigin : "United Kingdom"
        },
        { 
            name: 'American Short Hair',
            breed : "Cat",
            countryOrigin : "USA"
        },
        { 
            name: 'Bull Dog',
            breed : "Dog",
            countryOrigin : "Switzerland"
        }
    ]);

    let animals = await Animal.find({});
    console.log(animals);

    const breedResult = await Animal.findByBreed("Dog", "Bull Dog");
    console.log(breedResult);

    const nameResult = await Animal.findByName("American Short Hair", Animal);
    console.log(nameResult);

}

1)Here we have created a schema called animalSchema and a model regarding this called Animal .
2) Then we have built a statics method called "findByBreed"
inside the Schema and another one is "findByName" outside schema
3) Now check the output inside the terminal.

PS C:\Users\USER\Downloads\mongoExpress\SchemaModel_statics> node src/statics_1.js
[
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333b'),
    name: 'German Shepard',
    type: 'Dog',
    priceUSD: 2500,
    discPerc: 22,
    discAvailable: true,
    countryOrigin: 'Germany',
    breedQuality: 'High',
    medicalExp: 490,
    __v: 0
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333c'),
    name: 'Husky',
    type: 'Dog',
    priceUSD: 1865,
    discPerc: 16,
    discAvailable: true,
    countryOrigin: 'Alaska',
    breedQuality: 'Medium',
    medicalExp: 255,
    __v: 0
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333d'),
    name: 'British Short Hair',
    type: 'Cat',
    priceUSD: 1250,
    discPerc: 34,
    discAvailable: false,
    countryOrigin: 'United Kingdom',
    breedQuality: 'Medium',
    medicalExp: 345,
    __v: 0
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333e'),
    name: 'American Fluffy',
    type: 'Cat',
    priceUSD: 1750,
    discPerc: 28,
    discAvailable: true,
    countryOrigin: 'United Kingdom',
    breedQuality: 'Low',
    medicalExp: 259,
    __v: 0
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333f'),
    name: 'Bittle Sumdohg',
    type: 'Rat',
    priceUSD: 2445,
    discPerc: 11,
    discAvailable: false,
    countryOrigin: 'Alaska',
    breedQuality: 'High',
    medicalExp: 735,
    __v: 0
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a0363340'),
    name: 'Rattle Snake',
    type: 'Snake',
    priceUSD: 3775,
    discPerc: 25,
    discAvailable: true,
    countryOrigin: 'Germany',
    breedQuality: 'Low',
    medicalExp: 1325,
    __v: 0
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a0363341'),
    name: 'Black Mamba',
    type: 'Snake',
    priceUSD: 1985,
    discPerc: 39,
    discAvailable: false,
    countryOrigin: 'Uited States of America',
    breedQuality: 'Medium',
    medicalExp: 688,
    __v: 0
  },
  {
    _id: new ObjectId('65c4fd3acb91cae32f906537'),
    name: 'Siberian Husky',
    breed: 'Dog',
    countryOrigin: 'Siberia',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fd3acb91cae32f906538'),
    name: 'British Smooth Hair',
    breed: 'Cat',
    countryOrigin: 'United Kingdom',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fd3acb91cae32f906539'),
    name: 'American Short Hair',
    breed: 'Cat',
    countryOrigin: 'USA',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fd3acb91cae32f90653a'),
    name: 'Bull Dog',
    breed: 'Dog',
    countryOrigin: 'Switzerland',
    __v: 0
  }
]
All animal species is = {
  _id: new ObjectId('65c4fd3acb91cae32f906537'),
  name: 'Siberian Husky',
  breed: 'Dog',
  countryOrigin: 'Siberia',
  __v: 0
},{
  _id: new ObjectId('65c4fd3acb91cae32f90653a'),
  name: 'Bull Dog',
  breed: 'Dog',
  countryOrigin: 'Switzerland',
  __v: 0
}
all the breed = Dog, total found animal number = 2
name is = Siberian Husky
breed is = Dog
countryOrigin is = Siberia

name is = Bull Dog
breed is = Dog
countryOrigin is = Switzerland

[
  {
    _id: new ObjectId('65c4fd3acb91cae32f906537'),
    name: 'Siberian Husky',
    breed: 'Dog',
    countryOrigin: 'Siberia',
    __v: 0
  },
  {
    _id: new ObjectId('65c4fd3acb91cae32f90653a'),
    name: 'Bull Dog',
    breed: 'Dog',
    countryOrigin: 'Switzerland',
    __v: 0
  }
]
I am inside findByName() method....American Short Hair
[
  {
    _id: new ObjectId('65c4fd3acb91cae32f906539'),
    name: 'American Short Hair',
    breed: 'Cat',
    countryOrigin: 'USA',
    __v: 0
  }
]
number of animals with name : American Short Hair : found = 1
name of the animal = American Short Hair
breed of the animal = Cat
country of origin of the animal = USA
[
  {
    _id: new ObjectId('65c4fd3acb91cae32f906539'),
    name: 'American Short Hair',
    breed: 'Cat',
    countryOrigin: 'USA',
    __v: 0
  }

MongoDBCompass output =>

Mongoose Instance Methods () , create methods inside and outside Schema

swapnanilWebDeveloper — Thu, 08 Feb 2024 15:54:54 +0000

How to create an instance method inside and outside of schema

Here is a large size and complex program to enhance your skill on SchemaModel and instance method ..

follow my github account to get this code on my github profile

click to get into this code


const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {

    await mongoose.connect('mongodb://127.0.0.1:27017/AnimalData');

    const animalSchema = new mongoose.Schema({ 
                             name: String,
                             type: String,
                             priceUSD : Number,
                             discPerc : Number,
                             discAvailable : Boolean,
                             countryOrigin : String,
                             breedQuality : String,
                             medicalExp : Number,
                            },
        {
            methods: {

                async findByName(modelName){
                   console.log("findByName method executed successfully....");
                   const name_result = await modelName.find({ name : this.name});

                   console.log("name = "+this.name+", type = "+this.type+
                   ",\nprice $"+this.priceUSD+" USD ,discount percentage = "+this.discPerc+", discount available = "+this.discAvailable+
                   "\n, country of origin = "+this.countryOrigin+
                   ",\nbreed quality = "+this.breedQuality+", medical expenses anually = $"+this.medicalExp+"USD\n")
                },

                async findSimilarTypes(modelName) {
                    console.log("findSimilarTypes function() has been executed successfully.....");

                    console.log("all the animals of type : "+this.type+" is \n");
                    return await modelName.find({ type: this.type }, "name type countryOrigin breedQuality");
                },

                async findSimilarCountryOrigins(modelName) {
                    console.log("findSimilarCountryOrigin function() has been executed successfully.....");

                    console.log("all the animals originated from : "+this.countryOrigin+" is \n");
                    return await modelName.find({ countryOrigin: this.countryOrigin }, "name countryOrigin priceUSD medicalExp");
                },

                async findSimilarBreedQualities(modelName) {
                    console.log("findSimilarBreedQuality function() has been executed successfully.....");

                    console.log("all the animals of breed quality : "+this.breedQuality+" is \n");
                    return await modelName.find({ breedQuality: this.breedQuality  }, "name type breedQuality countryOrigin");
                }

            }
        });

        animalSchema.methods.findPrice = async function() {
             console.log("\nI am inside findPrice method....");

             console.log("name = "+this.name+", type = "+this.type+
                   ",\nprice $"+this.priceUSD+" USD ,discount percentage = "+this.discPerc+", discount available = "+this.discAvailable+
                   "\n, country of origin = "+this.countryOrigin+
                   ",\nbreed quality = "+this.breedQuality+", medical expenses anually = "+this.medicalExp);

                   if(this.discAvailable){
                    const netPrice = this.priceUSD - this.priceUSD * ( this.discPerc / 100); 
                    return "price after discount = $"+netPrice+"\n";
                   }
                   else{
                     return "Discount is not available for "+this.name+" ("+this.type+")";
                   }
          };

    const Animal = mongoose.model('Animal', animalSchema);

    await Animal.insertMany([
        { 
            name : "German Shepard",
            type: 'Dog' ,
            priceUSD : 2500,
            discPerc : 22,
            discAvailable : true,
            countryOrigin : "Germany",
            breedQuality : "High",
            medicalExp : 490, 
        },
        {
            name : "Husky",
            type : "Dog",
            priceUSD : 1865,
            discPerc : 16,
            discAvailable : true,
            countryOrigin : "Alaska",
            breedQuality : "Medium",
            medicalExp : 255, 
        },
        {
            name : "British Short Hair",
            type : "Cat",
            priceUSD : 1250,
            discPerc : 34,
            discAvailable : false,
            countryOrigin : "United Kingdom",
            breedQuality : "Medium",
            medicalExp : 345, 
        },
        {
            name : "American Fluffy",
            type : "Cat",
            priceUSD : 1750,
            discPerc : 28,
            discAvailable : true,
            countryOrigin : "United Kingdom",
            breedQuality : "Low",
            medicalExp : 259, 
        },
        {
            name : "Bittle Sumdohg",
            type : "Rat",
            priceUSD : 2445,
            discPerc : 11,
            discAvailable : false,
            countryOrigin : "Alaska",
            breedQuality : "High",
            medicalExp : 735, 
        },
        {
            name : "Rattle Snake",
            type : "Snake",
            priceUSD : 3775,
            discPerc : 25,
            discAvailable : true,
            countryOrigin : "Germany",
            breedQuality : "Low",
            medicalExp : 1325, 
        },
        {
            name : "Black Mamba",
            type : "Snake",
            priceUSD : 1985,
            discPerc : 39,
            discAvailable : false,
            countryOrigin : "Uited States of America",
            breedQuality : "Medium",
            medicalExp : 688, 
        },
    ]);

    const allAnimals = await Animal.find({});
    // console.log(allAnimals);

    const name_results = await allAnimals[2].findByName(Animal);

    const type_results = await allAnimals[5].findSimilarTypes(Animal);
    console.log(type_results);

    const countryOrigin_results = await allAnimals[1].findSimilarCountryOrigins(Animal);
    console.log(countryOrigin_results);

    const breed_results = await allAnimals[3].findSimilarBreedQualities(Animal);
    console.log(breed_results);

    const price_result1 = await allAnimals[4].findPrice() 
    console.log(price_result1);

    const price_result2 = await allAnimals[3].findPrice() ;
    console.log(price_result2);
}

// {name : "Bittle Sumdohg", countryOrigin : "Alaska"}

In the above code we have created findByName(),findSimilarTypes(),
findSimilarCountryOrigins(), findSimilarBreedQualities() these 4 instance methods inside schema and there is another instance method which we have created outside schema and that is : findPrice().

Now Let's checkout the following output :

PS C:\Users\USER\Downloads\mongoExpress\SchemaModel_1> node src/instanceMethods_1.js
findByName method executed successfully....
name = British Short Hair, type = Cat,
price $1250 USD ,discount percentage = 34, discount available = false
, country of origin = United Kingdom,
breed quality = Medium, medical expenses anually = $345USD

findSimilarTypes function() has been executed successfully.....
all the animals of type : Snake is 

[
  {
    _id: new ObjectId('65c4f4509bdd71e1a0363340'),
    name: 'Rattle Snake',
    type: 'Snake',
    countryOrigin: 'Germany',
    breedQuality: 'Low'
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a0363341'),
    name: 'Black Mamba',
    type: 'Snake',
    countryOrigin: 'Uited States of America',
    breedQuality: 'Medium'
  }
]
findSimilarCountryOrigin function() has been executed successfully.....
all the animals originated from : Alaska is

[
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333c'),
    name: 'Husky',
    priceUSD: 1865,
    countryOrigin: 'Alaska',
    medicalExp: 255
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333f'),
    name: 'Bittle Sumdohg',
    priceUSD: 2445,
    countryOrigin: 'Alaska',
    medicalExp: 735
  }
]
findSimilarBreedQuality function() has been executed successfully.....
all the animals of breed quality : Low is

[
  {
    _id: new ObjectId('65c4f4509bdd71e1a036333e'),
    name: 'American Fluffy',
    type: 'Cat',
    countryOrigin: 'United Kingdom',
    breedQuality: 'Low'
  },
  {
    _id: new ObjectId('65c4f4509bdd71e1a0363340'),
    name: 'Rattle Snake',
    type: 'Snake',
    countryOrigin: 'Germany',
    breedQuality: 'Low'
  }
]

I am inside findPrice method....
name = Bittle Sumdohg, type = Rat,
price $2445 USD ,discount percentage = 11, discount available = false
, country of origin = Alaska,
breed quality = High, medical expenses anually = 735
Discount is not available for Bittle Sumdohg (Rat)

I am inside findPrice method....
name = American Fluffy, type = Cat,
price $1750 USD ,discount percentage = 28, discount available = true
, country of origin = United Kingdom,
breed quality = Low, medical expenses anually = 259
price after discount = $1260

Mongoose Virtuals(Schema/Model)#clear concept of Virtuals

swapnanilWebDeveloper — Thu, 08 Feb 2024 14:53:31 +0000

Here is example of virtuals in Schema Model.Go through it deeply.

Follw the link below to get the full code on my git hub account

Click on this for full code in gitHub

const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/employeeData');

  const employeeSchema = new mongoose.Schema({
    name: {
      first: { type : String},
      last: {type : String},
    },
    job : {
        domain : { type : String},
        experience : { type : Number},
        company : { type : String}
    }
  },

1) At first Create a folder Virtuals_Schema and then create
virtuals.js (file) inside it.
2) Then Open your command-prompt and start your mongoshell and also create connection to MongoDBCompass and then Start writing your code into visual studio code editor.
3) First create connection with the mongoDB database and create a database called "employeeData" then create Schema called "employeeSchema".
4)Inside this Schema define two nested properties called "name" and "job" . In the 'name' property there are "first" and "last" two embeded properties and similar to "job" : "domain" , "experience" and "company" three embeded properties.

{
    virtuals: {
      fullName: {
        get() {
          return "Full name of the employee : "+this.name.first + ' ' + this.name.last;
        }
      },
      jobDescription : {
         get() {
             let JD;

             JD = this.name.first+" "+this.name.last+ " is working as : "+this.job.domain+", with a experience of : "+this.job.experience+
                   " years , in company : "+this.job.company;
            return JD;
         }
      }
    }
 });

5)Now we have created two virtuals called "fullName" and "jobDescription" .
6)In the "fullName" virtual we have returned this.name.first and this.name.last concatinated string value; Now If any document calls this virtual with = ".fullName" it will get the returned value of firstName and lastName merged with each other.
ex-> Full name of the employee : Mayuk Mukherjee.

7)In the second virtual jobDescription we have get function where five document-values are merged and inserted into variable called JD. Five srtings are =>
this.name.first, this.name.last, this.job.domain, this.job.experience, this.job.company

 const Employee = mongoose.model('Employee', employeeSchema);

  await Employee.insertMany([
       {
         name : {
               first : "Mayuk",
               last : "Mukherjee",
           },
        job : {
            domain : "MERN Stack Developer",
            experience : 7,
            company : "DELL Co. Technologies"
        }
       },
       {
        name : {
              first : "Suryendu",
              last : "Sarkar",
          },
       job : {
           domain : "ASP.NET Developer",
           experience : 11,
           company : "Mint GREEN Solutions"
       }
      }
  ])

8) Then create a model called Employee which is created through a reference of schema called "employeeSchema".
9) Then use insertMany([ {/document1/} , {/document2/} , {/document3/} ....]) , method to insert multiple documents.

   const allEmployee = await Employee.find({});
   console.log(allEmployee);

   console.log(allEmployee[0].fullName);
   console.log(allEmployee[0].jobDescription);

   console.log(allEmployee[1].fullName);
   console.log(allEmployee[1].jobDescription);
}

10)Now we will write some code with find({}) query on Employee Model aand gather all the documents that we have inserted into Employee model.
11) This data that have been collected by find() is assigned to a variable called allEmployee as array of objects => [{}, {}]; where each document is considered as a single object .
12) Now to access these specific documents we will use allEmployee[index_no] => allEmployee[0] , allEmployee[1].
13) To access the virtuals for a specific document we will write our code like => allEmployee[0].fullName //allEmployee[1].fullName // allEmployee[0].jobDescription // allEmployee[1].jobDescription.
14) Now all the code has been completed and now let's see wht is the output.


PS C:\Users\USER\Downloads\mongoExpress\Schema_Virtuals> node src/virtuals_3.js
[
  {
    name: { first: 'Mayuk', last: 'Mukherjee' },
    job: {
      domain: 'MERN Stack Developer',
      experience: 7,
      company: 'DELL Co. Technologies'
    },
    _id: new ObjectId('65c4e414ea6d2c6b55a85619'),
    __v: 0
  },
  {
    name: { first: 'Suryendu', last: 'Sarkar' },
    job: {
      domain: 'ASP.NET Developer',
      experience: 11,
      company: 'Mint GREEN Solutions'
    },
    _id: new ObjectId('65c4e414ea6d2c6b55a8561a'),
    __v: 0
  }
]
Full name of the employee : Mayuk Mukherjee
Mayuk Mukherjee is working as : MERN Stack Developer, with a experience of : 7 years , in company : DELL Co. Technologies
Full name of the employee : Suryendu Sarkar
Suryendu Sarkar is working as : ASP.NET Developer, with a experience of : 11 years , in company : Mint GREEN Solutions

Look at the output and analyse this code by yourself

Mongoose : insertMany() function / insert multiple documents....[Schema/Model]

swapnanilWebDeveloper — Tue, 06 Feb 2024 22:13:36 +0000

1)Here you guys are going to learn about Schema , models and how the model of a particular schema can create a reference to database for collection where multiple documents will be inserted.

2)Let's create a TankInformation data base and then create a schema called TankSchema and then then we will create a model called Tank .

3)if the model is "Tank" then collection name regarding to this will be "tanks" ...

4)Then multiple documents will be inserted into this Tank model.

link to to this code is on my github profile


const mongoose = require('mongoose');

main().catch(err => console.log(err));

async function main() {

    await mongoose.connect('mongodb://127.0.0.1:27017/TankInformation');

    // creating Schema
    const TankSchema = new mongoose.Schema({
        name: String,
        size : String,
        EnteredService : Number,
        CountryOrigin : String,
        NumberBuilt : {type : Number, min : 10, max : 25000},
        MassTonns : {type : Number, min : 5, max : 100},
        EnginePowerHP : Number,
        RangeKM : Number,
    });

    // creating model
    const Tank = mongoose.model('Tank', TankSchema);

    await Tank.insertMany([
        {
            name: 'M60',
            size : "medium",
            EnteredService : 1959,
            CountryOrigin : "United States of America",
            NumberBuilt : 15000,
            MassTonns : 46,
            EnginePowerHP : 750,
            RangeKM : 450,
        }, 
        {
            name: 'T_62',
            size : "medium-large",
            EnteredService : 1961,
            CountryOrigin : "Soviet Union",
            NumberBuilt : 22700,
            MassTonns : 37,
            EnginePowerHP : 620,
            RangeKM : 320,

        }, 
        {
            name: 'Leopard_1',
            size : "large",
            EnteredService : 1999,
            CountryOrigin : "Canada",
            NumberBuilt : 114,
            MassTonns : 43,
            EnginePowerHP : 830,
            RangeKM : 600,

        }, 
        {
            name: 'Panzer_61',
            size : "small-medium",
            EnteredService : 1965,
            CountryOrigin : "Switzerland",
            NumberBuilt : 150,
            MassTonns : 39,
            EnginePowerHP : 630,
            RangeKM : 250,

        }
    ]);

    const all_TankData = await Tank.find();
    console.log(all_TankData);

   for(var i = 0; i < all_TankData.length; i++){
        console.log("name is  = "+all_TankData[i].name+", size is = "+all_TankData[i].size+", year when it entered service = "+all_TankData[i].EnteredService+
        "\n country from where originated = "+all_TankData[i].CountryOrigin+", number of tanks built = "+all_TankData[i].NumberBuilt+
        "\n mass is = "+all_TankData[i].MassTonns+" Tonns"+", Engine Power is = "+all_TankData[i].EnginePowerHP+" HP "+", range is = "+all_TankData[i].RangeKM+" Km\n");
    }

output :

  [
  {
    _id: new ObjectId('65c2abe703b6e70019622ca3'),
    name: 'M60',
    size: 'medium',
    EnteredService: 1959,
    CountryOrigin: 'United States of America',
    NumberBuilt: 15000,
    MassTonns: 46,
    EnginePowerHP: 750,
    RangeKM: 450,
    __v: 0
  },
  {
    _id: new ObjectId('65c2abe703b6e70019622ca4'),
    name: 'T_62',
    size: 'medium-large',
    EnteredService: 1961,
    CountryOrigin: 'Soviet Union',
    NumberBuilt: 22700,
    MassTonns: 37,
    EnginePowerHP: 620,
    RangeKM: 320,
    __v: 0
  },
  {
    _id: new ObjectId('65c2abe703b6e70019622ca5'),
    name: 'Leopard_1',
    size: 'large',
    EnteredService: 1999,
    CountryOrigin: 'Canada',
    NumberBuilt: 114,
    MassTonns: 43,
    EnginePowerHP: 830,
    RangeKM: 600,
    __v: 0
  },
  {
    _id: new ObjectId('65c2abe703b6e70019622ca6'),
    name: 'Panzer_61',
    size: 'small-medium',
    EnteredService: 1965,
    CountryOrigin: 'Switzerland',
    NumberBuilt: 150,
    MassTonns: 39,
    EnginePowerHP: 630,
    RangeKM: 250,
    __v: 0
  }
]
name is  = M60, size is = medium, year when it entered service = 1959
 country from where originated = United States of America, number of tanks built = 15000
 mass is = 46 Tonns, Engine Power is = 750 HP , range is = 450 Km

name is  = T_62, size is = medium-large, year when it entered service = 1961
 country from where originated = Soviet Union, number of tanks built = 22700
 mass is = 37 Tonns, Engine Power is = 620 HP , range is = 320 Km

name is  = Leopard_1, size is = large, year when it entered service = 1999
 country from where originated = Canada, number of tanks built = 114
 mass is = 43 Tonns, Engine Power is = 830 HP , range is = 600 Km

name is  = Panzer_61, size is = small-medium, year when it entered service = 1965
 country from where originated = Switzerland, number of tanks built = 150
 mass is = 39 Tonns, Engine Power is = 630 HP , range is = 250 Km