You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
359 lines
9.7 KiB
JavaScript
359 lines
9.7 KiB
JavaScript
// Dependencies and Modules
|
|
const User = require("../models/User");
|
|
const Course = require("../models/Course");
|
|
const bcrypt = require("bcrypt");
|
|
|
|
// Auth
|
|
const auth = require("../auth");
|
|
|
|
// Contoller function to check if email already exists
|
|
/*
|
|
Business Logic:
|
|
1. Use mongoose "find" method to find duplicate emails
|
|
2. Use the "then" method to send the response back to the frontend application based on the result of the "find" method
|
|
*/
|
|
module.exports.checkEmailExists = (reqBody) => {
|
|
|
|
return User.find({ email: reqBody.email }).then(result => {
|
|
|
|
// The "find" method returns a record if a match is found
|
|
// It will be returned as an array
|
|
// Return true if there exist an email in the DB
|
|
if(result.length > 0){
|
|
return true;
|
|
|
|
// No duplicate email found, return false
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
|
|
// User registration controller
|
|
/*
|
|
MINI ACTIVITY
|
|
registerUser
|
|
Steps:
|
|
1. Create a new User object using the mongoose model and the information from the request body
|
|
- firstName
|
|
- lastName
|
|
- email
|
|
- mobileNo
|
|
- password
|
|
2. Make sure that the password is encrypted
|
|
3. Save the new User to the database
|
|
*/
|
|
module.exports.registerUser = (reqBody) => {
|
|
|
|
// Creates a variable "newUser" and instantiates a new "User" object using the mongoose model
|
|
// Uses the information from the request body to provide all the necessary informate
|
|
let newUser = new User({
|
|
firstName: reqBody.firstName,
|
|
lastName: reqBody.lastName,
|
|
email: reqBody.email,
|
|
mobileNo: reqBody.mobileNo,
|
|
// 10 is the value provided as the number of "salt" rounds that the bcrypt algorithm will run in order to encrypt the password
|
|
password: bcrypt.hashSync(reqBody.password, 10)
|
|
});
|
|
|
|
// Saves the created object to our database
|
|
return newUser.save().then((user, error) => {
|
|
|
|
// User registration fails
|
|
if(error){
|
|
return false
|
|
|
|
// User registration succeed
|
|
} else {
|
|
return true
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
// User Authentication Controller
|
|
/*
|
|
Steps:
|
|
1. Check the database if the user email exists
|
|
2. Compare the password provided in the login form with the password stored in the database.
|
|
3. Generate/return a JSON web token (access token) if the user is successfully logged in and return false if not
|
|
*/
|
|
module.exports.loginUser = (req, res) => {
|
|
|
|
return User.findOne({email: req.body.email}).then(result => {
|
|
|
|
// If User does not exist
|
|
if(result == null){
|
|
|
|
return false;
|
|
|
|
// If user exists
|
|
} else {
|
|
|
|
const isPasswordCorrect = bcrypt.compareSync(req.body.password, result.password);
|
|
|
|
if(isPasswordCorrect) {
|
|
|
|
res.send({
|
|
access: auth.createAccessToken(result)
|
|
});
|
|
} else {
|
|
|
|
return res.send(false);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Retrieve User Details Controller
|
|
/*
|
|
Steps:
|
|
1. Find the document in the db using the user's ID
|
|
2. Reassign the password of the returned document to an empty string
|
|
3. Return the result back to the frontend
|
|
*/
|
|
// module.exports.getProfile = (req, res) => {
|
|
|
|
// return User.findById(req.user.id).then(result => {
|
|
|
|
// // Changes the value of the user's password to an empty string for security
|
|
// result.password = "";
|
|
|
|
// // Returns the user information with the password as an empty string
|
|
// return res.send(result);
|
|
|
|
// //if there are errors finding the document
|
|
// }).catch(error => res.send(error));
|
|
// }
|
|
|
|
// // Enroll User to a Course
|
|
// /*
|
|
// Steps:
|
|
// 1. Find the document in the db using the user's ID
|
|
// 2. Add the course ID to the user's enrollment array
|
|
// 3. Update the document in the MongoDB database
|
|
// */
|
|
// module.exports.enroll = async (req, res) => {
|
|
|
|
|
|
// // The admin is not allowed to enroll to a course
|
|
// if(req.user.isAdmin){
|
|
// return res.send("Action forbidden")
|
|
// }
|
|
|
|
// // Store the value true to the isUserUpdated variable if the enrollment is successful
|
|
// let isUserUpdated = await User.findById(req.user.id).then(user => {
|
|
|
|
// // Add the courseId in an object and push that object into the user's enrollment array
|
|
// let newEnrollment = {
|
|
// courseId: req.body.courseId,
|
|
// courseName: req.body.courseName,
|
|
// courseDescription: req.body.courseDescription,
|
|
// coursePrice: req.body.coursePrice
|
|
// }
|
|
|
|
// user.enrollments.push(newEnrollment);
|
|
|
|
// // Return true if the saving is successful or return the error message if there are errors
|
|
// return user.save().then(user => true).catch(error => error.message);
|
|
|
|
// });
|
|
|
|
|
|
// // Checks if isUserUpdated is not true
|
|
// if(isUserUpdated !== true){
|
|
|
|
// return res.send({
|
|
// message: isUserUpdated
|
|
// });
|
|
// }
|
|
|
|
// // Find the course and update the enrollees array of that course with the user id
|
|
// let isCourseUpdated = await Course.findById(req.body.courseId).then(course => {
|
|
|
|
// let enrollee = {
|
|
// userId: req.user.id
|
|
// }
|
|
|
|
// course.enrollees.push(enrollee);
|
|
|
|
// return course.save().then(course => true).catch(error => error.message);
|
|
|
|
// });
|
|
|
|
|
|
// // Check if there was an error saving our course document
|
|
// if(isCourseUpdated !== true){
|
|
// return res.send({
|
|
// message: isCourseUpdated
|
|
// });
|
|
// }
|
|
|
|
// // Checks if isUserUpdated and isCourseUpdated is true, then the enrollment is successful
|
|
// if(isUserUpdated && isCourseUpdated){
|
|
// return res.send({
|
|
// message: "Enrolled Successfully."
|
|
// });
|
|
// }
|
|
|
|
|
|
// }
|
|
|
|
|
|
// // Function to reset the password
|
|
// module.exports.resetPassword = async (req, res) => {
|
|
// try {
|
|
// const { newPassword } = req.body;
|
|
// const { id } = req.user; // Extracting user ID from the authorization header
|
|
|
|
// // Hashing the new password
|
|
// const hashedPassword = await bcrypt.hash(newPassword, 10);
|
|
|
|
// // Updating the user's password in the database
|
|
// await User.findByIdAndUpdate(id, { password: hashedPassword });
|
|
|
|
// // Sending a success response
|
|
// res.status(200).json({ message: 'Password reset successfully' });
|
|
// } catch (error) {
|
|
// console.error(error);
|
|
// res.status(500).json({ message: 'Internal server error' });
|
|
// }
|
|
// };
|
|
|
|
|
|
// // Controller function to update the user profile
|
|
// module.exports.updateProfile = async (req, res) => {
|
|
// try {
|
|
// // Get the user ID from the authenticated token
|
|
// const userId = req.user.id;
|
|
|
|
// // Retrieve the updated profile information from the request body
|
|
// const { firstName, lastName, mobileNo } = req.body;
|
|
|
|
// // Update the user's profile in the database
|
|
// const updatedUser = await User.findByIdAndUpdate(
|
|
// userId,
|
|
// { firstName, lastName, mobileNo },
|
|
// { new: true }
|
|
// );
|
|
|
|
// res.json(updatedUser);
|
|
// } catch (error) {
|
|
// console.error(error);
|
|
// res.status(500).json({ message: 'Failed to update profile' });
|
|
// }
|
|
// };
|
|
|
|
|
|
// module.exports.getEnrollments = (req, res) => {
|
|
|
|
// return User.findById(req.user.id).then(foundUser => {
|
|
// return res.send(foundUser.enrollments);
|
|
// })
|
|
|
|
// };
|
|
|
|
// module.exports.resetPassword = async (req, res) => {
|
|
// try {
|
|
// const password = req.body.password;
|
|
// console.log(password);
|
|
// let userId = req.user.id; // Extracting user ID from the authorization header
|
|
// console.log(userId);
|
|
// // Hashing the new password
|
|
// let hashedPassword = bcrypt.hashSync(password, 10);
|
|
// console.log(hashedPassword);
|
|
// // Updating the user's password in the database
|
|
// return User.findByIdAndUpdate(userId, { password: hashedPassword }).then(result => {
|
|
// return res.send(result);
|
|
// })
|
|
// // Sending a success response
|
|
// }
|
|
// catch(error) {
|
|
// return res.send(error);
|
|
// }
|
|
|
|
// }
|
|
|
|
// module.exports.updateProfile = async (req, res) => {
|
|
// try {
|
|
// // Get the user ID from the authenticated token
|
|
// let userId = req.user.id;
|
|
|
|
// // Retrieve the updated profile information from the request body
|
|
// let { firstName, lastName, mobileNumber, email } = req.body;
|
|
|
|
// // Update the user's profile in the database
|
|
// const updatedUser = await User.findByIdAndUpdate(
|
|
// userId,
|
|
// { firstName, lastName, email, mobileNumber },
|
|
// { new: true }
|
|
// );
|
|
|
|
// res.json(updatedUser);
|
|
// } catch (error) {
|
|
// console.error(error);
|
|
// res.status(500).json({ message: 'Failed to update profile' });
|
|
// }
|
|
// }
|
|
|
|
// module.exports.updateEnrollmentStatus = async (req,res) => {
|
|
// try {
|
|
// const { userId, courseId } = req.body;
|
|
// const { updatedStatus } = req.body;
|
|
|
|
// // Check if the user and course exist
|
|
// const user = await User.findById(userId);
|
|
// if (!user) {
|
|
// return res.status(404).json({ message: 'User not found.' });
|
|
// }
|
|
|
|
// const courseIndex = user.enrollments.findIndex((enrollment) => enrollment.courseId === courseId);
|
|
|
|
// if (courseIndex === -1) {
|
|
// return res.status(404).json({ message: 'Course not found in user\'s enrollments.' });
|
|
// }
|
|
// // Update the enrollment status
|
|
// user.enrollments[courseIndex].status = updatedStatus;
|
|
|
|
// // Save the updated user object
|
|
// await user.save();
|
|
|
|
// res.status(200).json({ message: 'Enrollment status updated successfully.' });
|
|
// } catch (err) {
|
|
// console.error(err);
|
|
// res.status(500).json({ message: 'Internal server error.' });
|
|
// }
|
|
// }
|
|
|
|
|
|
// Controller function to update a user as an admin
|
|
// exports.updateUserAsAdmin = async (req, res) => {
|
|
// try {
|
|
// const { userId } = req.body;
|
|
|
|
// // Find the user by userId
|
|
// const user = await User.findById(userId);
|
|
|
|
// if (!user) {
|
|
// return res.status(404).json({ message: 'User not found' });
|
|
// }
|
|
|
|
// // Update the user as an admin
|
|
// user.isAdmin = true;
|
|
// await user.save();
|
|
|
|
// res.status(200).json({ message: 'User updated as admin successfully' });
|
|
// } catch (error) {
|
|
// console.error(error);
|
|
// res.status(500).json({ message: 'An error occurred while updating the user as admin' });
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|