Merge pull request #36 from MoaidHashem3/master

Ezzz

controllers/handelCourse.js

@@ -1,9 +1,10 @@
 const Course = require("../models/courseModel");
 const User = require("../models/usersModel");
+const Quiz = require("../models/quizModel")
 
 const getAllCourse = async (req, res) => {
   try {
-    const courses = await Course.find().populate("quizzes").populate("students");
+    const courses = await Course.find().populate("quizzes").populate("students").populate("professor", "name");
     if (courses.length == 0) {
       return res.status(404).json({ message: "No Courses Found!" });
     }
@@ -42,31 +43,57 @@ const getCourseById = async (req, res) => {
 const createCourse = async (req, res) => {
   const course = req.body;
   try {
-    if(req.file){
-      course.image=req.file.path;
+    if (req.file) {
+      course.image = req.file.path;
     }
+
     const newCourse = new Course(course);
     const savedCourse = await newCourse.save();
 
+    await User.findByIdAndUpdate(
+      course.professor, 
+      { $push: { createdCourses: savedCourse._id} }, 
+      { new: true } 
+    );
+
     res.status(201).json({ message: "Course created successfully", data: savedCourse });
   } catch (err) {
+    console.error("Error creating course:", err); 
     res.status(400).json({ message: err.message });
   }
 };
 
 const updateCourse = async (req, res) => {
-  const { id } = req.params;
-  const updates = req.body;
+  const { title, major, professor, duration, quizId } = req.body;
+  const updates = {};
+  if (title) updates.title = title;
+  if (major) updates.major = major;
+  if (professor) updates.professor = professor;
+  if (duration) updates.duration = duration;
+
   try {
-    const updatedCourse = await Course.findByIdAndUpdate(id, updates, {
-      new: true,
-    });
-    if (!updatedCourse) {
-      return res.status(404).json({ message: "Course not found" });
-    }
-    res.status(200).json({ message: "Course updated successfully" });
-  } catch (err) {
-    res.status(400).json({ message: err.message });
+      const update = {
+          $set: updates,
+      };
+
+      if (quizId) {
+          update.$push = { quizzes: quizId };
+      }
+
+      const updatedCourse = await Course.updateOne(
+          { _id: req.params.id }, 
+          update, 
+          { new: true } 
+      );
+
+      if (updatedCourse.nModified === 0) {
+          return res.status(404).json({ message: 'Course not found or no changes made.' });
+      }
+
+      res.status(200).json({ message: 'Course updated successfully', updatedCourse });
+  } catch (error) {
+      console.error(error);
+      res.status(500).json({ message: 'Internal server error' });
   }
 };
 
@@ -168,6 +195,52 @@ const enrollInCourse = async (req, res)=>{
     return res.status(500).json({ message: error.message });
   }
 }
+const getStudentsInCourse = async (req, res) => {
+  try {
+    const { courseId } = req.params;
+
+    // Fetch the course to get the enrolled students
+    const course = await Course.findById(courseId).populate('students');
+
+    if (!course) {
+      return res.status(404).json({ message: "Course not found" });
+    }
+
+    // Find all students enrolled in the course
+    const enrolledStudents = await User.find(
+      { _id: { $in: course.students } },
+      "name email quizzes"
+    );
+
+    // Find all quizzes in the course
+    const quizzes = await Quiz.find({ course: courseId });
+
+    // Fetch quiz scores for each student
+    const studentsData = await Promise.all(
+      enrolledStudents.map(async (student) => {
+        let totalScore = 0;
+
+        // Iterate through the student's quizzes and sum the total score
+        student.quizzes.forEach(quiz => {
+          totalScore += quiz.totalScore;
+        });
+
+        return {
+          name: student.name,
+          email: student.email,
+          totalScore: totalScore, // Combined total score of all quizzes
+        };
+      })
+    );
+
+    res.status(200).json({
+      message: "Students data retrieved successfully",
+      data: studentsData,
+    });
+  } catch (error) {
+    res.status(500).json({ message: "Server error", error: error.message });
+  }
+};
 
 
 module.exports = {
@@ -180,4 +253,5 @@ module.exports = {
   deleteCourseById,
   deleteAllCourse,
   enrollInCourse,
+  getStudentsInCourse
 };

controllers/handelQuiz.js

@@ -82,7 +82,7 @@ updateQuiz = async (req, res) => {
 
 retriveQuizs = async (req, res) => {
   try {
-    const retrivedQuizes = await Quiz.find();
+    const retrivedQuizes = await Quiz.find().populate("quizzes","title");
     if (!retrivedQuizes)
       return res.status(404).json({ message: "Quizes not found" });
     res

controllers/handelUser.js

@@ -34,35 +34,60 @@ const getByid = async (req, res) => {
 }
 const updateOne = async (req, res) => {
     try {
-        let { id } = req.params;
-        let {password,...newupdate} = req.body;
-        const updatedata={...newupdate}
-        if(password){
-            const hashedPassword = await bcrypt.hash(password, 10); // Hash the new password
-            updatedata.password = hashedPassword;
-        }
-        let updatedtuser = await usermodel.findByIdAndUpdate(id, updatedata , { new: true });
-        res.json({ message: "updated", data: updatedtuser })
-
-    } catch (e) {
-        res.json({ message: "not updated", error: e.message })
-    }
-}
-const createone = async (req, res) => {
-    try {
-      let newuser = req.body;
+      const { id } = req.params;
+      const { password, ...newUpdate } = req.body; // Extract other fields from req.body
+      const updateData = { ...newUpdate };
+
+      // Handle password hashing if provided
+      if (password) {
+        const hashedPassword = await bcrypt.hash(password, 10);
+        updateData.password = hashedPassword;
+      }
 
+      // If an image is provided, handle file upload
       if (req.file) {
-        newuser.image = req.file.path;
+        updateData.image = req.file.path; // Set image path from multer file upload
       }
 
-      let inserteduser = await usermodel.create(newuser);
-      res.json({ message: "created", data: inserteduser });
-    } catch (err) {
-      res.json({ message: "cannot be created", error: err.message });
+      // Find the user and update
+      const updatedUser = await usermodel.findByIdAndUpdate(id, updateData, { new: true });
+
+      if (!updatedUser) {
+        return res.status(404).json({ message: "User not found" });
+      }
+
+      res.status(200).json({ message: "Profile updated", data: updatedUser });
+    } catch (error) {
+      res.status(500).json({ message: "Error updating profile", error: error.message });
     }
   };
 
+
+const createone = async (req, res) => {
+    try {
+        // Extract user data from the request body
+        let newuser = {
+            name: req.body.name,
+            email: req.body.email,
+            password: req.body.password,
+            role: req.body.role
+        };
+
+        // Check if a file was uploaded and set the image path if it exists
+        if (req.file) {
+            newuser.image = req.file.path;
+        }
+
+        // Insert the new user into the database
+        let inserteduser = await usermodel.create(newuser);
+        res.json({ message: "User created successfully", data: inserteduser });
+    } catch (err) {
+        console.error(err); // Log the error for debugging
+        res.status(400).json({ message: "User cannot be created", error: err.message });
+    }
+};
+
+
 const deleteOne =async (req, res) => {
     try {
         let { id } = req.params;
@@ -85,15 +110,31 @@ const deleteall = async (req, res) => {
     }
 
 }
-const login = async (req, res) => {
+const getAllProfessors = async (req,res) => {
+    try {
+        const professors = await usermodel.find({ role: "professor" }).select("name email createdCourses");
+        if (professors) {
+            res.status(200).json({ message: "all professors", data: professors });
+
+        } else {
+            res.status(404).json({ message: 'can not be fouund' })
+        }
+
+      } catch (e) {
+        res.json({ message: e.message })
+      }
+  };
+
+  const login = async (req, res) => {
     const { email, password } = req.body;
 
     if (!email || !password) {
         return res.status(400).json({ message: "Email and password are required" });
     }
 
     try {
-        const user = await usermodel.findOne({ email });
+        const user = await usermodel.findOne({ email }).populate('createdCourses', 'title');
+
         if (!user) {
             return res.status(401).json({ message: "Invalid email or password" });
         }
@@ -102,13 +143,21 @@ const login = async (req, res) => {
         if (!isValid) {
             return res.status(401).json({ message: "Invalid email or password" });
         }
+        const imageUrl = `${req.protocol}://${req.get('host')}/${user.image}`;
 
-        // Sign token with user data
         const token = jwt.sign(
-            { data: {name:user.name, email: user.email, id: user._id, role: user.role, image: user.image,
-                enrolledCourses: user.enrolledCourses, 
-                createdCourses: user.createdCourses, 
-                quizzes: user.quizzes } },
+            {
+                data: {
+                    name: user.name,
+                    email: user.email,
+                    id: user._id,
+                    role: user.role,
+                    image: imageUrl,
+                    enrolledCourses: user.enrolledCourses,
+                    createdCourses: user.createdCourses, 
+                    quizzes: user.quizzes
+                }
+            },
             process.env.secret,
             { expiresIn: "3h" }
         );
@@ -117,21 +166,24 @@ const login = async (req, res) => {
         return res.status(200).json({
             message: "success",
             token,
-            user: {  id: user._id,
+            user: {
+                id: user._id,
                 name: user.name,
                 email: user.email,
                 role: user.role,
-                image: user.image,
-                enrolledCourses: user.enrolledCourses, 
+                image: imageUrl,
+                enrolledCourses: user.enrolledCourses,
                 createdCourses: user.createdCourses, 
-                quizzes: user.quizzes }
+                quizzes: user.quizzes
+            }
         });
     } catch (error) {
         return res.status(500).json({ message: "Server error, please try again later" });
     }
 };
 
 
+
 const uploadImage = async (req, res) => {
 
     try {
@@ -147,4 +199,4 @@ const uploadImage = async (req, res) => {
       res.status(500).send(err.message);
     }
   };
-module.exports = { getall, getByid, updateOne,createone,deleteOne,deleteall,login, uploadImage }
+module.exports = { getall, getByid, updateOne,createone,deleteOne,deleteall,login, uploadImage,getAllProfessors }

models/courseModel.js

@@ -14,9 +14,9 @@ const courseSchema = new mongoose.Schema({
     trim: true,
   },
   professor: {
-    type: String,
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
     required: true,
-    trim: true,
   },
   major: {
     type: String,
@@ -56,4 +56,4 @@ const courseSchema = new mongoose.Schema({
 });
 
 const Course = mongoose.model("Course", courseSchema);
-module.exports = Course;
+module.exports = Course;

models/usersModel.js

@@ -35,8 +35,8 @@ const userSchema = new mongoose.Schema({
   enrolledCourses: [{ type: mongoose.Schema.Types.ObjectId, ref: "Course" }],
 
   // For Instructors, store references to created courses and quizzes
-  createdCourses: [{ type: mongoose.Schema.Types.ObjectId, ref: "Course" }],
-
+  createdCourses: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Course' }],
+  
   quizzes: [
     {
       quizId: { type: mongoose.Schema.Types.ObjectId, ref: "Quiz" },

routes/courseRoute.js

@@ -12,19 +12,20 @@ const {
   deleteCourseById,
   deleteAllCourse,
   enrollInCourse,
+  getStudentsInCourse
 } = require("../controllers/handelCourse");
 
 app.use(express.json());
 router.get("/", getAllCourse);
 router.get("/:id", getCourseById);
 router.post("/", upload.single('image'),createCourse);
-router.put("/:id", updateCourse);
+router.patch("/:id", updateCourse);
 router.post("/enroll/:courseId/:studentId", enrollInCourse);
 router.post('/uploadCourseImage/:id',upload.single('image'),uploadImage);
 router.post('/uploadCourseContent/:id',upload.single('pdfFile'),uploadContent);
 router.delete("/:id", deleteCourseById);
 router.delete("/", deleteAllCourse);
-
+router.get("/:courseId/students", getStudentsInCourse);
 
 
 module.exports = router;