You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1799 lines
53 KiB
1799 lines
53 KiB
const Admin = require('../models/admin')
|
|
const boom = require("boom");
|
|
const jwt = require('jsonwebtoken')
|
|
const bcrypt = require('bcrypt')
|
|
|
|
|
|
const fastify = require("fastify");
|
|
const { Tank, MotorData, IotData } = require('../models/tanks');
|
|
const { Deparments, City, Branch } = require('../models/Department');
|
|
const JWT_SECRET = 'your-secret-key';
|
|
|
|
async function generateCustomerId(role) {
|
|
let adminId;
|
|
let isUnique = false;
|
|
let prefix;
|
|
|
|
// Set the prefix based on the role
|
|
switch (role) {
|
|
case 'admin':
|
|
prefix = 'AWSAD';
|
|
break;
|
|
case 'sales':
|
|
prefix = 'AWSSL';
|
|
break;
|
|
case 'store':
|
|
prefix = 'AWSST';
|
|
break;
|
|
default:
|
|
throw new Error('Invalid role for customer ID generation');
|
|
}
|
|
|
|
while (!isUnique) {
|
|
// Generate a random number or string for the customer ID
|
|
const randomId = Math.floor(1000 + Math.random() * 9000).toString(); // Generates a random number between 1000 and 9999
|
|
adminId = `${prefix}${randomId}`;
|
|
// Check for uniqueness in the Admin collection
|
|
const existingAdmin = await Admin.findOne({ customerId });
|
|
if (!existingAdmin) {
|
|
isUnique = true; // Exit the loop if the customer ID is unique
|
|
}
|
|
}
|
|
|
|
return adminId;
|
|
}
|
|
|
|
|
|
exports.adminSignUp = async (request, reply) => {
|
|
try {
|
|
const { phone, username, password, role } = request.body;
|
|
|
|
if (!username || username.trim() === '') {
|
|
return reply.status(400).send({ message: 'Username is required' });
|
|
}
|
|
|
|
// Validate role
|
|
if (!role || !['admin', 'sales', 'store'].includes(role)) {
|
|
return reply.status(400).send({ message: 'Invalid role. Must be either admin, sales, or store' });
|
|
}
|
|
|
|
|
|
|
|
// Check if an admin with the same phone number or username already exists
|
|
// const existingAdminUsername = await Admin.findOne({ username });
|
|
// const existingAdmin = await Admin.findOne({ phone });
|
|
|
|
// if (existingAdmin) {
|
|
// return reply.status(400).send({ message: 'Phone already registered' });
|
|
// }
|
|
// if (existingAdminUsername) {
|
|
// return reply.status(400).send({ message: 'Username already registered' });
|
|
// }
|
|
|
|
// Hash the password using bcrypt
|
|
const hashedPassword = await bcrypt.hash(password, 10);
|
|
|
|
const adminId = await generateCustomerId(role); // Assuming you have this function defined elsewhere
|
|
//const building = 'ADMIN'; // You can customize this logic to derive from a parameter or a default value
|
|
//const customerId = `AWSU${building}${c_id}`; // Construct the customer ID
|
|
|
|
// Create a new admin object with the hashed password and role
|
|
const admin = new Admin({ phone, username, password: hashedPassword, adminId, role });
|
|
|
|
// Save the new admin to the database
|
|
await admin.save();
|
|
|
|
reply.send({ message: 'Admin Account Created Successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
exports.editAdmin = async (request, reply) => {
|
|
try {
|
|
const { customerId } = request.params;
|
|
const {
|
|
|
|
phone,
|
|
username,
|
|
picture,
|
|
|
|
} = request.body;
|
|
|
|
|
|
const existing = await Admin.findOne({ customerId });
|
|
if (!existing) {
|
|
return reply.status(404).send({ message: 'City not found' });
|
|
}
|
|
|
|
existing.phone = phone || existing.phone;
|
|
existing.username = username || existing.username;
|
|
existing.picture = picture || existing.picture;
|
|
|
|
|
|
|
|
|
|
await existing.save();
|
|
|
|
reply.send({ message: 'Admin user updated successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
// Admin Login Function (With Phone Number)
|
|
// exports.adminLogin = async (request, reply) => {
|
|
// try {
|
|
// const { phone, password } = request.body;
|
|
|
|
// // Check if an admin with the phone number exists
|
|
// const admin = await Admin.findOne({ phone });
|
|
|
|
// if (!admin) {
|
|
// return reply.status(401).send({ message: 'Invalid phone number or password' });
|
|
// }
|
|
|
|
// // Compare the password entered by the user with the hashed password stored in the database
|
|
// const isPasswordValid = await bcrypt.compare(password, admin.password);
|
|
|
|
// if (!isPasswordValid) {
|
|
// return reply.status(401).send({ message: 'Invalid phone number or password' });
|
|
// }
|
|
|
|
|
|
// // Generate a JWT token for the authenticated admin
|
|
// const token = jwt.sign({ phone: admin.phone, role: 'admin' }, JWT_SECRET, { expiresIn: '1h' });
|
|
|
|
// return reply.send({ token, admin });
|
|
// } catch (err) {
|
|
// reply.status(500).send({ message: err.message });
|
|
// }
|
|
// };
|
|
|
|
exports.adminLogin = async (request, reply) => {
|
|
try {
|
|
const { phone, password } = request.body;
|
|
|
|
// Check if an admin with the phone number exists
|
|
const admin = await Admin.findOne({ phone });
|
|
|
|
if (!admin) {
|
|
return reply.status(401).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Invalid phone number or password",
|
|
},
|
|
});
|
|
}
|
|
|
|
// Compare the password entered by the user with the hashed password stored in the database
|
|
const isPasswordValid = await bcrypt.compare(password, admin.password);
|
|
|
|
if (!isPasswordValid) {
|
|
return reply.status(401).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Invalid phone number or password",
|
|
},
|
|
});
|
|
}
|
|
|
|
// Generate a JWT token for the authenticated admin
|
|
const token = jwt.sign(
|
|
{ phone: admin.phone, role: admin.role },
|
|
JWT_SECRET,
|
|
{ expiresIn: "1h" }
|
|
);
|
|
|
|
// Create the response payload
|
|
const responsePayload = {
|
|
simplydata: {
|
|
error: false,
|
|
apiversion: process.env.APIVERSION,
|
|
access_token: token,
|
|
phone: admin.phone,
|
|
type: admin.role,
|
|
customerId: admin.adminId || null,
|
|
username: admin.username || null,
|
|
},
|
|
};
|
|
|
|
// Send the response
|
|
return reply.send(responsePayload);
|
|
} catch (err) {
|
|
reply.status(500).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: err.message,
|
|
},
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
// adminController.js
|
|
|
|
exports.editUserByCustomerId = async (req, reply) => {
|
|
const { customerId } = req.params;
|
|
const { phone, username, role, date } = req.body;
|
|
|
|
try {
|
|
const updatedUser = await Admin.findOneAndUpdate(
|
|
{ customerId: customerId },
|
|
{ phone, username, role, date },
|
|
);
|
|
|
|
if (!updatedUser) {
|
|
return reply.status(404).send({ success: false, message: "User not found" });
|
|
}
|
|
|
|
return reply.send({ success: true, message: "User details updated successfully", data: updatedUser });
|
|
} catch (error) {
|
|
return reply.status(500).send({ success: false, message: error.message });
|
|
}
|
|
};
|
|
|
|
exports.deleteUserInfo = async (req, reply) => {
|
|
try {
|
|
const customerId = req.params.customerId;
|
|
|
|
const tank = await Admin.findOneAndDelete({ customerId:customerId });
|
|
|
|
reply.send({ status_code: 200, message: 'Delete Sucessfully'});
|
|
// return tank;
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
exports.salesStoreLogin = async (request, reply) => {
|
|
try {
|
|
const { phone, password, role } = request.body;
|
|
|
|
// Check if a user (sales or store) with the phone number and role exists
|
|
const user = await Admin.findOne({ phone, role });
|
|
|
|
if (!user) {
|
|
return reply.status(401).send({ message: 'Invalid phone number, password, or role' });
|
|
}
|
|
|
|
// Compare the password entered by the user with the hashed password stored in the database
|
|
const isPasswordValid = await bcrypt.compare(password, user.password);
|
|
|
|
if (!isPasswordValid) {
|
|
return reply.status(401).send({ message: 'Invalid phone number, password, or role' });
|
|
}
|
|
|
|
// Generate a JWT token for the authenticated user (with role sales or store)
|
|
const token = jwt.sign({ phone: user.phone, role: user.role }, JWT_SECRET, { expiresIn: '1h' });
|
|
|
|
return reply.send({ token });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getUsersByRole = async (request, reply) => {
|
|
try {
|
|
const { role } = request.params;
|
|
|
|
// Ensure the role is either 'sales' or 'store'
|
|
if (!['sales', 'store'].includes(role)) {
|
|
return reply.status(400).send({ message: 'Invalid role. Must be either sales or store.' });
|
|
}
|
|
|
|
// Find users with the specific role (sales or store)
|
|
const users = await Admin.find({ role });
|
|
|
|
// Send back the list of users
|
|
reply.send(users);
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
exports.getUserByCustomerId = async (request, reply) => {
|
|
try {
|
|
const { customerId } = request.params;
|
|
|
|
// Check if customerId is provided
|
|
if (!customerId) {
|
|
return reply.status(400).send({ message: 'Customer ID is required' });
|
|
}
|
|
|
|
// Fetch the user from the database
|
|
const user = await Admin.findOne({ customerId });
|
|
|
|
// If user not found, return a 404 response
|
|
if (!user) {
|
|
return reply.status(404).send({ message: 'User not found' });
|
|
}
|
|
|
|
// Return the user data
|
|
return reply.send(user);
|
|
} catch (err) {
|
|
return reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.createUser = async (request, reply) => {
|
|
const { phone, password, role } = request.body;
|
|
|
|
// Validate role (only sales or store)
|
|
if (!['sales', 'store'].includes(role)) {
|
|
return reply.status(400).send({ message: 'Invalid role. Must be either sales or store' });
|
|
}
|
|
|
|
try {
|
|
const existingUser = await Admin.findOne({ phone });
|
|
|
|
if (existingUser) {
|
|
return reply.status(400).send({ message: 'User with this phone number already exists' });
|
|
}
|
|
|
|
// Hash the password
|
|
const hashedPassword = await bcrypt.hash(password, 10);
|
|
|
|
// Create the new user
|
|
const newUser = new Admin({
|
|
phone,
|
|
password: hashedPassword,
|
|
role,
|
|
});
|
|
|
|
await newUser.save();
|
|
return reply.send({ message: 'User created successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.integratingHardwareidToTank = async (request, reply) => {
|
|
try {
|
|
const { customerId, tankName,tankLocation,hardwareId,hardwareId_company,hardwareId_type } = request.body
|
|
const tank = await Tank.findOneAndUpdate({customerId, tankName:tankName ,tankLocation:tankLocation.toLowerCase()}, { $set: { hardwareId: hardwareId,hardwareId_company:hardwareId_company,hardwareId_type:hardwareId_type } });
|
|
reply.send({ status_code: 200, message:`${hardwareId} set to ${tankName}` });
|
|
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message })
|
|
}
|
|
}
|
|
|
|
|
|
exports.getDepartmentDetailsByAdminAndName = async (req, reply) => {
|
|
try {
|
|
const { adminId } = req.params;
|
|
const { departmentName, reportingManager } = req.body;
|
|
|
|
if (!adminId) {
|
|
return reply.status(400).send({
|
|
simplydata: { error: true, message: "adminId is required in path params" }
|
|
});
|
|
}
|
|
|
|
if (!departmentName || !reportingManager) {
|
|
return reply.status(400).send({
|
|
simplydata: { error: true, message: "departmentName and reportingManager are required in body" }
|
|
});
|
|
}
|
|
|
|
// ✅ Find department by adminId, departmentName and reportingManager
|
|
const department = await Deparments.findOne({
|
|
adminId,
|
|
departmentName,
|
|
reportingManager
|
|
}).lean();
|
|
|
|
if (!department) {
|
|
return reply.status(404).send({
|
|
simplydata: { error: true, message: "Department not found with given criteria" }
|
|
});
|
|
}
|
|
|
|
// ✅ Build response data
|
|
const responseData = {
|
|
phone: department.phone,
|
|
firstName: department.firstName,
|
|
lastName: department.lastName,
|
|
email: department.email
|
|
};
|
|
|
|
return reply.send({
|
|
simplydata: {
|
|
error: false,
|
|
message: "Department details fetched successfully",
|
|
data: responseData
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.error("Error fetching department details:", err);
|
|
reply.status(500).send({
|
|
simplydata: { error: true, message: "Internal server error" }
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
exports.getAllCompanys = async (req, reply) => {
|
|
try {
|
|
const companyList = await City.find();
|
|
|
|
|
|
return reply.send({
|
|
status_code: 200,
|
|
message: "Fetched successfully",
|
|
data: companyList,
|
|
});
|
|
} catch (err) {
|
|
console.error("Error fetching ", err);
|
|
return reply.status(500).send({ error: "Internal server error" });
|
|
}
|
|
};
|
|
|
|
// exports.getBranchDetails = async (req, reply) => {
|
|
// try {
|
|
// const { officeName } = req.params;
|
|
|
|
// const branchDetails = await Branch.find({
|
|
// officeName: { $regex: new RegExp(`^${officeName}$`, 'i') }
|
|
// });
|
|
|
|
// return reply.send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: branchDetails,
|
|
// });
|
|
// } catch (err) {
|
|
// console.error("Error fetching branch details:", err);
|
|
// return reply.status(500).send({ error: "Internal server error" });
|
|
// }
|
|
// };
|
|
|
|
|
|
// exports.getAllOffices = async (req, reply) => {
|
|
// try {
|
|
// const { officeName } = req.query;
|
|
|
|
// let filter = {};
|
|
|
|
// if (officeName && officeName.toUpperCase() !== "ALL") {
|
|
// // Partial and case-insensitive match
|
|
// filter.officeName = { $regex: new RegExp(officeName, "i") };
|
|
// }
|
|
|
|
// const offices = await Branch.find(filter).lean();
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: offices
|
|
// });
|
|
// } catch (error) {
|
|
// console.error("Error fetching offices:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error"
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
// exports.getAllOffices = async (req, reply) => {
|
|
// try {
|
|
// const { officeName } = req.query;
|
|
|
|
// if (!officeName) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "officeName query param is required"
|
|
// });
|
|
// }
|
|
|
|
// const nameRegex = new RegExp(officeName.trim(), "i");
|
|
|
|
// // Fetch head offices, branches, and departments
|
|
// const [headOffices, branches, departments] = await Promise.all([
|
|
// City.find({ officeName: nameRegex }).lean(),
|
|
// Branch.find({ officeName: nameRegex }).lean(),
|
|
// Deparments.find({ officeName: nameRegex }).lean()
|
|
// ]);
|
|
|
|
// if (headOffices.length === 0 && branches.length === 0) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: "No offices found for the given officeName"
|
|
// });
|
|
// }
|
|
|
|
// const allOffices = [];
|
|
|
|
// // Process head offices (with employee count)
|
|
// headOffices.forEach(ho => {
|
|
// const officeNameTrimmed = ho.officeName.trim().toLowerCase();
|
|
|
|
// // Get all department docs for this office
|
|
// const matchingDepartments = departments.filter(
|
|
// d => d.officeName?.trim().toLowerCase() === officeNameTrimmed
|
|
// );
|
|
|
|
// // Count employees: 1 main person per doc + sub-team members
|
|
// const employeeCount = matchingDepartments.reduce((count, dep) => {
|
|
// const mainPerson = 1;
|
|
// const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
// ? dep.team_member.team_member.length
|
|
// : 0;
|
|
// return count + mainPerson + subTeamCount;
|
|
// }, 0);
|
|
|
|
// allOffices.push({
|
|
// officeType: "headOffice",
|
|
// officeName: ho.officeName.trim(),
|
|
// city: ho.city?.trim() || "",
|
|
// cityId: ho.cityId || "",
|
|
// employeeCount,
|
|
// phone: ho.phone || "",
|
|
// address: ho.office_address1 || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || "",
|
|
// latitude:ho.latitude || "",
|
|
// longitude: ho.longitude || "",
|
|
// googleLocation: ho.googleLocation || "",
|
|
// createdAt: ho.createdAt || "",
|
|
// updatedAt: ho.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// // Process branches (no employee count here)
|
|
// branches.forEach(br => {
|
|
// allOffices.push({
|
|
// officeType: "branch",
|
|
// branchId: br.branchId || "",
|
|
// officeName: br.officeName?.trim() || "",
|
|
// city: br.city?.trim() || "",
|
|
// zone: br.zone || "",
|
|
// location: br.location || [],
|
|
// phone: br.phone || "",
|
|
// address: br.office_address1 || "",
|
|
// address2: br.address2 || "",
|
|
// state: br.state || "",
|
|
// country: br.country || "",
|
|
// pincode: br.pincode || "",
|
|
// email: br.email || "",
|
|
// contactPerson: br.nameoftheContactPerson || "",
|
|
// latitude:br.latitude || "",
|
|
// longitude: br.longitude || "",
|
|
// googleLocation: br.googleLocation || "",
|
|
// createdAt: br.createdAt || "",
|
|
// updatedAt: br.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: allOffices
|
|
// });
|
|
|
|
// } catch (error) {
|
|
// console.error("Error fetching city offices:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error"
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
|
|
// exports.getAllOffices = async (req, reply) => {
|
|
// try {
|
|
// const { officeName } = req.query;
|
|
|
|
// if (!officeName) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "officeName query param is required"
|
|
// });
|
|
// }
|
|
|
|
// let headOffices, branches, departments;
|
|
|
|
// if (officeName.trim().toUpperCase() === "ALL") {
|
|
// // ✅ Fetch all without filtering
|
|
// [headOffices, branches, departments] = await Promise.all([
|
|
// City.find().lean(),
|
|
// Branch.find().lean(),
|
|
// Deparments.find().lean()
|
|
// ]);
|
|
// } else {
|
|
// const nameRegex = new RegExp(officeName.trim(), "i");
|
|
// [headOffices, branches, departments] = await Promise.all([
|
|
// City.find({ officeName: nameRegex }).lean(),
|
|
// Branch.find({ officeName: nameRegex }).lean(),
|
|
// Deparments.find({ officeName: nameRegex }).lean()
|
|
// ]);
|
|
// }
|
|
|
|
// if (headOffices.length === 0 && branches.length === 0) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: "No offices found"
|
|
// });
|
|
// }
|
|
|
|
// const allOffices = [];
|
|
|
|
// // Process head offices (with employee count)
|
|
// headOffices.forEach(ho => {
|
|
// const officeNameTrimmed = ho.officeName.trim().toLowerCase();
|
|
|
|
// // Get all department docs for this office
|
|
// const matchingDepartments = departments.filter(
|
|
// d => d.officeName?.trim().toLowerCase() === officeNameTrimmed
|
|
// );
|
|
|
|
// // Count employees: 1 main person per doc + sub-team members
|
|
// const employeeCount = matchingDepartments.reduce((count, dep) => {
|
|
// const mainPerson = 1;
|
|
// const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
// ? dep.team_member.team_member.length
|
|
// : 0;
|
|
// return count + mainPerson + subTeamCount;
|
|
// }, 0);
|
|
|
|
// allOffices.push({
|
|
// officeType: "headOffice",
|
|
// officeName: ho.officeName.trim(),
|
|
// city: ho.city?.trim() || "",
|
|
// cityId: ho.cityId || "",
|
|
// employeeCount,
|
|
// phone: ho.phone || "",
|
|
// address: ho.office_address1 || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || "",
|
|
// latitude: ho.latitude || "",
|
|
// longitude: ho.longitude || "",
|
|
// googleLocation: ho.googleLocation || "",
|
|
// createdAt: ho.createdAt || "",
|
|
// updatedAt: ho.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// // Process branches (no employee count here)
|
|
// branches.forEach(br => {
|
|
// allOffices.push({
|
|
// officeType: "branch",
|
|
// branchId: br.branchId || "",
|
|
// officeName: br.officeName?.trim() || "",
|
|
// city: br.city?.trim() || "",
|
|
// zone: br.zone || "",
|
|
// location: br.location || [],
|
|
// phone: br.phone || "",
|
|
// address: br.office_address1 || "",
|
|
// address2: br.address2 || "",
|
|
// state: br.state || "",
|
|
// country: br.country || "",
|
|
// pincode: br.pincode || "",
|
|
// email: br.email || "",
|
|
// contactPerson: br.nameoftheContactPerson || "",
|
|
// latitude: br.latitude || "",
|
|
// longitude: br.longitude || "",
|
|
// googleLocation: br.googleLocation || "",
|
|
// createdAt: br.createdAt || "",
|
|
// updatedAt: br.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: allOffices
|
|
// });
|
|
|
|
// } catch (error) {
|
|
// console.error("Error fetching city offices:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error"
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
exports.getAllOffices = async (req, reply) => {
|
|
try {
|
|
const { officeName } = req.query;
|
|
|
|
|
|
if (!officeName) {
|
|
return reply.code(400).send({
|
|
status_code: 400,
|
|
message: "officeName query param is required"
|
|
});
|
|
}
|
|
|
|
let headOffices, branches, departments;
|
|
|
|
if (officeName.trim().toUpperCase() === "ALL") {
|
|
// ✅ Fetch all without filtering
|
|
[headOffices, branches, departments] = await Promise.all([
|
|
City.find().lean(),
|
|
Branch.find().lean(),
|
|
Deparments.find().lean()
|
|
]);
|
|
} else {
|
|
const nameRegex = new RegExp(officeName.trim(), "i");
|
|
[headOffices, branches, departments] = await Promise.all([
|
|
City.find({ officeName: nameRegex }).lean(),
|
|
Branch.find({ officeName: nameRegex }).lean(),
|
|
Deparments.find({ officeName: nameRegex }).lean()
|
|
]);
|
|
}
|
|
|
|
if (headOffices.length === 0 && branches.length === 0) {
|
|
return reply.code(404).send({
|
|
status_code: 404,
|
|
message: "No offices found"
|
|
});
|
|
}
|
|
|
|
// 🏢 Group by officeName
|
|
const grouped = {};
|
|
|
|
// Head offices
|
|
headOffices.forEach(ho => {
|
|
const key = ho.officeName.trim().toLowerCase();
|
|
if (!grouped[key]) grouped[key] = [];
|
|
|
|
const matchingDepartments = departments.filter(
|
|
d => d.officeName?.trim().toLowerCase() === key
|
|
);
|
|
|
|
const employeeCount = matchingDepartments.reduce((count, dep) => {
|
|
const mainPerson = 1;
|
|
const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
? dep.team_member.team_member.length
|
|
: 0;
|
|
return count + mainPerson + subTeamCount;
|
|
}, 0);
|
|
|
|
grouped[key].push({
|
|
officeType: "headOffice",
|
|
officeName: ho.officeName.trim(),
|
|
city: ho.city?.trim() || "",
|
|
cityId: ho.cityId || "",
|
|
employeeCount,
|
|
phone: ho.phone || "",
|
|
address: ho.office_address1 || "",
|
|
address2: ho.address2 || "",
|
|
state: ho.state || "",
|
|
country: ho.country || "",
|
|
pincode: ho.pincode || "",
|
|
email: ho.email || "",
|
|
latitude: ho.latitude || 0,
|
|
longitude: ho.longitude || 0,
|
|
googleLocation: ho.googleLocation || "",
|
|
createdAt: ho.createdAt || "",
|
|
updatedAt: ho.updatedAt || ""
|
|
});
|
|
});
|
|
|
|
// Branches
|
|
branches.forEach(br => {
|
|
const key = br.officeName.trim().toLowerCase();
|
|
if (!grouped[key]) grouped[key] = [];
|
|
|
|
const matchingDepartments = departments.filter(
|
|
d => d.officeName?.trim().toLowerCase() === key && d.city === br.city
|
|
);
|
|
|
|
const employeeCount = matchingDepartments.reduce((count, dep) => {
|
|
const mainPerson = 1;
|
|
const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
? dep.team_member.team_member.length
|
|
: 0;
|
|
return count + mainPerson + subTeamCount;
|
|
}, 0);
|
|
|
|
grouped[key].push({
|
|
officeType: "branchOffice",
|
|
branchId: br.branchId || "",
|
|
officeName: br.officeName?.trim() || "",
|
|
city: br.city?.trim() || "",
|
|
employeeCount,
|
|
phone: br.phone || "",
|
|
address: br.office_address1 || "",
|
|
address2: br.address2 || "",
|
|
state: br.state || "",
|
|
country: br.country || "",
|
|
pincode: br.pincode || "",
|
|
email: br.email || "",
|
|
contactPerson: br.nameoftheContactPerson || "",
|
|
latitude: br.latitude || 0,
|
|
longitude: br.longitude || 0,
|
|
googleLocation: br.googleLocation || "",
|
|
createdAt: br.createdAt || "",
|
|
updatedAt: br.updatedAt || ""
|
|
});
|
|
});
|
|
|
|
// Convert grouped object into array
|
|
const result = Object.values(grouped).map(offices => ({ offices }));
|
|
|
|
return reply.code(200).send({
|
|
status_code: 200,
|
|
message: "Fetched successfully",
|
|
data: result
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error("Error fetching city offices:", error);
|
|
return reply.code(500).send({
|
|
status_code: 500,
|
|
message: "Internal server error"
|
|
});
|
|
}
|
|
};
|
|
|
|
exports.getAllOfficesByCity = async (req, reply) => {
|
|
try {
|
|
const { city } = req.query;
|
|
|
|
if (!city) {
|
|
return reply.code(400).send({
|
|
status_code: 400,
|
|
message: "city query param is required",
|
|
});
|
|
}
|
|
|
|
const cityRegex = new RegExp(city.trim(), "i");
|
|
|
|
|
|
// 🔹 Step 1: Find all headOffices in this city
|
|
const headOffices = await City.find({ city: cityRegex }).lean();
|
|
|
|
// 🔹 Step 2: Find all branchOffices in this city
|
|
const branchMatches = await Branch.find({ city: cityRegex }).lean();
|
|
|
|
if (!headOffices.length && !branchMatches.length) {
|
|
return reply.code(404).send({
|
|
status_code: 404,
|
|
message: `No headOffice or branch found for city ${city}`,
|
|
});
|
|
}
|
|
|
|
// 🔹 Step 3: Collect all unique officeNames
|
|
const officeNames = [
|
|
...new Set([
|
|
...headOffices.map((ho) => ho.officeName.trim()),
|
|
...branchMatches.map((br) => br.officeName.trim()),
|
|
]),
|
|
];
|
|
|
|
const finalResponse = [];
|
|
|
|
// 🔹 Step 4: For each officeName, gather HO + Branches
|
|
for (const name of officeNames) {
|
|
const ho = await City.findOne({
|
|
officeName: new RegExp(name, "i"),
|
|
}).lean();
|
|
|
|
// Get employee count for headOffice (if exists)
|
|
let employeeCount = 0;
|
|
if (ho) {
|
|
const departments = await Deparments.find({ city: ho.city }).lean();
|
|
employeeCount = departments.reduce((count, dep) => {
|
|
const mainPerson = 1;
|
|
const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
? dep.team_member.team_member.length
|
|
: 0;
|
|
return count + mainPerson + subTeamCount;
|
|
}, 0);
|
|
}
|
|
|
|
// Get all branches for this officeName
|
|
const branches = await Branch.find({
|
|
officeName: new RegExp(name, "i"),
|
|
}).lean();
|
|
|
|
const offices = [];
|
|
|
|
// Add headOffice if found
|
|
if (ho) {
|
|
offices.push({
|
|
officeType: "headOffice",
|
|
officeName: ho.officeName?.trim() || "",
|
|
city: ho.city?.trim() || "",
|
|
cityId: ho.cityId || "",
|
|
employeeCount,
|
|
phone: ho.phone || "",
|
|
address: ho.office_address1 || "",
|
|
address2: ho.address2 || "",
|
|
state: ho.state || "",
|
|
country: ho.country || "",
|
|
pincode: ho.pincode || "",
|
|
email: ho.email || "",
|
|
latitude: ho.latitude || 0,
|
|
longitude: ho.longitude || 0,
|
|
googleLocation: ho.googleLocation || "",
|
|
createdAt: ho.createdAt || "",
|
|
updatedAt: ho.updatedAt || "",
|
|
});
|
|
}
|
|
|
|
// Add all branchOffices
|
|
branches.forEach((br) => {
|
|
offices.push({
|
|
officeType: "branchOffice",
|
|
branchId: br.branchId || "",
|
|
officeName: br.officeName?.trim() || "",
|
|
city: br.city?.trim() || "",
|
|
employeeCount, // using HO employee count (optional)
|
|
phone: br.phone || "",
|
|
address: br.office_address1 || "",
|
|
address2: br.address2 || "",
|
|
state: br.state || "",
|
|
country: br.country || "",
|
|
pincode: br.pincode || "",
|
|
email: br.email || "",
|
|
contactPerson: br.nameoftheContactPerson || "",
|
|
latitude: br.latitude || 0,
|
|
longitude: br.longitude || 0,
|
|
googleLocation: br.googleLocation || "",
|
|
createdAt: br.createdAt || "",
|
|
updatedAt: br.updatedAt || "",
|
|
});
|
|
});
|
|
|
|
finalResponse.push({
|
|
officeName: name,
|
|
city,
|
|
offices,
|
|
});
|
|
}
|
|
|
|
return reply.code(200).send({
|
|
status_code: 200,
|
|
message: "Fetched successfully",
|
|
data: finalResponse,
|
|
});
|
|
} catch (error) {
|
|
console.error("❌ Error in getAllOfficesByCity:", error);
|
|
return reply.code(500).send({
|
|
status_code: 500,
|
|
message: "Internal server error",
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
// exports.getAllOfficesByCity = async (req, reply) => {
|
|
// try {
|
|
// const { city } = req.query;
|
|
|
|
// if (!city) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "city query param is required"
|
|
// });
|
|
// }
|
|
|
|
// const cityRegex = new RegExp(city.trim(), "i");
|
|
|
|
// // 1) Find head offices (city schema)
|
|
// const headOffices = await City.find({ city: cityRegex }).lean();
|
|
|
|
// if (!headOffices.length) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: `No head office found for city ${city}`
|
|
// });
|
|
// }
|
|
|
|
// // 2) Build response for each headOffice
|
|
// const finalResponse = [];
|
|
|
|
// for (const ho of headOffices) {
|
|
// // (optional) Employee count logic
|
|
// const departments = await Deparments.find({ city: ho.city }).lean();
|
|
// const employeeCount = departments.reduce((count, dep) => {
|
|
// const mainPerson = 1;
|
|
// const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
// ? dep.team_member.team_member.length
|
|
// : 0;
|
|
// return count + mainPerson + subTeamCount;
|
|
// }, 0);
|
|
|
|
// // 3) Find branches with same officeName
|
|
// const branches = await Branch.find({
|
|
// officeName: new RegExp(ho.officeName.trim(), "i")
|
|
// }).lean();
|
|
|
|
// // 4) Construct office data
|
|
// const offices = [];
|
|
|
|
// // Head Office (from citySchema)
|
|
// offices.push({
|
|
// officeType: "headOffice",
|
|
// officeName: ho.officeName?.trim() || "",
|
|
// city: ho.city?.trim() || "",
|
|
// cityId: ho.cityId || "",
|
|
// employeeCount,
|
|
// phone: ho.phone || "",
|
|
// address: ho.office_address1 || "",
|
|
// address2: ho.address2 || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || "",
|
|
// latitude: ho.latitude || 0,
|
|
// longitude: ho.longitude || 0,
|
|
// googleLocation: ho.googleLocation || "",
|
|
// createdAt: ho.createdAt || "",
|
|
// updatedAt: ho.updatedAt || ""
|
|
// });
|
|
|
|
// // Branches (from branchSchema)
|
|
// branches.forEach(br => {
|
|
// offices.push({
|
|
// officeType: "branchOffice",
|
|
// branchId: br.branchId || "",
|
|
// officeName: br.officeName?.trim() || "",
|
|
// city: br.city?.trim() || "",
|
|
// employeeCount, // optional: same count or separate
|
|
// phone: br.phone || "",
|
|
// address: br.office_address1 || "",
|
|
// address2: br.address2 || "",
|
|
// state: br.state || "",
|
|
// country: br.country || "",
|
|
// pincode: br.pincode || "",
|
|
// email: br.email || "",
|
|
// contactPerson: br.nameoftheContactPerson || "",
|
|
// latitude: br.latitude || 0,
|
|
// longitude: br.longitude || 0,
|
|
// googleLocation: br.googleLocation || "",
|
|
// createdAt: br.createdAt || "",
|
|
// updatedAt: br.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// // 5) Push into final response
|
|
// finalResponse.push({
|
|
// officeName: ho.officeName?.trim() || "",
|
|
// city: ho.city?.trim() || "",
|
|
// offices
|
|
// });
|
|
// }
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: finalResponse
|
|
// });
|
|
|
|
// } catch (error) {
|
|
// console.error("❌ Error in getAllOfficesByCity:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error",
|
|
// error: error.message
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
|
|
// exports.getAllOfficesByCity = async (req, reply) => {
|
|
// try {
|
|
// const { city } = req.query;
|
|
|
|
// if (!city) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "city query param is required"
|
|
// });
|
|
// }
|
|
|
|
// const cityRegex = new RegExp(city.trim(), "i");
|
|
|
|
// // Fetch head offices, branches, and departments
|
|
// const [headOffices, branches, departments] = await Promise.all([
|
|
// City.find({ city: cityRegex }).lean(),
|
|
// Branch.find({ city: cityRegex }).lean(),
|
|
// Deparments.find({ city: cityRegex }).lean()
|
|
// ]);
|
|
|
|
// if (!headOffices.length && !branches.length) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: `No offices found in city ${city}`
|
|
// });
|
|
// }
|
|
|
|
// const officeMap = new Map();
|
|
|
|
// // 🔹 Process Head Offices
|
|
// headOffices.forEach(ho => {
|
|
// const cityTrimmed = ho.city?.trim().toLowerCase();
|
|
// const matchingDepartments = departments.filter(
|
|
// d => d.city?.trim().toLowerCase() === cityTrimmed
|
|
// );
|
|
|
|
// // Count employees
|
|
// const employeeCount = matchingDepartments.reduce((count, dep) => {
|
|
// const mainPerson = 1;
|
|
// const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
// ? dep.team_member.team_member.length
|
|
// : 0;
|
|
// return count + mainPerson + subTeamCount;
|
|
// }, 0);
|
|
|
|
// const officeNameKey = ho.officeName?.trim().toLowerCase();
|
|
|
|
// if (!officeMap.has(officeNameKey)) {
|
|
// officeMap.set(officeNameKey, {
|
|
// officeName: ho.officeName?.trim() || "",
|
|
// city: ho.city?.trim() || "",
|
|
// offices: []
|
|
// });
|
|
// }
|
|
|
|
// officeMap.get(officeNameKey).offices.push({
|
|
// officeType: "headOffice",
|
|
// officeName: ho.officeName?.trim() || "",
|
|
// city: ho.city?.trim() || "",
|
|
// cityId: ho.cityId || "",
|
|
// employeeCount,
|
|
// phone: ho.phone || "",
|
|
// address: ho.office_address1 || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || "",
|
|
// latitude: ho.latitude || "",
|
|
// longitude: ho.longitude || "",
|
|
// googleLocation: ho.googleLocation || "",
|
|
// createdAt: ho.createdAt || "",
|
|
// updatedAt: ho.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// // 🔹 Process Branches
|
|
// branches.forEach(br => {
|
|
// const officeNameKey = br.officeName?.trim().toLowerCase();
|
|
|
|
// if (!officeMap.has(officeNameKey)) {
|
|
// officeMap.set(officeNameKey, {
|
|
// officeName: br.officeName?.trim() || "",
|
|
// city: br.city?.trim() || "",
|
|
// offices: []
|
|
// });
|
|
// }
|
|
|
|
// officeMap.get(officeNameKey).offices.push({
|
|
// officeType: "branch",
|
|
// branchId: br.branchId || "",
|
|
// officeName: br.officeName?.trim() || "",
|
|
// city: br.city?.trim() || "",
|
|
// zone: br.zone || "",
|
|
// location: Array.isArray(br.location) ? br.location : [],
|
|
// phone: br.phone || "",
|
|
// address: br.office_address1 || "",
|
|
// address2: br.address2 || "",
|
|
// state: br.state || "",
|
|
// country: br.country || "",
|
|
// pincode: br.pincode || "",
|
|
// email: br.email || "",
|
|
// contactPerson: br.nameoftheContactPerson || "",
|
|
// latitude: br.latitude || "",
|
|
// longitude: br.longitude || "",
|
|
// googleLocation: br.googleLocation || "",
|
|
// createdAt: br.createdAt || "",
|
|
// updatedAt: br.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// // 🔹 Final grouped response
|
|
// const finalResponse = Array.from(officeMap.values());
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: finalResponse
|
|
// });
|
|
|
|
// } catch (error) {
|
|
// console.error("❌ Error in getAllOfficesByCity:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error",
|
|
// error: error.message
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
|
|
// exports.getAllOfficesByCity = async (req, reply) => {
|
|
// try {
|
|
// const { city } = req.query;
|
|
|
|
// if (!city) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "city query param is required"
|
|
// });
|
|
// }
|
|
|
|
// const cityRegex = new RegExp(city.trim(), "i");
|
|
|
|
// // Fetch head offices and branches in this city
|
|
// const headOffices = await City.find({ city: cityRegex }).lean();
|
|
// const branches = await Branch.find({ city: cityRegex }).lean();
|
|
|
|
// if (!headOffices.length && !branches.length) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: `No offices found in city ${city}`
|
|
// });
|
|
// }
|
|
|
|
// // Group by officeName
|
|
// const officeMap = new Map();
|
|
|
|
// // Process head offices
|
|
// headOffices.forEach(ho => {
|
|
// const key = ho.officeName?.trim().toLowerCase();
|
|
// if (!officeMap.has(key)) {
|
|
// officeMap.set(key, {
|
|
// officeName: ho.officeName?.trim() || "",
|
|
// city: ho.city?.trim() || "",
|
|
// headOffices: []
|
|
// });
|
|
// }
|
|
// officeMap.get(key).headOffices.push({
|
|
// officeType: "headOffice",
|
|
// city: ho.city?.trim() || "",
|
|
// employeeCount: ho.employeeCount || 0,
|
|
// phone: ho.phone || "",
|
|
// address: ho.address || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || ""
|
|
// });
|
|
// });
|
|
|
|
// // Process branches
|
|
// branches.forEach(br => {
|
|
// const key = br.officeName?.trim().toLowerCase();
|
|
// if (!officeMap.has(key)) {
|
|
// officeMap.set(key, {
|
|
// officeName: br.officeName?.trim() || "",
|
|
// city: br.city?.trim() || "",
|
|
// headOffices: []
|
|
// });
|
|
// }
|
|
// officeMap.get(key).headOffices.push({
|
|
// officeType: "branch",
|
|
// branchId: br.branchId || "",
|
|
// city: br.city?.trim() || "",
|
|
// zone: br.zone || "",
|
|
// phone: br.phone || "",
|
|
// address: br.address || "",
|
|
// state: br.state || ""
|
|
// });
|
|
// });
|
|
|
|
// // Final response array
|
|
// const finalResponse = Array.from(officeMap.values());
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: finalResponse
|
|
// });
|
|
|
|
// } catch (err) {
|
|
// console.error("❌ Error in getAllOfficesByCity:", err);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error",
|
|
// error: err.message
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
|
|
|
|
// exports.getCityOffices = async (req, reply) => {
|
|
// try {
|
|
// const { officeName } = req.query;
|
|
|
|
// if (!officeName) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "officeName query param is required"
|
|
// });
|
|
// }
|
|
|
|
// // Regex filter for partial & case-insensitive match
|
|
// const nameRegex = new RegExp(officeName.trim(), "i");
|
|
|
|
// // Step 1: Fetch head offices matching the officeName
|
|
// const headOffices = await City.find({ officeName: nameRegex }).lean();
|
|
|
|
// // Step 2: Fetch branches matching the officeName
|
|
// const branches = await Branch.find({ officeName: nameRegex }).lean();
|
|
|
|
// // Step 3: Fetch departments matching the officeName
|
|
// const departments = await Deparments.find({ officeName: nameRegex }).lean();
|
|
|
|
// if (headOffices.length === 0 && branches.length === 0) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: "No offices found for the given officeName"
|
|
// });
|
|
// }
|
|
|
|
// // Step 4: Build city-wise result
|
|
// const cityMap = {};
|
|
|
|
// headOffices.forEach(ho => {
|
|
// const officeNameTrimmed = ho.officeName.trim();
|
|
|
|
// // Find department for this office to get employee count
|
|
// const departmentDoc = departments.find(
|
|
// d =>
|
|
// d.officeName &&
|
|
// d.officeName.trim().toLowerCase() === officeNameTrimmed.toLowerCase()
|
|
// );
|
|
// const employeeCount =
|
|
// departmentDoc?.team_member?.team_member?.length || 0;
|
|
|
|
// cityMap[ho.city.trim().toLowerCase()] = {
|
|
// city: ho.city.trim(),
|
|
// headOffice: {
|
|
// officeName: ho.officeName.trim(),
|
|
// employeeCount,
|
|
// phone: ho.phone || "",
|
|
// address: ho.office_address1 || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || ""
|
|
// },
|
|
// branches: []
|
|
// };
|
|
// });
|
|
|
|
// // Step 5: Attach branches
|
|
// branches.forEach(br => {
|
|
// const cityKey = br.city.trim().toLowerCase();
|
|
// if (!cityMap[cityKey]) {
|
|
// cityMap[cityKey] = {
|
|
// city: br.city.trim(),
|
|
// headOffice: null,
|
|
// branches: []
|
|
// };
|
|
// }
|
|
// cityMap[cityKey].branches.push({
|
|
// officeName: br.officeName?.trim() || "",
|
|
// location: br.location || [],
|
|
// phone: br.phone || "",
|
|
// address: br.address1 || ""
|
|
// });
|
|
// });
|
|
|
|
// // Step 6: Convert to array
|
|
// const result = Object.values(cityMap);
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: result
|
|
// });
|
|
// } catch (error) {
|
|
// console.error("Error fetching city offices:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error"
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
// exports.getCityOffices = async (req, reply) => {
|
|
// try {
|
|
// const { officeName } = req.query;
|
|
|
|
// if (!officeName) {
|
|
// return reply.code(400).send({
|
|
// status_code: 400,
|
|
// message: "officeName query param is required"
|
|
// });
|
|
// }
|
|
|
|
// const nameRegex = new RegExp(officeName.trim(), "i");
|
|
|
|
// // Step 1: Fetch head offices
|
|
// const headOffices = await City.find({ officeName: nameRegex }).lean();
|
|
|
|
// // Step 2: Fetch branches
|
|
// const branches = await Branch.find({ officeName: nameRegex }).lean();
|
|
|
|
// // Step 3: Fetch departments
|
|
// const departments = await Deparments.find({ officeName: nameRegex }).lean();
|
|
|
|
// if (headOffices.length === 0 && branches.length === 0) {
|
|
// return reply.code(404).send({
|
|
// status_code: 404,
|
|
// message: "No offices found for the given officeName"
|
|
// });
|
|
// }
|
|
|
|
// const cityMap = {};
|
|
|
|
// headOffices.forEach(ho => {
|
|
// const officeNameTrimmed = ho.officeName.trim();
|
|
|
|
// // Find department for this office to get employee count
|
|
// const departmentDoc = departments.find(
|
|
// d => d.officeName?.trim().toLowerCase() === officeNameTrimmed.toLowerCase()
|
|
// );
|
|
// console.log("departmentDoc",departmentDoc)
|
|
// const mainPersonCount = departmentDoc?.team_member?.main_person ? 1 : 0;
|
|
// const subTeamCount = Array.isArray(departmentDoc?.team_member?.team_member)
|
|
// ? departmentDoc.team_member.team_member.length
|
|
// : 0;
|
|
|
|
// const employeeCount = mainPersonCount + subTeamCount;
|
|
|
|
// cityMap[ho.city.trim().toLowerCase()] = {
|
|
// // cityId: ho.cityId || "", // added cityId
|
|
// city: ho.city.trim(),
|
|
// headOffice: {
|
|
// officeName: ho.officeName.trim(),
|
|
// cityId: ho.cityId || "", // added cityId
|
|
// employeeCount,
|
|
// phone: ho.phone || "",
|
|
// address: ho.office_address1 || "",
|
|
// state: ho.state || "",
|
|
// country: ho.country || "",
|
|
// pincode: ho.pincode || "",
|
|
// email: ho.email || ""
|
|
// },
|
|
// // branches: []
|
|
// };
|
|
// });
|
|
|
|
// // Step 5: Attach branches
|
|
// branches.forEach(br => {
|
|
// const cityKey = br.city.trim().toLowerCase();
|
|
|
|
// if (!cityMap[cityKey]) {
|
|
// cityMap[cityKey] = {
|
|
// //cityId: br.cityId || "",
|
|
// city: br.city.trim(),
|
|
// // headOffice: null,
|
|
// branches: []
|
|
// };
|
|
// }
|
|
|
|
// cityMap[cityKey].branches.push({
|
|
// branchId: br.branchId || "",
|
|
// officeName: br.officeName?.trim() || "",
|
|
// zone: br.zone || "",
|
|
// location: br.location || [],
|
|
// phone: br.phone || "",
|
|
// address: br.office_address1 || "",
|
|
// address2: br.address2 || "",
|
|
// state: br.state || "",
|
|
// country: br.country || "",
|
|
// pincode: br.pincode || "",
|
|
// email: br.email || "",
|
|
// contactPerson: br.nameoftheContactPerson || "",
|
|
// createdAt: br.createdAt || "",
|
|
// updatedAt: br.updatedAt || ""
|
|
// });
|
|
// });
|
|
|
|
// const result = Object.values(cityMap);
|
|
|
|
// return reply.code(200).send({
|
|
// status_code: 200,
|
|
// message: "Fetched successfully",
|
|
// data: result
|
|
// });
|
|
|
|
// } catch (error) {
|
|
// console.error("Error fetching city offices:", error);
|
|
// return reply.code(500).send({
|
|
// status_code: 500,
|
|
// message: "Internal server error"
|
|
// });
|
|
// }
|
|
// };
|
|
|
|
exports.getCityOffices = async (req, reply) => {
|
|
try {
|
|
const { officeName } = req.query;
|
|
|
|
if (!officeName) {
|
|
return reply.code(400).send({
|
|
status_code: 400,
|
|
message: "officeName query param is required"
|
|
});
|
|
}
|
|
|
|
const nameRegex = new RegExp(officeName.trim(), "i");
|
|
|
|
// Fetch head offices, branches, and departments
|
|
const [headOffices, branches, departments] = await Promise.all([
|
|
City.find({ officeName: nameRegex }).lean(),
|
|
Branch.find({ officeName: nameRegex }).lean(),
|
|
Deparments.find({ officeName: nameRegex }).lean()
|
|
]);
|
|
|
|
if (headOffices.length === 0 && branches.length === 0) {
|
|
return reply.code(404).send({
|
|
status_code: 404,
|
|
message: "No offices found for the given officeName"
|
|
});
|
|
}
|
|
|
|
const cityMap = {};
|
|
|
|
headOffices.forEach(ho => {
|
|
const officeNameTrimmed = ho.officeName.trim().toLowerCase();
|
|
|
|
// Get all department docs for this office
|
|
const matchingDepartments = departments.filter(
|
|
d => d.officeName?.trim().toLowerCase() === officeNameTrimmed
|
|
);
|
|
|
|
// Count employees: each department doc = 1 main person + sub-team members
|
|
const employeeCount = matchingDepartments.reduce((count, dep) => {
|
|
const mainPerson = 1; // the document itself
|
|
const subTeamCount = Array.isArray(dep?.team_member?.team_member)
|
|
? dep.team_member.team_member.length
|
|
: 0;
|
|
return count + mainPerson + subTeamCount;
|
|
}, 0);
|
|
|
|
cityMap[ho.city.trim().toLowerCase()] = {
|
|
city: ho.city.trim(),
|
|
headOffice: {
|
|
officeName: ho.officeName.trim(),
|
|
cityId: ho.cityId || "",
|
|
employeeCount,
|
|
phone: ho.phone || "",
|
|
address: ho.office_address1 || "",
|
|
state: ho.state || "",
|
|
country: ho.country || "",
|
|
pincode: ho.pincode || "",
|
|
email: ho.email || ""
|
|
},
|
|
// branches: []
|
|
};
|
|
});
|
|
|
|
// Attach branches
|
|
branches.forEach(br => {
|
|
const cityKey = br.city.trim().toLowerCase();
|
|
if (!cityMap[cityKey]) {
|
|
cityMap[cityKey] = {
|
|
city: br.city.trim(),
|
|
branches: []
|
|
};
|
|
}
|
|
cityMap[cityKey].branches.push({
|
|
branchId: br.branchId || "",
|
|
officeName: br.officeName?.trim() || "",
|
|
zone: br.zone || "",
|
|
location: br.location || [],
|
|
phone: br.phone || "",
|
|
address: br.office_address1 || "",
|
|
address2: br.address2 || "",
|
|
state: br.state || "",
|
|
country: br.country || "",
|
|
pincode: br.pincode || "",
|
|
email: br.email || "",
|
|
contactPerson: br.nameoftheContactPerson || "",
|
|
createdAt: br.createdAt || "",
|
|
updatedAt: br.updatedAt || ""
|
|
});
|
|
});
|
|
|
|
return reply.code(200).send({
|
|
status_code: 200,
|
|
message: "Fetched successfully",
|
|
data: Object.values(cityMap)
|
|
});
|
|
} catch (error) {
|
|
console.error("Error fetching city offices:", error);
|
|
return reply.code(500).send({
|
|
status_code: 500,
|
|
message: "Internal server error"
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
exports.getOfficeDetails = async (req, reply) => {
|
|
try {
|
|
let { officeName, city } = req.params;
|
|
|
|
if (!officeName || !city) {
|
|
return reply.code(400).send({ message: "officeName and city are required." });
|
|
}
|
|
|
|
// Normalize whitespace and case
|
|
officeName = officeName.trim().replace(/\s+/g, ' ');
|
|
city = city.trim().replace(/\s+/g, ' ');
|
|
|
|
const filters = {};
|
|
|
|
if (officeName.toUpperCase() !== 'ALL') {
|
|
filters.officeName = { $regex: new RegExp(officeName.replace(/\s+/g, '\\s*'), 'i') };
|
|
}
|
|
|
|
if (city.toUpperCase() !== 'ALL') {
|
|
filters.city = { $regex: new RegExp(city.replace(/\s+/g, '\\s*'), 'i') };
|
|
}
|
|
|
|
// Query City collection
|
|
const cityResults = await City.find(filters).lean();
|
|
|
|
// Query Branch collection
|
|
const branchResults = await Branch.find(filters).lean();
|
|
|
|
const combinedResults = [...cityResults, ...branchResults];
|
|
|
|
if (combinedResults.length === 0) {
|
|
return reply.status(404).send({ message: "No office details found for the given filters." });
|
|
}
|
|
|
|
reply.send({
|
|
status_code: 200,
|
|
message: "Office details fetched successfully.",
|
|
data: combinedResults,
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error("Error in getOfficeDetails:", error);
|
|
reply.status(500).send({
|
|
status_code: 500,
|
|
message: "Internal server error",
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
exports.adminEditTeamMember = async (request, reply) => {
|
|
try {
|
|
const { departmentId, teamMemberId } = request.params;
|
|
const updateData = request.body;
|
|
|
|
// Find the installation
|
|
const installation = await Deparments.findOne({ departmentId });
|
|
|
|
if (!installation) {
|
|
return reply.status(404).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Installation not found",
|
|
},
|
|
});
|
|
}
|
|
|
|
// Find the team member
|
|
let teamMember = installation.team_member.team_member.find(
|
|
(member) => member.teamMemberId === teamMemberId
|
|
);
|
|
|
|
if (!teamMember) {
|
|
return reply.status(404).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Team member not found",
|
|
},
|
|
});
|
|
}
|
|
|
|
// Update fields
|
|
Object.assign(teamMember, updateData);
|
|
|
|
// Save changes
|
|
await installation.markModified("team_member.team_member");
|
|
await installation.save();
|
|
|
|
return reply.send({
|
|
simplydata: {
|
|
error: false,
|
|
message: "Team member updated successfully",
|
|
},
|
|
});
|
|
|
|
} catch (err) {
|
|
console.error("Error updating team member:", err);
|
|
reply.status(500).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Internal server error",
|
|
},
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
exports.AdmindeleteTeamMember = async (request, reply) => {
|
|
try {
|
|
const { departmentId, teamMemberId } = request.params;
|
|
|
|
// Find the installation
|
|
const installation = await Deparments.findOne({ departmentId });
|
|
|
|
if (!installation) {
|
|
return reply.status(404).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Installation not found",
|
|
},
|
|
});
|
|
}
|
|
|
|
// Find index of the team member
|
|
const memberIndex = installation.team_member.team_member.findIndex(
|
|
(member) => member.teamMemberId === teamMemberId
|
|
);
|
|
|
|
if (memberIndex === -1) {
|
|
return reply.status(404).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Team member not found",
|
|
},
|
|
});
|
|
}
|
|
|
|
// Remove the team member from the array
|
|
installation.team_member.team_member.splice(memberIndex, 1);
|
|
|
|
// Save changes
|
|
await installation.markModified("team_member.team_member");
|
|
await installation.save();
|
|
|
|
return reply.send({
|
|
simplydata: {
|
|
error: false,
|
|
message: "Team member deleted successfully",
|
|
},
|
|
});
|
|
|
|
} catch (err) {
|
|
console.error("Error deleting team member:", err);
|
|
reply.status(500).send({
|
|
simplydata: {
|
|
error: true,
|
|
message: "Internal server error",
|
|
},
|
|
});
|
|
}
|
|
}; |