557 lines
17 KiB
JavaScript
557 lines
17 KiB
JavaScript
// import hashPassword from '../utils/hashPassword';
|
|
|
|
import crypto from 'crypto';
|
|
import Patient from './PatientModel.js'
|
|
import sendEmail, { sendOtp } from '../../Utils/sendEmail.js';
|
|
import validator from "validator";
|
|
import password from "secure-random-password";
|
|
import cloudinary from '../../Utils/cloudinary.js';
|
|
|
|
export const register = async (req, res) => {
|
|
let { name, countryCode, mobileNumber } = req.body;
|
|
// Trim the country code and mobile number
|
|
countryCode = countryCode.trim();
|
|
mobileNumber = mobileNumber.trim();
|
|
const fullMobileNumber = `${countryCode}${mobileNumber}`;
|
|
try {
|
|
let patient = await Patient.findOne({ mobileNumber: fullMobileNumber });
|
|
if (patient && patient.isVerified) {
|
|
return res.status(400).json({ message: 'Patient already registered and verified for This Mobile No.' });
|
|
}
|
|
const otp = crypto.randomInt(100000, 1000000).toString();
|
|
const otpExpires = Date.now() + 3 * 60 * 1000; // 3 minutes
|
|
|
|
if (patient) {
|
|
patient.otp = otp;
|
|
patient.otpExpires = otpExpires;
|
|
} else {
|
|
patient = new Patient({ name, mobileNumber: fullMobileNumber, otp, otpExpires });
|
|
}
|
|
await patient.save();
|
|
await sendOtp(fullMobileNumber, `Your tavisa verification OTP is: ${otp}`);
|
|
|
|
|
|
|
|
return res.status(200).json({ patient, 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 { mobileNumber, otp } = req.body;
|
|
try {
|
|
let mobileNmr = mobileNumber.trim();
|
|
const patient = await Patient.findOne({ mobileNumber: mobileNmr });
|
|
|
|
if (!patient) {
|
|
return res.status(400).json({ message: 'Invalid mobile number or OTP' });
|
|
}
|
|
|
|
if (patient.otp !== otp || patient.otpExpires < Date.now()) {
|
|
return res.status(400).json({ message: 'Invalid or expired OTP' });
|
|
}
|
|
patient.isVerified = true;
|
|
patient.otp = undefined;
|
|
patient.otpExpires = undefined;
|
|
await patient.save();
|
|
const token = patient.getJWTToken();
|
|
res.status(200).json({
|
|
success: true,
|
|
token, message: 'Mobile number verified successfully'
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|
|
// Login Patient
|
|
export const loginPatient = async (req, res) => {
|
|
const { email, password } = req.body;
|
|
// checking if patient has given password and email both
|
|
|
|
try {
|
|
if (!email || !password) {
|
|
return res.status(400).json({ message: "Please Enter Email & Password" });
|
|
}
|
|
|
|
const patient = await Patient.findOne({ email }).select("+password");
|
|
|
|
if (!patient) {
|
|
return res.status(400).json({ message: "Invalid Email or Password" });
|
|
}
|
|
|
|
const isPasswordMatched = await patient.comparePassword(password);
|
|
|
|
if (!isPasswordMatched) {
|
|
return res.status(400).json({ message: "Invalid Email or Password" });
|
|
}
|
|
const token = patient.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!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//get All patient
|
|
export const getAllPatient = async (req, res) => {
|
|
try {
|
|
const PAGE_SIZE = parseInt(req.query?.show || "10");
|
|
const page = parseInt(req.query?.page - 1 || "0");
|
|
let obj = {};
|
|
if (req.query?.name)
|
|
obj.name = {
|
|
$regex: new RegExp(req.query.name),
|
|
$options: "i",
|
|
};
|
|
if (req.query?.category) obj.category = req.query.category;
|
|
if (req.query?.isVerified)
|
|
obj.isVerified = req.query.isVerified;
|
|
const total = await Patient.countDocuments(obj);
|
|
const patient = await Patient.find(obj)
|
|
// .populate({
|
|
// path: "category addedBy master_GST variants.gst_Id",
|
|
// select: "name categoryName tax",
|
|
// })
|
|
.limit(PAGE_SIZE)
|
|
.skip(PAGE_SIZE * page)
|
|
// .sort("name")
|
|
.sort({
|
|
createdAt: -1,
|
|
})
|
|
.exec();
|
|
|
|
if (patient) {
|
|
return res.status(200).json({
|
|
success: true,
|
|
total_data: total,
|
|
total_pages: Math.ceil(total / PAGE_SIZE),
|
|
patient,
|
|
});
|
|
}
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
msg: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
export const create1RegistrationDetails = async (req, res) => {
|
|
const {
|
|
email,
|
|
password,
|
|
confirmPassword,
|
|
} = req.body;
|
|
if (!email) return res.status(400).json({ message: 'Email is required' });
|
|
if (!password) return res.status(400).json({ message: 'Password is required' });
|
|
if (!confirmPassword) return res.status(400).json({ message: 'Confirm password is required' });
|
|
// Validate email format
|
|
if (!validator.isEmail(email)) {
|
|
return res.status(400).json({ message: 'Invalid email format' });
|
|
}
|
|
|
|
if (password !== confirmPassword) {
|
|
return res.status(400).json({ message: 'Password and confirm password do not match' });
|
|
}
|
|
try {
|
|
const patient = await Patient.findById(req.patient._id);
|
|
if (!patient) {
|
|
return res.status(404).json({ message: 'Patient not found ' });
|
|
}
|
|
if (!patient.isVerified) {
|
|
return res.status(400).json({ message: 'Patient not verified' });
|
|
}
|
|
|
|
// Check if another patient with the same email exists
|
|
const emailExists = await Patient.findOne({ email });
|
|
if (emailExists && emailExists._id.toString() !== req.patient._id) {
|
|
return res.status(400).json({ message: 'This Email ID is already in use By Another patient' });
|
|
}
|
|
patient.email = email;
|
|
patient.password = password;
|
|
|
|
await patient.save();
|
|
const patientResponse = patient.toObject();
|
|
delete patientResponse.password;
|
|
|
|
res.status(200).json({ patient: patientResponse, message: 'Registration details updated successfully' });
|
|
} catch (error) {
|
|
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
|
|
}
|
|
};
|
|
|
|
|
|
export const EnterPatientDetails = async (req, res) => {
|
|
const {
|
|
gender,
|
|
weightValue,
|
|
weightUnit,
|
|
heightValue,
|
|
heightUnit,
|
|
age,
|
|
} = req.body;
|
|
|
|
switch (true) {
|
|
case !gender:
|
|
return res.status(400).json({ message: 'Gender is required' });
|
|
case !weightValue:
|
|
return res.status(400).json({ message: 'weight Value is required' });
|
|
case !weightUnit:
|
|
return res.status(400).json({ message: 'weight Unit is required' });
|
|
case !heightValue:
|
|
return res.status(400).json({ message: 'height Value is required' });
|
|
case !heightUnit:
|
|
return res.status(400).json({ message: 'height Unit is required' });
|
|
case !age:
|
|
return res.status(400).json({ message: 'Age is required and Must Be a Number' });
|
|
default:
|
|
|
|
//gender Validate
|
|
if (!['Male', 'Female'].includes(gender)) {
|
|
return res.status(400).json({ message: 'Invalid gender:gender Must be "Male" or "Female"' });
|
|
}
|
|
// Validate weightUnit
|
|
if (!['Kgs', 'Lbs'].includes(weightUnit)) {
|
|
return res.status(400).json({ message: 'Invalid weight unit. Must be "Kgs" or "Lbs"' });
|
|
}
|
|
// Ensure weightValue is a number
|
|
if (isNaN(weightValue)) {
|
|
return res.status(400).json({ message: 'Weight value must be a number' });
|
|
}
|
|
// Validate heightUnit
|
|
if (!['Ft', 'Cm'].includes(heightUnit)) {
|
|
return res.status(400).json({ message: 'Invalid height unit. Must be "Ft" or "Cm"' });
|
|
}
|
|
// Ensure heightValue is a number
|
|
if (isNaN(heightValue)) {
|
|
return res.status(400).json({ message: 'Height value must be a number' });
|
|
}
|
|
if (isNaN(age)) {
|
|
return res.status(400).json({ message: 'age must be a number' });
|
|
}
|
|
|
|
try {
|
|
const patient = await Patient.findById(req.patient._id);
|
|
if (!patient) {
|
|
return res.status(404).json({ message: 'Patient not found ' });
|
|
}
|
|
if (!patient.isVerified) {
|
|
return res.status(400).json({ message: 'Patient not verified' });
|
|
}
|
|
|
|
patient.gender = gender;
|
|
patient.weight = {
|
|
value: weightValue,
|
|
unit: weightUnit,
|
|
};
|
|
patient.height = {
|
|
value: heightValue,
|
|
unit: heightUnit,
|
|
};
|
|
patient.age = age;
|
|
await patient.save();
|
|
const patientResponse = patient.toObject();
|
|
delete patientResponse.password;
|
|
res.status(200).json({ patient: patientResponse, message: 'Patient details updated successfully' });
|
|
} catch (error) {
|
|
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
|
|
}
|
|
}
|
|
};
|
|
|
|
export const EnterPersonalDetails = async (req, res) => {
|
|
const {
|
|
commonHealthComplaints,
|
|
familyHistory,
|
|
personalHistory,
|
|
dailyRoutine,
|
|
} = req.body;
|
|
const patientId = req.cookies.patientId;
|
|
if (!patientId) {
|
|
return res.status(400).json({ message: 'Patient did not registered Or verified' });
|
|
}
|
|
try {
|
|
const patient = await Patient.findById(req.patient._id);
|
|
if (!patient) {
|
|
return res.status(404).json({ message: 'Patient not found ' });
|
|
}
|
|
if (!patient.isVerified) {
|
|
return res.status(400).json({ message: 'Patient not verified' });
|
|
}
|
|
// Check if another patient with the same email exists
|
|
|
|
patient.commonHealthComplaints = commonHealthComplaints;
|
|
patient.familyHistory = familyHistory;
|
|
patient.personalHistory = personalHistory;
|
|
patient.dailyRoutine = dailyRoutine;
|
|
await patient.save();
|
|
const patientResponse = patient.toObject();
|
|
delete patientResponse.password;
|
|
res.status(200).json({ patient: patientResponse, message: 'Patient Pesonal details updated successfully' });
|
|
} catch (error) {
|
|
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// 4.Forgot Password
|
|
|
|
export const forgotPassword = async (req, res) => {
|
|
const patient = await Patient.findOne({ email: req.body.email });
|
|
if (!req.body.email) {
|
|
return res.status(400).json({ message: 'please Enter Email!' });
|
|
}
|
|
if (!patient) {
|
|
return res.status(404).json({ message: "Patient not found" });
|
|
}
|
|
// Get ResetPassword Token
|
|
// const resetToken = patient.getResetPasswordToken(); //call function
|
|
|
|
//save database reset token
|
|
// await patient.save({ validateBeforeSave: false });
|
|
|
|
const passwords = password.randomPassword({
|
|
length: 12,
|
|
characters: [
|
|
{ characters: password.upper, exactly: 1 },
|
|
{ characters: password.symbols, exactly: 1 },
|
|
password.lower,
|
|
password.digits,
|
|
],
|
|
});
|
|
|
|
patient.password = passwords;
|
|
await patient.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: `${patient?.email}`, // Change to your recipient
|
|
|
|
from: `${process.env.SEND_EMAIL_FROM}`, // Change to your verified sender
|
|
|
|
subject: `Tavisa 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 ${patient?.email} successfully`,
|
|
});
|
|
} catch (error) {
|
|
patient.resetPasswordToken = undefined;
|
|
patient.resetPasswordExpire = undefined;
|
|
|
|
await patient.save({ validateBeforeSave: false });
|
|
|
|
return res
|
|
.status(500)
|
|
.json({
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
//update Patient Profile Image
|
|
export const UploadProfileImage = async (req, res) => {
|
|
if (!req.files) {
|
|
return res.status(404).json({ message: "Please Select Image" });
|
|
}
|
|
const patient = await Patient.findById(req.patient._id);
|
|
if (!patient) {
|
|
return res.status(404).json({ message: 'Patient not found ' });
|
|
}
|
|
if (!patient.isVerified) {
|
|
return res.status(400).json({ message: 'Patient not verified First verify Mobile No.' });
|
|
}
|
|
let newPatientData = {};
|
|
try {
|
|
if (req.files) {
|
|
const patientImage = req.files?.avatar;
|
|
const patient = await Patient.findById(req.patient._id);
|
|
|
|
if (patient?.avatar === null) {
|
|
// console.log(patient?.avatar)
|
|
const imageId = patient?.avatar?.public_id;
|
|
|
|
await cloudinary.uploader.destroy(imageId)
|
|
}
|
|
|
|
const myCloud = await cloudinary.v2.uploader.upload(patientImage.tempFilePath,
|
|
{
|
|
folder: "tavisa/patient-image",
|
|
|
|
});
|
|
|
|
newPatientData.avatar = {
|
|
public_id: myCloud.public_id,
|
|
url: myCloud.secure_url,
|
|
};
|
|
let patientDetail = await Patient.findByIdAndUpdate(
|
|
req.patient._id, newPatientData,
|
|
{ new: true } // Return the updated document
|
|
);
|
|
|
|
|
|
return res.status(200).json({
|
|
success: true,
|
|
message: "Image Uploaded Successfully!",
|
|
patientDetail,
|
|
});
|
|
}
|
|
} catch (error) {
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
export const deletePatient = async (req, res) => {
|
|
try {
|
|
if (!req.params.id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "Please Provide Patient ID!",
|
|
});
|
|
}
|
|
const getPatient = await Patient.findById(req.params.id);
|
|
if (!getPatient) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "patient not Found!",
|
|
});
|
|
}
|
|
|
|
// Deleting Images From Cloudinary
|
|
if (getPatient?.avatar?.public_id) {
|
|
await cloudinary.v2.uploader.destroy(getPatient.avatar?.public_id);
|
|
}
|
|
|
|
//-------------------------//
|
|
const patient = await Patient.findByIdAndDelete(req.params.id);
|
|
if (!patient) {
|
|
return res.status(404).json({ message: "patient Not Found" });
|
|
}
|
|
await patient.remove();
|
|
res.status(200).json({
|
|
success: true,
|
|
message: "patient Deleted Successfully!!",
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: error.message ? error.message : "Something went wrong!",
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
export const completeRegistration = async (req, res) => {
|
|
const {
|
|
mobileNumber,
|
|
email,
|
|
password,
|
|
confirmPassword,
|
|
gender,
|
|
weight,
|
|
height,
|
|
age,
|
|
commonHealthComplaints,
|
|
familyHistory,
|
|
personalHistory,
|
|
dailyRoutine,
|
|
} = req.body;
|
|
if (password !== confirmPassword) {
|
|
return res.status(400).json({ message: 'Password and confirm password do not match' });
|
|
}
|
|
try {
|
|
const patient = await Patient.findOne({ mobileNumber });
|
|
|
|
if (!patient || !patient.isVerified) {
|
|
return res.status(400).json({ message: 'Patient not found or not verified' });
|
|
}
|
|
|
|
// const hashedPassword = await hashPassword(password);
|
|
|
|
patient.email = email;
|
|
patient.password = hashedPassword;
|
|
patient.gender = gender;
|
|
patient.weight = weight;
|
|
patient.height = height;
|
|
patient.age = age;
|
|
patient.commonHealthComplaints = commonHealthComplaints;
|
|
patient.familyHistory = familyHistory;
|
|
patient.personalHistory = personalHistory;
|
|
patient.dailyRoutine = dailyRoutine;
|
|
|
|
await patient.save();
|
|
|
|
res.status(200).json({ message: 'Registration details updated successfully' });
|
|
} catch (error) {
|
|
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
|
|
}
|
|
};
|
|
|
|
|
|
export const Otp = async (req, res) => {
|
|
// const { name, mobileNumber } = req.body;
|
|
try {
|
|
// let patient = await Patient.findOne({ mobileNumber });
|
|
|
|
// if (patient && patient.isVerified) {
|
|
// return res.status(400).json({ message: 'Patient 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 (patient) {
|
|
// patient.otp = otp;
|
|
// patient.otpExpires = otpExpires;
|
|
// } else {
|
|
// patient = new Patient({ name, mobileNumber, otp, otpExpires });
|
|
// }
|
|
|
|
// await patient.save();
|
|
await sendOtp();
|
|
|
|
// res.status(200).json({patient, message: `OTP ${otp} sent to your mobile number successfully` });
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
message: error.message ? error.message : "Server error!",
|
|
});
|
|
}
|
|
};
|