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.
1519 lines
42 KiB
1519 lines
42 KiB
const boom = require("boom");
|
|
const bcrypt = require('bcrypt');
|
|
const jwt = require('jsonwebtoken');
|
|
const customJwtAuth = require("../customAuthJwt");
|
|
const mongoose = require("mongoose");
|
|
|
|
const fastify = require("fastify")({
|
|
logger: true,
|
|
genReqId(req) {
|
|
return uuidv4();
|
|
},
|
|
});
|
|
const { Counter} = require('../models/User')
|
|
|
|
const {Department, Desgination, City, Deparments, Branch, Zone,IndianLocations} = require('../models/Department')
|
|
|
|
const generateCityId = async () => {
|
|
var result = await Counter.findOneAndUpdate(
|
|
{ _id: 'customer_id' },
|
|
{ $inc: { seq: 1 } },
|
|
{ upsert: true, new: true }
|
|
);
|
|
|
|
return result.seq;
|
|
};
|
|
const generateBranchId = async () => {
|
|
var result = await Counter.findOneAndUpdate(
|
|
{ _id: 'customer_id' },
|
|
{ $inc: { seq: 1 } },
|
|
{ upsert: true, new: true }
|
|
);
|
|
|
|
return result.seq;
|
|
};
|
|
|
|
const generateDepartmentId = async (city, departmentName) => {
|
|
const cityPrefix = city.substring(0, 2).toUpperCase(); // Extract first two letters of city
|
|
const departmentPrefix = departmentName.substring(0, 2).toUpperCase(); // Extract first two letters of departmentName
|
|
|
|
const result = await Counter.findOneAndUpdate(
|
|
{ _id: 'desgination_id' },
|
|
{ $inc: { seq: 1 } },
|
|
{ upsert: true, new: true }
|
|
);
|
|
|
|
return `AW${cityPrefix}${departmentPrefix}${result.seq}`; // Generate ID
|
|
};
|
|
|
|
exports.addCity = async (request, reply) => {
|
|
try {
|
|
const {
|
|
phone,
|
|
officeName,
|
|
location,
|
|
city,
|
|
state,
|
|
country,
|
|
zone,
|
|
office_address1,
|
|
address2,
|
|
pincode,
|
|
createdBy,
|
|
updatedBy,
|
|
email,
|
|
gstNo,
|
|
googleLocation,
|
|
latitude,
|
|
longitude,
|
|
// nameoftheContactPerson,
|
|
|
|
} = request.body;
|
|
|
|
// Generate unique cityId
|
|
const c_id = await generateCityId();
|
|
const cityId = `AWCI${c_id}`;
|
|
|
|
// Check for existing records with specific fields
|
|
const existingPhone = await City.findOne({ phone });
|
|
if (existingPhone) {
|
|
return reply.status(400).send({ message: 'Phone number already exists' });
|
|
}
|
|
|
|
const existingOfficeName = await City.findOne({ officeName });
|
|
if (existingOfficeName) {
|
|
return reply.status(400).send({ message: 'Office name already exists' });
|
|
}
|
|
|
|
const existingCityId = await City.findOne({ cityId });
|
|
if (existingCityId) {
|
|
return reply.status(400).send({ message: 'City ID already exists' });
|
|
}
|
|
|
|
// Create new city record
|
|
const citys = new City({
|
|
cityId,
|
|
phone,
|
|
officeName,
|
|
location,
|
|
city,
|
|
office_address1,
|
|
address2,
|
|
state,
|
|
zone,
|
|
country,
|
|
pincode,
|
|
email,
|
|
gstNo,
|
|
googleLocation,
|
|
latitude,
|
|
longitude,
|
|
// nameoftheContactPerson,
|
|
createdBy,
|
|
updatedBy,
|
|
});
|
|
|
|
await citys.save();
|
|
|
|
reply.send({ citys, message: 'City Created Successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
exports.addBranch = async (request, reply) => {
|
|
try {
|
|
const {
|
|
phone,
|
|
land_line_number,
|
|
officeName,
|
|
location,
|
|
city,
|
|
state,
|
|
country,
|
|
zone,
|
|
office_address1,
|
|
address2,
|
|
pincode,
|
|
createdBy,
|
|
updatedBy,
|
|
email,
|
|
//nameoftheContactPerson,
|
|
googleLocation,
|
|
latitude,
|
|
longitude
|
|
} = request.body;
|
|
|
|
// Generate departmentId based on departmentName
|
|
// const prefix = departmentName.substring(0, 2).toUpperCase(); // Extract first two letters and convert to uppercase
|
|
const b_id = await generateBranchId();
|
|
const branchId = `AWBR${b_id}`;
|
|
|
|
// Check for existing department
|
|
const existingStore = await Branch.findOne({ branchId });
|
|
if (existingStore) {
|
|
return reply.status(400).send({ message: 'Branch is already registered' });
|
|
}
|
|
|
|
// Create new department
|
|
const branch = new Branch({
|
|
branchId,
|
|
phone,
|
|
land_line_number,
|
|
officeName,
|
|
location,
|
|
city,
|
|
office_address1,
|
|
address2,
|
|
state,
|
|
zone,
|
|
country,
|
|
pincode,
|
|
email,
|
|
// nameoftheContactPerson,
|
|
googleLocation,
|
|
latitude,
|
|
longitude,
|
|
// departmentName,
|
|
createdBy,
|
|
updatedBy,
|
|
});
|
|
|
|
await branch.save();
|
|
|
|
reply.send({ branch, message: 'Account Created Successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
exports.addZone = async (request, reply) => {
|
|
try {
|
|
const {
|
|
officeName,
|
|
location,
|
|
city,
|
|
zone,
|
|
area,
|
|
createdBy,
|
|
updatedBy,
|
|
} = request.body;
|
|
|
|
// Generate departmentId based on departmentName
|
|
// const prefix = departmentName.substring(0, 2).toUpperCase(); // Extract first two letters and convert to uppercase
|
|
const b_id = await generateBranchId();
|
|
const zoneId = `AWZN${b_id}`;
|
|
|
|
// Check for existing department
|
|
const existingStore = await Zone.findOne({ zoneId });
|
|
if (existingStore) {
|
|
return reply.status(400).send({ message: 'Branch is already registered' });
|
|
}
|
|
|
|
const zones = new Zone({
|
|
zoneId,
|
|
officeName,
|
|
location,
|
|
city,
|
|
zone,
|
|
area,
|
|
createdBy,
|
|
updatedBy,
|
|
});
|
|
|
|
await zones.save();
|
|
|
|
reply.send({ zones, message: 'Account Created Successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
exports.getallCompanyNames = async (req, reply) => {
|
|
try {
|
|
await City.find()
|
|
.select("officeName -_id") // Select only officeName and exclude _id
|
|
.exec()
|
|
.then((docs) => {
|
|
const officeNames = ["ALL", ...docs.map((doc) => doc.officeName)]; // Prepend "ALL"
|
|
reply.send({ status_code: 200, data: officeNames, count: officeNames.length });
|
|
})
|
|
.catch((err) => {
|
|
console.log(err);
|
|
reply.send({ error: err });
|
|
});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.deletecityInfo = async (req, reply) => {
|
|
try {
|
|
const cityId = req.params.cityId;
|
|
|
|
const department = await City.findOneAndDelete({ cityId:cityId });
|
|
|
|
reply.send({ status_code: 200, message: 'Delete Sucessfully', department});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.deleteBranchInfo = async (req, reply) => {
|
|
try {
|
|
const branchId = req.params.branchId;
|
|
|
|
const branch = await Branch.findOneAndDelete({ branchId:branchId });
|
|
|
|
reply.send({ status_code: 200, message: 'Delete Sucessfully', branch});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
exports.editcity = async (request, reply) => {
|
|
try {
|
|
const { cityId } = request.params;
|
|
const {
|
|
|
|
phone,
|
|
city,
|
|
state,
|
|
country,
|
|
zone,
|
|
address1,
|
|
address2,
|
|
pincode,
|
|
email,
|
|
officeName
|
|
|
|
} = request.body;
|
|
|
|
|
|
const existing = await City.findOne({ cityId });
|
|
if (!existing) {
|
|
return reply.status(404).send({ message: 'City not found' });
|
|
}
|
|
|
|
// const phoneExists = await Department.findOne({ phone, departmentId: { $ne: departmentId } });
|
|
// if (phoneExists) {
|
|
// return reply.status(400).send({ message: 'Phone is already registered to another user' });
|
|
// }
|
|
|
|
|
|
existing.phone = phone || existing.phone;
|
|
existing.city = city || existing.city;
|
|
existing.state = state || existing.state;
|
|
existing.country = country || existing.country;
|
|
existing.zone = zone || existing.zone;
|
|
existing.officeName = officeName || existing.officeName;
|
|
existing.pincode = pincode || existing.pincode;
|
|
|
|
existing.address1 = address1 || existing.address1;
|
|
existing.address2 = address2 || existing.address2;
|
|
existing.email = email || existing.email;
|
|
|
|
|
|
|
|
await existing.save();
|
|
|
|
reply.send({ message: 'City user updated successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
exports.editBranch = async (request, reply) => {
|
|
try {
|
|
const { branchId } = request.params;
|
|
const {
|
|
|
|
phone,
|
|
land_line_number,
|
|
officeName,
|
|
city,
|
|
state,
|
|
country,
|
|
zone,
|
|
address1,
|
|
address2,
|
|
pincode,
|
|
email
|
|
// departmentName
|
|
|
|
} = request.body;
|
|
|
|
|
|
const existing = await Branch.findOne({ branchId });
|
|
if (!existing) {
|
|
return reply.status(404).send({ message: 'Branch not found' });
|
|
}
|
|
|
|
// const phoneExists = await Department.findOne({ phone, departmentId: { $ne: departmentId } });
|
|
// if (phoneExists) {
|
|
// return reply.status(400).send({ message: 'Phone is already registered to another user' });
|
|
// }
|
|
|
|
|
|
existing.phone = phone || existing.phone;
|
|
existing.land_line_number = land_line_number || existing.land_line_number;
|
|
existing.city = city || existing.city;
|
|
existing.state = state || existing.state;
|
|
existing.country = country || existing.country;
|
|
existing.zone = zone || existing.zone;
|
|
existing.officeName = officeName || existing.officeName;
|
|
existing.pincode = pincode || existing.pincode;
|
|
|
|
existing.address1 = address1 || existing.address1;
|
|
existing.address2 = address2 || existing.address2;
|
|
existing.email = email || existing.email;
|
|
|
|
|
|
|
|
await existing.save();
|
|
|
|
reply.send({ message: 'Branch user updated successfully' });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
exports.addDepartment = async (request, reply) => {
|
|
try {
|
|
const {
|
|
phone,
|
|
officeName,
|
|
alternativeContactNumber,
|
|
gender,
|
|
personalEmail,
|
|
city,
|
|
personal_city,
|
|
reportingManager_mobile_number,
|
|
reportingManager_email,
|
|
firstName,
|
|
lastName,
|
|
departmentName,
|
|
reportingManager,
|
|
email,
|
|
state,
|
|
password,
|
|
country,
|
|
zone,
|
|
address1,
|
|
address2,
|
|
pincode,
|
|
desginationName,
|
|
location,
|
|
picture,
|
|
dateOfJoin,
|
|
employeeType,
|
|
createdBy,
|
|
updatedBy,
|
|
} = request.body;
|
|
|
|
// Generate departmentId
|
|
const departmentId = await generateDepartmentId(city, departmentName);
|
|
|
|
// Check if the phone is already registered
|
|
const existingStore = await Deparments.findOne({ phone });
|
|
if (existingStore) {
|
|
return reply.status(400).send({ message: "Phone is already registered" });
|
|
}
|
|
|
|
// Hash the password
|
|
const hashedPassword = await bcrypt.hash(password, 10);
|
|
|
|
// 🟢 Handle reportingManager "Self"
|
|
let finalReportingManager = reportingManager;
|
|
let finalReportingManagerMobile = reportingManager_mobile_number;
|
|
let finalReportingManagerEmail = reportingManager_email;
|
|
|
|
if (reportingManager?.toLowerCase() === "self") {
|
|
finalReportingManager = `${firstName || ""} ${lastName || ""} - (${phone}) - ${city}`;
|
|
finalReportingManagerMobile = phone;
|
|
finalReportingManagerEmail = email;
|
|
}
|
|
|
|
// Create new department
|
|
const department = new Deparments({
|
|
departmentId,
|
|
alternativeContactNumber,
|
|
officeName,
|
|
reportingManager_mobile_number: finalReportingManagerMobile,
|
|
reportingManager_email: finalReportingManagerEmail,
|
|
personal_city,
|
|
gender,
|
|
city,
|
|
firstName,
|
|
lastName,
|
|
email,
|
|
personalEmail,
|
|
reportingManager: finalReportingManager,
|
|
departmentName,
|
|
phone,
|
|
address1,
|
|
address2,
|
|
services: { password: { bcrypt: hashedPassword } },
|
|
state,
|
|
zone,
|
|
country,
|
|
pincode,
|
|
desginationName,
|
|
location,
|
|
picture,
|
|
dateOfJoin,
|
|
employeeType,
|
|
createdBy,
|
|
updatedBy,
|
|
});
|
|
|
|
await department.save();
|
|
|
|
reply.send({ department, message: "Account Created Successfully" });
|
|
} catch (err) {
|
|
console.error("❌ Error in addDepartment:", err);
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getDetails = async (request, reply) => {
|
|
try {
|
|
const { id } = request.params;
|
|
let data;
|
|
|
|
if (id.startsWith('AWBR')) {
|
|
data = await Branch.findOne({ branchId: id });
|
|
} else {
|
|
data = await City.findOne({ cityId: id });
|
|
}
|
|
|
|
if (!data) {
|
|
return reply.status(404).send({ message: 'Not found' });
|
|
}
|
|
|
|
reply.send({ data });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
exports.getCityDetails = async (request, reply) => {
|
|
try {
|
|
const cityId = request.params.cityId;
|
|
const data = await City.findOne({ cityId });
|
|
if (!data) {
|
|
return reply.status(404).send({ message: 'City not found' });
|
|
}
|
|
reply.send({ data });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
exports.getBranchDetails = async (request, reply) => {
|
|
try {
|
|
const branchId = request.params.branchId;
|
|
const data = await Branch.findOne({ branchId });
|
|
if (!data) {
|
|
return reply.status(404).send({ message: 'Branch not found' });
|
|
}
|
|
reply.send({ data });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
exports.getSinledepartmentData = async (req, reply) => {
|
|
try {
|
|
const { departmentId } = req.params;
|
|
|
|
const department = await Deparments.findOne({ departmentId: departmentId });
|
|
|
|
if (!department) {
|
|
return reply.code(404).send({
|
|
success: false,
|
|
message: 'Department not found.'
|
|
});
|
|
}
|
|
|
|
reply.code(200).send({
|
|
success: true,
|
|
message: 'Designation data retrieved successfully.',
|
|
data: department
|
|
});
|
|
} catch (error) {
|
|
console.error('Error fetching department data:', error);
|
|
reply.code(500).send({
|
|
success: false,
|
|
message: 'Failed to retrieve department data.',
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
exports.getalldepartments = async (req, reply) => {
|
|
try {
|
|
await Deparments.find()
|
|
.exec()
|
|
.then((docs) => {
|
|
reply.send({ status_code: 200, data: docs, count: docs.length });
|
|
})
|
|
.catch((err) => {
|
|
console.log(err);
|
|
reply.send({ error: err });
|
|
});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.getallCitiesData = async (req, reply) => {
|
|
try {
|
|
console.log("Fetching all cities..."); // Debug log
|
|
const cities = await City.distinct('city'); // Fetch distinct city names from the database
|
|
|
|
// Normalize the city names to avoid duplicates
|
|
const normalizedCities = [...new Set(cities.map(city => city.trim().toUpperCase()))];
|
|
|
|
console.log("Cities fetched:", normalizedCities); // Log the cleaned cities
|
|
reply.send({ status_code: 200, data: normalizedCities, count: normalizedCities.length });
|
|
} catch (err) {
|
|
console.error("Error fetching cities:", err); // Log the error for debugging
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.getallZonesData = async (req, reply) => {
|
|
try {
|
|
console.log("Fetching all zones..."); // Debug log
|
|
const zones = await City.distinct('zone'); // Fetch distinct zone names from the database
|
|
|
|
// Normalize the zone names to avoid duplicates
|
|
const normalizedZones = [...new Set(zones.map(zone => zone.trim().toUpperCase()))];
|
|
|
|
console.log("Zones fetched:", normalizedZones); // Log the cleaned zones
|
|
reply.send({ status_code: 200, data: normalizedZones, count: normalizedZones.length });
|
|
} catch (err) {
|
|
console.error("Error fetching zones:", err); // Log the error for debugging
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
exports.getallLocationData = async (req, reply) => {
|
|
try {
|
|
console.log("Fetching all locations..."); // Debug log
|
|
const locations = await City.distinct('location'); // Fetch distinct locations from the database
|
|
|
|
// Normalize the location names to uppercase and remove duplicates
|
|
const normalizedLocations = [...new Set(locations.map(location => location.trim().toUpperCase()))];
|
|
|
|
console.log("Locations fetched:", normalizedLocations); // Log the cleaned locations
|
|
reply.send({ status_code: 200, data: normalizedLocations, count: normalizedLocations.length });
|
|
} catch (err) {
|
|
console.error("Error fetching locations:", err); // Log the error for debugging
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.deletedepartmentInfo = async (req, reply) => {
|
|
try {
|
|
const departmentId = req.params.departmentId;
|
|
|
|
const department = await Deparments.findOneAndDelete({ departmentId:departmentId });
|
|
|
|
reply.send({ status_code: 200, message: 'Delete Sucessfully', department});
|
|
} catch (err) {
|
|
throw boom.boomify(err);
|
|
}
|
|
};
|
|
|
|
|
|
exports.editdepartment = async (request, reply) => {
|
|
try {
|
|
const { departmentId } = request.params;
|
|
const {
|
|
phone,
|
|
alternativeContactNumber,
|
|
gender,
|
|
personalEmail,
|
|
city,
|
|
firstName,
|
|
lastName,
|
|
email,
|
|
reportingManager,
|
|
departmentName,
|
|
state,
|
|
country,
|
|
zone,
|
|
address1,
|
|
address2,
|
|
pincode,
|
|
desginationName,
|
|
personal_city,
|
|
reportingManager_mobile_number,
|
|
reportingManager_email,
|
|
officeName,
|
|
picture,
|
|
employeeType
|
|
} = request.body;
|
|
|
|
const existing = await Deparments.findOne({ departmentId });
|
|
if (!existing) {
|
|
return reply.status(404).send({ message: "Department not found" });
|
|
}
|
|
|
|
const phoneExists = await Deparments.findOne({
|
|
phone,
|
|
departmentId: { $ne: departmentId },
|
|
});
|
|
if (phoneExists) {
|
|
return reply
|
|
.status(400)
|
|
.send({ message: "Phone is already registered to another user" });
|
|
}
|
|
|
|
// 🟢 Handle reportingManager "Self"
|
|
let finalReportingManager = reportingManager || existing.reportingManager;
|
|
let finalReportingManagerMobile =
|
|
reportingManager_mobile_number || existing.reportingManager_mobile_number;
|
|
let finalReportingManagerEmail =
|
|
reportingManager_email || existing.reportingManager_email;
|
|
|
|
if (reportingManager?.toLowerCase() === "self") {
|
|
finalReportingManager = `${firstName || existing.firstName || ""} ${
|
|
lastName || existing.lastName || ""
|
|
} - (${phone || existing.phone}) - ${city || existing.city}`;
|
|
finalReportingManagerMobile = phone || existing.phone;
|
|
finalReportingManagerEmail = email || existing.email;
|
|
}
|
|
|
|
// 🔹 Update fields
|
|
existing.phone = phone || existing.phone;
|
|
existing.alternativeContactNumber =
|
|
alternativeContactNumber || existing.alternativeContactNumber;
|
|
existing.personalEmail = personalEmail || existing.personalEmail;
|
|
existing.gender = gender || existing.gender;
|
|
existing.city = city || existing.city;
|
|
existing.state = state || existing.state;
|
|
existing.country = country || existing.country;
|
|
existing.zone = zone || existing.zone;
|
|
existing.desginationName = desginationName || existing.desginationName;
|
|
existing.pincode = pincode || existing.pincode;
|
|
existing.address1 = address1 || existing.address1;
|
|
existing.address2 = address2 || existing.address2;
|
|
existing.email = email || existing.email;
|
|
existing.firstName = firstName || existing.firstName;
|
|
existing.lastName = lastName || existing.lastName;
|
|
existing.departmentName = departmentName || existing.departmentName;
|
|
existing.personal_city = personal_city || existing.personal_city;
|
|
existing.officeName = officeName || existing.officeName;
|
|
existing.picture = picture || existing.picture;
|
|
existing.employeeType = employeeType || existing.employeeType;
|
|
|
|
// 🔹 Assign formatted reportingManager
|
|
existing.reportingManager = finalReportingManager;
|
|
existing.reportingManager_mobile_number = finalReportingManagerMobile;
|
|
existing.reportingManager_email = finalReportingManagerEmail;
|
|
|
|
await existing.save();
|
|
|
|
reply.send({ message: "Department user updated successfully" });
|
|
} catch (err) {
|
|
console.error("❌ Error in editdepartment:", err);
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
const getLocationsByCityZoneOffice = async (city, zone, officeName) => {
|
|
try {
|
|
// Build matchCondition dynamically
|
|
const matchCondition = {};
|
|
|
|
// City filter
|
|
if (city.trim().toUpperCase() !== "ALL") {
|
|
matchCondition.city = { $regex: `^${city.trim().toLowerCase()}$`, $options: "i" };
|
|
}
|
|
|
|
// Zone filter
|
|
if (zone.trim().toUpperCase() !== "ALL") {
|
|
matchCondition.zone = zone.trim();
|
|
}
|
|
|
|
// Office name filter
|
|
if (officeName && officeName.trim().toUpperCase() !== "ALL") {
|
|
matchCondition.officeName = { $regex: `^${officeName.trim()}$`, $options: "i" };
|
|
}
|
|
|
|
const result = await Zone.aggregate([
|
|
{
|
|
$project: {
|
|
city: { $toLower: { $trim: { input: "$city" } } },
|
|
zone: { $trim: { input: "$zone" } },
|
|
officeName: { $trim: { input: "$officeName" } },
|
|
location: 1
|
|
}
|
|
},
|
|
{ $match: matchCondition },
|
|
{
|
|
$group: {
|
|
_id: {
|
|
city: "$city",
|
|
officeName: "$officeName"
|
|
},
|
|
locations: { $push: "$location" }
|
|
}
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
city: "$_id.city",
|
|
officeName: "$_id.officeName",
|
|
locations: {
|
|
$reduce: {
|
|
input: "$locations",
|
|
initialValue: [],
|
|
in: { $concatArrays: ["$$value", "$$this"] }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
]);
|
|
|
|
if (result.length) {
|
|
// Flatten all locations from all offices if city/zone are ALL
|
|
let allLocations = [...new Set(result.flatMap(r => r.locations))];
|
|
|
|
// Ensure "ALL" at the top
|
|
if (!allLocations.includes("ALL")) {
|
|
allLocations.unshift("ALL");
|
|
}
|
|
|
|
return {
|
|
city: city.trim().toUpperCase(),
|
|
officeName: officeName ? officeName.trim().toUpperCase() : "ALL",
|
|
locations: allLocations
|
|
};
|
|
} else {
|
|
return {
|
|
city: city.trim().toUpperCase(),
|
|
officeName: officeName ? officeName.trim().toUpperCase() : "ALL",
|
|
locations: ["ALL"]
|
|
};
|
|
}
|
|
} catch (err) {
|
|
console.error(err);
|
|
throw new Error("Error fetching locations.");
|
|
}
|
|
};
|
|
|
|
exports.getZonebasedLocations = async (req, reply) => {
|
|
try {
|
|
const { city, zone, officeName } = req.query;
|
|
console.log("Received City:", `"${city}"`, "Zone:", `"${zone}"`, "Office:", `"${officeName}"`);
|
|
|
|
if (!city || !zone) {
|
|
return reply.status(400).send({ message: "City and zone are required." });
|
|
}
|
|
|
|
const locations = await getLocationsByCityZoneOffice(
|
|
city.trim(),
|
|
zone.trim(),
|
|
officeName ? officeName.trim() : "ALL"
|
|
);
|
|
|
|
if (!locations) {
|
|
return reply.send({ status_code: 404, message: "No data found." });
|
|
}
|
|
|
|
reply.send({ status_code: 200, data: locations });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
const getLocationsByZone = async (zone) => {
|
|
try {
|
|
const result = await City.aggregate([
|
|
{
|
|
$match: {
|
|
zone: { $regex: `^${zone}$`, $options: "i" }, // Case-insensitive match for the zone
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$location" // Unwind the location field if it is an array
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$zone", // Group by zone
|
|
locations: {
|
|
$addToSet: {
|
|
$toUpper: { $trim: { input: "$location" } } // Convert to uppercase and trim whitespace
|
|
}
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0, // Exclude the _id field
|
|
zone: "$_id", // Include zone
|
|
locations: 1 // Return locations
|
|
},
|
|
},
|
|
]);
|
|
|
|
return result;
|
|
} catch (err) {
|
|
console.error(err);
|
|
throw new Error("Error fetching locations.");
|
|
}
|
|
};
|
|
|
|
|
|
|
|
exports.getLocationsByZone = async (req, reply) => {
|
|
try {
|
|
const { zone } = req.params; // Get zone from path params
|
|
|
|
if (!zone) {
|
|
return reply.status(400).send({ message: "Zone is required." });
|
|
}
|
|
|
|
const locations = await getLocationsByZone(zone);
|
|
reply.send({ status_code: 200, data: locations });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
const getZonesByCityAndOffice = async (city, officeName) => {
|
|
try {
|
|
const result = await Zone.aggregate([
|
|
{
|
|
$project: {
|
|
city: { $trim: { input: "$city" } }, // Trim city
|
|
officeName: { $trim: { input: "$officeName" } }, // Trim officeName
|
|
zone: 1
|
|
}
|
|
},
|
|
{
|
|
$match: {
|
|
...(city && city !== "ALL" ? { city: { $regex: `^${city.trim()}$`, $options: "i" } } : {}),
|
|
...(officeName && officeName !== "ALL" ? { officeName: { $regex: `^${officeName.trim()}$`, $options: "i" } } : {})
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: {
|
|
city: { $toUpper: "$city" },
|
|
officeName: { $toUpper: "$officeName" }
|
|
},
|
|
zones: { $addToSet: "$zone" }
|
|
}
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
city: "$_id.city",
|
|
officeName: "$_id.officeName",
|
|
zones: 1
|
|
}
|
|
}
|
|
]);
|
|
|
|
// Add "ALL" to zones and sort
|
|
result.forEach(item => {
|
|
item.zones = ["ALL", ...new Set(item.zones)].sort((a, b) =>
|
|
a === "ALL" ? -1 : b.localeCompare(a)
|
|
);
|
|
});
|
|
|
|
|
|
return result;
|
|
} catch (err) {
|
|
console.error("Error fetching zones:", err);
|
|
throw new Error("Error fetching zones.");
|
|
}
|
|
};
|
|
|
|
exports.getZonesByCityAndOffice = async (req, reply) => {
|
|
try {
|
|
const { city, officeName } = req.params;
|
|
|
|
if (!city || city.trim() === "" || !officeName || officeName.trim() === "") {
|
|
return reply.status(400).send({ message: "City and Office Name are required." });
|
|
}
|
|
|
|
const zones = await getZonesByCityAndOffice(city.trim(), officeName.trim());
|
|
|
|
if (zones.length === 0) {
|
|
return reply.status(404).send({ message: "No zones found for the specified city and office." });
|
|
}
|
|
|
|
reply.send({ status_code: 200, data: zones });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
const getAreasByCitys = async (city) => {
|
|
try {
|
|
const result = await Zone.aggregate([
|
|
{
|
|
$project: {
|
|
city: { $trim: { input: "$city" } }, // Trim city field in DB
|
|
area: 1 // Keep zone field
|
|
}
|
|
},
|
|
{
|
|
$match: {
|
|
city: { $regex: `^${city.trim()}$`, $options: "i" }, // Trim & case-insensitive
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: { $toUpper: "$city" }, // Normalize city name
|
|
areas: { $addToSet: "$area" } // Collect unique zones
|
|
}
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0, // Exclude _id
|
|
city: "$_id", // Return city name
|
|
areas: 1 // Return collected zones
|
|
}
|
|
}
|
|
]);
|
|
|
|
// Add "ALL" to the zones array and sort it
|
|
result.forEach(item => {
|
|
item.areas = ["ALL", ...new Set(item.areas)].sort((a, b) => (a === "ALL" ? -1 : a - b));
|
|
});
|
|
|
|
return result;
|
|
} catch (err) {
|
|
console.error("Error fetching areas:", err);
|
|
throw new Error("Error fetching areas.");
|
|
}
|
|
};
|
|
exports.getAreasByCity = async (req, reply) => {
|
|
try {
|
|
const { city } = req.params;
|
|
|
|
if (!city || city.trim() === "") {
|
|
return reply.status(400).send({ message: "City is required." });
|
|
}
|
|
|
|
const zones = await getAreasByCitys(city.trim()); // Trim input
|
|
|
|
if (zones.length === 0) {
|
|
return reply.status(404).send({ message: "No zones found for the specified city." });
|
|
}
|
|
|
|
reply.send({ status_code: 200, data: zones });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
const getZonesByArea = async (area) => {
|
|
try {
|
|
const result = await Zone.aggregate([
|
|
{
|
|
$project: {
|
|
area: { $trim: { input: "$area" } }, // Trim area field in DB
|
|
zone: 1 // Keep zone field
|
|
}
|
|
},
|
|
{
|
|
$match: {
|
|
area: { $regex: `^${area.trim()}$`, $options: "i" } // Case-insensitive match on area
|
|
}
|
|
},
|
|
{
|
|
$group: {
|
|
_id: { $toUpper: "$area" }, // Normalize area name
|
|
zones: { $addToSet: "$zone" } // Collect unique zones
|
|
}
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0, // Exclude _id
|
|
area: "$_id",
|
|
zones: 1 // Return collected zones
|
|
}
|
|
}
|
|
]);
|
|
|
|
// ✅ Correct sorting: "ALL" first, then other zones in ascending order
|
|
result.forEach(item => {
|
|
item.zones = ["ALL", ...item.zones.filter(z => z !== "ALL").sort((a, b) => a.localeCompare(b))];
|
|
});
|
|
|
|
return result;
|
|
} catch (err) {
|
|
console.error("Error fetching zones:", err);
|
|
throw new Error("Error fetching zones.");
|
|
}
|
|
};
|
|
|
|
|
|
// Fastify route handler to get zones based on area only
|
|
exports.getZonesByArea = async (req, reply) => {
|
|
try {
|
|
const { area } = req.params;
|
|
|
|
if (!area || area.trim() === "") {
|
|
return reply.status(400).send({ message: "Area is required." });
|
|
}
|
|
|
|
const zones = await getZonesByArea(area.trim());
|
|
|
|
if (zones.length === 0) {
|
|
return reply.status(404).send({ message: "No zones found for the specified area." });
|
|
}
|
|
|
|
reply.send({ status_code: 200, data: zones });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
exports.getDepartments = async (req, reply) => {
|
|
try {
|
|
console.log("Request Params:", req.params);
|
|
|
|
let { departmentName, city, officeName, employeeType } = req.params;
|
|
|
|
if (!departmentName || !city || !officeName || !employeeType) {
|
|
return reply.status(400).send({
|
|
message: "Department Name, City, Office Name, and Employee Type are required.",
|
|
});
|
|
}
|
|
|
|
const departments = await getDepartmentsByName(officeName, city, departmentName, employeeType);
|
|
|
|
if (departments.length === 0) {
|
|
return reply.status(404).send({
|
|
message: "No departments found for the specified parameters.",
|
|
});
|
|
}
|
|
|
|
reply.send({ status_code: 200, data: departments });
|
|
} catch (err) {
|
|
console.error("API Error:", err);
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
const getDepartmentsByName = async (officeName, city, departmentName, employeeType) => {
|
|
try {
|
|
const query = {};
|
|
|
|
if (officeName && officeName.trim().toUpperCase() !== "ALL") {
|
|
query.officeName = { $regex: officeName.trim(), $options: "i" };
|
|
}
|
|
|
|
if (city && city.trim().toUpperCase() !== "ALL") {
|
|
query.city = { $regex: city.trim(), $options: "i" };
|
|
}
|
|
|
|
if (departmentName && departmentName.trim().toUpperCase() !== "ALL") {
|
|
query.departmentName = { $regex: departmentName.trim(), $options: "i" };
|
|
}
|
|
|
|
if (employeeType && employeeType.trim().toUpperCase() !== "ALL") {
|
|
query.employeeType = { $regex: `^${employeeType.trim()}$`, $options: "i" };
|
|
}
|
|
|
|
console.log("MongoDB Query:", JSON.stringify(query, null, 2));
|
|
|
|
const result = await Deparments.find(query).lean();
|
|
console.log("Query Result:", result);
|
|
|
|
return result;
|
|
} catch (err) {
|
|
console.error("Error fetching department data:", err);
|
|
throw new Error("Error fetching department data.");
|
|
}
|
|
};
|
|
|
|
|
|
const getDepartmentNames = async () => {
|
|
try {
|
|
const result = await Deparments.aggregate([
|
|
{
|
|
$group: {
|
|
_id: {
|
|
$toUpper: { $trim: { input: "$departmentName" } }, // Convert to uppercase & trim spaces
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$sort: { _id: 1 } // Sort alphabetically
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
departmentNames: { $addToSet: "$_id" } // Collect unique values in an array
|
|
}
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
departmentNames: 1 // Return only the array
|
|
},
|
|
}
|
|
]);
|
|
|
|
return result.length > 0 ? result[0].departmentNames : []; // Return an empty array if no data
|
|
} catch (err) {
|
|
console.error(err);
|
|
throw new Error("Error fetching department names.");
|
|
}
|
|
};
|
|
|
|
// API Route
|
|
exports.getAllDepartmentNames = async (req, reply) => {
|
|
try {
|
|
const departments = await getDepartmentNames();
|
|
reply.send({ status_code: 200, data: departments });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getCitiesByOfficeName = async (req, reply) => {
|
|
try {
|
|
let { officeName } = req.params;
|
|
|
|
if (!officeName) {
|
|
return reply.code(400).send({ error: "officeName is required" });
|
|
}
|
|
|
|
// Split by comma and normalize names
|
|
let officeNames = officeName.split(',').map(name =>
|
|
name.trim().replace(/\s+/g, ' ')
|
|
);
|
|
|
|
// Handle "All" — fetch all cities from both collections
|
|
if (officeNames.includes('All')) {
|
|
const allCityDocs = await City.find().select("city -_id").lean();
|
|
const allBranchDocs = await Branch.find().select("city -_id").lean();
|
|
|
|
const allCities = [...new Set([
|
|
...allCityDocs.map(doc => doc.city),
|
|
...allBranchDocs.map(doc => doc.city),
|
|
])];
|
|
|
|
allCities.unshift("ALL"); // ✅ Add "ALL" at the beginning
|
|
|
|
return reply.send({ status_code: 200, data: allCities });
|
|
}
|
|
|
|
// Build regex conditions for each office name
|
|
const regexConditions = officeNames.map(name => ({
|
|
officeName: { $regex: new RegExp(name.replace(/\s+/g, '\\s*'), 'i') }
|
|
}));
|
|
|
|
// Query both collections
|
|
const cityResults = await City.find({ $or: regexConditions }).select("city -_id").lean();
|
|
const branchResults = await Branch.find({ $or: regexConditions }).select("city -_id").lean();
|
|
|
|
// Extract and merge unique city names
|
|
const cityNames = [...new Set([
|
|
...cityResults.map(c => c.city),
|
|
...branchResults.map(b => b.city)
|
|
])];
|
|
|
|
cityNames.unshift("ALL"); // ✅ Add "ALL" at the beginning
|
|
|
|
reply.send({ status_code: 200, data: cityNames });
|
|
} catch (err) {
|
|
console.error("Error fetching cities:", err);
|
|
reply.send({ error: err.message });
|
|
}
|
|
};
|
|
|
|
// Helper function to fetch department names by city
|
|
const getDepartmentNamesByCity = async (city) => {
|
|
try {
|
|
const trimmedCity = city.trim();
|
|
|
|
const query = {
|
|
$or: [
|
|
{ city: { $regex: `^\\s*${trimmedCity}\\s*$`, $options: "i" } },
|
|
// { officeName: { $regex: `^\\s*${trimmedCity}\\s*$`, $options: "i" } }
|
|
]
|
|
};
|
|
|
|
console.log("MongoDB Query:", JSON.stringify(query, null, 2));
|
|
|
|
const result = await Deparments.find(query)
|
|
.select("departmentName -_id")
|
|
.lean();
|
|
|
|
// Remove duplicate department names
|
|
return [...new Set(result.map(doc => doc.departmentName))];
|
|
} catch (error) {
|
|
console.error("Error fetching departments by city or officeName:", error);
|
|
throw new Error("Error fetching departments by city or officeName.");
|
|
}
|
|
};
|
|
|
|
exports.getOffices = async (req, reply) => {
|
|
try {
|
|
let { officeName, city } = req.params;
|
|
|
|
const filter = {};
|
|
|
|
// Apply officeName filter only if not ALL
|
|
if (officeName && officeName.toUpperCase() !== 'ALL') {
|
|
const officeNames = officeName.split(',').map(name =>
|
|
new RegExp(name.trim().replace(/\s+/g, '\\s*'), 'i') // fuzzy match
|
|
);
|
|
filter.officeName = { $in: officeNames };
|
|
}
|
|
|
|
// Apply city filter only if not ALL
|
|
if (city && city.toUpperCase() !== 'ALL') {
|
|
const cities = city.split(',').map(name =>
|
|
new RegExp(name.trim().replace(/\s+/g, '\\s*'), 'i')
|
|
);
|
|
filter.city = { $in: cities };
|
|
}
|
|
|
|
console.log("Filter being applied:", filter);
|
|
|
|
// Fetch offices from DB
|
|
const offices = await Deparments.find(filter).lean();
|
|
|
|
// Extract unique department names
|
|
let departmentNames = [...new Set(offices.map(o => o.departmentName))];
|
|
|
|
// Always include "ALL" at the start of the list
|
|
departmentNames = ['ALL', ...departmentNames];
|
|
|
|
reply.send({
|
|
status_code: 200,
|
|
message: "Fetched successfully",
|
|
data: departmentNames,
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error("Error in getOffices:", error);
|
|
reply.code(500).send({
|
|
status_code: 500,
|
|
message: "Internal server error",
|
|
error: error.message,
|
|
});
|
|
}
|
|
};
|
|
|
|
exports.getDepartmentsByCity = async (req, reply) => {
|
|
try {
|
|
const { city } = req.params;
|
|
if (!city || city.trim() === "") {
|
|
return reply.status(400).send({ message: "City is required." });
|
|
}
|
|
|
|
const departmentNames = await getDepartmentNamesByCity(city);
|
|
|
|
if (departmentNames.length === 0) {
|
|
return reply.status(404).send({ message: "No departments found for the specified city." });
|
|
}
|
|
|
|
reply.send({ status_code: 200, data: departmentNames });
|
|
} catch (error) {
|
|
console.error("API Error:", error);
|
|
reply.status(500).send({ message: error.message });
|
|
}
|
|
};
|
|
|
|
|
|
|
|
exports.getAllStates = async (req, reply) => {
|
|
try {
|
|
const states = await IndianLocations.find({}, "state").sort({ state: 1 }); // Sorting A to Z
|
|
reply.send(states);
|
|
} catch (err) {
|
|
reply.status(500).send({ error: "Failed to fetch states" });
|
|
}
|
|
};
|
|
|
|
exports.getAllCities = async (req, reply) => {
|
|
try {
|
|
// Fetch only the majorCities field from all documents
|
|
const docs = await IndianLocations.find({}, "majorCities").lean();
|
|
|
|
// Flatten the array of arrays and remove duplicates
|
|
const cities = [...new Set(docs.flatMap(doc => doc.majorCities))];
|
|
|
|
// Sort alphabetically (case-insensitive)
|
|
cities.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
|
|
|
|
reply.send(cities);
|
|
|
|
} catch (err) {
|
|
console.error("Error fetching cities:", err);
|
|
reply.status(500).send({ error: "Failed to fetch cities" });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getStaeBasedCites = async (request, reply) => {
|
|
try {
|
|
const { stateName } = request.params;
|
|
const state = await IndianLocations.findOne({ state: stateName }, "majorCities");
|
|
|
|
if (!state) {
|
|
return reply.status(404).send({ error: "State not found" });
|
|
}
|
|
|
|
reply.send(state.majorCities);
|
|
} catch (err) {
|
|
reply.status(500).send({ error: "Failed to fetch cities" });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getCitiesBasedState = async (request, reply) => {
|
|
try {
|
|
// Match the param name from the route exactly
|
|
const { majorcities } = request.params;
|
|
|
|
if (!majorcities) {
|
|
return reply.status(400).send({ error: "majorcities param is required" });
|
|
}
|
|
|
|
// Case-insensitive regex match against elements in the array
|
|
const stateDoc = await IndianLocations.findOne(
|
|
{ majorCities: { $regex: new RegExp(`^${majorcities.trim()}$`, "i") } },
|
|
"state"
|
|
).lean();
|
|
|
|
if (!stateDoc) {
|
|
return reply.status(404).send({ error: "City not found" });
|
|
}
|
|
|
|
reply.send({ state: stateDoc.state });
|
|
|
|
} catch (err) {
|
|
console.error("Error fetching state:", err);
|
|
reply.status(500).send({ error: "Failed to fetch state" });
|
|
}
|
|
};
|
|
|
|
|
|
exports.getStaffDepartmentDetails = async (request, reply) => {
|
|
try {
|
|
const { officeName, city } = request.params;
|
|
|
|
const department = await Deparments.find({
|
|
officeName: { $regex: officeName.trim(), $options: "i" }, // no ^$ anchors
|
|
city: { $regex: city.trim(), $options: "i" }
|
|
});
|
|
|
|
if (!department.length) {
|
|
return reply.status(404).send({ message: "Department not found" });
|
|
}
|
|
|
|
reply.send({ department });
|
|
} catch (err) {
|
|
reply.status(500).send({ message: err.message });
|
|
}
|
|
};
|
|
|
|
|
|
exports.updateBranchOrCompanyDetails = async (request, reply) => {
|
|
try {
|
|
const { id } = request.params;
|
|
const updateData = request.body;
|
|
let updatedDoc;
|
|
|
|
if (id.startsWith("AWBR")) {
|
|
// Find existing Branch before update
|
|
const existing = await Branch.findOne({ branchId: id });
|
|
|
|
updatedDoc = await Branch.findOneAndUpdate(
|
|
{ branchId: id },
|
|
{ ...updateData, updatedAt: new Date() },
|
|
{ new: true }
|
|
);
|
|
|
|
// 🔄 Cascade update to Department employees if city/officeName changed
|
|
if (updatedDoc && existing) {
|
|
if (
|
|
(updateData.city && updateData.city !== existing.city) ||
|
|
(updateData.officeName && updateData.officeName !== existing.officeName)
|
|
) {
|
|
await Deparments.updateMany(
|
|
{ officeName: existing.officeName, city: existing.city },
|
|
{
|
|
$set: {
|
|
city: updateData.city || existing.city,
|
|
officeName: updateData.officeName || existing.officeName,
|
|
},
|
|
}
|
|
);
|
|
}
|
|
}
|
|
} else if (id.startsWith("AWCI")) {
|
|
// Find existing City before update
|
|
const existing = await City.findOne({ cityId: id });
|
|
|
|
updatedDoc = await City.findOneAndUpdate(
|
|
{ cityId: id },
|
|
{ ...updateData, updatedAt: new Date() },
|
|
{ new: true }
|
|
);
|
|
|
|
// 🔄 Cascade update to Department employees if city/officeName changed
|
|
if (updatedDoc && existing) {
|
|
if (
|
|
(updateData.city && updateData.city !== existing.city) ||
|
|
(updateData.officeName && updateData.officeName !== existing.officeName)
|
|
) {
|
|
await Deparments.updateMany(
|
|
{ officeName: existing.officeName, city: existing.city },
|
|
{
|
|
$set: {
|
|
city: updateData.city || existing.city,
|
|
officeName: updateData.officeName || existing.officeName,
|
|
},
|
|
}
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
return reply.code(400).send({ error: "Invalid ID format" });
|
|
}
|
|
|
|
if (!updatedDoc) {
|
|
return reply.code(404).send({ message: "Record not found" });
|
|
}
|
|
|
|
return reply.send({
|
|
message: "Details updated successfully",
|
|
data: updatedDoc,
|
|
});
|
|
} catch (err) {
|
|
request.log.error(err);
|
|
return reply
|
|
.code(500)
|
|
.send({ error: "Failed to update details", details: err.message });
|
|
}
|
|
};
|