@7365admin1/module-hygiene 4.4.0 → 4.5.0

package/dist/index.js

@@ -55,6 +55,7 @@ __export(src_exports, {
   useAreaChecklistRepo: () => useAreaChecklistRepo,
   useAreaChecklistService: () => useAreaChecklistService,
   useAreaController: () => useAreaController,
+  useAreaExportService: () => useAreaExportService,
   useAreaRepo: () => useAreaRepo,
   useAreaService: () => useAreaService,
   useCheckOutItemController: () => useCheckOutItemController,
@@ -64,6 +65,8 @@ __export(src_exports, {
   useHygieneDashboardRepository: () => useHygieneDashboardRepository,
   useParentChecklistController: () => useParentChecklistController,
   useParentChecklistRepo: () => useParentChecklistRepo,
+  useQRController: () => useQRController,
+  useQRService: () => useQRService,
   useScheduleTaskController: () => useScheduleTaskController,
   useScheduleTaskRepository: () => useScheduleTaskRepository,
   useScheduleTaskService: () => useScheduleTaskService,
@@ -73,6 +76,7 @@ __export(src_exports, {
   useSupplyController: () => useSupplyController,
   useSupplyRepository: () => useSupplyRepository,
   useUnitController: () => useUnitController,
+  useUnitExportService: () => useUnitExportService,
   useUnitRepository: () => useUnitRepository,
   useUnitService: () => useUnitService
 });
@@ -1077,9 +1081,283 @@ function useAreaRepo() {
 }
 
 // src/services/hygiene-area.service.ts
+var import_node_server_utils8 = require("@7365admin1/node-server-utils");
+
+// src/services/hygiene-area-export.service.ts
 var import_node_server_utils5 = require("@7365admin1/node-server-utils");
+var xlsx = __toESM(require("xlsx"));
+function useAreaExportService() {
+  async function generateAreaExcel(areas) {
+    try {
+      const rows = [];
+      rows.push(["AREA", "TYPE", "SET", "UNITS"]);
+      for (const area of areas) {
+        const areaName = area.name || "";
+        const areaType = area.type || "";
+        const areaSet = String(area.set || 0);
+        const unitsString = area.units && area.units.length > 0 ? area.units.map((u) => u.name || "").join(", ") : "";
+        rows.push([areaName, areaType, areaSet, unitsString]);
+      }
+      const workbook = xlsx.utils.book_new();
+      const worksheet = xlsx.utils.aoa_to_sheet(rows);
+      worksheet["!cols"] = [
+        { width: 30 },
+        // AREA
+        { width: 20 },
+        // TYPE
+        { width: 10 },
+        // SET
+        { width: 40 }
+        // UNITS
+      ];
+      xlsx.utils.book_append_sheet(workbook, worksheet, "Areas");
+      const excelBuffer = xlsx.write(workbook, {
+        type: "buffer",
+        bookType: "xlsx"
+      });
+      return excelBuffer;
+    } catch (error) {
+      import_node_server_utils5.logger.log({
+        level: "error",
+        message: `Failed to generate area Excel: ${error.message}`
+      });
+      throw error;
+    }
+  }
+  return {
+    generateAreaExcel
+  };
+}
+
+// src/repositories/hygiene-unit.repository.ts
+var import_mongodb5 = require("mongodb");
+var import_node_server_utils7 = require("@7365admin1/node-server-utils");
+
+// src/models/hygiene-unit.model.ts
+var import_joi3 = __toESM(require("joi"));
+var import_mongodb4 = require("mongodb");
+var import_node_server_utils6 = require("@7365admin1/node-server-utils");
+var unitSchema = import_joi3.default.object({
+  site: import_joi3.default.string().hex().required(),
+  name: import_joi3.default.string().required()
+});
+function MUnit(value) {
+  const { error } = unitSchema.validate(value);
+  if (error) {
+    import_node_server_utils6.logger.info(`Hygiene Unit Model: ${error.message}`);
+    throw new import_node_server_utils6.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb4.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils6.BadRequestError("Invalid site ID format.");
+    }
+  }
+  return {
+    site: value.site,
+    name: value.name,
+    status: "active",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/hygiene-unit.repository.ts
+function useUnitRepository() {
+  const db = import_node_server_utils7.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils7.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "site.cleaning.area.unit";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils7.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils7.InternalServerError("Failed to create index on hygiene unit.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new import_node_server_utils7.InternalServerError(
+        "Failed to create text index on hygiene unit."
+      );
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { site: 1, name: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_node_server_utils7.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_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils7.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_utils7.BadRequestError("Unit already exists.");
+      }
+      throw error;
+    }
+  }
+  async function getUnits({
+    page = 1,
+    limit = 10,
+    search = "",
+    site
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      site = new import_mongodb5.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils7.BadRequestError("Invalid site ID format.");
+    }
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils7.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils7.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        { $project: { name: 1 } },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils7.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils7.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils7.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateUnit(_id, value, session) {
+    try {
+      _id = new import_mongodb5.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils7.BadRequestError("Invalid unit 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_utils7.InternalServerError("Unable to update cleaning unit.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils7.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_utils7.BadRequestError("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function deleteUnit(_id, session) {
+    try {
+      _id = new import_mongodb5.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils7.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_utils7.InternalServerError("Unable to delete unit.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils7.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    createUnit,
+    getUnits,
+    updateUnit,
+    deleteUnit
+  };
+}
+
+// src/services/hygiene-area.service.ts
 function useAreaService() {
-  const { createArea: _createArea } = useAreaRepo();
+  const { createArea: _createArea, getAreasForChecklist } = useAreaRepo();
+  const { generateAreaExcel } = useAreaExportService();
+  const { getUnits: _getUnits } = useUnitRepository();
   async function importArea({
     dataJson,
     site
@@ -1088,10 +1366,24 @@ function useAreaService() {
     try {
       dataArray = JSON.parse(dataJson);
     } catch (error) {
-      throw new import_node_server_utils5.BadRequestError("Invalid JSON format for data in excel");
+      throw new import_node_server_utils8.BadRequestError("Invalid JSON format for data in excel");
     }
     if (!dataArray || dataArray.length === 0) {
-      throw new import_node_server_utils5.NotFoundError("No data found in the uploaded file");
+      throw new import_node_server_utils8.NotFoundError("No data found in the uploaded file");
+    }
+    let availableUnits = [];
+    try {
+      const unitsData = await _getUnits({
+        page: 1,
+        limit: 999999,
+        search: "",
+        site
+      });
+      if (unitsData && unitsData.items) {
+        availableUnits = unitsData.items;
+      }
+    } catch (error) {
+      import_node_server_utils8.logger.warn(`Failed to fetch units for site: ${error}`);
     }
     const insertedAreaIds = [];
     const duplicateAreas = [];
@@ -1101,42 +1393,74 @@ function useAreaService() {
       for (let i = 0; i < dataArray.length; i++) {
         const row = dataArray[i];
         if (!row?.TYPE) {
-          import_node_server_utils5.logger.warn(`Skipping row ${i + 1} with missing TYPE:`, row);
+          import_node_server_utils8.logger.warn(`Skipping row ${i + 1} with missing TYPE:`, row);
           skippedRows.push(i + 1);
           continue;
         }
         const areaType = String(row.TYPE).trim().toLowerCase();
         if (!areaType) {
-          import_node_server_utils5.logger.warn(`Skipping row ${i + 1} with empty area type`);
+          import_node_server_utils8.logger.warn(`Skipping row ${i + 1} with empty area type`);
           skippedRows.push(i + 1);
           continue;
         }
-        if (!row?.AREA) {
-          import_node_server_utils5.logger.warn(`Skipping row ${i + 1} with missing AREA:`, row);
+        const areaNameValue = row?.NAME || row?.AREA;
+        if (!areaNameValue) {
+          import_node_server_utils8.logger.warn(`Skipping row ${i + 1} with missing NAME/AREA:`, row);
           skippedRows.push(i + 1);
           continue;
         }
-        const areaName = String(row.AREA).trim();
+        const areaName = String(areaNameValue).trim();
         if (!areaName) {
-          import_node_server_utils5.logger.warn(`Skipping row ${i + 1} with empty ${areaType} area name`);
+          import_node_server_utils8.logger.warn(`Skipping row ${i + 1} with empty ${areaType} area name`);
           skippedRows.push(i + 1);
           continue;
         }
         if (areaName.startsWith("Sample:")) {
-          import_node_server_utils5.logger.warn(`Skipping row ${i + 1} with sample area: ${areaName}`);
+          import_node_server_utils8.logger.warn(`Skipping row ${i + 1} with sample area: ${areaName}`);
           skippedRows.push(i + 1);
           continue;
         }
         try {
-          const insertedId = await _createArea({
+          const areaData = {
             type: areaType,
             name: areaName,
             site
-          });
+          };
+          if (row.SET !== void 0 && row.SET !== null && row.SET !== "") {
+            const setNumber = parseInt(String(row.SET).trim());
+            if (!isNaN(setNumber) && setNumber >= 0) {
+              areaData.set = setNumber;
+            }
+          }
+          if (row.UNITS && availableUnits.length > 0) {
+            const unitNames = String(row.UNITS).split(",").map((u) => u.trim()).filter((u) => u);
+            if (unitNames.length > 0) {
+              const areaUnits = [];
+              for (const unitName of unitNames) {
+                const foundUnit = availableUnits.find(
+                  (u) => u.name.toLowerCase() === unitName.toLowerCase()
+                );
+                if (foundUnit) {
+                  areaUnits.push({
+                    unit: foundUnit._id,
+                    name: foundUnit.name
+                  });
+                } else {
+                  import_node_server_utils8.logger.warn(
+                    `Unit "${unitName}" not found in site for area "${areaName}"`
+                  );
+                }
+              }
+              if (areaUnits.length > 0) {
+                areaData.units = areaUnits;
+              }
+            }
+          }
+          const insertedId = await _createArea(areaData);
           insertedAreaIds.push(insertedId);
-          import_node_server_utils5.logger.info(`Successfully created ${areaType} area: ${areaName}`);
+          import_node_server_utils8.logger.info(`Successfully created ${areaType} area: ${areaName}`);
         } catch (error) {
-          import_node_server_utils5.logger.error(
+          import_node_server_utils8.logger.error(
             `Error creating ${areaType} area "${areaName}": ${error.message}`
           );
           if (error.message.includes("duplicate")) {
@@ -1156,18 +1480,18 @@ function useAreaService() {
       if (skippedRows.length > 0) {
         message += `, ${skippedRows.length} rows skipped (invalid data)`;
       }
-      import_node_server_utils5.logger.info(message);
+      import_node_server_utils8.logger.info(message);
       if (insertedAreaIds.length === 0) {
         if (duplicateAreas.length > 0 && failedAreas.length === 0 && skippedRows.length === 0) {
           return {
             message: `No new areas were created. All ${duplicateAreas.length} areas already exist in the system: ${duplicateAreas.join(", ")}`
           };
         } else if (failedAreas.length > 0) {
-          throw new import_node_server_utils5.BadRequestError(
+          throw new import_node_server_utils8.BadRequestError(
             `No areas were created. ${failedAreas.length} areas failed due to errors. Please check your data format and ensure area names are valid.`
           );
         } else if (skippedRows.length > 0 && duplicateAreas.length === 0) {
-          throw new import_node_server_utils5.BadRequestError(
+          throw new import_node_server_utils8.BadRequestError(
             `No areas were created. All ${skippedRows.length} rows contained invalid or missing data.`
           );
         } else {
@@ -1178,30 +1502,46 @@ function useAreaService() {
       }
       return { message };
     } catch (error) {
-      import_node_server_utils5.logger.error("Error while uploading area information", error);
-      if (error instanceof import_node_server_utils5.BadRequestError) {
+      import_node_server_utils8.logger.error("Error while uploading area information", error);
+      if (error instanceof import_node_server_utils8.BadRequestError) {
         throw error;
       } else if (error.message.includes("validation")) {
-        throw new import_node_server_utils5.BadRequestError(
+        throw new import_node_server_utils8.BadRequestError(
           "Upload failed due to invalid data format. Please check that all required fields are properly filled."
         );
       } else {
-        throw new import_node_server_utils5.BadRequestError(
+        throw new import_node_server_utils8.BadRequestError(
           `Upload failed: ${error.message || "Please check your data format and try again."}`
         );
       }
     }
   }
-  return { importArea };
+  async function exportAreas(site) {
+    try {
+      const areas = await getAreasForChecklist(site);
+      if (!areas || !Array.isArray(areas) || areas.length === 0) {
+        throw new import_node_server_utils8.BadRequestError("No data found to export");
+      }
+      const excelBuffer = await generateAreaExcel(areas);
+      if (!excelBuffer || excelBuffer.length === 0) {
+        throw new Error("Generated Excel file is empty or invalid.");
+      }
+      return excelBuffer;
+    } catch (error) {
+      import_node_server_utils8.logger.error(`Error downloading areas: ${error.message}`);
+      throw error;
+    }
+  }
+  return { importArea, exportAreas };
 }
 
 // src/controllers/hygiene-area.controller.ts
-var import_joi3 = __toESM(require("joi"));
-var import_node_server_utils6 = require("@7365admin1/node-server-utils");
+var import_joi4 = __toESM(require("joi"));
+var import_node_server_utils9 = require("@7365admin1/node-server-utils");
 
 // src/utils/convert-excel.util.ts
 var import_stream = require("stream");
-var xlsx = __toESM(require("xlsx"));
+var xlsx2 = __toESM(require("xlsx"));
 function convertBufferFile(bufferFile) {
   return new Promise((resolve, reject) => {
     const fileStream = import_stream.Readable.from(bufferFile);
@@ -1211,10 +1551,10 @@ function convertBufferFile(bufferFile) {
     });
     fileStream.on("end", () => {
       try {
-        const workbook = xlsx.read(fileBuffer, { type: "buffer" });
+        const workbook = xlsx2.read(fileBuffer, { type: "buffer" });
         const sheetName = workbook.SheetNames[0];
         const sheet = workbook.Sheets[sheetName];
-        const jsonData = xlsx.utils.sheet_to_json(sheet);
+        const jsonData = xlsx2.utils.sheet_to_json(sheet);
         resolve(jsonData);
       } catch (error) {
         reject("Error parsing file");
@@ -1235,13 +1575,13 @@ function useAreaController() {
     updateArea: _updateArea,
     deleteArea: _deleteById
   } = useAreaRepo();
-  const { importArea: _importArea } = useAreaService();
+  const { importArea: _importArea, exportAreas: _exportAreas } = useAreaService();
   async function createArea(req, res, next) {
     const payload = { ...req.body, ...req.params };
     const { error } = areaSchema.validate(payload);
     if (error) {
-      import_node_server_utils6.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils6.BadRequestError(error.message));
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
       return;
     }
     try {
@@ -1249,24 +1589,24 @@ function useAreaController() {
       res.status(201).json({ message: "Area created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils6.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils9.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getAreas(req, res, next) {
     const query = { ...req.query, ...req.params };
-    const validation = import_joi3.default.object({
-      page: import_joi3.default.number().min(1).optional().allow("", null),
-      limit: import_joi3.default.number().min(1).optional().allow("", null),
-      search: import_joi3.default.string().optional().allow("", null),
-      type: import_joi3.default.string().valid("all", ...allowedTypes).optional().allow("", null),
-      site: import_joi3.default.string().hex().required()
+    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),
+      type: import_joi4.default.string().valid("all", ...allowedTypes).optional().allow("", null),
+      site: import_joi4.default.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils6.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils6.BadRequestError(error.message));
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -1290,12 +1630,12 @@ function useAreaController() {
     }
   }
   async function getAreaById(req, res, next) {
-    const validation = import_joi3.default.string().hex().required();
+    const validation = import_joi4.default.string().hex().required();
     const _id = req.params.id;
     const { error, value } = validation.validate(_id);
     if (error) {
-      import_node_server_utils6.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils6.BadRequestError(error.message));
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
       return;
     }
     try {
@@ -1303,22 +1643,22 @@ function useAreaController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils6.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils9.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_joi3.default.object({
-      id: import_joi3.default.string().hex().required(),
-      name: import_joi3.default.string().optional().allow("", null),
-      type: import_joi3.default.string().optional().allow("", null, ...allowedTypes),
-      set: import_joi3.default.number().min(0).optional(),
-      units: import_joi3.default.array().items(
-        import_joi3.default.object({
-          unit: import_joi3.default.string().hex().required(),
-          name: import_joi3.default.string().required()
+    const schema = import_joi4.default.object({
+      id: import_joi4.default.string().hex().required(),
+      name: import_joi4.default.string().optional().allow("", null),
+      type: import_joi4.default.string().optional().allow("", null, ...allowedTypes),
+      set: import_joi4.default.number().min(0).optional(),
+      units: import_joi4.default.array().items(
+        import_joi4.default.object({
+          unit: import_joi4.default.string().hex().required(),
+          name: import_joi4.default.string().required()
         }).required()
       ).min(1).unique("unit", { ignoreUndefined: true }).optional().messages({
         "array.unique": "Duplicate area units are not allowed"
@@ -1326,8 +1666,8 @@ function useAreaController() {
     });
     const { error } = schema.validate(payload);
     if (error) {
-      import_node_server_utils6.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils6.BadRequestError(error.message));
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
       return;
     }
     try {
@@ -1336,286 +1676,135 @@ function useAreaController() {
       res.json({ message: "Area updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils6.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils9.logger.log({ level: "error", message: error2.message });
       next(error2);
-      return;
-    }
-  }
-  async function deleteArea(req, res, next) {
-    const id = req.params.id;
-    const validation = import_joi3.default.string().hex().required();
-    const { error, value } = validation.validate(id);
-    if (error) {
-      import_node_server_utils6.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils6.BadRequestError(error.message));
-      return;
-    }
-    try {
-      await _deleteById(value);
-      res.json({ message: "Area deleted successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils6.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function importArea(req, res, next) {
-    if (!req.file) {
-      next(new import_node_server_utils6.BadRequestError("File is required!"));
-      return;
-    }
-    const { site } = req.params;
-    const schema = import_joi3.default.string().hex().required();
-    const { error, value } = schema.validate(site);
-    if (error) {
-      import_node_server_utils6.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils6.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const xlsData = await convertBufferFile(req.file.buffer);
-      const dataJson = JSON.stringify(xlsData);
-      const result = await _importArea({ dataJson, site: value });
-      return res.status(201).json(result);
-    } catch (error2) {
-      import_node_server_utils6.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  return {
-    createArea,
-    getAreas,
-    getAreaById,
-    updateArea,
-    deleteArea,
-    importArea
-  };
-}
-
-// src/models/hygiene-unit.model.ts
-var import_joi4 = __toESM(require("joi"));
-var import_mongodb4 = require("mongodb");
-var import_node_server_utils7 = require("@7365admin1/node-server-utils");
-var unitSchema = import_joi4.default.object({
-  site: import_joi4.default.string().hex().required(),
-  name: import_joi4.default.string().required()
-});
-function MUnit(value) {
-  const { error } = unitSchema.validate(value);
-  if (error) {
-    import_node_server_utils7.logger.info(`Hygiene Unit Model: ${error.message}`);
-    throw new import_node_server_utils7.BadRequestError(error.message);
-  }
-  if (value.site) {
-    try {
-      value.site = new import_mongodb4.ObjectId(value.site);
-    } catch (error2) {
-      throw new import_node_server_utils7.BadRequestError("Invalid site ID format.");
-    }
-  }
-  return {
-    site: value.site,
-    name: value.name,
-    status: "active",
-    createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: "",
-    deletedAt: ""
-  };
-}
-
-// src/services/hygiene-unit.service.ts
-var import_node_server_utils9 = require("@7365admin1/node-server-utils");
-
-// src/repositories/hygiene-unit.repository.ts
-var import_mongodb5 = require("mongodb");
-var import_node_server_utils8 = require("@7365admin1/node-server-utils");
-function useUnitRepository() {
-  const db = import_node_server_utils8.useAtlas.getDb();
-  if (!db) {
-    throw new import_node_server_utils8.InternalServerError("Unable to connect to server.");
-  }
-  const namespace_collection = "site.cleaning.area.unit";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils8.useCache)(namespace_collection);
-  async function createIndex() {
-    try {
-      await collection.createIndexes([
-        { key: { site: 1 } },
-        { key: { status: 1 } }
-      ]);
-    } catch (error) {
-      throw new import_node_server_utils8.InternalServerError("Failed to create index on hygiene unit.");
-    }
-  }
-  async function createTextIndex() {
-    try {
-      await collection.createIndex({ name: "text" });
-    } catch (error) {
-      throw new import_node_server_utils8.InternalServerError(
-        "Failed to create text index on hygiene unit."
-      );
-    }
-  }
-  async function createUniqueIndex() {
-    try {
-      await collection.createIndex(
-        { site: 1, name: 1, deletedAt: 1 },
-        { unique: true }
-      );
-    } catch (error) {
-      throw new import_node_server_utils8.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_utils8.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils8.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_utils8.BadRequestError("Unit already exists.");
-      }
-      throw error;
-    }
-  }
-  async function getUnits({
-    page = 1,
-    limit = 10,
-    search = "",
-    site
-  }) {
-    page = page > 0 ? page - 1 : 0;
-    const query = {
-      status: { $ne: "deleted" }
-    };
-    const cacheOptions = {
-      page,
-      limit
-    };
-    try {
-      site = new import_mongodb5.ObjectId(site);
-      query.site = site;
-      cacheOptions.site = site.toString();
-    } catch (error) {
-      throw new import_node_server_utils8.BadRequestError("Invalid site ID format.");
-    }
-    if (search) {
-      query.$or = [{ name: { $regex: search, $options: "i" } }];
-      cacheOptions.search = search;
-    }
-    const cacheKey = (0, import_node_server_utils8.makeCacheKey)(namespace_collection, cacheOptions);
-    const cachedData = await getCache(cacheKey);
-    if (cachedData) {
-      import_node_server_utils8.logger.info(`Cache hit for key: ${cacheKey}`);
-      return cachedData;
+      return;
+    }
+  }
+  async function deleteArea(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi4.default.string().hex().required();
+    const { error, value } = validation.validate(id);
+    if (error) {
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
+      return;
     }
     try {
-      const items = await collection.aggregate([
-        { $match: query },
-        { $project: { name: 1 } },
-        { $sort: { _id: -1 } },
-        { $skip: page * limit },
-        { $limit: limit }
-      ]).toArray();
-      const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils8.paginate)(items, page, limit, length);
-      setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils8.logger.info(`Cache set for key: ${cacheKey}`);
-      }).catch((err) => {
-        import_node_server_utils8.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
-      });
-      return data;
-    } catch (error) {
-      throw error;
+      await _deleteById(value);
+      res.json({ message: "Area deleted successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils9.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
     }
   }
-  async function updateUnit(_id, value, session) {
-    try {
-      _id = new import_mongodb5.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils8.BadRequestError("Invalid unit ID format.");
+  async function importArea(req, res, next) {
+    if (!req.file) {
+      next(new import_node_server_utils9.BadRequestError("File is required!"));
+      return;
+    }
+    const { site } = req.params;
+    const schema = import_joi4.default.string().hex().required();
+    const { error, value } = schema.validate(site);
+    if (error) {
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
+      return;
     }
     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_utils8.InternalServerError("Unable to update cleaning unit.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils8.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils8.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_utils8.BadRequestError("Area already exists.");
-      }
-      throw error;
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _importArea({ dataJson, site: value });
+      return res.status(201).json(result);
+    } catch (error2) {
+      import_node_server_utils9.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
     }
   }
-  async function deleteUnit(_id, session) {
-    try {
-      _id = new import_mongodb5.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils8.BadRequestError("Invalid unit ID format.");
+  async function exportAreas(req, res, next) {
+    const { site } = req.params;
+    const validation = import_joi4.default.string().hex().required();
+    const { error, value } = validation.validate(site);
+    if (error) {
+      import_node_server_utils9.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils9.BadRequestError(error.message));
+      return;
     }
     try {
-      const updateValue = {
-        status: "deleted",
-        updatedAt: /* @__PURE__ */ new Date(),
-        deletedAt: /* @__PURE__ */ new Date()
-      };
-      const res = await collection.updateOne(
-        { _id },
-        { $set: updateValue },
-        { session }
+      const excelBuffer = await _exportAreas(value);
+      const date = /* @__PURE__ */ new Date();
+      const formattedDate = `${String(date.getMonth() + 1).padStart(
+        2,
+        "0"
+      )}-${String(date.getDate()).padStart(2, "0")}-${date.getFullYear()}`;
+      res.setHeader(
+        "Content-Type",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
       );
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils8.InternalServerError("Unable to delete unit.");
+      res.setHeader(
+        "Content-Disposition",
+        `attachment; filename="areas-${formattedDate}.xlsx"`
+      );
+      res.setHeader("Content-Length", excelBuffer.length);
+      res.end(excelBuffer);
+      return;
+    } catch (error2) {
+      import_node_server_utils9.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createArea,
+    getAreas,
+    getAreaById,
+    updateArea,
+    deleteArea,
+    importArea,
+    exportAreas
+  };
+}
+
+// src/services/hygiene-unit.service.ts
+var import_node_server_utils11 = require("@7365admin1/node-server-utils");
+
+// src/services/hygiene-unit-export.service.ts
+var import_node_server_utils10 = require("@7365admin1/node-server-utils");
+var xlsx3 = __toESM(require("xlsx"));
+function useUnitExportService() {
+  async function generateUnitExcel(units) {
+    try {
+      const rows = [];
+      rows.push(["UNIT"]);
+      for (const unit of units) {
+        const unitName = unit.name || "";
+        rows.push([unitName]);
       }
-      delNamespace().then(() => {
-        import_node_server_utils8.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils8.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
+      const workbook = xlsx3.utils.book_new();
+      const worksheet = xlsx3.utils.aoa_to_sheet(rows);
+      worksheet["!cols"] = [
+        { width: 25 }
+        // UNIT
+      ];
+      xlsx3.utils.book_append_sheet(workbook, worksheet, "Units");
+      const excelBuffer = xlsx3.write(workbook, {
+        type: "buffer",
+        bookType: "xlsx"
       });
-      return res.modifiedCount;
+      return excelBuffer;
     } catch (error) {
+      import_node_server_utils10.logger.log({
+        level: "error",
+        message: `Failed to generate unit Excel: ${error.message}`
+      });
       throw error;
     }
   }
   return {
-    createIndex,
-    createTextIndex,
-    createUniqueIndex,
-    createUnit,
-    getUnits,
-    updateUnit,
-    deleteUnit
+    generateUnitExcel
   };
 }
 
@@ -1635,10 +1824,10 @@ function useUnitService() {
     try {
       dataArray = JSON.parse(dataJson);
     } catch (error) {
-      throw new import_node_server_utils9.BadRequestError("Invalid JSON format for data in excel");
+      throw new import_node_server_utils11.BadRequestError("Invalid JSON format for data in excel");
     }
     if (!dataArray || dataArray.length === 0) {
-      throw new import_node_server_utils9.NotFoundError("No data found in the uploaded file");
+      throw new import_node_server_utils11.NotFoundError("No data found in the uploaded file");
     }
     const insertedUnitIds = [];
     const duplicateUnits = [];
@@ -1648,18 +1837,18 @@ function useUnitService() {
       for (let i = 0; i < dataArray.length; i++) {
         const row = dataArray[i];
         if (!row?.UNIT) {
-          import_node_server_utils9.logger.warn(`Skipping row ${i + 1} with missing UNIT:`, row);
+          import_node_server_utils11.logger.warn(`Skipping row ${i + 1} with missing UNIT:`, row);
           skippedRows.push(i + 1);
           continue;
         }
         const unitName = String(row.UNIT).trim();
         if (!unitName) {
-          import_node_server_utils9.logger.warn(`Skipping row ${i + 1} with empty unit name`);
+          import_node_server_utils11.logger.warn(`Skipping row ${i + 1} with empty unit name`);
           skippedRows.push(i + 1);
           continue;
         }
         if (unitName.startsWith("Sample:")) {
-          import_node_server_utils9.logger.warn(`Skipping row ${i + 1} with sample unit: ${unitName}`);
+          import_node_server_utils11.logger.warn(`Skipping row ${i + 1} with sample unit: ${unitName}`);
           skippedRows.push(i + 1);
           continue;
         }
@@ -1669,9 +1858,9 @@ function useUnitService() {
             site
           });
           insertedUnitIds.push(insertedId);
-          import_node_server_utils9.logger.info(`Successfully created unit: ${unitName}`);
+          import_node_server_utils11.logger.info(`Successfully created unit: ${unitName}`);
         } catch (error) {
-          import_node_server_utils9.logger.error(`Error creating unit "${unitName}": ${error.message}`);
+          import_node_server_utils11.logger.error(`Error creating unit "${unitName}": ${error.message}`);
           if (error.message.includes("Unit already exists")) {
             duplicateUnits.push(unitName);
           } else {
@@ -1689,44 +1878,44 @@ function useUnitService() {
       if (skippedRows.length > 0) {
         message += `, ${skippedRows.length} rows skipped (invalid data)`;
       }
-      import_node_server_utils9.logger.info(message);
+      import_node_server_utils11.logger.info(message);
       if (insertedUnitIds.length === 0) {
         if (duplicateUnits.length > 0 && failedUnits.length === 0) {
-          throw new import_node_server_utils9.BadRequestError(
+          throw new import_node_server_utils11.BadRequestError(
             `No new units were created. All ${duplicateUnits.length} units already exist in the system: ${duplicateUnits.join(", ")}`
           );
         } else if (failedUnits.length > 0) {
-          throw new import_node_server_utils9.BadRequestError(
+          throw new import_node_server_utils11.BadRequestError(
             `No units were created. Please check your data format and ensure unit names are valid.`
           );
         } else if (skippedRows.length > 0) {
-          throw new import_node_server_utils9.BadRequestError(
+          throw new import_node_server_utils11.BadRequestError(
             `No units were created. All rows contained invalid or missing unit names.`
           );
         }
       }
       return { message };
     } catch (error) {
-      import_node_server_utils9.logger.error("Error while uploading unit information", error);
-      if (error instanceof import_node_server_utils9.BadRequestError) {
+      import_node_server_utils11.logger.error("Error while uploading unit information", error);
+      if (error instanceof import_node_server_utils11.BadRequestError) {
         throw error;
       } else if (error.message.includes("duplicate")) {
-        throw new import_node_server_utils9.BadRequestError(
+        throw new import_node_server_utils11.BadRequestError(
           "Upload failed due to duplicate unit names. Please ensure all unit names are unique."
         );
       } else if (error.message.includes("validation")) {
-        throw new import_node_server_utils9.BadRequestError(
+        throw new import_node_server_utils11.BadRequestError(
           "Upload failed due to invalid data format. Please check that all required fields are properly filled."
         );
       } else {
-        throw new import_node_server_utils9.BadRequestError(
+        throw new import_node_server_utils11.BadRequestError(
           `Upload failed: ${error.message || "Please check your data format and try again."}`
         );
       }
     }
   }
   async function updateUnit(_id, value) {
-    const session = import_node_server_utils9.useAtlas.getClient()?.startSession();
+    const session = import_node_server_utils11.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const result = await _updateUnit(_id, value, session);
@@ -1737,7 +1926,7 @@ function useUnitService() {
       await session?.commitTransaction();
       return result;
     } catch (error) {
-      import_node_server_utils9.logger.error(`Error updating unit and associated areas:`, error);
+      import_node_server_utils11.logger.error(`Error updating unit and associated areas:`, error);
       if (session?.inTransaction()) {
         await session?.abortTransaction();
       }
@@ -1747,18 +1936,18 @@ function useUnitService() {
     }
   }
   async function deleteUnit(_id) {
-    const session = import_node_server_utils9.useAtlas.getClient()?.startSession();
+    const session = import_node_server_utils11.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const isExistingArea = await verifyAreaByUnitId(_id);
       if (isExistingArea) {
-        throw new import_node_server_utils9.BadRequestError("Failed to delete unit, unit is in use.");
+        throw new import_node_server_utils11.BadRequestError("Failed to delete unit, unit is in use.");
       }
       const result = await _deleteUnit(_id, session);
       await session?.commitTransaction();
       return result;
     } catch (error) {
-      import_node_server_utils9.logger.error(`Error deleting unit:`, error);
+      import_node_server_utils11.logger.error(`Error deleting unit:`, error);
       if (session?.inTransaction()) {
         await session?.abortTransaction();
       }
@@ -1767,25 +1956,49 @@ function useUnitService() {
       session?.endSession();
     }
   }
-  return { importUnit, updateUnit, deleteUnit };
+  async function exportUnits(site) {
+    const { generateUnitExcel: _generateUnitExcel } = useUnitExportService();
+    const { getUnits: _getUnits } = useUnitRepository();
+    try {
+      const data = await _getUnits({
+        page: 1,
+        limit: 999999,
+        search: "",
+        site
+      });
+      if (!data || !data.items || data.items.length === 0) {
+        throw new import_node_server_utils11.BadRequestError("No data found to export");
+      }
+      const excelBuffer = await _generateUnitExcel(data.items);
+      if (!excelBuffer || excelBuffer.length === 0) {
+        throw new Error("Generated Excel file is empty or invalid.");
+      }
+      return excelBuffer;
+    } catch (error) {
+      import_node_server_utils11.logger.error(`Error downloading units: ${error.message}`);
+      throw error;
+    }
+  }
+  return { importUnit, updateUnit, deleteUnit, exportUnits };
 }
 
 // src/controllers/hygiene-unit.controller.ts
 var import_joi5 = __toESM(require("joi"));
-var import_node_server_utils10 = require("@7365admin1/node-server-utils");
+var import_node_server_utils12 = require("@7365admin1/node-server-utils");
 function useUnitController() {
   const { createUnit: _createUnit, getUnits: _getUnits } = useUnitRepository();
   const {
     updateUnit: _updateUnit,
     deleteUnit: _deleteUnit,
-    importUnit: _importUnit
+    importUnit: _importUnit,
+    exportUnits: _exportUnits
   } = useUnitService();
   async function createUnit(req, res, next) {
     const payload = { ...req.body, ...req.params };
     const { error } = unitSchema.validate(payload);
     if (error) {
-      import_node_server_utils10.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils10.BadRequestError(error.message));
+      import_node_server_utils12.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils12.BadRequestError(error.message));
       return;
     }
     try {
@@ -1793,7 +2006,7 @@ function useUnitController() {
       res.status(201).json({ message: "Unit created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils10.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils12.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -1808,8 +2021,8 @@ function useUnitController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils10.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils10.BadRequestError(error.message));
+      import_node_server_utils12.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils12.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -1826,7 +2039,7 @@ function useUnitController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils10.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils12.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -1839,8 +2052,8 @@ function useUnitController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils10.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils10.BadRequestError(error.message));
+      import_node_server_utils12.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils12.BadRequestError(error.message));
       return;
     }
     try {
@@ -1849,7 +2062,7 @@ function useUnitController() {
       res.json({ message: "Unit updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils10.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils12.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -1861,8 +2074,8 @@ function useUnitController() {
     });
     const { error, value } = validation.validate({ id });
     if (error) {
-      import_node_server_utils10.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils10.BadRequestError(error.message));
+      import_node_server_utils12.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils12.BadRequestError(error.message));
       return;
     }
     try {
@@ -1870,22 +2083,22 @@ function useUnitController() {
       res.json({ message: "Unit deleted successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils10.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils12.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function importUnit(req, res, next) {
     if (!req.file) {
-      next(new import_node_server_utils10.BadRequestError("File is required!"));
+      next(new import_node_server_utils12.BadRequestError("File is required!"));
       return;
     }
     const { site } = req.params;
     const validation = import_joi5.default.string().hex().required();
     const { error, value } = validation.validate(site);
     if (error) {
-      import_node_server_utils10.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils10.BadRequestError(error.message));
+      import_node_server_utils12.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils12.BadRequestError(error.message));
       return;
     }
     try {
@@ -1894,7 +2107,40 @@ function useUnitController() {
       const result = await _importUnit({ dataJson, site: value });
       return res.status(201).json(result);
     } catch (error2) {
-      import_node_server_utils10.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils12.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function exportUnits(req, res, next) {
+    const { site } = req.params;
+    const validation = import_joi5.default.string().hex().required();
+    const { error, value } = validation.validate(site);
+    if (error) {
+      import_node_server_utils12.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils12.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const excelBuffer = await _exportUnits(value);
+      const date = /* @__PURE__ */ new Date();
+      const formattedDate = `${String(date.getMonth() + 1).padStart(
+        2,
+        "0"
+      )}-${String(date.getDate()).padStart(2, "0")}-${date.getFullYear()}`;
+      res.setHeader(
+        "Content-Type",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      );
+      res.setHeader(
+        "Content-Disposition",
+        `attachment; filename="units-${formattedDate}.xlsx"`
+      );
+      res.setHeader("Content-Length", excelBuffer.length);
+      res.end(excelBuffer);
+      return;
+    } catch (error2) {
+      import_node_server_utils12.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -1904,14 +2150,15 @@ function useUnitController() {
     getUnits,
     updateUnit,
     deleteUnit,
-    importUnit
+    importUnit,
+    exportUnits
   };
 }
 
 // src/models/hygiene-parent-checklist.model.ts
 var import_joi6 = __toESM(require("joi"));
 var import_mongodb6 = require("mongodb");
-var import_node_server_utils11 = require("@7365admin1/node-server-utils");
+var import_node_server_utils13 = require("@7365admin1/node-server-utils");
 var parentChecklistSchema = import_joi6.default.object({
   createdAt: import_joi6.default.alternatives().try(import_joi6.default.date(), import_joi6.default.string()).optional().allow("", null),
   site: import_joi6.default.string().hex().required()
@@ -1919,14 +2166,14 @@ var parentChecklistSchema = import_joi6.default.object({
 function MParentChecklist(value) {
   const { error } = parentChecklistSchema.validate(value);
   if (error) {
-    import_node_server_utils11.logger.info(`Hygiene Parent Checklist Model: ${error.message}`);
-    throw new import_node_server_utils11.BadRequestError(error.message);
+    import_node_server_utils13.logger.info(`Hygiene Parent Checklist Model: ${error.message}`);
+    throw new import_node_server_utils13.BadRequestError(error.message);
   }
   if (value.site) {
     try {
       value.site = new import_mongodb6.ObjectId(value.site);
     } catch (error2) {
-      throw new import_node_server_utils11.BadRequestError(`Invalid site ID format: ${value.site}`);
+      throw new import_node_server_utils13.BadRequestError(`Invalid site ID format: ${value.site}`);
     }
   }
   return {
@@ -1939,17 +2186,17 @@ function MParentChecklist(value) {
 
 // src/repositories/hygiene-parent-checklist.repository.ts
 var import_mongodb7 = require("mongodb");
-var import_node_server_utils12 = require("@7365admin1/node-server-utils");
+var import_node_server_utils14 = require("@7365admin1/node-server-utils");
 function useParentChecklistRepo() {
-  const db = import_node_server_utils12.useAtlas.getDb();
+  const db = import_node_server_utils14.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils12.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils14.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "site.cleaning.schedules";
   const site_collection = "sites";
   const collection = db.collection(namespace_collection);
   const siteCollection = db.collection(site_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils12.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils14.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -1958,7 +2205,7 @@ function useParentChecklistRepo() {
         { key: { status: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils12.InternalServerError(
+      throw new import_node_server_utils14.InternalServerError(
         "Failed to create index on hygiene parent checklist."
       );
     }
@@ -1979,16 +2226,16 @@ function useParentChecklistRepo() {
       if (value.site) {
         try {
           existingQuery.site = new import_mongodb7.ObjectId(value.site);
-          import_node_server_utils12.logger.info(
+          import_node_server_utils14.logger.info(
             `createParentChecklist: Looking for existing checklist with query: ${JSON.stringify(
               { ...existingQuery, site: value.site }
             )}`
           );
         } catch (error) {
-          throw new import_node_server_utils12.BadRequestError("Invalid site ID format.");
+          throw new import_node_server_utils14.BadRequestError("Invalid site ID format.");
         }
       } else {
-        import_node_server_utils12.logger.info(
+        import_node_server_utils14.logger.info(
           `createParentChecklist: Looking for existing checklist with query (no site filter): ${JSON.stringify(
             existingQuery
           )}`
@@ -1997,7 +2244,7 @@ function useParentChecklistRepo() {
       const existingChecklist = await collection.findOne(existingQuery);
       if (existingChecklist) {
         const dateStr2 = currentDate.toISOString().split("T")[0];
-        import_node_server_utils12.logger.info(
+        import_node_server_utils14.logger.info(
           `Parent checklist already exists for ${value.site ? `site ${value.site} on` : ""} today: ${dateStr2}. Found checklist: ${JSON.stringify({
             _id: existingChecklist._id,
             site: existingChecklist.site
@@ -2012,27 +2259,27 @@ function useParentChecklistRepo() {
         });
         const result2 = await collection.insertOne(checklistDoc, { session });
         delNamespace().then(() => {
-          import_node_server_utils12.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+          import_node_server_utils14.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
         }).catch((err) => {
-          import_node_server_utils12.logger.error(
+          import_node_server_utils14.logger.error(
             `Failed to clear cache for namespace: ${namespace_collection}`,
             err
           );
         });
         const dateStr2 = currentDate.toISOString().split("T")[0];
-        import_node_server_utils12.logger.info(
+        import_node_server_utils14.logger.info(
           `Created parent checklist for site ${value.site} for today: ${dateStr2}`
         );
         return result2.insertedId;
       }
       const siteIds = await getHygieneSiteIds();
       if (!Array.isArray(siteIds)) {
-        import_node_server_utils12.logger.error("getHygieneSiteIds returned non-array value:", siteIds);
-        throw new import_node_server_utils12.InternalServerError("Failed to retrieve site IDs");
+        import_node_server_utils14.logger.error("getHygieneSiteIds returned non-array value:", siteIds);
+        throw new import_node_server_utils14.InternalServerError("Failed to retrieve site IDs");
       }
       if (siteIds.length === 0) {
-        import_node_server_utils12.logger.warn("No sites found for creating parent checklist");
-        throw new import_node_server_utils12.BadRequestError("No sites available for checklist creation");
+        import_node_server_utils14.logger.warn("No sites found for creating parent checklist");
+        throw new import_node_server_utils14.BadRequestError("No sites available for checklist creation");
       }
       const checklistDocs = [];
       for (const site of siteIds) {
@@ -2045,20 +2292,20 @@ function useParentChecklistRepo() {
       }
       const result = await collection.insertMany(checklistDocs, { session });
       delNamespace().then(() => {
-        import_node_server_utils12.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils14.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils12.logger.error(
+        import_node_server_utils14.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
       });
       const dateStr = currentDate.toISOString().split("T")[0];
-      import_node_server_utils12.logger.info(
+      import_node_server_utils14.logger.info(
         `Created ${Object.keys(result.insertedIds).length} parent checklists for today: ${dateStr}`
       );
       return Object.values(result.insertedIds);
     } catch (error) {
-      import_node_server_utils12.logger.error("Failed to create daily parent checklist", error);
+      import_node_server_utils14.logger.error("Failed to create daily parent checklist", error);
       throw error;
     }
   }
@@ -2082,7 +2329,7 @@ function useParentChecklistRepo() {
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils12.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils14.BadRequestError("Invalid site ID format.");
     }
     if (search) {
       query.$text = { $search: search };
@@ -2106,10 +2353,10 @@ function useParentChecklistRepo() {
       query.status = status;
       cacheOptions.status = status;
     }
-    const cacheKey = (0, import_node_server_utils12.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils14.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils12.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils14.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -2142,11 +2389,11 @@ function useParentChecklistRepo() {
       );
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils12.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils14.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils12.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils14.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils12.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils14.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -2157,7 +2404,7 @@ function useParentChecklistRepo() {
     try {
       _id = new import_mongodb7.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils12.BadRequestError("Invalid parent checklist ID format.");
+      throw new import_node_server_utils14.BadRequestError("Invalid parent checklist ID format.");
     }
     try {
       const updateValue = {
@@ -2173,14 +2420,14 @@ function useParentChecklistRepo() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils12.InternalServerError(
+        throw new import_node_server_utils14.InternalServerError(
           "Unable to update parent checklist status."
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils12.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils14.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils12.logger.error(
+        import_node_server_utils14.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -2194,10 +2441,10 @@ function useParentChecklistRepo() {
     const query = {
       status: { $ne: "deleted" }
     };
-    const cacheKey = (0, import_node_server_utils12.makeCacheKey)(site_collection, { tag: "site-ids" });
+    const cacheKey = (0, import_node_server_utils14.makeCacheKey)(site_collection, { tag: "site-ids" });
     const cachedData = await getCache(cacheKey);
     if (cachedData && Array.isArray(cachedData)) {
-      import_node_server_utils12.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils14.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -2209,14 +2456,14 @@ function useParentChecklistRepo() {
       const siteIds = items.map((item) => item._id.toString());
       if (siteIds.length > 0) {
         setCache(cacheKey, siteIds, 15 * 60).then(() => {
-          import_node_server_utils12.logger.info(`Cache set for key: ${cacheKey}`);
+          import_node_server_utils14.logger.info(`Cache set for key: ${cacheKey}`);
         }).catch((err) => {
-          import_node_server_utils12.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+          import_node_server_utils14.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
         });
       }
       return siteIds;
     } catch (error) {
-      import_node_server_utils12.logger.error("Failed to get hygiene site IDs", error);
+      import_node_server_utils14.logger.error("Failed to get hygiene site IDs", error);
       throw error;
     }
   }
@@ -2230,7 +2477,7 @@ function useParentChecklistRepo() {
 
 // src/controllers/hygiene-parent-checklist.controller.ts
 var import_joi7 = __toESM(require("joi"));
-var import_node_server_utils13 = require("@7365admin1/node-server-utils");
+var import_node_server_utils15 = require("@7365admin1/node-server-utils");
 function useParentChecklistController() {
   const {
     createParentChecklist: _createParentChecklist,
@@ -2240,8 +2487,8 @@ function useParentChecklistController() {
     const payload = req.body;
     const { error } = parentChecklistSchema.validate(payload);
     if (error) {
-      import_node_server_utils13.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils13.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
@@ -2249,7 +2496,7 @@ function useParentChecklistController() {
       res.status(201).json({ message: "Parent checklist created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils13.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -2267,8 +2514,8 @@ function useParentChecklistController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils13.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils13.BadRequestError(error.message));
+      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;
@@ -2291,7 +2538,7 @@ function useParentChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils13.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -2305,7 +2552,7 @@ function useParentChecklistController() {
 // src/models/hygiene-area-checklist.model.ts
 var import_joi8 = __toESM(require("joi"));
 var import_mongodb8 = require("mongodb");
-var import_node_server_utils14 = require("@7365admin1/node-server-utils");
+var import_node_server_utils16 = require("@7365admin1/node-server-utils");
 var allowedChecklistStatus = ["ready", "completed"];
 var areaChecklistSchema = import_joi8.default.object({
   schedule: import_joi8.default.string().hex().required(),
@@ -2328,21 +2575,21 @@ var areaChecklistSchema = import_joi8.default.object({
 function MAreaChecklist(value) {
   const { error } = areaChecklistSchema.validate(value);
   if (error) {
-    import_node_server_utils14.logger.info(`Hygiene Checklist Area Model: ${error.message}`);
-    throw new import_node_server_utils14.BadRequestError(error.message);
+    import_node_server_utils16.logger.info(`Hygiene Checklist Area Model: ${error.message}`);
+    throw new import_node_server_utils16.BadRequestError(error.message);
   }
   if (value.schedule) {
     try {
       value.schedule = new import_mongodb8.ObjectId(value.schedule);
     } catch (error2) {
-      throw new import_node_server_utils14.BadRequestError("Invalid schedule ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid schedule ID format.");
     }
   }
   if (value.area) {
     try {
       value.area = new import_mongodb8.ObjectId(value.area);
     } catch (error2) {
-      throw new import_node_server_utils14.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid area ID format.");
     }
   }
   if (value.checklist && Array.isArray(value.checklist)) {
@@ -2364,7 +2611,7 @@ function MAreaChecklist(value) {
     try {
       value.createdBy = new import_mongodb8.ObjectId(value.createdBy);
     } catch (error2) {
-      throw new import_node_server_utils14.BadRequestError("Invalid createdBy ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid createdBy ID format.");
     }
   }
   return {
@@ -2382,19 +2629,19 @@ function MAreaChecklist(value) {
 }
 
 // src/services/hygiene-area-checklist.service.ts
-var import_node_server_utils16 = require("@7365admin1/node-server-utils");
+var import_node_server_utils18 = require("@7365admin1/node-server-utils");
 
 // src/repositories/hygiene-area-checklist.repository.ts
 var import_mongodb9 = require("mongodb");
-var import_node_server_utils15 = require("@7365admin1/node-server-utils");
+var import_node_server_utils17 = require("@7365admin1/node-server-utils");
 function useAreaChecklistRepo() {
-  const db = import_node_server_utils15.useAtlas.getDb();
+  const db = import_node_server_utils17.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils15.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils17.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "site.cleaning.schedule.areas";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils15.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils17.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -2406,7 +2653,7 @@ function useAreaChecklistRepo() {
         { key: { "checklist.units.status": 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils15.InternalServerError(
+      throw new import_node_server_utils17.InternalServerError(
         "Failed to create index on hygiene checklist area."
       );
     }
@@ -2419,7 +2666,7 @@ function useAreaChecklistRepo() {
         "checklist.units.remarks": "text"
       });
     } catch (error) {
-      throw new import_node_server_utils15.InternalServerError(
+      throw new import_node_server_utils17.InternalServerError(
         "Failed to create text index on hygiene checklist area."
       );
     }
@@ -2442,7 +2689,7 @@ function useAreaChecklistRepo() {
         }
       });
       if (existingChecklist) {
-        import_node_server_utils15.logger.info(
+        import_node_server_utils17.logger.info(
           `Area checklist already exists for area ${value.name} on ${currentDate.toISOString().split("T")[0]}`
         );
         return existingChecklist._id;
@@ -2450,9 +2697,9 @@ function useAreaChecklistRepo() {
       const processedValue = MAreaChecklist(value);
       const result = await collection.insertOne(processedValue, { session });
       delNamespace().then(() => {
-        import_node_server_utils15.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(
+        import_node_server_utils17.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -2480,7 +2727,7 @@ function useAreaChecklistRepo() {
       query.schedule = new import_mongodb9.ObjectId(schedule);
       cacheOptions.schedule = schedule.toString();
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid parent checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid parent checklist ID format.");
     }
     if (type && type !== "all") {
       query.type = type;
@@ -2494,11 +2741,11 @@ function useAreaChecklistRepo() {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils15.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, cacheOptions);
     if (!session) {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils15.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
     }
@@ -2572,11 +2819,11 @@ function useAreaChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline, { session }).toArray();
       const length = await collection.countDocuments(query, { session });
-      const data = (0, import_node_server_utils15.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils17.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils15.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -2602,7 +2849,7 @@ function useAreaChecklistRepo() {
       query.schedule = new import_mongodb9.ObjectId(schedule);
       cacheOptions.schedule = schedule.toString();
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid parent checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid parent checklist ID format.");
     }
     if (type) {
       query.type = type;
@@ -2625,10 +2872,10 @@ function useAreaChecklistRepo() {
     } else {
       query.status = { $in: ["ongoing", "completed"] };
     }
-    const cacheKey = (0, import_node_server_utils15.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils15.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -2676,11 +2923,11 @@ function useAreaChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils15.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils17.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils15.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -2691,14 +2938,14 @@ function useAreaChecklistRepo() {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
-    const cacheKey = (0, import_node_server_utils15.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, {
       _id: _id.toString()
     });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils15.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -2821,16 +3068,16 @@ function useAreaChecklistRepo() {
         collection.aggregate(unitPipeline).toArray()
       ]);
       if (!area.length) {
-        throw new import_node_server_utils15.BadRequestError("Area checklist not found.");
+        throw new import_node_server_utils17.BadRequestError("Area checklist not found.");
       }
       const items = {
         area: area[0],
         units
       };
       setCache(cacheKey, items, 15 * 60).then(() => {
-        import_node_server_utils15.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return items;
     } catch (error) {
@@ -2853,17 +3100,17 @@ function useAreaChecklistRepo() {
       query._id = new import_mongodb9.ObjectId(_id);
       cacheOptions._id = _id.toString();
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils15.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, cacheOptions);
     if (!session) {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils15.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
     }
@@ -2951,11 +3198,11 @@ function useAreaChecklistRepo() {
         collection.aggregate(countPipeline, { session }).toArray()
       ]);
       const length = countResult.length > 0 ? countResult[0].total : 0;
-      const data = (0, import_node_server_utils15.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils17.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils15.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -2966,7 +3213,7 @@ function useAreaChecklistRepo() {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
     try {
       const area = await collection.findOne(
@@ -2974,7 +3221,7 @@ function useAreaChecklistRepo() {
         { projection: { schedule: 1, name: 1, type: 1, status: 1 }, session }
       );
       if (!area) {
-        throw new import_node_server_utils15.BadRequestError("Area checklist not found.");
+        throw new import_node_server_utils17.BadRequestError("Area checklist not found.");
       }
       return area;
     } catch (error) {
@@ -2986,12 +3233,12 @@ function useAreaChecklistRepo() {
       schedule = new import_mongodb9.ObjectId(schedule);
       area = new import_mongodb9.ObjectId(area);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
     try {
       const data = await collection.findOne({ schedule, area }, { session });
       if (!data) {
-        throw new import_node_server_utils15.BadRequestError("Area checklist not found.");
+        throw new import_node_server_utils17.BadRequestError("Area checklist not found.");
       }
       return data;
     } catch (error) {
@@ -3002,12 +3249,12 @@ function useAreaChecklistRepo() {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
     try {
       unitId = new import_mongodb9.ObjectId(unitId);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid unit checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid unit checklist ID format.");
     }
     try {
       const now = /* @__PURE__ */ new Date();
@@ -3032,19 +3279,19 @@ function useAreaChecklistRepo() {
         { arrayFilters, session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils15.InternalServerError("Unable to update area checklist unit.");
+        throw new import_node_server_utils17.InternalServerError("Unable to update area checklist unit.");
       }
       delNamespace().then(() => {
-        import_node_server_utils15.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(
+        import_node_server_utils17.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
       });
       return res.modifiedCount;
     } catch (error) {
-      import_node_server_utils15.logger.error("Error updating area checklist unit:", error.message);
+      import_node_server_utils17.logger.error("Error updating area checklist unit:", error.message);
       throw error;
     }
   }
@@ -3052,7 +3299,7 @@ function useAreaChecklistRepo() {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
     try {
       const updateValue = {
@@ -3065,12 +3312,12 @@ function useAreaChecklistRepo() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils15.InternalServerError("Unable to update area checklist.");
+        throw new import_node_server_utils17.InternalServerError("Unable to update area checklist.");
       }
       delNamespace().then(() => {
-        import_node_server_utils15.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(
+        import_node_server_utils17.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3084,7 +3331,7 @@ function useAreaChecklistRepo() {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils15.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
     }
     try {
       const updateValue = {
@@ -3100,14 +3347,14 @@ function useAreaChecklistRepo() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils15.InternalServerError(
+        throw new import_node_server_utils17.InternalServerError(
           "Unable to update area checklist status."
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils15.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils15.logger.error(
+        import_node_server_utils17.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3130,7 +3377,7 @@ function useAreaChecklistRepo() {
       ).toArray();
       return result.length > 0 && result[0].maxSet ? result[0].maxSet : 0;
     } catch (error) {
-      import_node_server_utils15.logger.error(`Error getting max set number for area ${areaId}:`, error);
+      import_node_server_utils17.logger.error(`Error getting max set number for area ${areaId}:`, error);
       return 0;
     }
   }
@@ -3165,7 +3412,7 @@ function useAreaChecklistService() {
   } = useAreaChecklistRepo();
   const { updateParentChecklistStatuses } = useParentChecklistRepo();
   async function createAreaChecklist(value) {
-    const session = import_node_server_utils16.useAtlas.getClient()?.startSession();
+    const session = import_node_server_utils18.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const results = [];
@@ -3178,7 +3425,7 @@ function useAreaChecklistService() {
           const batch = areas.slice(i, i + BATCH_SIZE);
           const batchPromises = batch.map(async (area) => {
             if (!area.units || area.units.length === 0) {
-              import_node_server_utils16.logger.warn(
+              import_node_server_utils18.logger.warn(
                 `Skipping area ${area.name} (${area._id}): No units defined`
               );
               return null;
@@ -3209,19 +3456,19 @@ function useAreaChecklistService() {
           const batchResults = await Promise.all(batchPromises);
           results.push(...batchResults.filter((id) => id !== null));
         }
-        import_node_server_utils16.logger.info(
+        import_node_server_utils18.logger.info(
           `Created ${totalChecklistsCreated} area checklists out of ${areas.length} areas for site: ${value.site}`
         );
       } else {
-        import_node_server_utils16.logger.warn(`No common areas found for site: ${value.site}`);
+        import_node_server_utils18.logger.warn(`No common areas found for site: ${value.site}`);
       }
       await session?.commitTransaction();
-      import_node_server_utils16.logger.info(
+      import_node_server_utils18.logger.info(
         `Successfully created ${totalChecklistsCreated} area checklists for site: ${value.site}`
       );
       return results;
     } catch (error) {
-      import_node_server_utils16.logger.error(`Error generating area checklists:`, error);
+      import_node_server_utils18.logger.error(`Error generating area checklists:`, error);
       if (session?.inTransaction()) {
         await session?.abortTransaction();
       }
@@ -3231,7 +3478,7 @@ function useAreaChecklistService() {
     }
   }
   async function completeAreaChecklistUnits(_id, set, unitId, value) {
-    const session = import_node_server_utils16.useAtlas.getClient()?.startSession();
+    const session = import_node_server_utils18.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       await _completeAreaChecklistUnits(_id, set, unitId, value, session);
@@ -3297,7 +3544,7 @@ function useAreaChecklistService() {
             session
           );
         } else {
-          import_node_server_utils16.logger.info(
+          import_node_server_utils18.logger.info(
             "No area checklists found, keeping parent status as ready"
           );
         }
@@ -3305,7 +3552,7 @@ function useAreaChecklistService() {
       await session?.commitTransaction();
       return;
     } catch (error) {
-      import_node_server_utils16.logger.error(`Error updating area checklist unit and statuses:`, error);
+      import_node_server_utils18.logger.error(`Error updating area checklist unit and statuses:`, error);
       if (session?.inTransaction()) {
         await session?.abortTransaction();
       }
@@ -3319,7 +3566,7 @@ function useAreaChecklistService() {
 
 // src/controllers/hygiene-area-checklist.controller.ts
 var import_joi9 = __toESM(require("joi"));
-var import_node_server_utils17 = require("@7365admin1/node-server-utils");
+var import_node_server_utils19 = require("@7365admin1/node-server-utils");
 function useAreaChecklistController() {
   const {
     getAllAreaChecklist: _getAllAreaChecklist,
@@ -3349,8 +3596,8 @@ function useAreaChecklistController() {
     });
     const { error, value } = validation.validate(payload);
     if (error) {
-      import_node_server_utils17.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils17.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -3358,7 +3605,7 @@ function useAreaChecklistController() {
       res.status(201).json({ message: "Area checklist generated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils17.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3375,8 +3622,8 @@ function useAreaChecklistController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils17.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils17.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -3397,7 +3644,7 @@ function useAreaChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils17.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3415,8 +3662,8 @@ function useAreaChecklistController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils17.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils17.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -3439,7 +3686,7 @@ function useAreaChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils17.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3449,8 +3696,8 @@ function useAreaChecklistController() {
     const _id = req.params.id;
     const { error, value } = validation.validate(_id);
     if (error) {
-      import_node_server_utils17.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils17.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -3458,7 +3705,7 @@ function useAreaChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils17.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3473,8 +3720,8 @@ function useAreaChecklistController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils17.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils17.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -3491,7 +3738,7 @@ function useAreaChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils17.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3516,8 +3763,8 @@ function useAreaChecklistController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils17.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils17.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -3531,7 +3778,7 @@ function useAreaChecklistController() {
       res.json({ message: "Area checklist updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils17.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3549,7 +3796,7 @@ function useAreaChecklistController() {
 // src/models/hygiene-supply.model.ts
 var import_joi10 = __toESM(require("joi"));
 var import_mongodb10 = require("mongodb");
-var import_node_server_utils18 = require("@7365admin1/node-server-utils");
+var import_node_server_utils20 = require("@7365admin1/node-server-utils");
 var supplySchema = import_joi10.default.object({
   site: import_joi10.default.string().hex().required(),
   name: import_joi10.default.string().required(),
@@ -3558,14 +3805,14 @@ var supplySchema = import_joi10.default.object({
 function MSupply(value) {
   const { error } = supplySchema.validate(value);
   if (error) {
-    import_node_server_utils18.logger.info(`Hygiene Supply Model: ${error.message}`);
-    throw new import_node_server_utils18.BadRequestError(error.message);
+    import_node_server_utils20.logger.info(`Hygiene Supply Model: ${error.message}`);
+    throw new import_node_server_utils20.BadRequestError(error.message);
   }
   if (value.site) {
     try {
       value.site = new import_mongodb10.ObjectId(value.site);
     } catch (error2) {
-      throw new import_node_server_utils18.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils20.BadRequestError("Invalid site ID format.");
     }
   }
   return {
@@ -3582,20 +3829,20 @@ function MSupply(value) {
 
 // src/repositories/hygiene-supply.repository.ts
 var import_mongodb11 = require("mongodb");
-var import_node_server_utils19 = require("@7365admin1/node-server-utils");
+var import_node_server_utils21 = require("@7365admin1/node-server-utils");
 function useSupplyRepository() {
-  const db = import_node_server_utils19.useAtlas.getDb();
+  const db = import_node_server_utils21.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils19.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils21.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "site.supplies";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils19.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils21.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([{ key: { site: 1 } }]);
     } catch (error) {
-      throw new import_node_server_utils19.InternalServerError(
+      throw new import_node_server_utils21.InternalServerError(
         "Failed to create index on hygiene supply."
       );
     }
@@ -3604,7 +3851,7 @@ function useSupplyRepository() {
     try {
       await collection.createIndex({ name: "text" });
     } catch (error) {
-      throw new import_node_server_utils19.InternalServerError(
+      throw new import_node_server_utils21.InternalServerError(
         "Failed to create text index on hygiene supply."
       );
     }
@@ -3616,7 +3863,7 @@ function useSupplyRepository() {
         { unique: true }
       );
     } catch (error) {
-      throw new import_node_server_utils19.InternalServerError(
+      throw new import_node_server_utils21.InternalServerError(
         "Failed to create unique index on hygiene supply."
       );
     }
@@ -3626,9 +3873,9 @@ function useSupplyRepository() {
       value = MSupply(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils19.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils19.logger.error(
+        import_node_server_utils21.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3637,7 +3884,7 @@ function useSupplyRepository() {
     } catch (error) {
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_node_server_utils19.BadRequestError("Supply already exists.");
+        throw new import_node_server_utils21.BadRequestError("Supply already exists.");
       }
       throw error;
     }
@@ -3661,16 +3908,16 @@ function useSupplyRepository() {
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils19.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils21.BadRequestError("Invalid site ID format.");
     }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils19.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils19.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -3688,11 +3935,11 @@ function useSupplyRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils19.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils21.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils19.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils19.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -3703,23 +3950,23 @@ function useSupplyRepository() {
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils19.BadRequestError("Invalid supply ID format.");
+      throw new import_node_server_utils21.BadRequestError("Invalid supply ID format.");
     }
     const query = {
       _id,
       status: { $ne: "deleted" }
     };
-    const cacheKey = (0, import_node_server_utils19.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, {
       _id: _id.toString()
     });
     if (!session) {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils19.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
     } else {
-      import_node_server_utils19.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
+      import_node_server_utils21.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
     }
     try {
       const data = await collection.aggregate([
@@ -3733,12 +3980,12 @@ function useSupplyRepository() {
         }
       ]).toArray();
       if (!data || data.length === 0) {
-        throw new import_node_server_utils19.NotFoundError("Supply not found.");
+        throw new import_node_server_utils21.NotFoundError("Supply not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
-        import_node_server_utils19.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils19.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data[0];
     } catch (error) {
@@ -3749,7 +3996,7 @@ function useSupplyRepository() {
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils19.BadRequestError("Invalid supply ID format.");
+      throw new import_node_server_utils21.BadRequestError("Invalid supply ID format.");
     }
     try {
       const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
@@ -3759,12 +4006,12 @@ function useSupplyRepository() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils19.InternalServerError("Unable to update cleaning supply.");
+        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning supply.");
       }
       delNamespace().then(() => {
-        import_node_server_utils19.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils19.logger.error(
+        import_node_server_utils21.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3773,7 +4020,7 @@ function useSupplyRepository() {
     } catch (error) {
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_node_server_utils19.BadRequestError("Supply already exists.");
+        throw new import_node_server_utils21.BadRequestError("Supply already exists.");
       }
       throw error;
     }
@@ -3782,7 +4029,7 @@ function useSupplyRepository() {
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils19.BadRequestError("Invalid supply ID format.");
+      throw new import_node_server_utils21.BadRequestError("Invalid supply ID format.");
     }
     try {
       const updateValue = {
@@ -3796,12 +4043,12 @@ function useSupplyRepository() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils19.InternalServerError("Unable to delete supply.");
+        throw new import_node_server_utils21.InternalServerError("Unable to delete supply.");
       }
       delNamespace().then(() => {
-        import_node_server_utils19.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils19.logger.error(
+        import_node_server_utils21.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3825,7 +4072,7 @@ function useSupplyRepository() {
 
 // src/controllers/hygiene-supply.controller.ts
 var import_joi11 = __toESM(require("joi"));
-var import_node_server_utils20 = require("@7365admin1/node-server-utils");
+var import_node_server_utils22 = require("@7365admin1/node-server-utils");
 function useSupplyController() {
   const {
     createSupply: _createSupply,
@@ -3838,8 +4085,8 @@ function useSupplyController() {
     const payload = { ...req.body, ...req.params };
     const { error } = supplySchema.validate(payload);
     if (error) {
-      import_node_server_utils20.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils20.BadRequestError(error.message));
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -3847,7 +4094,7 @@ function useSupplyController() {
       res.status(201).json({ message: "Supply created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils20.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3862,8 +4109,8 @@ function useSupplyController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils20.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils20.BadRequestError(error.message));
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -3880,7 +4127,7 @@ function useSupplyController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils20.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3890,8 +4137,8 @@ function useSupplyController() {
     const _id = req.params.id;
     const { error, value } = validation.validate(_id);
     if (error) {
-      import_node_server_utils20.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils20.BadRequestError(error.message));
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -3899,7 +4146,7 @@ function useSupplyController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils20.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3914,8 +4161,8 @@ function useSupplyController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils20.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils20.BadRequestError(error.message));
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -3924,7 +4171,7 @@ function useSupplyController() {
       res.json({ message: "Supply updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils20.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3936,8 +4183,8 @@ function useSupplyController() {
     });
     const { error, value } = validation.validate({ id });
     if (error) {
-      import_node_server_utils20.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils20.BadRequestError(error.message));
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -3945,7 +4192,7 @@ function useSupplyController() {
       res.json({ message: "Supply deleted successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils20.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3962,7 +4209,7 @@ function useSupplyController() {
 // src/models/hygiene-stock.model.ts
 var import_joi12 = __toESM(require("joi"));
 var import_mongodb12 = require("mongodb");
-var import_node_server_utils21 = require("@7365admin1/node-server-utils");
+var import_node_server_utils23 = require("@7365admin1/node-server-utils");
 var stockSchema = import_joi12.default.object({
   site: import_joi12.default.string().hex().required(),
   supply: import_joi12.default.string().hex().required(),
@@ -3974,21 +4221,21 @@ var stockSchema = import_joi12.default.object({
 function MStock(value) {
   const { error } = stockSchema.validate(value);
   if (error) {
-    import_node_server_utils21.logger.info(`Hygiene Stock Model: ${error.message}`);
-    throw new import_node_server_utils21.BadRequestError(error.message);
+    import_node_server_utils23.logger.info(`Hygiene Stock Model: ${error.message}`);
+    throw new import_node_server_utils23.BadRequestError(error.message);
   }
   if (value.site) {
     try {
       value.site = new import_mongodb12.ObjectId(value.site);
     } catch (error2) {
-      throw new import_node_server_utils21.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils23.BadRequestError("Invalid site ID format.");
     }
   }
   if (value.supply) {
     try {
       value.supply = new import_mongodb12.ObjectId(value.supply);
     } catch (error2) {
-      throw new import_node_server_utils21.BadRequestError("Invalid supply ID format.");
+      throw new import_node_server_utils23.BadRequestError("Invalid supply ID format.");
     }
   }
   return {
@@ -4007,17 +4254,17 @@ function MStock(value) {
 
 // src/repositories/hygiene-stock.repository.ts
 var import_mongodb13 = require("mongodb");
-var import_node_server_utils22 = require("@7365admin1/node-server-utils");
+var import_node_server_utils24 = require("@7365admin1/node-server-utils");
 function useStockRepository() {
-  const db = import_node_server_utils22.useAtlas.getDb();
+  const db = import_node_server_utils24.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils22.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils24.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "site.supply.stocks";
   const supply_collection = "site.supplies";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils22.useCache)(namespace_collection);
-  const { delNamespace: delSupplyNamespace } = (0, import_node_server_utils22.useCache)(supply_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils24.useCache)(namespace_collection);
+  const { delNamespace: delSupplyNamespace } = (0, import_node_server_utils24.useCache)(supply_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -4027,7 +4274,7 @@ function useStockRepository() {
         { key: { status: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils22.InternalServerError("Failed to create index on hygiene stock.");
+      throw new import_node_server_utils24.InternalServerError("Failed to create index on hygiene stock.");
     }
   }
   async function createStock(value, session) {
@@ -4035,17 +4282,17 @@ function useStockRepository() {
       value = MStock(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils22.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils24.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils22.logger.error(
+        import_node_server_utils24.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
       });
       delSupplyNamespace().then(() => {
-        import_node_server_utils22.logger.info(`Cache cleared for namespace: ${supply_collection}`);
+        import_node_server_utils24.logger.info(`Cache cleared for namespace: ${supply_collection}`);
       }).catch((err) => {
-        import_node_server_utils22.logger.error(
+        import_node_server_utils24.logger.error(
           `Failed to clear cache for namespace: ${supply_collection}`,
           err
         );
@@ -4075,23 +4322,23 @@ function useStockRepository() {
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils22.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils24.BadRequestError("Invalid site ID format.");
     }
     try {
       supply = new import_mongodb13.ObjectId(supply);
       query.supply = supply;
       cacheOptions.supply = supply.toString();
     } catch (error) {
-      throw new import_node_server_utils22.BadRequestError("Invalid supply ID format.");
+      throw new import_node_server_utils24.BadRequestError("Invalid supply ID format.");
     }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils22.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils24.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils22.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils24.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -4110,11 +4357,11 @@ function useStockRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils22.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils24.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils22.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils24.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils22.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils24.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -4129,14 +4376,14 @@ function useStockRepository() {
 }
 
 // src/services/hygiene-stock.service.ts
-var import_node_server_utils23 = require("@7365admin1/node-server-utils");
+var import_node_server_utils25 = require("@7365admin1/node-server-utils");
 function useStockService() {
   const { createStock: _createStock } = useStockRepository();
   const { getSupplyById, updateSupply } = useSupplyRepository();
   async function createStock(value, out = false, session) {
     let ownSession = false;
     if (!session) {
-      session = import_node_server_utils23.useAtlas.getClient()?.startSession();
+      session = import_node_server_utils25.useAtlas.getClient()?.startSession();
       ownSession = true;
     }
     try {
@@ -4145,11 +4392,11 @@ function useStockService() {
       const { qty, ...stockData } = value;
       const supply = await getSupplyById(value.supply, session);
       if (!supply || supply.qty === void 0) {
-        throw new import_node_server_utils23.NotFoundError("Supply not found.");
+        throw new import_node_server_utils25.NotFoundError("Supply not found.");
       }
       const newSupplyQty = out ? supply.qty - qty : supply.qty + qty;
       if (out && newSupplyQty < 0) {
-        throw new import_node_server_utils23.BadRequestError(
+        throw new import_node_server_utils25.BadRequestError(
           `Insufficient stock. Available: ${supply.qty}, Requested: ${qty}`
         );
       }
@@ -4180,7 +4427,7 @@ function useStockService() {
 
 // src/controllers/hygiene-stock.controller.ts
 var import_joi13 = __toESM(require("joi"));
-var import_node_server_utils24 = require("@7365admin1/node-server-utils");
+var import_node_server_utils26 = require("@7365admin1/node-server-utils");
 function useStockController() {
   const { getStocksBySupplyId: _getStocksBySupplyId } = useStockRepository();
   const { createStock: _createStock } = useStockService();
@@ -4194,8 +4441,8 @@ function useStockController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils24.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils24.BadRequestError(error.message));
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
       return;
     }
     try {
@@ -4203,7 +4450,7 @@ function useStockController() {
       res.status(201).json({ message: "Stock created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils24.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4219,8 +4466,8 @@ function useStockController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils24.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils24.BadRequestError(error.message));
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -4239,7 +4486,7 @@ function useStockController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils24.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4253,7 +4500,7 @@ function useStockController() {
 // src/models/hygiene-checkout-item.model.ts
 var import_joi14 = __toESM(require("joi"));
 var import_mongodb14 = require("mongodb");
-var import_node_server_utils25 = require("@7365admin1/node-server-utils");
+var import_node_server_utils27 = require("@7365admin1/node-server-utils");
 var allowedCheckOutItemStatus = ["pending", "completed"];
 var checkOutItemSchema = import_joi14.default.object({
   site: import_joi14.default.string().hex().required(),
@@ -4267,21 +4514,21 @@ var checkOutItemSchema = import_joi14.default.object({
 function MCheckOutItem(value) {
   const { error } = checkOutItemSchema.validate(value);
   if (error) {
-    import_node_server_utils25.logger.info(`Hygiene Check Out Item Model: ${error.message}`);
-    throw new import_node_server_utils25.BadRequestError(error.message);
+    import_node_server_utils27.logger.info(`Hygiene Check Out Item Model: ${error.message}`);
+    throw new import_node_server_utils27.BadRequestError(error.message);
   }
   if (value.site) {
     try {
       value.site = new import_mongodb14.ObjectId(value.site);
     } catch (error2) {
-      throw new import_node_server_utils25.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils27.BadRequestError("Invalid site ID format.");
     }
   }
   if (value.supply) {
     try {
       value.supply = new import_mongodb14.ObjectId(value.supply);
     } catch (error2) {
-      throw new import_node_server_utils25.BadRequestError("Invalid supply ID format.");
+      throw new import_node_server_utils27.BadRequestError("Invalid supply ID format.");
     }
   }
   return {
@@ -4301,15 +4548,15 @@ function MCheckOutItem(value) {
 
 // src/repositories/hygiene-checkout-item.repository.ts
 var import_mongodb15 = require("mongodb");
-var import_node_server_utils26 = require("@7365admin1/node-server-utils");
+var import_node_server_utils28 = require("@7365admin1/node-server-utils");
 function useCheckOutItemRepository() {
-  const db = import_node_server_utils26.useAtlas.getDb();
+  const db = import_node_server_utils28.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils26.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils28.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "site.supply.checkouts";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils26.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils28.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -4318,7 +4565,7 @@ function useCheckOutItemRepository() {
         { key: { status: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils26.InternalServerError(
+      throw new import_node_server_utils28.InternalServerError(
         "Failed to create index on hygiene check out item."
       );
     }
@@ -4327,7 +4574,7 @@ function useCheckOutItemRepository() {
     try {
       await collection.createIndex({ supplyName: "text" });
     } catch (error) {
-      throw new import_node_server_utils26.InternalServerError(
+      throw new import_node_server_utils28.InternalServerError(
         "Failed to create text index on hygiene supply."
       );
     }
@@ -4337,9 +4584,9 @@ function useCheckOutItemRepository() {
       value = MCheckOutItem(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils26.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils28.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils26.logger.error(
+        import_node_server_utils28.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -4368,16 +4615,16 @@ function useCheckOutItemRepository() {
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils26.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils28.BadRequestError("Invalid site ID format.");
     }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils26.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils28.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils26.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils28.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -4424,11 +4671,11 @@ function useCheckOutItemRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils26.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils28.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils26.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils28.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils26.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils28.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -4439,20 +4686,20 @@ function useCheckOutItemRepository() {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils26.BadRequestError("Invalid check out item ID format.");
+      throw new import_node_server_utils28.BadRequestError("Invalid check out item ID format.");
     }
     const query = { _id };
-    const cacheKey = (0, import_node_server_utils26.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils28.makeCacheKey)(namespace_collection, {
       _id: _id.toString()
     });
     if (!session) {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils26.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils28.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
     } else {
-      import_node_server_utils26.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
+      import_node_server_utils28.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
     }
     try {
       const data = await collection.aggregate(
@@ -4487,12 +4734,12 @@ function useCheckOutItemRepository() {
         session ? { session } : void 0
       ).toArray();
       if (!data || data.length === 0) {
-        throw new import_node_server_utils26.NotFoundError("Check out item not found.");
+        throw new import_node_server_utils28.NotFoundError("Check out item not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
-        import_node_server_utils26.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils28.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils26.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils28.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data[0];
     } catch (error) {
@@ -4503,7 +4750,7 @@ function useCheckOutItemRepository() {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils26.BadRequestError("Invalid check out item ID format.");
+      throw new import_node_server_utils28.BadRequestError("Invalid check out item ID format.");
     }
     try {
       const updateValue = {
@@ -4516,12 +4763,12 @@ function useCheckOutItemRepository() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils26.InternalServerError("Unable to complete check out item.");
+        throw new import_node_server_utils28.InternalServerError("Unable to complete check out item.");
       }
       delNamespace().then(() => {
-        import_node_server_utils26.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils28.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils26.logger.error(
+        import_node_server_utils28.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -4543,7 +4790,7 @@ function useCheckOutItemRepository() {
 
 // src/services/hygiene-checkout-item.service.ts
 var import_core = require("@7365admin1/core");
-var import_node_server_utils27 = require("@7365admin1/node-server-utils");
+var import_node_server_utils29 = require("@7365admin1/node-server-utils");
 function useCheckOutItemService() {
   const {
     createCheckOutItem: _createCheckOutItem,
@@ -4554,7 +4801,7 @@ function useCheckOutItemService() {
   const { getUserById } = (0, import_core.useUserRepo)();
   const { createStock } = useStockService();
   async function createCheckOutItem(value) {
-    const session = import_node_server_utils27.useAtlas.getClient()?.startSession();
+    const session = import_node_server_utils29.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const supplyData = await getSupplyById(value.supply);
@@ -4572,7 +4819,7 @@ function useCheckOutItemService() {
         session
       );
       if (!checkOutItem) {
-        throw new import_node_server_utils27.BadRequestError("Failed to create check out item.");
+        throw new import_node_server_utils29.BadRequestError("Failed to create check out item.");
       }
       const createdStocks = await createStock(
         {
@@ -4594,7 +4841,7 @@ function useCheckOutItemService() {
     }
   }
   async function createCheckOutItemByBatch(value) {
-    const session = import_node_server_utils27.useAtlas.getClient()?.startSession();
+    const session = import_node_server_utils29.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const { site, attachment, createdBy, items } = value;
@@ -4642,7 +4889,7 @@ function useCheckOutItemService() {
 
 // src/controllers/hygiene-checkout-item.controller.ts
 var import_joi15 = __toESM(require("joi"));
-var import_node_server_utils28 = require("@7365admin1/node-server-utils");
+var import_node_server_utils30 = require("@7365admin1/node-server-utils");
 function useCheckOutItemController() {
   const {
     getCheckOutItems: _getCheckOutItems,
@@ -4672,8 +4919,8 @@ function useCheckOutItemController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils28.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils28.BadRequestError(error.message));
+      import_node_server_utils30.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils30.BadRequestError(error.message));
       return;
     }
     try {
@@ -4681,7 +4928,7 @@ function useCheckOutItemController() {
       res.status(201).json({ message: "Check out item created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils28.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils30.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4710,8 +4957,8 @@ function useCheckOutItemController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils28.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils28.BadRequestError(error.message));
+      import_node_server_utils30.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils30.BadRequestError(error.message));
       return;
     }
     try {
@@ -4719,7 +4966,7 @@ function useCheckOutItemController() {
       res.status(201).json({ message: "Check out items created successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils28.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils30.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4734,8 +4981,8 @@ function useCheckOutItemController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils28.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils28.BadRequestError(error.message));
+      import_node_server_utils30.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils30.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -4752,7 +4999,7 @@ function useCheckOutItemController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils28.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils30.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4762,8 +5009,8 @@ function useCheckOutItemController() {
     const _id = req.params.id;
     const { error, value } = validation.validate(_id);
     if (error) {
-      import_node_server_utils28.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils28.BadRequestError(error.message));
+      import_node_server_utils30.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils30.BadRequestError(error.message));
       return;
     }
     try {
@@ -4771,7 +5018,7 @@ function useCheckOutItemController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils28.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils30.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4785,7 +5032,7 @@ function useCheckOutItemController() {
 }
 
 // src/models/hygiene-schedule-task.model.ts
-var import_node_server_utils29 = require("@7365admin1/node-server-utils");
+var import_node_server_utils31 = require("@7365admin1/node-server-utils");
 var import_joi16 = __toESM(require("joi"));
 var import_mongodb16 = require("mongodb");
 var scheduleTaskSchema = import_joi16.default.object({
@@ -4806,14 +5053,14 @@ var scheduleTaskSchema = import_joi16.default.object({
 function MScheduleTask(value) {
   const { error } = scheduleTaskSchema.validate(value);
   if (error) {
-    import_node_server_utils29.logger.info(`Hygiene Schedule Task Model: ${error.message}`);
-    throw new import_node_server_utils29.BadRequestError(error.message);
+    import_node_server_utils31.logger.info(`Hygiene Schedule Task Model: ${error.message}`);
+    throw new import_node_server_utils31.BadRequestError(error.message);
   }
   if (value.site) {
     try {
       value.site = new import_mongodb16.ObjectId(value.site);
     } catch (error2) {
-      throw new import_node_server_utils29.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils31.BadRequestError("Invalid site ID format.");
     }
   }
   if (value.areas && Array.isArray(value.areas)) {
@@ -4824,7 +5071,7 @@ function MScheduleTask(value) {
           value: new import_mongodb16.ObjectId(area.value.toString())
         };
       } catch (error2) {
-        throw new import_node_server_utils29.BadRequestError(`Invalid area value format: ${area.name}`);
+        throw new import_node_server_utils31.BadRequestError(`Invalid area value format: ${area.name}`);
       }
     });
   }
@@ -4832,7 +5079,7 @@ function MScheduleTask(value) {
     try {
       value.createdBy = new import_mongodb16.ObjectId(value.createdBy);
     } catch (error2) {
-      throw new import_node_server_utils29.BadRequestError("Invalid createdBy ID format.");
+      throw new import_node_server_utils31.BadRequestError("Invalid createdBy ID format.");
     }
   }
   return {
@@ -4853,15 +5100,15 @@ function MScheduleTask(value) {
 
 // src/repositories/hygiene-schedule-task.repository.ts
 var import_mongodb17 = require("mongodb");
-var import_node_server_utils30 = require("@7365admin1/node-server-utils");
+var import_node_server_utils32 = require("@7365admin1/node-server-utils");
 function useScheduleTaskRepository() {
-  const db = import_node_server_utils30.useAtlas.getDb();
+  const db = import_node_server_utils32.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils30.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils32.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "site.schedule-tasks";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils30.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils32.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -4869,7 +5116,7 @@ function useScheduleTaskRepository() {
         { key: { status: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils30.InternalServerError(
+      throw new import_node_server_utils32.InternalServerError(
         "Failed to create index on hygiene schedule task."
       );
     }
@@ -4878,7 +5125,7 @@ function useScheduleTaskRepository() {
     try {
       await collection.createIndex({ title: "text", description: "text" });
     } catch (error) {
-      throw new import_node_server_utils30.InternalServerError(
+      throw new import_node_server_utils32.InternalServerError(
         "Failed to create text index on hygiene schedule task."
       );
     }
@@ -4888,9 +5135,9 @@ function useScheduleTaskRepository() {
       value = MScheduleTask(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils30.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils32.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils30.logger.error(
+        import_node_server_utils32.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -4919,16 +5166,16 @@ function useScheduleTaskRepository() {
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils30.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils32.BadRequestError("Invalid site ID format.");
     }
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils30.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils32.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils30.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils32.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -4946,11 +5193,11 @@ function useScheduleTaskRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils30.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils32.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils30.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils32.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils30.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils32.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -4987,16 +5234,16 @@ function useScheduleTaskRepository() {
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils30.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils32.BadRequestError("Invalid site ID format.");
     }
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils30.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils32.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils30.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils32.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -5013,11 +5260,11 @@ function useScheduleTaskRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils30.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils32.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils30.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils32.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils30.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils32.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -5028,23 +5275,23 @@ function useScheduleTaskRepository() {
     try {
       _id = new import_mongodb17.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils30.BadRequestError("Invalid schedule task ID format.");
+      throw new import_node_server_utils32.BadRequestError("Invalid schedule task ID format.");
     }
     const query = {
       _id,
       status: { $ne: "deleted" }
     };
-    const cacheKey = (0, import_node_server_utils30.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils32.makeCacheKey)(namespace_collection, {
       _id: _id.toString()
     });
     if (!session) {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils30.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils32.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
     } else {
-      import_node_server_utils30.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
+      import_node_server_utils32.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
     }
     try {
       const data = await collection.aggregate([
@@ -5063,12 +5310,12 @@ function useScheduleTaskRepository() {
         }
       ]).toArray();
       if (!data || data.length === 0) {
-        throw new import_node_server_utils30.NotFoundError("Schedule task not found.");
+        throw new import_node_server_utils32.NotFoundError("Schedule task not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
-        import_node_server_utils30.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils32.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils30.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils32.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data[0];
     } catch (error) {
@@ -5079,7 +5326,7 @@ function useScheduleTaskRepository() {
     try {
       _id = new import_mongodb17.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils30.BadRequestError("Invalid schedule task ID format.");
+      throw new import_node_server_utils32.BadRequestError("Invalid schedule task ID format.");
     }
     if (value.areas && Array.isArray(value.areas)) {
       value.areas = value.areas.map((area) => {
@@ -5089,7 +5336,7 @@ function useScheduleTaskRepository() {
             value: new import_mongodb17.ObjectId(area.value.toString())
           };
         } catch (error) {
-          throw new import_node_server_utils30.BadRequestError(`Invalid area value format: ${area.name}`);
+          throw new import_node_server_utils32.BadRequestError(`Invalid area value format: ${area.name}`);
         }
       });
     }
@@ -5101,14 +5348,14 @@ function useScheduleTaskRepository() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils30.InternalServerError(
+        throw new import_node_server_utils32.InternalServerError(
           "Unable to update hygiene schedule task."
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils30.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils32.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils30.logger.error(
+        import_node_server_utils32.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -5131,7 +5378,7 @@ function useScheduleTaskRepository() {
 }
 
 // src/services/hygiene-schedule-task.service.ts
-var import_node_server_utils31 = require("@7365admin1/node-server-utils");
+var import_node_server_utils33 = require("@7365admin1/node-server-utils");
 function useScheduleTaskService() {
   const { createParentChecklist } = useParentChecklistRepo();
   const { getAllScheduleTask } = useScheduleTaskRepository();
@@ -5154,13 +5401,13 @@ function useScheduleTaskService() {
       const currentDateString = now.toLocaleDateString("en-US", {
         timeZone: "Asia/Singapore"
       });
-      import_node_server_utils31.logger.info(
+      import_node_server_utils33.logger.info(
         `Checking schedule ${schedule._id}: Current time ${currentHour}:${currentMinute}, Current date ${currentDateString}, Schedule time ${schedule.time}, Start date ${schedule.startDate}, End date ${schedule.endDate}`
       );
       const startDate = /* @__PURE__ */ new Date(schedule.startDate + "T00:00:00");
       const currentDateOnly = /* @__PURE__ */ new Date(currentDateString + "T00:00:00");
       if (currentDateOnly < startDate) {
-        import_node_server_utils31.logger.info(
+        import_node_server_utils33.logger.info(
           `Schedule ${schedule._id}: Current date ${currentDateString} is before start date ${schedule.startDate}`
         );
         return false;
@@ -5168,7 +5415,7 @@ function useScheduleTaskService() {
       if (schedule.endDate) {
         const endDate = /* @__PURE__ */ new Date(schedule.endDate + "T00:00:00");
         if (currentDateOnly > endDate) {
-          import_node_server_utils31.logger.info(
+          import_node_server_utils33.logger.info(
             `Schedule ${schedule._id}: Current date ${currentDateString} is after end date ${schedule.endDate}`
           );
           return false;
@@ -5177,17 +5424,17 @@ function useScheduleTaskService() {
       const [scheduleHour, scheduleMinute] = schedule.time.split(":").map(Number);
       const timeMatches = currentHour === scheduleHour && currentMinute === scheduleMinute;
       if (!timeMatches) {
-        import_node_server_utils31.logger.info(
+        import_node_server_utils33.logger.info(
           `Schedule ${schedule._id}: Time does not match. Current: ${currentHour}:${currentMinute}, Expected: ${scheduleHour}:${scheduleMinute}`
         );
         return false;
       }
-      import_node_server_utils31.logger.info(
+      import_node_server_utils33.logger.info(
         `Schedule ${schedule._id}: All conditions matched - Date is within range and time matches`
       );
       return true;
     } catch (error) {
-      import_node_server_utils31.logger.error(
+      import_node_server_utils33.logger.error(
         `Error checking schedule conditions for ${schedule._id}:`,
         error
       );
@@ -5196,40 +5443,40 @@ function useScheduleTaskService() {
   }
   async function processScheduledTasks(currentDate) {
     try {
-      import_node_server_utils31.logger.info("Starting scheduled task processing...");
+      import_node_server_utils33.logger.info("Starting scheduled task processing...");
       const scheduleTasks = await getAllScheduleTask();
       if (!scheduleTasks || scheduleTasks.length === 0) {
-        import_node_server_utils31.logger.info("No schedule tasks found to process");
+        import_node_server_utils33.logger.info("No schedule tasks found to process");
         return { processed: 0, validated: 0 };
       }
-      import_node_server_utils31.logger.info(`Found ${scheduleTasks.length} schedule tasks to check`);
+      import_node_server_utils33.logger.info(`Found ${scheduleTasks.length} schedule tasks to check`);
       let processedCount = 0;
       let validatedCount = 0;
       const validatedTasks = [];
       for (const scheduleTask of scheduleTasks) {
         try {
-          import_node_server_utils31.logger.info(
+          import_node_server_utils33.logger.info(
             `Checking schedule ${scheduleTask._id} - ${scheduleTask.title}: time=${scheduleTask.time}, startDate=${scheduleTask.startDate}, endDate=${scheduleTask.endDate}`
           );
           const shouldRun = checkScheduleConditions(scheduleTask, currentDate);
           if (!shouldRun) {
-            import_node_server_utils31.logger.info(
+            import_node_server_utils33.logger.info(
               `Schedule ${scheduleTask._id} conditions not met, skipping`
             );
             continue;
           }
-          import_node_server_utils31.logger.info(
+          import_node_server_utils33.logger.info(
             `Schedule ${scheduleTask._id} conditions validated, creating area checklists`
           );
           if (!scheduleTask._id) {
-            import_node_server_utils31.logger.warn(`Schedule ${scheduleTask.title} has no _id, skipping`);
+            import_node_server_utils33.logger.warn(`Schedule ${scheduleTask.title} has no _id, skipping`);
             continue;
           }
           if (!scheduleTask.site) {
-            import_node_server_utils31.logger.warn(`Schedule ${scheduleTask._id} has no site, skipping`);
+            import_node_server_utils33.logger.warn(`Schedule ${scheduleTask._id} has no site, skipping`);
             continue;
           }
-          import_node_server_utils31.logger.info(
+          import_node_server_utils33.logger.info(
             `Getting or creating parent checklist for schedule ${scheduleTask._id} in site ${scheduleTask.site}`
           );
           const parentChecklistIds = await createParentChecklist({
@@ -5237,7 +5484,7 @@ function useScheduleTaskService() {
             createdAt: /* @__PURE__ */ new Date()
           });
           const parentChecklistId = Array.isArray(parentChecklistIds) ? parentChecklistIds[0] : parentChecklistIds;
-          import_node_server_utils31.logger.info(
+          import_node_server_utils33.logger.info(
             `Using parent checklist ${parentChecklistId}, now creating/updating area checklists`
           );
           for (const area of scheduleTask.areas) {
@@ -5250,14 +5497,14 @@ function useScheduleTaskService() {
                   unit: unit.unit.toString(),
                   name: unit.name
                 }));
-                import_node_server_utils31.logger.info(
+                import_node_server_utils33.logger.info(
                   `Area ${area.name} (${areaId}): Using units from area details: ${JSON.stringify(
                     units
                   )}`
                 );
               }
               if (units.length === 0) {
-                import_node_server_utils31.logger.warn(
+                import_node_server_utils33.logger.warn(
                   `Area ${area.name} (${areaId}): No units found, skipping area.`
                 );
                 continue;
@@ -5268,11 +5515,11 @@ function useScheduleTaskService() {
                   parentChecklistId.toString(),
                   areaId
                 );
-                import_node_server_utils31.logger.info(
+                import_node_server_utils33.logger.info(
                   `Area ${area.name} (${areaId}): Existing area checklist found: ${existingAreaChecklist ? "Yes" : "No"}`
                 );
                 if (existingAreaChecklist) {
-                  import_node_server_utils31.logger.info(
+                  import_node_server_utils33.logger.info(
                     `Area ${area.name} (${areaId}): Existing checklist content: ${JSON.stringify(
                       existingAreaChecklist.checklist
                     )}`
@@ -5280,7 +5527,7 @@ function useScheduleTaskService() {
                 }
               } catch (error) {
                 existingAreaChecklist = null;
-                import_node_server_utils31.logger.info(
+                import_node_server_utils33.logger.info(
                   `Area ${area.name} (${areaId}): No existing area checklist found (exception).`
                 );
               }
@@ -5294,7 +5541,7 @@ function useScheduleTaskService() {
                   ...existingAreaChecklist.checklist || [],
                   newSet
                 ];
-                import_node_server_utils31.logger.info(
+                import_node_server_utils33.logger.info(
                   `Area ${area.name} (${areaId}): Appending new set ${newSet.set} to checklist. Updated checklist: ${JSON.stringify(
                     updatedChecklist
                   )}`
@@ -5302,7 +5549,7 @@ function useScheduleTaskService() {
                 await updateAreaChecklist(existingAreaChecklist._id, {
                   checklist: updatedChecklist
                 });
-                import_node_server_utils31.logger.info(
+                import_node_server_utils33.logger.info(
                   `Appended set ${newSet.set} to area checklist for area ${area.name}`
                 );
                 try {
@@ -5310,13 +5557,13 @@ function useScheduleTaskService() {
                     parentChecklistId.toString(),
                     areaId
                   );
-                  import_node_server_utils31.logger.info(
+                  import_node_server_utils33.logger.info(
                     `Area ${area.name} (${areaId}): Checklist after update: ${JSON.stringify(
                       verifyChecklist.checklist
                     )}`
                   );
                 } catch (verifyError) {
-                  import_node_server_utils31.logger.warn(
+                  import_node_server_utils33.logger.warn(
                     `Area ${area.name} (${areaId}): Error verifying checklist after update:`,
                     verifyError
                   );
@@ -5335,50 +5582,50 @@ function useScheduleTaskService() {
                   ],
                   createdBy: scheduleTask.createdBy
                 };
-                import_node_server_utils31.logger.info(
+                import_node_server_utils33.logger.info(
                   `Area ${area.name} (${areaId}): Creating new area checklist with data: ${JSON.stringify(
                     checklistData
                   )}`
                 );
                 await createAreaChecklist(checklistData);
-                import_node_server_utils31.logger.info(`Created new area checklist for area ${area.name}`);
+                import_node_server_utils33.logger.info(`Created new area checklist for area ${area.name}`);
                 try {
                   const verifyChecklist = await getAreaChecklistByAreaAndSchedule(
                     parentChecklistId.toString(),
                     areaId
                   );
-                  import_node_server_utils31.logger.info(
+                  import_node_server_utils33.logger.info(
                     `Area ${area.name} (${areaId}): Checklist after creation: ${JSON.stringify(
                       verifyChecklist.checklist
                     )}`
                   );
                 } catch (verifyError) {
-                  import_node_server_utils31.logger.warn(
+                  import_node_server_utils33.logger.warn(
                     `Area ${area.name} (${areaId}): Error verifying checklist after creation:`,
                     verifyError
                   );
                 }
               }
             } catch (error) {
-              import_node_server_utils31.logger.error(`Error processing area ${area.name}:`, error);
+              import_node_server_utils33.logger.error(`Error processing area ${area.name}:`, error);
               continue;
             }
           }
           processedCount++;
           validatedCount++;
           validatedTasks.push(scheduleTask);
-          import_node_server_utils31.logger.info(
+          import_node_server_utils33.logger.info(
             `Successfully processed schedule ${scheduleTask._id}, created/updated area checklists for all areas.`
           );
         } catch (error) {
-          import_node_server_utils31.logger.error(
+          import_node_server_utils33.logger.error(
             `Error processing schedule task ${scheduleTask._id}:`,
             error
           );
           continue;
         }
       }
-      import_node_server_utils31.logger.info(
+      import_node_server_utils33.logger.info(
         `Scheduled task processing completed. Processed: ${processedCount}, Validated: ${validatedCount} tasks`
       );
       return {
@@ -5387,7 +5634,7 @@ function useScheduleTaskService() {
         tasks: validatedTasks
       };
     } catch (error) {
-      import_node_server_utils31.logger.error("Error processing scheduled tasks:", error);
+      import_node_server_utils33.logger.error("Error processing scheduled tasks:", error);
       throw error;
     }
   }
@@ -5396,7 +5643,7 @@ function useScheduleTaskService() {
 
 // src/controllers/hygiene-schedule-task.controller.ts
 var import_joi17 = __toESM(require("joi"));
-var import_node_server_utils32 = require("@7365admin1/node-server-utils");
+var import_node_server_utils34 = require("@7365admin1/node-server-utils");
 function useScheduleTaskController() {
   const {
     createScheduleTask: _createScheduleTask,
@@ -5414,8 +5661,8 @@ function useScheduleTaskController() {
     const payload = { ...req.body, ...req.params, createdBy };
     const { error } = scheduleTaskSchema.validate(payload);
     if (error) {
-      import_node_server_utils32.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils32.BadRequestError(error.message));
+      import_node_server_utils34.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils34.BadRequestError(error.message));
       return;
     }
     try {
@@ -5423,7 +5670,7 @@ function useScheduleTaskController() {
       res.status(201).json({ message: "Schedule task created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils32.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils34.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -5438,8 +5685,8 @@ function useScheduleTaskController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils32.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils32.BadRequestError(error.message));
+      import_node_server_utils34.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils34.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -5456,7 +5703,7 @@ function useScheduleTaskController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils32.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils34.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -5471,8 +5718,8 @@ function useScheduleTaskController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils32.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils32.BadRequestError(error.message));
+      import_node_server_utils34.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils34.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -5489,7 +5736,7 @@ function useScheduleTaskController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils32.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils34.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -5499,8 +5746,8 @@ function useScheduleTaskController() {
     const _id = req.params.id;
     const { error, value } = validation.validate(_id);
     if (error) {
-      import_node_server_utils32.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils32.BadRequestError(error.message));
+      import_node_server_utils34.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils34.BadRequestError(error.message));
       return;
     }
     try {
@@ -5508,7 +5755,7 @@ function useScheduleTaskController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils32.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils34.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -5531,8 +5778,8 @@ function useScheduleTaskController() {
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils32.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils32.BadRequestError(error.message));
+      import_node_server_utils34.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils34.BadRequestError(error.message));
       return;
     }
     try {
@@ -5541,7 +5788,7 @@ function useScheduleTaskController() {
       res.json({ message: "Schedule task updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils32.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils34.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -5554,6 +5801,275 @@ function useScheduleTaskController() {
     updateScheduleTask
   };
 }
+
+// src/services/hygiene-qr.service.ts
+var import_node_server_utils35 = require("@7365admin1/node-server-utils");
+var import_puppeteer = require("puppeteer");
+var import_qrcode = __toESM(require("qrcode"));
+function useQRService() {
+  async function generateQRDataUrl(qrUrl) {
+    return import_qrcode.default.toDataURL(qrUrl, {
+      width: 350,
+      margin: 2,
+      errorCorrectionLevel: "M",
+      color: {
+        dark: "#000000",
+        light: "#FFFFFF"
+      }
+    });
+  }
+  async function generateQRImage(qrUrl) {
+    try {
+      const qrDataUrl = await generateQRDataUrl(qrUrl);
+      const browser = await (0, import_puppeteer.launch)({
+        headless: true,
+        executablePath: process.env.CHROME_BINARY,
+        args: [`--no-sandbox`, `--disable-gpu`, `--disable-dev-shm-usage`]
+      });
+      const page = await browser.newPage();
+      await page.setViewport({
+        width: 400,
+        height: 400
+      });
+      const html = `
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <meta charset="UTF-8">
+          <style>
+            body {
+              margin: 0;
+              padding: 20px;
+              display: flex;
+              justify-content: center;
+              align-items: center;
+              background: white;
+              min-height: 100vh;
+            }
+            #qr-image {
+              display: block;
+              width: 350px;
+              height: 350px;
+            }
+          </style>
+        </head>
+        <body>
+          <img id="qr-image" src="${qrDataUrl}" alt="QR Code" />
+        </body>
+        </html>
+      `;
+      await page.setContent(html, {
+        waitUntil: ["load", "networkidle0"]
+      });
+      await page.waitForSelector("#qr-image", { timeout: 1e4 });
+      const imageBuffer = await page.screenshot({
+        type: "png",
+        clip: {
+          x: 0,
+          y: 0,
+          width: 400,
+          height: 400
+        }
+      });
+      await browser.close();
+      return imageBuffer;
+    } catch (error) {
+      import_node_server_utils35.logger.log({
+        level: "error",
+        message: `Failed to generate QR image: ${error.message}`
+      });
+      throw error;
+    }
+  }
+  async function generateQRPDF(qrUrl, title) {
+    try {
+      const qrDataUrl = await generateQRDataUrl(qrUrl);
+      const browser = await (0, import_puppeteer.launch)({
+        headless: true,
+        executablePath: process.env.CHROME_BINARY,
+        args: [`--no-sandbox`, `--disable-gpu`, `--disable-dev-shm-usage`]
+      });
+      const page = await browser.newPage();
+      await page.setViewport({
+        width: 800,
+        height: 1100
+      });
+      const escapedTitle = (title || "Cleaning Schedule QR Code").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+      const html = `
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <meta charset="UTF-8">
+          <style>
+            * {
+              margin: 0;
+              padding: 0;
+              box-sizing: border-box;
+            }
+            body {
+              font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+              background: white;
+              padding: 60px 40px;
+              display: flex;
+              flex-direction: column;
+              align-items: center;
+              justify-content: center;
+              min-height: 100vh;
+            }
+            .qr-container {
+              text-align: center;
+              background: transparent;
+              padding: 0;
+            }
+            h1 {
+              font-size: 28px;
+              color: #333;
+              margin-bottom: 20px;
+              font-weight: 600;
+            }
+            .qr-wrapper {
+              display: inline-block;
+              padding: 0;
+              background: transparent;
+              border: none;
+              border-radius: 0;
+              margin: 20px 0;
+            }
+            #qr-image {
+              display: block;
+              width: 350px;
+              height: 350px;
+            }
+            .instructions {
+              margin-top: 30px;
+              font-size: 16px;
+              color: #666;
+              line-height: 1.6;
+            }
+            .url-info {
+              margin-top: 20px;
+              padding: 15px;
+              background: #f5f5f5;
+              border-radius: 6px;
+              font-size: 12px;
+              color: #888;
+              word-break: break-all;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="qr-container">
+            <h1>${escapedTitle}</h1>
+            <div class="qr-wrapper">
+              <img id="qr-image" src="${qrDataUrl}" alt="QR Code" />
+            </div>
+            <div class="instructions">
+              <p>Scan this QR code to access the cleaning schedule.</p>
+            </div>
+            <div class="url-info">
+              ${qrUrl}
+            </div>
+          </div>
+        </body>
+        </html>
+      `;
+      await page.setContent(html, {
+        waitUntil: ["load", "networkidle0"]
+      });
+      await page.waitForSelector("#qr-image", { timeout: 1e4 });
+      await page.waitForFunction(
+        () => {
+          const img = document.getElementById("qr-image");
+          return img && img.complete && img.naturalWidth > 0;
+        },
+        { timeout: 1e4 }
+      );
+      const pdfBuffer = await page.pdf({
+        format: "A4",
+        printBackground: true,
+        margin: {
+          top: "20mm",
+          right: "20mm",
+          bottom: "20mm",
+          left: "20mm"
+        }
+      });
+      await browser.close();
+      return pdfBuffer;
+    } catch (error) {
+      import_node_server_utils35.logger.log({
+        level: "error",
+        message: `Failed to generate QR PDF: ${error.message}`
+      });
+      throw error;
+    }
+  }
+  return {
+    generateQRImage,
+    generateQRPDF
+  };
+}
+
+// src/controllers/hygiene-qr.controller.ts
+var import_joi18 = __toESM(require("joi"));
+var import_node_server_utils36 = require("@7365admin1/node-server-utils");
+function useQRController() {
+  const { generateQRImage: _generateQRImage, generateQRPDF: _generateQRPDF } = useQRService();
+  async function generateQR(req, res, next) {
+    const validation = import_joi18.default.object({
+      url: import_joi18.default.string().uri().required(),
+      filename: import_joi18.default.string().optional().allow("", null),
+      title: import_joi18.default.string().optional().allow("", null),
+      download: import_joi18.default.boolean().optional().default(false)
+    });
+    const query = { ...req.query };
+    const { error, value } = validation.validate(query);
+    if (error) {
+      import_node_server_utils36.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils36.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { url, filename, title, download } = value;
+      if (download) {
+        const pdfBuffer = await _generateQRPDF(url, title);
+        if (!pdfBuffer || pdfBuffer.length === 0) {
+          throw new Error("Generated QR PDF is empty or invalid.");
+        }
+        const sanitizedFilename = (filename || "qrcode").replace(/['"]/g, "").replace(/[^a-zA-Z0-9_-]/g, "_");
+        const date = /* @__PURE__ */ new Date();
+        const formattedDate = `${String(date.getMonth() + 1).padStart(
+          2,
+          "0"
+        )}-${String(date.getDate()).padStart(2, "0")}-${date.getFullYear()}`;
+        res.setHeader("Content-Type", "application/pdf");
+        res.setHeader(
+          "Content-Disposition",
+          `attachment; filename="${sanitizedFilename}-${formattedDate}.pdf"`
+        );
+        res.setHeader("Content-Length", pdfBuffer.length);
+        res.end(pdfBuffer);
+      } else {
+        const imageBuffer = await _generateQRImage(url);
+        if (!imageBuffer || imageBuffer.length === 0) {
+          throw new Error("Generated QR image is empty or invalid.");
+        }
+        res.setHeader("Content-Type", "image/png");
+        res.setHeader("Cache-Control", "public, max-age=3600");
+        res.setHeader("Content-Length", imageBuffer.length);
+        res.end(imageBuffer);
+      }
+      return;
+    } catch (error2) {
+      import_node_server_utils36.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    generateQR
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MArea,
@@ -5581,6 +6097,7 @@ function useScheduleTaskController() {
   useAreaChecklistRepo,
   useAreaChecklistService,
   useAreaController,
+  useAreaExportService,
   useAreaRepo,
   useAreaService,
   useCheckOutItemController,
@@ -5590,6 +6107,8 @@ function useScheduleTaskController() {
   useHygieneDashboardRepository,
   useParentChecklistController,
   useParentChecklistRepo,
+  useQRController,
+  useQRService,
   useScheduleTaskController,
   useScheduleTaskRepository,
   useScheduleTaskService,
@@ -5599,6 +6118,7 @@ function useScheduleTaskController() {
   useSupplyController,
   useSupplyRepository,
   useUnitController,
+  useUnitExportService,
   useUnitRepository,
   useUnitService
 });