591 lines
18 KiB
JavaScript
591 lines
18 KiB
JavaScript
// import hashPassword from '../utils/hashPassword';
|
|
import crypto from "crypto";
|
|
import TerritoryManager from "./TerritoryManagerModel.js";
|
|
import sendEmail, { sendOtp } from "../../Utils/sendEmail.js";
|
|
import validator from "validator";
|
|
import password from "secure-random-password";
|
|
import catchAsyncErrors from "../../middlewares/catchAsyncErrors.js";
|
|
|
|
export const register = async (req, res) => {
|
|
let { name, email, countryCode, mobileNumber } = req.body;
|
|
countryCode = countryCode?.trim();
|
|
mobileNumber = mobileNumber?.trim();
|
|
const fullMobileNumber = `${countryCode}${mobileNumber}`;
|
|
|
|
try {
|
|
let territoryManager = await TerritoryManager.findOne({
|
|
mobileNumber: fullMobileNumber,
|
|
});
|
|
|
|
if (territoryManager && territoryManager.isVerified) {
|
|
return res.status(400).json({
|
|
message:
|
|
"TerritoryManager already registered and verified for this mobile number.",
|
|
});
|
|
}
|
|
// const otp = crypto.randomInt(100000, 1000000).toString();
|
|
const otp = "123456";
|
|
const otpExpires = Date.now() + 1 * 60 * 1000;
|
|
|
|
if (territoryManager) {
|
|
territoryManager.otp = otp;
|
|
territoryManager.otpExpires = otpExpires;
|
|
} else {
|
|
territoryManager = new TerritoryManager({
|
|
name,
|
|
email,
|
|
mobileNumber: fullMobileNumber,
|
|
otp,
|
|
otpExpires,
|
|
});
|
|
}
|
|
// Generate uniqueId if not already present
|
|
if (!territoryManager.uniqueId) {
|
|
const currentYear = new Date().getFullYear().toString().slice(-2);
|
|
const randomChars = crypto.randomBytes(4).toString("hex").toUpperCase();
|
|
territoryManager.uniqueId = `${currentYear}-${randomChars}`;
|
|
}
|
|
await territoryManager.save();
|
|
// await sendOtp(
|
|
// fullMobileNumber,
|
|
// Your Cheminova verification OTP is: ${otp}
|
|
// );
|
|
return res.status(200).json({
|
|
message: `OTP sent to your mobile number ${fullMobileNumber} successfully`,
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
|
|
export const verifyOtp = async (req, res) => {
|
|
const { fullMobileNumber, otp } = req.body;
|
|
|
|
try {
|
|
let mobileNmr = fullMobileNumber?.trim();
|
|
const territoryManager = await TerritoryManager.findOne({
|
|
mobileNumber: mobileNmr,
|
|
});
|
|
|
|
if (!territoryManager) {
|
|
return res.status(400).json({ message: "Invalid mobile number or OTP" });
|
|
}
|
|
|
|
if (
|
|
territoryManager.otp !== otp ||
|
|
territoryManager.otpExpires < Date.now()
|
|
) {
|
|
return res.status(400).json({ message: "Invalid or expired OTP" });
|
|
}
|
|
const name = territoryManager.name;
|
|
const mobile = territoryManager.mobileNumber;
|
|
territoryManager.isVerified = true;
|
|
territoryManager.otp = undefined;
|
|
territoryManager.otpExpires = undefined;
|
|
|
|
// Generate a random password
|
|
const newPassword = password.randomPassword({
|
|
length: 12,
|
|
characters: [
|
|
{ characters: password.upper, exactly: 1 },
|
|
{ characters: password.symbols, exactly: 1 },
|
|
password.lower,
|
|
password.digits,
|
|
],
|
|
});
|
|
|
|
// Save the new password (hashed)
|
|
territoryManager.password = newPassword;
|
|
await territoryManager.save();
|
|
|
|
// Send email with the new password
|
|
await sendEmail({
|
|
to: `${territoryManager?.email}`, // Change to your recipient
|
|
from: `${process.env.SEND_EMAIL_FROM}`, // Change to your verified sender
|
|
subject: `Cheminova Account Created`,
|
|
html: `Your Territory Manager Account is created successfully.
|
|
<br/>name is: <strong>${name}</strong><br/>
|
|
<br/>MobileNumber is: <strong>${mobile}</strong><br/>
|
|
<br/>password is: <strong>${newPassword}</strong><br/><br/>If you have not requested this email, please ignore it.`,
|
|
});
|
|
|
|
const token = territoryManager.getJWTToken();
|
|
res.status(200).json({
|
|
success: true,
|
|
token,
|
|
message: "Mobile number verified and new password sent successfully",
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
// Login TerritoryManager
|
|
export const loginTerritoryManager = async (req, res) => {
|
|
const { email, password } = req.body;
|
|
// console.log(email, password);
|
|
try {
|
|
if (!email || !password) {
|
|
return res.status(400).json({ message: "Please Enter Email & Password" });
|
|
}
|
|
|
|
const territoryManager = await TerritoryManager.findOne({ email }).select(
|
|
"+password"
|
|
);
|
|
|
|
if (!territoryManager) {
|
|
return res.status(400).json({ message: "Invalid Email or Password" });
|
|
}
|
|
|
|
const isPasswordMatched = await territoryManager.comparePassword(password);
|
|
|
|
if (!isPasswordMatched) {
|
|
return res.status(400).json({ message: "Invalid Email or Password" });
|
|
}
|
|
const token = territoryManager.getJWTToken();
|
|
|
|
return res.status(200).json({
|
|
success: true,
|
|
token,
|
|
message: "Login Successfully",
|
|
});
|
|
} catch (error) {
|
|
return res.status(500).json({
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
// Logout User
|
|
export const logout = catchAsyncErrors(async (req, res, next) => {
|
|
res.cookie("token", null, {
|
|
expires: new Date(Date.now()),
|
|
httpOnly: true,
|
|
});
|
|
|
|
res.status(200).json({
|
|
success: true,
|
|
message: "Logged Out",
|
|
});
|
|
});
|
|
//get All territorymanager
|
|
export const getAllTerritoryManager = async (req, res) => {
|
|
try {
|
|
const PAGE_SIZE = parseInt(req.query?.show || "10");
|
|
const page = parseInt(req.query?.page || "1") - 1;
|
|
let filter = {};
|
|
if (req.query?.name) {
|
|
filter.name = {
|
|
$regex: new RegExp(req.query.name, "i"),
|
|
};
|
|
}
|
|
if (req.query?.mobileNumber) {
|
|
filter.mobileNumber = {
|
|
$regex: new RegExp(req.query.mobileNumber, "i"),
|
|
};
|
|
}
|
|
if (req.query?.isVerified) {
|
|
filter.isVerified = req.query.isVerified === "true";
|
|
}
|
|
|
|
const total = await TerritoryManager.countDocuments(filter);
|
|
const territoryManager = await TerritoryManager.find(filter)
|
|
.limit(PAGE_SIZE)
|
|
.skip(PAGE_SIZE * page)
|
|
.sort({ createdAt: -1 });
|
|
|
|
return res.status(200).json({
|
|
success: true,
|
|
total_data: total,
|
|
total_pages: Math.ceil(total / PAGE_SIZE),
|
|
territoryManager,
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
export const getOneTerritoryManager = async (req, res) => {
|
|
try {
|
|
if (!req.params.id) {
|
|
return res
|
|
.status(400)
|
|
.json({ message: "Please provide sales coordinator ID" });
|
|
}
|
|
const territoryManager = await TerritoryManager.findById(req.params.id);
|
|
if (territoryManager) {
|
|
return res.status(200).json({
|
|
success: true,
|
|
message: "Fetched successfully",
|
|
data: territoryManager,
|
|
});
|
|
} else {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "Sales coordinator not found",
|
|
});
|
|
}
|
|
} catch (error) {
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
// 4.Forgot Password
|
|
|
|
export const forgotPassword = async (req, res) => {
|
|
const territorymanager = await TerritoryManager.findOne({
|
|
email: req.body.email,
|
|
});
|
|
if (!req.body.email) {
|
|
return res.status(400).json({ message: "please Enter Email!" });
|
|
}
|
|
if (!territorymanager) {
|
|
return res.status(404).json({ message: "TerritoryManager not found" });
|
|
}
|
|
// Get ResetPassword Token
|
|
// const resetToken = territorymanager.getResetPasswordToken(); //call function
|
|
|
|
//save database reset token
|
|
// await territorymanager.save({ validateBeforeSave: false });
|
|
|
|
const passwords = password.randomPassword({
|
|
length: 12,
|
|
characters: [
|
|
{ characters: password.upper, exactly: 1 },
|
|
{ characters: password.symbols, exactly: 1 },
|
|
password.lower,
|
|
password.digits,
|
|
],
|
|
});
|
|
// console.log(passwords);
|
|
territorymanager.password = passwords;
|
|
await territorymanager.save();
|
|
// const message = `Your password reset token are :- \n\n ${resetPasswordUrl} \n\nyour new password is:${password}\n\nIf you have not requested this email then, please ignore it.`;
|
|
try {
|
|
await sendEmail({
|
|
to: `${territorymanager?.email}`, // Change to your recipient
|
|
|
|
from: `${process.env.SEND_EMAIL_FROM}`, // Change to your verified sender
|
|
|
|
subject: `Cheminova Password Recovery`,
|
|
html: `your new password is: <br/> <strong> ${passwords}</strong><br/><br/>If you have not requested this email then, please ignore it.`,
|
|
});
|
|
|
|
res.status(200).json({
|
|
success: true,
|
|
message: `Email sent to ${territorymanager?.email} successfully`,
|
|
});
|
|
} catch (error) {
|
|
territorymanager.resetPasswordToken = undefined;
|
|
territorymanager.resetPasswordExpire = undefined;
|
|
|
|
await territorymanager.save({ validateBeforeSave: false });
|
|
|
|
return res.status(500).json({
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//Update mobile Number
|
|
export const updateMobileNumber = async (req, res) => {
|
|
const { id } = req.params;
|
|
const userId = id || req.user._id;
|
|
let { newCountryCode, newMobileNumber } = req.body;
|
|
newCountryCode = newCountryCode?.trim();
|
|
newMobileNumber = newMobileNumber?.trim();
|
|
const newFullMobileNumber = `${newCountryCode}${newMobileNumber}`;
|
|
|
|
try {
|
|
const territorymanager = await TerritoryManager.findById(userId);
|
|
if (!territorymanager) {
|
|
return res.status(400).json({ message: "TerritoryManager not found" });
|
|
}
|
|
if (territorymanager.mobileNumber === newFullMobileNumber) {
|
|
return res.status(400).json({
|
|
message:
|
|
"New mobile number cannot be the same as the old mobile number",
|
|
});
|
|
}
|
|
// Check if the new mobile number already exists in another document
|
|
const existingTerritoryManager = await TerritoryManager.findOne({
|
|
mobileNumber: newFullMobileNumber,
|
|
});
|
|
|
|
if (existingTerritoryManager) {
|
|
return res.status(400).json({
|
|
message: "Mobile number already registered and verified by someone",
|
|
});
|
|
}
|
|
// const otp = crypto.randomInt(100000, 1000000).toString();
|
|
const otp = "123456";
|
|
const otpExpires = Date.now() + 3 * 60 * 1000; // 3 minutes
|
|
|
|
territorymanager.newMobileNumber = newFullMobileNumber;
|
|
territorymanager.otp = otp;
|
|
territorymanager.otpExpires = otpExpires;
|
|
|
|
await territorymanager.save();
|
|
await sendOtp(
|
|
newFullMobileNumber,
|
|
`Your Cheminova verification OTP is: ${otp}`
|
|
);
|
|
|
|
return res.status(200).json({
|
|
message: `OTP sent to your new mobile number ${newFullMobileNumber} successfully`,
|
|
});
|
|
} catch (error) {
|
|
console.error("Error updating mobile number:", error);
|
|
return res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//verify Updated Number OTP
|
|
export const verifyUpdatedMobileOtp = async (req, res) => {
|
|
const { newMobileNumber, otp } = req.body;
|
|
// console.log(newMobileNumber, otp);
|
|
try {
|
|
let mobileNmr = newMobileNumber?.trim();
|
|
const territoryManager = await TerritoryManager.findOne({
|
|
newMobileNumber: mobileNmr,
|
|
});
|
|
|
|
if (!territoryManager) {
|
|
return res.status(400).json({ message: "Invalid mobile number or OTP" });
|
|
}
|
|
|
|
if (
|
|
territoryManager.otp !== otp ||
|
|
territoryManager.otpExpires < Date.now()
|
|
) {
|
|
return res.status(400).json({ message: "Invalid or expired OTP" });
|
|
}
|
|
|
|
// Update sales coordinator's mobile number and verification status
|
|
territoryManager.mobileNumber = territoryManager.newMobileNumber;
|
|
territoryManager.newMobileNumber = undefined;
|
|
territoryManager.isVerified = true;
|
|
territoryManager.otp = undefined;
|
|
territoryManager.otpExpires = undefined;
|
|
|
|
// Save changes to the database
|
|
await territoryManager.save();
|
|
|
|
const token = territoryManager.getJWTToken();
|
|
return res.status(200).json({
|
|
success: true,
|
|
token,
|
|
message: "Mobile number updated and verified successfully",
|
|
});
|
|
} catch (error) {
|
|
console.error("Error verifying mobile OTP:", error);
|
|
return res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//getmyProfile
|
|
export const getmyProfile = async (req, res) => {
|
|
try {
|
|
const myData = await TerritoryManager.findById(req.user?._id);
|
|
if (myData) {
|
|
return res.status(200).json({
|
|
success: true,
|
|
message: "feched!",
|
|
myData,
|
|
});
|
|
}
|
|
} catch (error) {
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//
|
|
export const deleteTerritoryManager = async (req, res) => {
|
|
try {
|
|
if (!req.params.id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "Please Provide TerritoryManager ID!",
|
|
});
|
|
}
|
|
const getTerritoryManager = await TerritoryManager.findById(req.params.id);
|
|
if (!getTerritoryManager) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "territorymanager not Found!",
|
|
});
|
|
}
|
|
|
|
//-------------------------//
|
|
const territorymanager = await TerritoryManager.findByIdAndDelete(
|
|
req.params.id
|
|
);
|
|
if (!territorymanager) {
|
|
return res.status(404).json({ message: "territorymanager Not Found" });
|
|
}
|
|
await territorymanager.remove();
|
|
res.status(200).json({
|
|
success: true,
|
|
message: "territorymanager Deleted Successfully!!",
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
export const UpdateProfile = async (req, res) => {
|
|
const { name, email } = req.body;
|
|
const { id } = req.params;
|
|
// console.log(name, email);
|
|
const userId = id || req.user._id;
|
|
// console.log(userId);
|
|
// Validate email
|
|
if (!validator.isEmail(email)) {
|
|
return res.status(400).json({ message: "Invalid email address" });
|
|
}
|
|
|
|
try {
|
|
const territoryManager = await TerritoryManager.findById(userId); // Use the ID from params
|
|
|
|
if (!territoryManager) {
|
|
return res.status(404).json({ message: "TerritoryManager not found" });
|
|
}
|
|
|
|
if (!territoryManager.isVerified) {
|
|
return res.status(400).json({ message: "TerritoryManager not verified" });
|
|
}
|
|
|
|
// Check if email is being changed and already exists
|
|
if (email && email !== territoryManager.email) {
|
|
const emailExists = await TerritoryManager.findOne({ email });
|
|
if (emailExists && emailExists._id.toString() !== userId) {
|
|
return res.status(400).json({
|
|
message:
|
|
"This Email ID is already in use by another TerritoryManager",
|
|
});
|
|
}
|
|
territoryManager.email = email;
|
|
}
|
|
|
|
// Update name if provided
|
|
if (name) {
|
|
territoryManager.name = name;
|
|
}
|
|
|
|
// Save the updated territoryManager
|
|
await territoryManager.save();
|
|
|
|
return res.status(200).json({
|
|
territoryManager,
|
|
message: "Profile updated successfully",
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//change TerritoryManager password
|
|
export const ChangePassword = async (req, res) => {
|
|
const { id } = req.params; // Retrieve id from req.params
|
|
const { oldPassword, newPassword, confirmPassword } = req.body;
|
|
const userId = id || req.user._id; // Use the ID from the URL or from the authenticated user
|
|
|
|
if (!oldPassword) {
|
|
return res.status(400).json({ message: "Please Enter Old password" });
|
|
}
|
|
if (!newPassword) {
|
|
return res.status(400).json({ message: "Please Enter New Password " });
|
|
}
|
|
if (!confirmPassword) {
|
|
return res.status(400).json({ message: "Please Enter Confirm Password" });
|
|
}
|
|
try {
|
|
const territorymanager = await TerritoryManager.findById(userId).select(
|
|
"+password"
|
|
);
|
|
|
|
if (!territorymanager) {
|
|
return res.status(404).json({ message: "TerritoryManager not found" });
|
|
}
|
|
|
|
const isPasswordMatched = await territorymanager.comparePassword(
|
|
oldPassword
|
|
);
|
|
|
|
if (!isPasswordMatched) {
|
|
return res.status(400).json({ message: "Old password is incorrect" });
|
|
}
|
|
|
|
if (newPassword !== confirmPassword) {
|
|
return res
|
|
.status(400)
|
|
.json({ message: "New password and confirm Password do not match" });
|
|
}
|
|
|
|
territorymanager.password = newPassword;
|
|
await territorymanager.save();
|
|
|
|
return res
|
|
.status(200)
|
|
.json({ success: true, message: "Password updated successfully" });
|
|
} catch (error) {
|
|
console.error("Error updating password:", error);
|
|
return res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
|
|
export const Otp = async (req, res) => {
|
|
// const { name, mobileNumber } = req.body;
|
|
try {
|
|
// let territorymanager = await TerritoryManager.findOne({ mobileNumber });
|
|
|
|
// if (territorymanager && territorymanager.isVerified) {
|
|
// return res.status(400).json({ message: 'TerritoryManager already registered and verified for This Mobile No.' });
|
|
// }
|
|
|
|
// const otp = crypto.randomInt(100000, 1000000).toString();
|
|
|
|
// // const otp ="123456";
|
|
|
|
// const otpExpires = Date.now() + 10 * 60 * 1000; // 10 minutes
|
|
|
|
// if (territorymanager) {
|
|
// territorymanager.otp = otp;
|
|
// territorymanager.otpExpires = otpExpires;
|
|
// } else {
|
|
// territorymanager = new TerritoryManager({ name, mobileNumber, otp, otpExpires });
|
|
// }
|
|
|
|
// await territorymanager.save();
|
|
await sendOtp();
|
|
|
|
// res.status(200).json({territorymanager, message: `OTP ${otp} sent to your mobile number successfully` });
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|