@iservice365/module-hygiene 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,2 +1,4682 @@
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MArea: () => MArea,
+  MAreaChecklist: () => MAreaChecklist,
+  MParentChecklist: () => MParentChecklist,
+  MScheduleTaskArea: () => MScheduleTaskArea,
+  MToiletLocation: () => MToiletLocation,
+  MUnit: () => MUnit,
+  MUnitChecklist: () => MUnitChecklist,
+  allowedStatus: () => allowedStatus,
+  allowedTypes: () => allowedTypes,
+  areaChecklistSchema: () => areaChecklistSchema,
+  areaSchema: () => areaSchema,
+  parentChecklistSchema: () => parentChecklistSchema,
+  scheduleTaskAreaSchema: () => scheduleTaskAreaSchema,
+  toiletLocationSchema: () => toiletLocationSchema,
+  unitChecklistSchema: () => unitChecklistSchema,
+  unitSchema: () => unitSchema,
+  useAreaChecklistController: () => useAreaChecklistController,
+  useAreaChecklistRepo: () => useAreaChecklistRepo,
+  useAreaController: () => useAreaController,
+  useAreaRepository: () => useAreaRepository,
+  useAreaService: () => useAreaService,
+  useParentChecklistController: () => useParentChecklistController,
+  useParentChecklistRepo: () => useParentChecklistRepo,
+  useScheduleTaskAreaController: () => useScheduleTaskAreaController,
+  useScheduleTaskAreaRepository: () => useScheduleTaskAreaRepository,
+  useScheduleTaskAreaService: () => useScheduleTaskAreaService,
+  useToiletLocationController: () => useToiletLocationController,
+  useToiletLocationRepository: () => useToiletLocationRepository,
+  useToiletLocationService: () => useToiletLocationService,
+  useUnitChecklistController: () => useUnitChecklistController,
+  useUnitChecklistRepo: () => useUnitChecklistRepo,
+  useUnitController: () => useUnitController,
+  useUnitRepository: () => useUnitRepository,
+  useUnitService: () => useUnitService
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/models/hygiene-area.model.ts
+var import_node_server_utils = require("@iservice365/node-server-utils");
+var import_joi = __toESM(require("joi"));
+var import_mongodb = require("mongodb");
+var areaSchema = import_joi.default.object({
+  name: import_joi.default.string().required(),
+  site: import_joi.default.string().hex().required(),
+  createdBy: import_joi.default.string().hex().required(),
+  checklist: import_joi.default.array().items(
+    import_joi.default.object({
+      _id: import_joi.default.string().hex().required(),
+      name: import_joi.default.string().required()
+    })
+  ).optional()
+});
+function MArea(value) {
+  const { error } = areaSchema.validate(value);
+  if (error) {
+    import_node_server_utils.logger.info(`Hygiene Area Model: ${error.message}`);
+    throw new import_node_server_utils.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new import_mongodb.ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new import_node_server_utils.BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((item) => {
+      try {
+        return {
+          ...item,
+          _id: new import_mongodb.ObjectId(item._id)
+        };
+      } catch (error2) {
+        throw new import_node_server_utils.BadRequestError(
+          `Invalid checklist item ID format: ${item._id}`
+        );
+      }
+    });
+  }
+  return {
+    name: value.name,
+    site: value.site,
+    createdBy: value.createdBy,
+    checklist: value.checklist,
+    status: value.status ?? "active",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-area.repository.ts
+var import_mongodb2 = require("mongodb");
+var import_node_server_utils2 = require("@iservice365/node-server-utils");
+function useAreaRepository() {
+  const db = import_node_server_utils2.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils2.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-areas";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils2.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { createdBy: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils2.InternalServerError("Failed to create index on hygiene area.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new import_node_server_utils2.InternalServerError(
+        "Failed to create text index on hygiene area."
+      );
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_node_server_utils2.InternalServerError(
+        "Failed to create unique index on hygiene area."
+      );
+    }
+  }
+  async function createArea(value, session) {
+    try {
+      value = MArea(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils2.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils2.BadRequestError("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function getAreas({
+    page = 1,
+    limit = 10,
+    search = "",
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    if (site) {
+      try {
+        site = new import_mongodb2.ObjectId(site);
+        cacheOptions.site = site.toString();
+      } catch (error) {
+        throw new import_node_server_utils2.BadRequestError("Invalid site ID format.");
+      }
+    }
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    if (startDate && endDate) {
+      query.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    } else if (startDate) {
+      query.createdAt = { $gte: new Date(startDate) };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+    } else if (endDate) {
+      query.createdAt = { $lte: new Date(endDate) };
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    }
+    const cacheKey = (0, import_node_server_utils2.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils2.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils2.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils2.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAreaById(_id) {
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = (0, import_node_server_utils2.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils2.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            name: 1,
+            checklist: 1
+          }
+        }
+      ]).toArray();
+      if (!data || !data.length) {
+        throw new import_node_server_utils2.NotFoundError("Area not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        import_node_server_utils2.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAreaByName(name, site) {
+    try {
+      if (site)
+        site = new import_mongodb2.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Unable to fetch area by name.");
+    }
+  }
+  async function updateArea(_id, value) {
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils2.InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils2.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils2.BadRequestError("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function updateAreaChecklist(_id, value) {
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
+    }
+    if (value.checklist && Array.isArray(value.checklist)) {
+      value.checklist = value.checklist.map((item) => {
+        try {
+          return {
+            ...item,
+            _id: new import_mongodb2.ObjectId(item._id)
+          };
+        } catch (error) {
+          throw new import_node_server_utils2.BadRequestError(
+            `Invalid checklist item ID format: ${item._id}`
+          );
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils2.InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils2.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function deleteArea(_id, session) {
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils2.InternalServerError("Unable to delete area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils2.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    createArea,
+    getAreas,
+    getAreaById,
+    getAreaByName,
+    updateArea,
+    updateAreaChecklist,
+    deleteArea
+  };
+}
+
+// src/services/hygiene-area.service.ts
+var import_node_server_utils3 = require("@iservice365/node-server-utils");
+function useAreaService() {
+  const { createArea: _createArea } = useAreaRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new import_node_server_utils3.BadRequestError("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new import_node_server_utils3.NotFoundError("No data found in the uploaded file");
+    }
+    const session = import_node_server_utils3.useAtlas.getClient()?.startSession();
+    const insertedAreaIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.AREA_NAME) {
+          import_node_server_utils3.logger.warn("Skipping row with missing AREA_NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _createArea(
+            {
+              name: String(row.AREA_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedAreaIds.push(insertedId);
+        } catch (error) {
+          import_node_server_utils3.logger.error(
+            `Error creating area "${row.AREA_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      import_node_server_utils3.logger.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
+      return {
+        message: `Successfully uploaded ${insertedAreaIds.length} areas`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      import_node_server_utils3.logger.error("Error while uploading area information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-area.controller.ts
+var import_node_server_utils4 = require("@iservice365/node-server-utils");
+var import_joi2 = __toESM(require("joi"));
+
+// src/utils/convert-excel.util.ts
+var import_stream = require("stream");
+var xlsx = __toESM(require("xlsx"));
+function convertBufferFile(bufferFile) {
+  return new Promise((resolve, reject) => {
+    const fileStream = import_stream.Readable.from(bufferFile);
+    let fileBuffer = Buffer.alloc(0);
+    fileStream.on("data", (chunk) => {
+      fileBuffer = Buffer.concat([fileBuffer, chunk]);
+    });
+    fileStream.on("end", () => {
+      try {
+        const workbook = xlsx.read(fileBuffer, { type: "buffer" });
+        const sheetName = workbook.SheetNames[0];
+        const sheet = workbook.Sheets[sheetName];
+        const jsonData = xlsx.utils.sheet_to_json(sheet);
+        resolve(jsonData);
+      } catch (error) {
+        reject("Error parsing file");
+      }
+    });
+    fileStream.on("error", (err) => {
+      reject("Error Reading File: " + err.message);
+    });
+  });
+}
+
+// src/controllers/hygiene-area.controller.ts
+function useAreaController() {
+  const {
+    createArea: _createArea,
+    getAreas: _getAll,
+    getAreaById: _getAreaById,
+    updateArea: _updateArea,
+    updateAreaChecklist: _updateAreaChecklist,
+    deleteArea: _deleteById
+  } = useAreaRepository();
+  const { uploadByFile: _uploadByFile } = useAreaService();
+  async function createArea(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const { error } = areaSchema.validate(payload);
+    if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createArea(payload);
+      res.status(201).json({ message: "Area created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi2.default.object({
+      page: import_joi2.default.number().min(1).optional().allow("", null),
+      limit: import_joi2.default.number().min(1).optional().allow("", null),
+      search: import_joi2.default.string().optional().allow("", null),
+      startDate: import_joi2.default.alternatives().try(import_joi2.default.date(), import_joi2.default.string()).optional().allow("", null),
+      endDate: import_joi2.default.alternatives().try(import_joi2.default.date(), import_joi2.default.string()).optional().allow("", null),
+      site: import_joi2.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.query.site ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
+    try {
+      const data = await _getAll({
+        page,
+        limit,
+        search,
+        site,
+        startDate,
+        endDate
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  async function getAreaById(req, res, next) {
+    const validation = import_joi2.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAreaById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateArea(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = import_joi2.default.object({
+      id: import_joi2.default.string().hex().required(),
+      name: import_joi2.default.string().required()
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateArea(id, value);
+      res.json({ message: "Area updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateAreaChecklist(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = import_joi2.default.object({
+      id: import_joi2.default.string().hex().required(),
+      checklist: import_joi2.default.array().items(
+        import_joi2.default.object({
+          _id: import_joi2.default.string().hex().required(),
+          name: import_joi2.default.string().required()
+        }).required()
+      ).min(1).unique("_id", { ignoreUndefined: true }).messages({
+        "array.unique": "Duplicate checklist items are not allowed"
+      })
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateAreaChecklist(id, value);
+      res.json({ message: "Area updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function deleteArea(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi2.default.object({
+      id: import_joi2.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _deleteById(id);
+      res.json({ message: "Area deleted successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new import_node_server_utils4.BadRequestError("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = import_joi2.default.object({
+      site: import_joi2.default.string().hex().optional().allow("", null),
+      createdBy: import_joi2.default.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils4.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createArea,
+    getAll,
+    getAreaById,
+    updateArea,
+    updateAreaChecklist,
+    deleteArea,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-toilet-location.model.ts
+var import_node_server_utils5 = require("@iservice365/node-server-utils");
+var import_joi3 = __toESM(require("joi"));
+var import_mongodb3 = require("mongodb");
+var toiletLocationSchema = import_joi3.default.object({
+  name: import_joi3.default.string().required(),
+  site: import_joi3.default.string().hex().required(),
+  createdBy: import_joi3.default.string().hex().required(),
+  checklist: import_joi3.default.array().items(
+    import_joi3.default.object({
+      _id: import_joi3.default.string().hex().required(),
+      name: import_joi3.default.string().required()
+    })
+  ).optional(),
+  updatedAt: import_joi3.default.date().optional().allow("", null),
+  status: import_joi3.default.string().allow("", null).optional()
+});
+function MToiletLocation(value) {
+  const { error } = toiletLocationSchema.validate(value);
+  if (error) {
+    throw new import_node_server_utils5.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb3.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils5.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new import_mongodb3.ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new import_node_server_utils5.BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((item) => {
+      try {
+        return {
+          ...item,
+          _id: new import_mongodb3.ObjectId(item._id)
+        };
+      } catch (error2) {
+        throw new import_node_server_utils5.BadRequestError(
+          `Invalid checklist item ID format: ${item._id}`
+        );
+      }
+    });
+  }
+  return {
+    name: value.name,
+    site: value.site,
+    createdBy: value.createdBy,
+    checklist: value.checklist,
+    status: value.status ?? "",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-toilet-location.repository.ts
+var import_mongodb4 = require("mongodb");
+var import_node_server_utils6 = require("@iservice365/node-server-utils");
+function useToiletLocationRepository() {
+  const db = import_node_server_utils6.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils6.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-toilet-locations";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils6.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { name: "text" } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils6.InternalServerError("Failed to create index on site.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_node_server_utils6.InternalServerError(
+        "Failed to create unique index on hygiene area."
+      );
+    }
+  }
+  async function create(value, session) {
+    try {
+      value = MToiletLocation(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils6.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils6.BadRequestError("Toilet location already exists.");
+      }
+      throw error;
+    }
+  }
+  async function updateToiletLocation(_id, value) {
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
+    }
+    if (value.checklist && Array.isArray(value.checklist)) {
+      value.checklist = value.checklist.map((item) => {
+        try {
+          return {
+            ...item,
+            _id: new import_mongodb4.ObjectId(item._id)
+          };
+        } catch (error) {
+          throw new import_node_server_utils6.BadRequestError(
+            `Invalid checklist item ID format: ${item._id}`
+          );
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils6.InternalServerError("Unable to update toilet location.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils6.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils6.BadRequestError("Toilet location already exists.");
+      }
+      throw error;
+    }
+  }
+  async function deleteToiletLocation(_id, session) {
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils6.InternalServerError("Unable to delete toilet location.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils6.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getToiletLocations({
+    page = 1,
+    limit = 10,
+    search = "",
+    sort = {},
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    let dateFilter = {};
+    try {
+      site = new import_mongodb4.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Invalid site ID format.");
+    }
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      site: site.toString()
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    cacheOptions.sort = JSON.stringify(sort);
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    delNamespace().then(() => {
+      import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+    }).catch((err) => {
+      import_node_server_utils6.logger.error(
+        `Failed to clear cache for namespace: ${namespace_collection}`,
+        err
+      );
+    });
+    const cacheKey = (0, import_node_server_utils6.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils6.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    if (startDate && endDate) {
+      dateFilter = {
+        createdAt: {
+          $gte: new Date(startDate),
+          $lte: new Date(endDate)
+        }
+      };
+    } else if (startDate) {
+      dateFilter = { createdAt: { $gte: new Date(startDate) } };
+    } else if (endDate) {
+      dateFilter = { createdAt: { $lte: new Date(endDate) } };
+    }
+    try {
+      const items = await collection.aggregate([
+        {
+          $match: {
+            ...dateFilter,
+            ...query
+          }
+        },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils6.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils6.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils6.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getToiletLocationByName(name, site) {
+    try {
+      if (site)
+        site = new import_mongodb4.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Unable to fetch toilet location by name.");
+    }
+  }
+  async function updateToiletLocationChecklist(_id, value) {
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
+    }
+    if (value.checklist && Array.isArray(value.checklist)) {
+      value.checklist = value.checklist.map((item) => {
+        try {
+          return {
+            ...item,
+            _id: new import_mongodb4.ObjectId(item._id)
+          };
+        } catch (error) {
+          throw new import_node_server_utils6.BadRequestError(
+            `Invalid checklist item ID format: ${item._id}`
+          );
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils6.InternalServerError("Unable to update toilet location.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils6.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getToiletLocationById(_id) {
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = (0, import_node_server_utils6.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils6.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            name: 1,
+            checklist: 1
+          }
+        }
+      ]).toArray();
+      if (!data || !data.length) {
+        throw new import_node_server_utils6.NotFoundError("Area not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        import_node_server_utils6.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils6.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndexes,
+    createUniqueIndex,
+    getToiletLocations,
+    create,
+    updateToiletLocation,
+    deleteToiletLocation,
+    getToiletLocationByName,
+    getToiletLocationById,
+    updateToiletLocationChecklist
+  };
+}
+
+// src/services/hygiene-toilet-location.service.ts
+var import_node_server_utils7 = require("@iservice365/node-server-utils");
+function useToiletLocationService() {
+  const { create: _createToilet } = useToiletLocationRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new import_node_server_utils7.BadRequestError("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new import_node_server_utils7.NotFoundError("No data found in the uploaded file");
+    }
+    const session = import_node_server_utils7.useAtlas.getClient()?.startSession();
+    const insertedAreaIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.AREA_NAME) {
+          import_node_server_utils7.logger.warn("Skipping row with missing TOILET NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _createToilet(
+            {
+              name: String(row.TOILET_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedAreaIds.push(insertedId);
+        } catch (error) {
+          import_node_server_utils7.logger.error(
+            `Error creating area "${row.AREA_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      import_node_server_utils7.logger.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
+      return {
+        message: `Successfully uploaded ${insertedAreaIds.length} areas`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      import_node_server_utils7.logger.error("Error while uploading area information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-toilet-location.controller.ts
+var import_joi4 = __toESM(require("joi"));
+var import_node_server_utils8 = require("@iservice365/node-server-utils");
+function useToiletLocationController() {
+  const { uploadByFile: _uploadByFile } = useToiletLocationService();
+  const {
+    create: _createToiletLocation,
+    updateToiletLocation: _updateToiletLocation,
+    updateToiletLocationChecklist: _updateToiletLocationChecklist,
+    getToiletLocationById: _getToiletLocationById,
+    getToiletLocations: _getAll,
+    deleteToiletLocation: _deleteById
+  } = useToiletLocationRepository();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi4.default.object({
+      page: import_joi4.default.number().min(1).optional().allow("", null),
+      limit: import_joi4.default.number().min(1).optional().allow("", null),
+      search: import_joi4.default.string().optional().allow("", null),
+      site: import_joi4.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const site = req.query.site ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        site,
+        search
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function createToiletLocation(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const schema = import_joi4.default.object({
+      name: import_joi4.default.string().required(),
+      site: import_joi4.default.string().hex().optional().allow("", null),
+      status: import_joi4.default.string().optional().allow("", null),
+      createdBy: import_joi4.default.string().hex().optional().allow("", null)
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      import_node_server_utils8.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _createToiletLocation(payload);
+      res.status(201).json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateToiletLocation(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = import_joi4.default.object({
+      id: import_joi4.default.string().hex().required(),
+      name: import_joi4.default.string().required(),
+      checklist: import_joi4.default.array().items(
+        import_joi4.default.object({
+          _id: import_joi4.default.string().hex().required(),
+          name: import_joi4.default.string().required()
+        }).optional()
+      ),
+      site: import_joi4.default.string().hex().optional().allow("", null),
+      status: import_joi4.default.string().optional().allow("", null)
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      import_node_server_utils8.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateToiletLocation(id, value);
+      res.status(201).json({ message: "Toilet location updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
+      next(error2);
+    }
+  }
+  async function deleteToiletLocation(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi4.default.object({
+      id: import_joi4.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateToiletLocationChecklist(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = import_joi4.default.object({
+      id: import_joi4.default.string().hex().required(),
+      checklist: import_joi4.default.array().items(
+        import_joi4.default.object({
+          _id: import_joi4.default.string().hex().required(),
+          name: import_joi4.default.string().required()
+        }).required()
+      ).min(1).unique("_id", { ignoreUndefined: true }).messages({
+        "array.unique": "Duplicate checklist items are not allowed"
+      })
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      import_node_server_utils8.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateToiletLocationChecklist(id, value);
+      res.json({ message: "Toilet location updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getToiletLocationById(req, res, next) {
+    const validation = import_joi4.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils8.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getToiletLocationById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new import_node_server_utils8.BadRequestError("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = import_joi4.default.object({
+      site: import_joi4.default.string().hex().optional().allow("", null),
+      createdBy: import_joi4.default.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      import_node_server_utils8.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    getAll,
+    createToiletLocation,
+    updateToiletLocation,
+    deleteToiletLocation,
+    updateToiletLocationChecklist,
+    getToiletLocationById,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-parent-checklist.model.ts
+var import_node_server_utils9 = require("@iservice365/node-server-utils");
+var import_joi5 = __toESM(require("joi"));
+var import_mongodb5 = require("mongodb");
+var allowedTypes = ["cleaner", "toilet"];
+var allowedStatus = [
+  "To Do",
+  "Pending",
+  "In Progress",
+  "Completed",
+  "Expired"
+];
+var parentChecklistSchema = import_joi5.default.object({
+  date: import_joi5.default.date().required(),
+  status: import_joi5.default.array().items(
+    import_joi5.default.object({
+      type: import_joi5.default.string().required().valid(...allowedTypes),
+      site: import_joi5.default.string().hex().required()
+    })
+  ).optional()
+});
+function MParentChecklist(value) {
+  const { error } = parentChecklistSchema.validate(value);
+  if (error) {
+    import_node_server_utils9.logger.info(`Hygiene Parent Checklist Model: ${error.message}`);
+    throw new import_node_server_utils9.BadRequestError(error.message);
+  }
+  if (value.status && Array.isArray(value.status)) {
+    value.status = value.status.map((item) => {
+      try {
+        return {
+          ...item,
+          site: new import_mongodb5.ObjectId(item.site),
+          status: item.status || "To Do",
+          completedAt: item.completedAt || ""
+        };
+      } catch (error2) {
+        throw new import_node_server_utils9.BadRequestError(
+          `Invalid status site ID format: ${item.site}`
+        );
+      }
+    });
+  }
+  return {
+    date: new Date(value.date),
+    status: value.status,
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-parent-checklist.repository.ts
+var import_mongodb6 = require("mongodb");
+var import_node_server_utils10 = require("@iservice365/node-server-utils");
+function useParentChecklistRepo() {
+  const db = import_node_server_utils10.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils10.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-parent-checklist";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils10.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { date: 1 } },
+        { key: { "status.type": 1, "status.site": 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils10.InternalServerError(
+        "Failed to create index on hygiene parent checklist."
+      );
+    }
+  }
+  async function createParentChecklist(value, session) {
+    try {
+      const currentDate = value.date ? new Date(value.date) : /* @__PURE__ */ new Date();
+      const startOfDay = new Date(currentDate);
+      startOfDay.setUTCHours(0, 0, 0, 0);
+      const endOfDay = new Date(currentDate);
+      endOfDay.setUTCHours(23, 59, 59, 999);
+      const existingChecklist = await collection.findOne({
+        date: {
+          $gte: startOfDay,
+          $lte: endOfDay
+        }
+      });
+      if (existingChecklist) {
+        const dateStr2 = currentDate.toISOString().split("T")[0];
+        import_node_server_utils10.logger.info(`Parent checklist already exists for today: ${dateStr2}`);
+        return existingChecklist._id;
+      }
+      const processedValue = MParentChecklist(value);
+      const result = await collection.insertOne(processedValue, { session });
+      delNamespace().then(() => {
+        import_node_server_utils10.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils10.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      const dateStr = currentDate.toISOString().split("T")[0];
+      import_node_server_utils10.logger.info(
+        `Created new parent checklist ${result.insertedId} for today: ${dateStr}`
+      );
+      return result.insertedId;
+    } catch (error) {
+      import_node_server_utils10.logger.error("Failed to create daily parent checklist", error);
+      throw error;
+    }
+  }
+  async function getAllParentChecklist({
+    page = 1,
+    limit = 10,
+    search = "",
+    site,
+    type,
+    startDate = "",
+    endDate = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {};
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      site = new import_mongodb6.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils10.BadRequestError("Invalid site ID format.");
+    }
+    cacheOptions.type = type;
+    query.status = {
+      $elemMatch: {
+        site: new import_mongodb6.ObjectId(site),
+        type
+      }
+    };
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    if (startDate && endDate) {
+      query.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    } else if (startDate) {
+      query.createdAt = { $gte: new Date(startDate) };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+    } else if (endDate) {
+      query.createdAt = { $lte: new Date(endDate) };
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    }
+    const cacheKey = (0, import_node_server_utils10.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils10.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const pipeline = [{ $match: query }];
+      const filterConditions = [];
+      filterConditions.push({ $eq: ["$$this.site", new import_mongodb6.ObjectId(site)] });
+      filterConditions.push({ $eq: ["$$this.type", type] });
+      pipeline.push({
+        $addFields: {
+          filteredStatus: {
+            $filter: {
+              input: "$status",
+              cond: { $and: filterConditions }
+            }
+          }
+        }
+      });
+      pipeline.push({
+        $match: {
+          filteredStatus: { $ne: [] }
+        }
+      });
+      pipeline.push({
+        $addFields: {
+          statusObj: { $arrayElemAt: ["$filteredStatus", 0] }
+        }
+      });
+      pipeline.push({
+        $project: {
+          _id: 1,
+          date: 1,
+          status: "$statusObj.status",
+          completedAt: "$statusObj.completedAt",
+          createdAt: 1
+        }
+      });
+      pipeline.push(
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      );
+      const items = await collection.aggregate(pipeline).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils10.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils10.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils10.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateParentChecklistStatuses(date) {
+    try {
+      const currentDate = /* @__PURE__ */ new Date();
+      const dateToUpdate = date || new Date(currentDate.getTime() - 24 * 60 * 60 * 1e3);
+      const startOfDay = new Date(dateToUpdate);
+      startOfDay.setUTCHours(0, 0, 0, 0);
+      const endOfDay = new Date(dateToUpdate);
+      endOfDay.setUTCHours(23, 59, 59, 999);
+      import_node_server_utils10.logger.info(
+        `Updating parent checklist statuses for date: ${dateToUpdate.toISOString().split("T")[0]}`
+      );
+      const statusUpdates = await collection.aggregate([
+        {
+          $match: {
+            createdAt: {
+              $gte: startOfDay,
+              $lte: endOfDay
+            }
+          }
+        },
+        {
+          $lookup: {
+            from: "hygiene-checklist.areas",
+            localField: "_id",
+            foreignField: "parentChecklist",
+            pipeline: [
+              {
+                $group: {
+                  _id: {
+                    site: "$site",
+                    type: "$type"
+                  },
+                  completedCount: {
+                    $sum: {
+                      $cond: [{ $eq: ["$status", "Completed"] }, 1, 0]
+                    }
+                  },
+                  inProgressCount: {
+                    $sum: {
+                      $cond: [{ $eq: ["$status", "In Progress"] }, 1, 0]
+                    }
+                  },
+                  toDoCount: {
+                    $sum: {
+                      $cond: [
+                        {
+                          $or: [
+                            { $eq: ["$status", "To Do"] },
+                            { $eq: ["$status", "Pending"] }
+                          ]
+                        },
+                        1,
+                        0
+                      ]
+                    }
+                  },
+                  totalCount: { $sum: 1 }
+                }
+              },
+              {
+                $addFields: {
+                  finalStatus: {
+                    $cond: {
+                      if: {
+                        $and: [
+                          { $gt: ["$completedCount", 0] },
+                          { $eq: ["$inProgressCount", 0] },
+                          { $eq: ["$toDoCount", 0] }
+                        ]
+                      },
+                      then: "Completed",
+                      else: {
+                        $cond: {
+                          if: {
+                            $and: [
+                              { $eq: ["$completedCount", 0] },
+                              { $eq: ["$inProgressCount", 0] }
+                            ]
+                          },
+                          then: "Expired",
+                          else: "In Progress"
+                        }
+                      }
+                    }
+                  },
+                  completedAt: {
+                    $cond: {
+                      if: {
+                        $and: [
+                          { $gt: ["$completedCount", 0] },
+                          { $eq: ["$inProgressCount", 0] },
+                          { $eq: ["$toDoCount", 0] }
+                        ]
+                      },
+                      then: /* @__PURE__ */ new Date(),
+                      else: null
+                    }
+                  }
+                }
+              }
+            ],
+            as: "areaStats"
+          }
+        },
+        {
+          $addFields: {
+            newStatus: {
+              $map: {
+                input: "$areaStats",
+                as: "stat",
+                in: {
+                  site: "$$stat._id.site",
+                  type: "$$stat._id.type",
+                  status: "$$stat.finalStatus",
+                  completedAt: "$$stat.completedAt"
+                }
+              }
+            }
+          }
+        },
+        { $match: { newStatus: { $ne: [] } } },
+        {
+          $project: {
+            _id: 1,
+            newStatus: 1
+          }
+        }
+      ]).toArray();
+      import_node_server_utils10.logger.info(
+        `Found ${statusUpdates.length} parent checklists to potentially update`
+      );
+      if (statusUpdates.length === 0) {
+        import_node_server_utils10.logger.info(
+          `No parent checklists found for date range: ${startOfDay.toISOString()} to ${endOfDay.toISOString()}`
+        );
+        return null;
+      }
+      const bulkOps = statusUpdates.map((update) => {
+        const statusTypes = update.newStatus.map((s) => `${s.type}(${s.status})`).join(", ");
+        import_node_server_utils10.logger.info(
+          `Updating parent checklist ${update._id} with ${update.newStatus.length} status entries: [${statusTypes}]`
+        );
+        return {
+          updateOne: {
+            filter: { _id: update._id },
+            update: {
+              $set: {
+                status: update.newStatus,
+                updatedAt: /* @__PURE__ */ new Date()
+              }
+            }
+          }
+        };
+      });
+      let result = null;
+      if (bulkOps.length > 0) {
+        result = await collection.bulkWrite(bulkOps);
+        delNamespace().then(() => {
+          import_node_server_utils10.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        }).catch((err) => {
+          import_node_server_utils10.logger.error(
+            `Failed to clear cache for namespace: ${namespace_collection}`,
+            err
+          );
+        });
+      }
+      import_node_server_utils10.logger.info(`Updated statuses for ${bulkOps.length} parent checklists.`);
+      return result;
+    } catch (error) {
+      import_node_server_utils10.logger.error("Failed to update parent checklist statuses", error);
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createParentChecklist,
+    getAllParentChecklist,
+    updateParentChecklistStatuses
+  };
+}
+
+// src/controllers/hygiene-parent-checklist.controller.ts
+var import_node_server_utils11 = require("@iservice365/node-server-utils");
+var import_joi6 = __toESM(require("joi"));
+function useParentChecklistController() {
+  const {
+    createParentChecklist: _createParentChecklist,
+    getAllParentChecklist: _getAllParentChecklist
+  } = useParentChecklistRepo();
+  async function createParentChecklist(req, res, next) {
+    const payload = req.body;
+    const { error } = parentChecklistSchema.validate(payload);
+    if (error) {
+      import_node_server_utils11.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils11.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createParentChecklist(payload);
+      res.status(201).json({ message: "Parent checklist created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils11.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAllParentChecklist(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi6.default.object({
+      page: import_joi6.default.number().min(1).optional().allow("", null),
+      limit: import_joi6.default.number().min(1).optional().allow("", null),
+      search: import_joi6.default.string().optional().allow("", null),
+      site: import_joi6.default.string().hex().required(),
+      type: import_joi6.default.string().required().valid(...allowedTypes),
+      startDate: import_joi6.default.alternatives().try(import_joi6.default.date(), import_joi6.default.string()).optional().allow("", null),
+      endDate: import_joi6.default.alternatives().try(import_joi6.default.date(), import_joi6.default.string()).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils11.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils11.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    const type = req.params.type ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
+    try {
+      const data = await _getAllParentChecklist({
+        page,
+        limit,
+        search,
+        site,
+        type,
+        startDate,
+        endDate
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils11.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createParentChecklist,
+    getAllParentChecklist
+  };
+}
+
+// src/models/hygiene-unit.model.ts
+var import_node_server_utils12 = require("@iservice365/node-server-utils");
+var import_joi7 = __toESM(require("joi"));
+var import_mongodb7 = require("mongodb");
+var unitSchema = import_joi7.default.object({
+  name: import_joi7.default.string().required(),
+  site: import_joi7.default.string().hex().required(),
+  createdBy: import_joi7.default.string().hex().required()
+});
+function MUnit(value) {
+  const { error } = unitSchema.validate(value);
+  if (error) {
+    import_node_server_utils12.logger.info(`Hygiene Unit Model: ${error.message}`);
+    throw new import_node_server_utils12.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb7.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils12.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new import_mongodb7.ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new import_node_server_utils12.BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  return {
+    name: value.name,
+    createdBy: value.createdBy,
+    site: value.site,
+    status: "active",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/services/hygiene-unit.service.ts
+var import_node_server_utils14 = require("@iservice365/node-server-utils");
+
+// src/repositories/hygiene-unit.repository.ts
+var import_mongodb8 = require("mongodb");
+var import_node_server_utils13 = require("@iservice365/node-server-utils");
+function useUnitRepository() {
+  const db = import_node_server_utils13.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils13.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-units";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils13.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { createdBy: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils13.InternalServerError("Failed to create index on hygiene unit.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new import_node_server_utils13.InternalServerError(
+        "Failed to create text index on hygiene unit."
+      );
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_node_server_utils13.InternalServerError(
+        "Failed to create unique index on hygiene unit."
+      );
+    }
+  }
+  async function createUnit(value, session) {
+    try {
+      value = MUnit(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils13.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils13.BadRequestError("Unit already exists.");
+      }
+      throw error;
+    }
+  }
+  async function getUnits({
+    page = 1,
+    limit = 10,
+    search = "",
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    try {
+      site = new import_mongodb8.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Invalid site ID format.");
+    }
+    const query = {
+      status: { $ne: "deleted" },
+      site
+    };
+    const cacheOptions = {
+      page,
+      limit,
+      site: site.toString()
+    };
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    if (startDate && endDate) {
+      query.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    } else if (startDate) {
+      query.createdAt = { $gte: new Date(startDate) };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+    } else if (endDate) {
+      query.createdAt = { $lte: new Date(endDate) };
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    }
+    const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils13.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils13.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils13.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getUnitByName(name, site) {
+    try {
+      if (site)
+        site = new import_mongodb8.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Unable to fetch unit by name.");
+    }
+  }
+  async function getUnitById(id, site) {
+    try {
+      id = typeof id === "string" ? new import_mongodb8.ObjectId(id) : id;
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Invalid unit ID format.");
+    }
+    try {
+      if (site)
+        site = new import_mongodb8.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError(
+        "Unable to fetch unit by ID, Invalid site ID format."
+      );
+    }
+    try {
+      return await collection.findOne({ _id: id, ...site && { site } });
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Unable to fetch unit by id.");
+    }
+  }
+  async function updateUnit(_id, value) {
+    try {
+      _id = new import_mongodb8.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Invalid unit ID format.");
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils13.InternalServerError("Unable to update cleaning unit.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils13.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils13.BadRequestError("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function deleteUnit(_id, session) {
+    try {
+      _id = new import_mongodb8.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Invalid unit ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils13.InternalServerError("Unable to delete unit.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils13.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    createUnit,
+    getUnits,
+    getUnitByName,
+    getUnitById,
+    updateUnit,
+    deleteUnit
+  };
+}
+
+// src/services/hygiene-unit.service.ts
+function useUnitService() {
+  const { createUnit: _createUnit } = useUnitRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new import_node_server_utils14.BadRequestError("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new import_node_server_utils14.NotFoundError("No data found in the uploaded file");
+    }
+    const session = import_node_server_utils14.useAtlas.getClient()?.startSession();
+    const insertedUnitIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.UNIT_NAME) {
+          import_node_server_utils14.logger.warn("Skipping row with missing UNIT_NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _createUnit(
+            {
+              name: String(row.UNIT_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedUnitIds.push(insertedId);
+        } catch (error) {
+          import_node_server_utils14.logger.error(
+            `Error creating unit "${row.UNIT_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      import_node_server_utils14.logger.info(`Successfully uploaded ${insertedUnitIds.length} units`);
+      return {
+        message: `Successfully uploaded ${insertedUnitIds.length} units`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      import_node_server_utils14.logger.error("Error while uploading unit information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-unit.controller.ts
+var import_node_server_utils15 = require("@iservice365/node-server-utils");
+var import_joi8 = __toESM(require("joi"));
+function useUnitController() {
+  const {
+    createUnit: _createUnit,
+    getUnits: _getUnits,
+    updateUnit: _updateUnit,
+    deleteUnit: _deleteUnit
+  } = useUnitRepository();
+  const { uploadByFile: _uploadByFile } = useUnitService();
+  async function createUnit(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const { error } = unitSchema.validate(payload);
+    if (error) {
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createUnit(payload);
+      res.status(201).json({ message: "Unit created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi8.default.object({
+      page: import_joi8.default.number().min(1).optional().allow("", null),
+      limit: import_joi8.default.number().min(1).optional().allow("", null),
+      search: import_joi8.default.string().optional().allow("", null),
+      startDate: import_joi8.default.alternatives().try(import_joi8.default.date(), import_joi8.default.string()).optional().allow("", null),
+      endDate: import_joi8.default.alternatives().try(import_joi8.default.date(), import_joi8.default.string()).optional().allow("", null),
+      site: import_joi8.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.query.site ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
+    try {
+      const data = await _getUnits({
+        page,
+        limit,
+        search,
+        site,
+        startDate,
+        endDate
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateUnit(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required(),
+      name: import_joi8.default.string().required()
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateUnit(id, value);
+      res.json({ message: "Unit updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function deleteUnit(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _deleteUnit(id);
+      res.json({ message: "Unit deleted successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new import_node_server_utils15.BadRequestError("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = import_joi8.default.object({
+      site: import_joi8.default.string().hex().optional().allow("", null),
+      createdBy: import_joi8.default.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createUnit,
+    getAll,
+    updateUnit,
+    deleteUnit,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-schedule-task-area.model.ts
+var import_node_server_utils16 = require("@iservice365/node-server-utils");
+var import_joi9 = __toESM(require("joi"));
+var import_mongodb9 = require("mongodb");
+var scheduleTaskAreaSchema = import_joi9.default.object({
+  name: import_joi9.default.string().required(),
+  site: import_joi9.default.string().hex().required(),
+  createdBy: import_joi9.default.string().hex().required(),
+  checklist: import_joi9.default.array().items(
+    import_joi9.default.object({
+      _id: import_joi9.default.string().hex().required(),
+      name: import_joi9.default.string().required()
+    })
+  ).optional(),
+  updatedAt: import_joi9.default.date().optional().allow("", null),
+  status: import_joi9.default.string().allow("", null).optional()
+});
+function MScheduleTaskArea(value) {
+  const { error } = scheduleTaskAreaSchema.validate(value);
+  if (error) {
+    throw new import_node_server_utils16.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb9.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils16.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new import_mongodb9.ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new import_node_server_utils16.BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((item) => {
+      try {
+        return {
+          ...item,
+          _id: new import_mongodb9.ObjectId(item._id)
+        };
+      } catch (error2) {
+        throw new import_node_server_utils16.BadRequestError(
+          `Invalid checklist item ID format: ${item._id}`
+        );
+      }
+    });
+  }
+  return {
+    name: value.name,
+    site: value.site,
+    createdBy: value.createdBy,
+    checklist: value.checklist,
+    status: value.status ?? "",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-schedule-task-area.repository.ts
+var import_mongodb10 = require("mongodb");
+var import_node_server_utils17 = require("@iservice365/node-server-utils");
+function useScheduleTaskAreaRepository() {
+  const db = import_node_server_utils17.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils17.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-schedule-task-areas";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils17.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { name: "text" } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils17.InternalServerError("Failed to create index on site.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_node_server_utils17.InternalServerError(
+        "Failed to create unique index on hygiene area."
+      );
+    }
+  }
+  async function createScheduleTaskArea(value, session) {
+    try {
+      value = MScheduleTaskArea(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils17.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils17.BadRequestError("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function updateScheduleTaskArea(_id, params) {
+    try {
+      _id = new import_mongodb10.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const updateValue = { ...params, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils17.InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils17.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils17.BadRequestError("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function deleteScheduleTaskArea(_id, session) {
+    try {
+      _id = new import_mongodb10.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils17.InternalServerError("Unable to delete area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils17.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTaskAreas({
+    page = 1,
+    limit = 10,
+    search = "",
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    if (site) {
+      try {
+        site = new import_mongodb10.ObjectId(site);
+        cacheOptions.site = site.toString();
+      } catch (error) {
+        throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
+      }
+    }
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    if (startDate && endDate) {
+      query.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    } else if (startDate) {
+      query.createdAt = { $gte: new Date(startDate) };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+    } else if (endDate) {
+      query.createdAt = { $lte: new Date(endDate) };
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    }
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        {
+          $match: query
+        },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils17.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTaskAreaByName(name, site) {
+    try {
+      if (site)
+        site = new import_mongodb10.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Unable to fetch schedule task area by name.");
+    }
+  }
+  async function getScheduleTaskAreaById(id, site) {
+    try {
+      id = typeof id === "string" ? new import_mongodb10.ObjectId(id) : id;
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Invalid unit ID format.");
+    }
+    try {
+      if (site)
+        site = new import_mongodb10.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError(
+        "Unable to fetch schedule task area by ID, Invalid site ID format."
+      );
+    }
+    try {
+      return await collection.findOne({ _id: id, ...site && { site } });
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Unable to fetch schedule task area by id.");
+    }
+  }
+  async function getAreaById(_id) {
+    try {
+      _id = new import_mongodb10.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils17.BadRequestError("Invalid area ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            name: 1,
+            checklist: 1
+          }
+        }
+      ]).toArray();
+      if (!data || !data.length) {
+        throw new import_node_server_utils17.NotFoundError("Area not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createUniqueIndex,
+    createScheduleTaskArea,
+    updateScheduleTaskArea,
+    deleteScheduleTaskArea,
+    getScheduleTaskAreas,
+    createIndexes,
+    getScheduleTaskAreaByName,
+    getScheduleTaskAreaById,
+    getAreaById
+  };
+}
+
+// src/services/hygiene-schedule-task-area.service.ts
+var import_node_server_utils18 = require("@iservice365/node-server-utils");
+function useScheduleTaskAreaService() {
+  const { createScheduleTaskArea: _create } = useScheduleTaskAreaRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new import_node_server_utils18.BadRequestError("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new import_node_server_utils18.NotFoundError("No data found in the uploaded file");
+    }
+    const session = import_node_server_utils18.useAtlas.getClient()?.startSession();
+    const insertedAreaIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.AREA_NAME) {
+          import_node_server_utils18.logger.warn("Skipping row with missing AREA_NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _create(
+            {
+              name: String(row.AREA_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedAreaIds.push(insertedId);
+        } catch (error) {
+          import_node_server_utils18.logger.error(
+            `Error creating area "${row.AREA_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      import_node_server_utils18.logger.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
+      return {
+        message: `Successfully uploaded ${insertedAreaIds.length} areas`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      import_node_server_utils18.logger.error("Error while uploading area information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-schedule-task-area.controller.ts
+var import_node_server_utils19 = require("@iservice365/node-server-utils");
+var import_joi10 = __toESM(require("joi"));
+function useScheduleTaskAreaController() {
+  const { uploadByFile: _uploadByFile } = useScheduleTaskAreaService();
+  const {
+    getScheduleTaskAreas: _getAll,
+    createScheduleTaskArea: _createScheduleTaskArea,
+    updateScheduleTaskArea: _updateScheduleTaskArea,
+    deleteScheduleTaskArea: _deleteById,
+    getAreaById: _getAreaById
+  } = useScheduleTaskAreaRepository();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi10.default.object({
+      page: import_joi10.default.number().min(1).optional().allow("", null),
+      limit: import_joi10.default.number().min(1).optional().allow("", null),
+      search: import_joi10.default.string().optional().allow("", null),
+      startDate: import_joi10.default.alternatives().try(import_joi10.default.date(), import_joi10.default.string()).optional().allow("", null),
+      endDate: import_joi10.default.alternatives().try(import_joi10.default.date(), import_joi10.default.string()).optional().allow("", null),
+      site: import_joi10.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_node_server_utils19.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.query.site ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
+    try {
+      const data = await _getAll({
+        page,
+        limit,
+        search,
+        site,
+        startDate,
+        endDate
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  async function createScheduleTaskArea(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const { error } = scheduleTaskAreaSchema.validate(payload);
+    if (error) {
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createScheduleTaskArea(payload);
+      res.status(201).json({ message: "Area created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateScheduleTaskArea(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = import_joi10.default.object({
+      id: import_joi10.default.string().hex().required(),
+      name: import_joi10.default.string().required()
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      next(new import_node_server_utils19.BadRequestError(error.message));
+      import_node_server_utils19.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateScheduleTaskArea(id, value);
+      res.json({ message: "Area updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function deleteScheduleTaskArea(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi10.default.object({
+      id: import_joi10.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _deleteById(id);
+      res.json({ message: "Area deleted successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new import_node_server_utils19.BadRequestError("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = import_joi10.default.object({
+      site: import_joi10.default.string().hex().optional().allow("", null),
+      createdBy: import_joi10.default.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAreaById(req, res, next) {
+    const validation = import_joi10.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAreaById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    getAll,
+    getAreaById,
+    createScheduleTaskArea,
+    updateScheduleTaskArea,
+    deleteScheduleTaskArea,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-area-checklist.model.ts
+var import_node_server_utils20 = require("@iservice365/node-server-utils");
+var import_joi11 = __toESM(require("joi"));
+var import_mongodb11 = require("mongodb");
+var areaChecklistSchema = import_joi11.default.object({
+  type: import_joi11.default.string().required().valid(...allowedTypes),
+  site: import_joi11.default.string().hex().required(),
+  parentChecklist: import_joi11.default.string().hex().required(),
+  area: import_joi11.default.string().hex().required(),
+  name: import_joi11.default.string().optional().allow("", null),
+  createdBy: import_joi11.default.string().hex().optional().allow("", null)
+});
+function MAreaChecklist(value) {
+  const { error } = areaChecklistSchema.validate(value);
+  if (error) {
+    import_node_server_utils20.logger.info(`Hygiene Checklist Area Model: ${error.message}`);
+    throw new import_node_server_utils20.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb11.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils20.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.parentChecklist) {
+    try {
+      value.parentChecklist = new import_mongodb11.ObjectId(value.parentChecklist);
+    } catch (error2) {
+      throw new import_node_server_utils20.BadRequestError("Invalid checklist ID format.");
+    }
+  }
+  if (value.area) {
+    try {
+      value.area = new import_mongodb11.ObjectId(value.area);
+    } catch (error2) {
+      throw new import_node_server_utils20.BadRequestError("Invalid area ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new import_mongodb11.ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new import_node_server_utils20.BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  if (value.acceptedBy) {
+    try {
+      value.acceptedBy = new import_mongodb11.ObjectId(value.acceptedBy);
+    } catch (error2) {
+      throw new import_node_server_utils20.BadRequestError("Invalid acceptedBy ID format.");
+    }
+  }
+  return {
+    type: value.type,
+    site: value.site,
+    parentChecklist: value.parentChecklist,
+    area: value.area,
+    name: value.name ?? "",
+    status: value.status ?? "To Do",
+    createdBy: value.createdBy ?? "",
+    createdAt: /* @__PURE__ */ new Date(),
+    acceptedBy: value.acceptedBy ?? "",
+    acceptedAt: value.acceptedAt ?? "",
+    startedAt: value.startedAt ?? "",
+    endedAt: value.endedAt ?? "",
+    signature: value.signature ?? "",
+    updatedAt: value.updatedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-area-checklist.repository.ts
+var import_node_server_utils21 = require("@iservice365/node-server-utils");
+var import_mongodb12 = require("mongodb");
+function useAreaChecklistRepo() {
+  const db = import_node_server_utils21.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils21.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-checklist.areas";
+  const unit_checklist_collection = "hygiene-checklist.units";
+  const collection = db.collection(namespace_collection);
+  const unitChecklistCollection = db.collection(unit_checklist_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils21.useCache)(namespace_collection);
+  const { delNamespace: delUnitNamespace } = (0, import_node_server_utils21.useCache)(
+    unit_checklist_collection
+  );
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { type: 1 } },
+        { key: { site: 1 } },
+        { key: { parentChecklist: 1 } },
+        { key: { area: 1 } },
+        { key: { createdAt: 1 } },
+        { key: { acceptedBy: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils21.InternalServerError(
+        "Failed to create index on hygiene checklist area."
+      );
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new import_node_server_utils21.InternalServerError(
+        "Failed to create text index on hygiene checklist area."
+      );
+    }
+  }
+  async function createAreaChecklist(value, session) {
+    try {
+      const siteId = new import_mongodb12.ObjectId(value.site);
+      const parentChecklistId = new import_mongodb12.ObjectId(value.parentChecklist);
+      const areaId = new import_mongodb12.ObjectId(value.area);
+      const currentDate = /* @__PURE__ */ new Date();
+      const startOfDay = new Date(currentDate);
+      startOfDay.setUTCHours(0, 0, 0, 0);
+      const endOfDay = new Date(currentDate);
+      endOfDay.setUTCHours(23, 59, 59, 999);
+      const existingChecklist = await collection.findOne({
+        type: value.type,
+        site: siteId,
+        parentChecklist: parentChecklistId,
+        area: areaId,
+        createdAt: {
+          $gte: startOfDay,
+          $lte: endOfDay
+        }
+      });
+      if (existingChecklist) {
+        import_node_server_utils21.logger.info(
+          `Area checklist already exists for area ${areaId} on ${currentDate.toISOString().split("T")[0]}`
+        );
+        return existingChecklist._id;
+      }
+      const processedValue = MAreaChecklist(value);
+      const result = await collection.insertOne(processedValue, { session });
+      delNamespace().then(() => {
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return result.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAllAreaChecklist({
+    page = 1,
+    limit = 10,
+    search = "",
+    site,
+    type,
+    parentChecklist
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { type };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      query.site = new import_mongodb12.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      query.parentChecklist = new import_mongodb12.ObjectId(parentChecklist);
+      cacheOptions.parentChecklist = parentChecklist.toString();
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid parent checklist ID format.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const pipeline = [
+        { $match: query },
+        {
+          $lookup: {
+            from: "users",
+            localField: "acceptedBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "acceptedBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$acceptedBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            acceptedByName: "$acceptedBy.name",
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ];
+      const items = await collection.aggregate(pipeline).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils21.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAreaChecklistHistory({
+    page = 1,
+    limit = 10,
+    search = "",
+    site,
+    type,
+    parentChecklist,
+    status,
+    createdAt,
+    user
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { type };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      query.site = new import_mongodb12.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      query.parentChecklist = new import_mongodb12.ObjectId(parentChecklist);
+      cacheOptions.parentChecklist = parentChecklist.toString();
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid parent checklist ID format.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    if (createdAt) {
+      query.createdAt = {
+        $gte: /* @__PURE__ */ new Date(`${createdAt}T00:00:00Z`),
+        $lte: /* @__PURE__ */ new Date(`${createdAt}T23:59:59Z`)
+      };
+      cacheOptions.createdAt = new Date(createdAt).toISOString().split("T")[0];
+    }
+    if (status) {
+      query.status = status;
+      cacheOptions.status = status;
+    } else {
+      query.status = { $in: ["In Progress", "Completed"] };
+    }
+    if (user) {
+      try {
+        query.acceptedBy = new import_mongodb12.ObjectId(user);
+        cacheOptions.user = user.toString();
+      } catch (error) {
+        throw new import_node_server_utils21.BadRequestError("Invalid user ID format.");
+      }
+    }
+    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const pipeline = [
+        { $match: query },
+        {
+          $lookup: {
+            from: "users",
+            localField: "acceptedBy",
+            foreignField: "_id",
+            pipeline: [
+              ...search ? [{ $match: { name: { $regex: search, $options: "i" } } }] : [],
+              { $project: { name: 1 } }
+            ],
+            as: "acceptedBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$acceptedBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            createdAt: 1,
+            acceptedByName: "$acceptedBy.name",
+            status: 1,
+            startedAt: 1,
+            endedAt: 1
+          }
+        },
+        { $sort: { status: 1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ];
+      const items = await collection.aggregate(pipeline).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils21.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAreaChecklistHistoryDetails(_id) {
+    try {
+      _id = new import_mongodb12.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid area checklist ID format.");
+    }
+    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const areaPipeline = [
+        { $match: { _id } },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "acceptedBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "acceptedBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$acceptedBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            createdAt: 1,
+            createdByName: "$createdBy.name",
+            startedAt: 1,
+            endedAt: 1,
+            status: 1,
+            signature: 1,
+            acceptedByName: "$acceptedBy.name"
+          }
+        }
+      ];
+      const unitPipeline = [
+        { $match: { areaChecklist: _id } },
+        {
+          $project: {
+            name: 1,
+            remarks: "$metadata.remarks",
+            attachments: "$metadata.attachments",
+            approve: { $ifNull: ["$approve", null] },
+            reject: { $ifNull: ["$reject", null] }
+          }
+        }
+      ];
+      const [area, units] = await Promise.all([
+        collection.aggregate(areaPipeline).toArray(),
+        unitChecklistCollection.aggregate(unitPipeline).toArray()
+      ]);
+      if (!area.length) {
+        throw new import_node_server_utils21.BadRequestError("Area checklist not found.");
+      }
+      const items = {
+        area: area[0],
+        units
+      };
+      setCache(cacheKey, items, 15 * 60).then(() => {
+        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return items;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function acceptAreaChecklist(_id, acceptedBy) {
+    try {
+      _id = new import_mongodb12.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      acceptedBy = new import_mongodb12.ObjectId(acceptedBy);
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid acceptedBy ID format.");
+    }
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const updateValue = {
+        acceptedBy,
+        acceptedAt: now,
+        startedAt: now,
+        updatedAt: now
+      };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function attachImageAreaChecklist(_id, attachments, session) {
+    try {
+      _id = new import_mongodb12.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid area checklist ID format.");
+    }
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const updateValue = {
+        metadata: { attachments },
+        updatedAt: now
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils21.InternalServerError(
+          "Unable to update cleaning area checklist."
+        );
+      }
+      delNamespace().then(() => {
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      delUnitNamespace().then(() => {
+        import_node_server_utils21.logger.info(
+          `Cache cleared for namespace: ${unit_checklist_collection}`
+        );
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(
+          `Failed to clear cache for namespace: ${unit_checklist_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function submitAreaChecklist(_id, signature) {
+    try {
+      _id = new import_mongodb12.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const updateValue = {
+        signature,
+        status: "In Progress",
+        endedAt: now,
+        updatedAt: now
+      };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function completeAreaChecklist(_id, signature) {
+    try {
+      _id = new import_mongodb12.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils21.BadRequestError("Invalid area ID format.");
+    }
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const updateValue = {
+        signature,
+        status: "Completed",
+        endedAt: now,
+        updatedAt: now
+      };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils21.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createAreaChecklist,
+    getAllAreaChecklist,
+    getAreaChecklistHistory,
+    getAreaChecklistHistoryDetails,
+    acceptAreaChecklist,
+    attachImageAreaChecklist,
+    submitAreaChecklist,
+    completeAreaChecklist
+  };
+}
+
+// src/controllers/hygiene-area-checklist.controller.ts
+var import_node_server_utils23 = require("@iservice365/node-server-utils");
+var import_joi12 = __toESM(require("joi"));
+
+// src/services/hygiene-area-checklist.service.ts
+var import_node_server_utils22 = require("@iservice365/node-server-utils");
+function useAreaChecklistService() {
+  const { createAreaChecklist: _createAreaChecklist } = useAreaChecklistRepo();
+  const { getAreas } = useAreaRepository();
+  const { getToiletLocations } = useToiletLocationRepository();
+  async function createAreaChecklist(value) {
+    try {
+      const results = [];
+      if (value.type === "cleaner") {
+        const cleanerAreasResult = await getAreas({
+          site: value.site
+        });
+        const cleanerAreas = cleanerAreasResult.items || [];
+        if (cleanerAreas.length === 0) {
+          import_node_server_utils22.logger.warn(`No cleaner areas found for site: ${value.site}`);
+          return results;
+        }
+        for (const area of cleanerAreas) {
+          const checklistData = {
+            type: "cleaner",
+            site: value.site,
+            parentChecklist: value.parentChecklist,
+            area: area._id.toString(),
+            name: area.name,
+            createdBy: value.createdBy
+          };
+          const insertedId = await _createAreaChecklist(checklistData);
+          results.push(insertedId);
+        }
+        import_node_server_utils22.logger.info(
+          `Created ${results.length} cleaner area checklists for site: ${value.site}`
+        );
+      }
+      if (value.type === "toilet") {
+        const toiletAreasResult = await getToiletLocations({
+          site: value.site
+        });
+        const toiletAreas = toiletAreasResult.items || [];
+        if (toiletAreas.length === 0) {
+          import_node_server_utils22.logger.warn(`No toilet locations found for site: ${value.site}`);
+          return results;
+        }
+        for (const toiletLocation of toiletAreas) {
+          const checklistData = {
+            type: "toilet",
+            site: value.site,
+            parentChecklist: value.parentChecklist,
+            area: toiletLocation._id,
+            name: toiletLocation.name,
+            createdBy: value.createdBy
+          };
+          const insertedId = await _createAreaChecklist(checklistData);
+          results.push(insertedId);
+        }
+        import_node_server_utils22.logger.info(
+          `Created ${results.length} toilet area checklists for site: ${value.site}`
+        );
+      }
+      return results;
+    } catch (error) {
+      import_node_server_utils22.logger.error(`Error generating area checklists:`, error);
+      throw error;
+    }
+  }
+  return { createAreaChecklist };
+}
+
+// src/controllers/hygiene-area-checklist.controller.ts
+function useAreaChecklistController() {
+  const {
+    getAllAreaChecklist: _getAllAreaChecklist,
+    getAreaChecklistHistory: _getAreaChecklistHistory,
+    getAreaChecklistHistoryDetails: _getAreaChecklistHistoryDetails,
+    acceptAreaChecklist: _acceptAreaChecklist,
+    attachImageAreaChecklist: _attachImageAreaChecklist,
+    submitAreaChecklist: _submitAreaChecklist,
+    completeAreaChecklist: _completeAreaChecklist
+  } = useAreaChecklistRepo();
+  const { createAreaChecklist: _createAreaChecklist } = useAreaChecklistService();
+  async function createAreaChecklist(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, ...req.params, createdBy };
+    const validation = import_joi12.default.object({
+      type: import_joi12.default.string().required().valid(...allowedTypes),
+      site: import_joi12.default.string().hex().required(),
+      parentChecklist: import_joi12.default.string().hex().required(),
+      createdBy: import_joi12.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _createAreaChecklist(payload);
+      res.status(201).json({ message: "Area checklists generated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAllAreaChecklist(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi12.default.object({
+      page: import_joi12.default.number().min(1).optional().allow("", null),
+      limit: import_joi12.default.number().min(1).optional().allow("", null),
+      search: import_joi12.default.string().optional().allow("", null),
+      site: import_joi12.default.string().hex().required(),
+      type: import_joi12.default.string().valid(...allowedTypes).required(),
+      parentChecklist: import_joi12.default.string().hex().required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    const type = req.params.type ?? "";
+    const parentChecklist = req.params.parentChecklist ?? "";
+    try {
+      const data = await _getAllAreaChecklist({
+        page,
+        limit,
+        search,
+        site,
+        type,
+        parentChecklist
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAreaChecklistHistory(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const user = cookies["user"] || "";
+    const query = { ...req.query, ...req.params, user };
+    const validation = import_joi12.default.object({
+      page: import_joi12.default.number().min(1).optional().allow("", null),
+      limit: import_joi12.default.number().min(1).optional().allow("", null),
+      search: import_joi12.default.string().optional().allow("", null),
+      site: import_joi12.default.string().hex().required(),
+      type: import_joi12.default.string().valid(...allowedTypes).required(),
+      parentChecklist: import_joi12.default.string().hex().required(),
+      status: import_joi12.default.string().allow("", null, ...allowedStatus),
+      createdAt: import_joi12.default.alternatives().try(import_joi12.default.date(), import_joi12.default.string()).optional().allow("", null),
+      user: import_joi12.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    const type = req.params.type ?? "";
+    const parentChecklist = req.params.parentChecklist ?? "";
+    const status = req.query.status ?? "";
+    const createdAt = req.query.createdAt ?? "";
+    try {
+      const data = await _getAreaChecklistHistory({
+        page,
+        limit,
+        search,
+        site,
+        type,
+        parentChecklist,
+        status,
+        createdAt,
+        user
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAreaChecklistHistoryDetails(req, res, next) {
+    const validation = import_joi12.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAreaChecklistHistoryDetails(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function acceptAreaChecklist(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const acceptedBy = cookies["user"] || "";
+    const payload = { id: req.params.id, acceptedBy };
+    const validation = import_joi12.default.object({
+      id: import_joi12.default.string().hex().required(),
+      acceptedBy: import_joi12.default.string().hex().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _acceptAreaChecklist(payload.id, payload.acceptedBy);
+      res.json({ message: "Area checklist updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function attachImageAreaChecklist(req, res, next) {
+    const payload = { id: req.params.id, attachments: req.body.attachments };
+    const validation = import_joi12.default.object({
+      id: import_joi12.default.string().hex().required(),
+      attachments: import_joi12.default.array().items(import_joi12.default.string()).optional()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _attachImageAreaChecklist(payload.id, payload.attachments);
+      res.json({ message: "Area checklist attachments updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function submitAreaChecklist(req, res, next) {
+    const payload = { id: req.params.id, signature: req.body.signature };
+    const validation = import_joi12.default.object({
+      id: import_joi12.default.string().hex().required(),
+      signature: import_joi12.default.string().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _submitAreaChecklist(payload.id, payload.signature);
+      res.json({ message: "Area checklist submitted successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function completeAreaChecklist(req, res, next) {
+    const payload = { id: req.params.id, signature: req.body.signature };
+    const validation = import_joi12.default.object({
+      id: import_joi12.default.string().hex().required(),
+      signature: import_joi12.default.string().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils23.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils23.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _completeAreaChecklist(payload.id, payload.signature);
+      res.json({ message: "Area checklist completed successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createAreaChecklist,
+    getAllAreaChecklist,
+    getAreaChecklistHistory,
+    getAreaChecklistHistoryDetails,
+    acceptAreaChecklist,
+    attachImageAreaChecklist,
+    submitAreaChecklist,
+    completeAreaChecklist
+  };
+}
+
+// src/models/hygiene-unit-checklist.model.ts
+var import_node_server_utils24 = require("@iservice365/node-server-utils");
+var import_joi13 = __toESM(require("joi"));
+var import_mongodb13 = require("mongodb");
+var unitChecklistSchema = import_joi13.default.object({
+  site: import_joi13.default.string().hex().required(),
+  type: import_joi13.default.string().valid(...allowedTypes).required(),
+  parentChecklist: import_joi13.default.string().hex().required(),
+  areaChecklist: import_joi13.default.string().hex().required(),
+  unit: import_joi13.default.string().hex().required(),
+  name: import_joi13.default.string().optional().allow("", null),
+  createdBy: import_joi13.default.string().hex().optional().allow("", null)
+});
+function MUnitChecklist(value) {
+  const { error } = unitChecklistSchema.validate(value);
+  if (error) {
+    import_node_server_utils24.logger.info(`Hygiene Checklist Unit Model: ${error.message}`);
+    throw new import_node_server_utils24.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb13.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils24.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.parentChecklist) {
+    try {
+      value.parentChecklist = new import_mongodb13.ObjectId(value.parentChecklist);
+    } catch (error2) {
+      throw new import_node_server_utils24.BadRequestError("Invalid parent checklist ID format.");
+    }
+  }
+  if (value.areaChecklist) {
+    try {
+      value.areaChecklist = new import_mongodb13.ObjectId(value.areaChecklist);
+    } catch (error2) {
+      throw new import_node_server_utils24.BadRequestError("Invalid area checklist ID format.");
+    }
+  }
+  if (value.unit) {
+    try {
+      value.unit = new import_mongodb13.ObjectId(value.unit);
+    } catch (error2) {
+      throw new import_node_server_utils24.BadRequestError("Invalid unit ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new import_mongodb13.ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new import_node_server_utils24.BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  return {
+    site: value.site,
+    type: value.type,
+    parentChecklist: value.parentChecklist,
+    areaChecklist: value.areaChecklist,
+    unit: value.unit,
+    name: value.name ?? "",
+    approve: false,
+    reject: false,
+    createdBy: value.createdBy ?? "",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-unit-checklist.repository.ts
+var import_node_server_utils25 = require("@iservice365/node-server-utils");
+var import_mongodb14 = require("mongodb");
+function useUnitChecklistRepo() {
+  const db = import_node_server_utils25.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils25.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-checklist.units";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils25.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { type: 1 } },
+        { key: { parentChecklist: 1 } },
+        { key: { areaChecklist: 1 } },
+        { key: { "metadata.workOrder.category": 1 } },
+        { key: { "metadata.workOrder.createdBy": 1 } },
+        { key: { "metadata.workOrder.serviceProvider": 1 } },
+        { key: { "metadata.workOrder.organization": 1 } },
+        { key: { "metadata.workOrder.site": 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils25.InternalServerError(
+        "Failed to create index on hygiene unit checklist."
+      );
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new import_node_server_utils25.InternalServerError(
+        "Failed to create text index on hygiene unit checklist."
+      );
+    }
+  }
+  async function createUnitChecklist(value, session) {
+    try {
+      value = MUnitChecklist(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils25.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils25.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAllUnitChecklist({
+    page = 1,
+    limit = 10,
+    search = "",
+    site,
+    type,
+    parentChecklist,
+    areaChecklist
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { type };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      query.site = new import_mongodb14.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils25.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      query.parentChecklist = new import_mongodb14.ObjectId(parentChecklist);
+      cacheOptions.parentChecklist = parentChecklist.toString();
+    } catch (error) {
+      throw new import_node_server_utils25.BadRequestError("Invalid parent checklist ID format.");
+    }
+    try {
+      query.areaChecklist = new import_mongodb14.ObjectId(areaChecklist);
+      cacheOptions.areaChecklist = areaChecklist.toString();
+    } catch (error) {
+      throw new import_node_server_utils25.BadRequestError("Invalid area checklist ID format.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils25.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils25.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const areaAttachmentsResult = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "hygiene-checklist.areas",
+            localField: "areaChecklist",
+            foreignField: "_id",
+            pipeline: [
+              { $project: { attachments: "$metadata.attachments" } }
+            ],
+            as: "areaChecklistData"
+          }
+        },
+        {
+          $unwind: {
+            path: "$areaChecklistData",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $group: {
+            _id: null,
+            attachments: { $first: "$areaChecklistData.attachments" }
+          }
+        }
+      ]).toArray();
+      const areaAttachments = areaAttachmentsResult.length > 0 ? areaAttachmentsResult[0].attachments || [] : [];
+      const pipeline = [
+        { $match: query },
+        {
+          $lookup: {
+            from: "organizations",
+            localField: "metadata.workOrder.category",
+            foreignField: "_id",
+            pipeline: [{ $project: { nature: 1 } }],
+            as: "categoryData"
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "metadata.workOrder.createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdByData"
+          }
+        },
+        {
+          $lookup: {
+            from: "service-providers",
+            localField: "metadata.workOrder.serviceProvider",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "serviceProviderData"
+          }
+        },
+        {
+          $lookup: {
+            from: "organizations",
+            localField: "metadata.workOrder.organization",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "organizationData"
+          }
+        },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "metadata.workOrder.site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "siteData"
+          }
+        },
+        {
+          $addFields: {
+            "metadata.workOrder.categoryName": {
+              $arrayElemAt: ["$categoryData.nature", 0]
+            },
+            "metadata.workOrder.createdByName": {
+              $arrayElemAt: ["$createdByData.name", 0]
+            },
+            "metadata.workOrder.serviceProviderName": {
+              $arrayElemAt: ["$serviceProviderData.name", 0]
+            },
+            "metadata.workOrder.organizationName": {
+              $arrayElemAt: ["$organizationData.name", 0]
+            },
+            "metadata.workOrder.siteName": {
+              $arrayElemAt: ["$siteData.name", 0]
+            }
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            remarks: "$metadata.remarks",
+            attachments: "$metadata.attachments",
+            workOrder: "$metadata.workOrder",
+            approve: { $ifNull: ["$approve", null] },
+            reject: { $ifNull: ["$reject", null] }
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ];
+      const items = await collection.aggregate(pipeline).toArray();
+      const length = await collection.countDocuments(query);
+      const paginatedData = (0, import_node_server_utils25.paginate)(items, page, limit, length);
+      const data = {
+        attachments: areaAttachments,
+        ...paginatedData
+      };
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils25.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils25.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getUnitChecklistById(_id) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils25.BadRequestError("Invalid unit checklist ID format.");
+    }
+    try {
+      return await collection.findOne({ _id });
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateUnitChecklist(_id, value, session) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils25.BadRequestError("Invalid unit checklist ID format.");
+    }
+    if (value.checkedBy && typeof value.checkedBy === "string") {
+      try {
+        value.checkedBy = new import_mongodb14.ObjectId(value.checkedBy);
+      } catch (error) {
+        throw new import_node_server_utils25.BadRequestError("Invalid checkedBy ID format.");
+      }
+    }
+    if ("metadata" in value && value.metadata?.workOrder) {
+      const workOrder = value.metadata.workOrder;
+      if (workOrder.category && typeof workOrder.category === "string") {
+        try {
+          workOrder.category = new import_mongodb14.ObjectId(workOrder.category);
+        } catch (error) {
+          throw new import_node_server_utils25.BadRequestError("Invalid category ID format.");
+        }
+      }
+      if (workOrder.createdBy && typeof workOrder.createdBy === "string") {
+        try {
+          workOrder.createdBy = new import_mongodb14.ObjectId(workOrder.createdBy);
+        } catch (error) {
+          throw new import_node_server_utils25.BadRequestError("Invalid createdBy ID format.");
+        }
+      }
+      if (workOrder.serviceProvider && typeof workOrder.serviceProvider === "string") {
+        try {
+          workOrder.serviceProvider = new import_mongodb14.ObjectId(workOrder.serviceProvider);
+        } catch (error) {
+          throw new import_node_server_utils25.BadRequestError("Invalid serviceProvider ID format.");
+        }
+      }
+      if (workOrder.organization && typeof workOrder.organization === "string") {
+        try {
+          workOrder.organization = new import_mongodb14.ObjectId(workOrder.organization);
+        } catch (error) {
+          throw new import_node_server_utils25.BadRequestError("Invalid organization ID format.");
+        }
+      }
+      if (workOrder.site && typeof workOrder.site === "string") {
+        try {
+          workOrder.site = new import_mongodb14.ObjectId(workOrder.site);
+        } catch (error) {
+          throw new import_node_server_utils25.BadRequestError("Invalid site ID format.");
+        }
+      }
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils25.InternalServerError("Unable to update unit checklist.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils25.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils25.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUnitChecklist,
+    getAllUnitChecklist,
+    getUnitChecklistById,
+    updateUnitChecklist
+  };
+}
+
+// src/controllers/hygiene-unit-checklist.controller.ts
+var import_node_server_utils27 = require("@iservice365/node-server-utils");
+var import_joi14 = __toESM(require("joi"));
+
+// src/services/hygiene-unit-checklist.service.ts
+var import_node_server_utils26 = require("@iservice365/node-server-utils");
+var import_core = require("@iservice365/core");
+function useUnitChecklistService() {
+  const {
+    getUnitChecklistById: _getUnitChecklistById,
+    updateUnitChecklist: _updateUnitChecklist
+  } = useUnitChecklistRepo();
+  const { getSiteById } = (0, import_core.useSiteRepo)();
+  const { createWorkOrder } = (0, import_core.useWorkOrderService)();
+  async function approveUnitChecklist(id, value) {
+    try {
+      value.approve = true;
+      value.reject = false;
+      const result = await _updateUnitChecklist(id, value);
+      return result;
+    } catch (error) {
+      import_node_server_utils26.logger.error(`Error updating unit checklist with id ${id}:`, error);
+      throw error;
+    }
+  }
+  async function rejectUnitChecklist(id, value, fullHost) {
+    try {
+      value.reject = true;
+      value.approve = false;
+      if (value.metadata?.workOrder) {
+        const existingChecklist = await _getUnitChecklistById(id);
+        if (!existingChecklist)
+          throw new import_node_server_utils26.NotFoundError("Unit checklist not found.");
+        const site = await getSiteById(
+          existingChecklist.site
+        );
+        if (!site)
+          throw new import_node_server_utils26.NotFoundError("Site not found.");
+        const workOrderData = {
+          ...value.metadata.workOrder,
+          attachments: value.metadata.attachments,
+          createdBy: value.checkedBy,
+          organization: site.orgId,
+          site: site._id
+        };
+        const workOrder = await createWorkOrder(
+          workOrderData,
+          fullHost
+        );
+        if (!workOrder)
+          throw new import_node_server_utils26.NotFoundError("Failed to create work order.");
+      }
+      const result = await _updateUnitChecklist(id, value);
+      return result;
+    } catch (error) {
+      import_node_server_utils26.logger.error(`Error updating unit checklist with id ${id}:`, error);
+      throw error;
+    }
+  }
+  return {
+    approveUnitChecklist,
+    rejectUnitChecklist
+  };
+}
+
+// src/controllers/hygiene-unit-checklist.controller.ts
+var import_core2 = require("@iservice365/core");
+function useUnitChecklistController() {
+  const {
+    createUnitChecklist: _createUnitChecklist,
+    getAllUnitChecklist: _getAllUnitChecklist
+  } = useUnitChecklistRepo();
+  const {
+    approveUnitChecklist: _approveUnitChecklist,
+    rejectUnitChecklist: _rejectUnitChecklist
+  } = useUnitChecklistService();
+  async function createUnitChecklist(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, ...req.params, createdBy };
+    const { error } = unitChecklistSchema.validate(payload);
+    if (error) {
+      import_node_server_utils27.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils27.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createUnitChecklist(payload);
+      res.status(201).json({ message: "Unit checklist created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAllUnitChecklist(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi14.default.object({
+      page: import_joi14.default.number().min(1).optional().allow("", null),
+      limit: import_joi14.default.number().min(1).optional().allow("", null),
+      search: import_joi14.default.string().optional().allow("", null),
+      site: import_joi14.default.string().hex().required(),
+      type: import_joi14.default.string().valid(...allowedTypes).required(),
+      parentChecklist: import_joi14.default.string().hex().required(),
+      areaChecklist: import_joi14.default.string().hex().required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils27.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils27.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    const type = req.params.type ?? "";
+    const parentChecklist = req.params.parentChecklist ?? "";
+    const areaChecklist = req.params.areaChecklist ?? "";
+    try {
+      const data = await _getAllUnitChecklist({
+        page,
+        limit,
+        search,
+        site,
+        type,
+        parentChecklist,
+        areaChecklist
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function approveUnitChecklist(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const checkedBy = cookies["user"] || "";
+    const payload = { id: req.params.id, checkedBy };
+    const validation = import_joi14.default.object({
+      id: import_joi14.default.string().hex().required(),
+      checkedBy: import_joi14.default.string().hex().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils27.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils27.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _approveUnitChecklist(id, value);
+      res.json({ message: "Unit checklist approved successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function rejectUnitChecklist(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const checkedBy = cookies["user"] || "";
+    if (req.body.workOrder) {
+      req.body.workOrder.createdBy = checkedBy;
+    }
+    const payload = { id: req.params.id, checkedBy, ...req.body };
+    const validation = import_joi14.default.object({
+      id: import_joi14.default.string().hex().required(),
+      attachments: import_joi14.default.array().items(import_joi14.default.string()).optional(),
+      remarks: import_joi14.default.string().required(),
+      workOrder: import_core2.workOrderSchema.optional(),
+      checkedBy: import_joi14.default.string().hex().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils27.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils27.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, attachments, remarks, workOrder, ...value } = payload;
+      value.metadata = {
+        attachments: attachments || [],
+        remarks: remarks || "",
+        workOrder
+      };
+      if (value.metadata.workOrder) {
+        if (value.metadata.workOrder.category) {
+          value.metadata.workOrder.category = value.metadata.workOrder.category;
+        }
+        if (value.metadata.workOrder.serviceProvider) {
+          value.metadata.workOrder.serviceProvider = value.metadata.workOrder.serviceProvider;
+        }
+        value.metadata.workOrder.createdBy = checkedBy;
+      }
+      const fullHost = req.headers.origin;
+      await _rejectUnitChecklist(id, value, fullHost);
+      res.json({ message: "Unit checklist rejected successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createUnitChecklist,
+    getAllUnitChecklist,
+    approveUnitChecklist,
+    rejectUnitChecklist
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MArea,
+  MAreaChecklist,
+  MParentChecklist,
+  MScheduleTaskArea,
+  MToiletLocation,
+  MUnit,
+  MUnitChecklist,
+  allowedStatus,
+  allowedTypes,
+  areaChecklistSchema,
+  areaSchema,
+  parentChecklistSchema,
+  scheduleTaskAreaSchema,
+  toiletLocationSchema,
+  unitChecklistSchema,
+  unitSchema,
+  useAreaChecklistController,
+  useAreaChecklistRepo,
+  useAreaController,
+  useAreaRepository,
+  useAreaService,
+  useParentChecklistController,
+  useParentChecklistRepo,
+  useScheduleTaskAreaController,
+  useScheduleTaskAreaRepository,
+  useScheduleTaskAreaService,
+  useToiletLocationController,
+  useToiletLocationRepository,
+  useToiletLocationService,
+  useUnitChecklistController,
+  useUnitChecklistRepo,
+  useUnitController,
+  useUnitRepository,
+  useUnitService
+});
 //# sourceMappingURL=index.js.map